パイプラインADC 1.5ビット β進

# 初期の Vin の値と Vref を設定
Vin = 0.2  # 初期の Vin0 の値を適宜変更してください
Vref = 1.0  # Vref の値を適宜変更してください

# Vin1 から VinN までの値を計算する関数
def calculate_vin_values(Vin0, Vref, steps=10):
    vin_values = [Vin0]  # Vin0 の初期値をリストに追加
    D_values = []  # D の値を保存するリスト
    for _ in range(steps):
        Vin0 = vin_values[-1]  # 現在の Vin の値を取得
        if Vin0 > 0:
            D = 1
            Vin_next = 2 * Vin0 - Vref
        else:
            D = 0
            Vin_next = 2 * Vin0 + Vref
        vin_values.append(Vin_next)
        D_values.append(D)
    return vin_values, D_values

# Vin1 から Vin10 までの値を計算
vin_values, D_values = calculate_vin_values(Vin, Vref, steps=10)

# 結果を出力
for i, (vin, D) in enumerate(zip(vin_values, D_values), start=1):
    print(f'Step {i}: Vin = {vin_values[i-1]}, D = {D}')

# 初期の Vin の値と Vref を設定
Vin = 0.2  # 初期の Vin0 の値を適宜変更してください
Vref = 1.0  # Vref の値を適宜変更してください
beta = 1.997  # β の値を適宜変更してください

# Vin1 から VinN までの値を計算する関数
def calculate_vin_values(Vin0, Vref, beta, steps=10):
    vin_values = [Vin0]  # Vin0 の初期値をリストに追加
    D_values = []  # D の値を保存するリスト
    for _ in range(steps):
        Vin0 = vin_values[-1]  # 現在の Vin の値を取得
        if Vin0 > 0:
            D = 1
            Vin_next = beta * Vin0 - (beta - 1) * Vref
        else:
            D = 0
            Vin_next = beta * Vin0 + (beta - 1) * Vref
        vin_values.append(Vin_next)
        D_values.append(D)
    return vin_values, D_values

# Vin1 から Vin10 までの値を計算
vin_values, D_values = calculate_vin_values(Vin, Vref, beta, steps=10)

# 結果を出力
for i, (vin, D) in enumerate(zip(vin_values, D_values), start=1):
    print(f'Step {i}: Vin = {vin}, D = {D}')

# 最後に D をすべて並べて出力
print("D values:", D_values)

# 初期の Vin の値と Vref を設定
Vin = 0.2001  # 初期の Vin0 の値を適宜変更してください
Vref = 1.0  # Vref の値を適宜変更してください

# Vin1 から VinN までの値を計算する関数
def calculate_vin_values(Vin0, Vref, steps=10):
    vin_values = [Vin0]  # Vin0 の初期値をリストに追加
    D_values = []  # D の値を保存するリスト
    for _ in range(steps):
        Vin0 = vin_values[-1]  # 現在の Vin の値を取得
        if Vin0 > Vref / 4:
            D = '10'
            Vin_next = 2 * Vin0 - Vref
        elif Vin0 > -Vref / 4:
            D = '01'
            Vin_next = 2 * Vin0
        else:
            D = '00'
            Vin_next = 2 * Vin0 + Vref
        vin_values.append(Vin_next)
        D_values.append(D)
    return vin_values, D_values

# Vin1 から Vin10 までの値を計算
vin_values, D_values = calculate_vin_values(Vin, Vref, steps=10)

# 結果を出力
for i, (vin, D) in enumerate(zip(vin_values[1:], D_values), start=1):
    print(f'Step {i}: Vin = {vin}, D = {D}')

# 文字列を定義
binary_string = '1010'

# β進数を10進数に変換する関数を定義
def binary_to_base(binary_string, base):
    decimal_number = 0
    power = len(binary_string) - 1  # 最上位桁の指数

    for digit in binary_string:
        decimal_number += int(digit) * (base ** power)
        power -= 1

    return decimal_number

# β進数に変換して結果を出力（ここではβを置き換えます）
beta_number = binary_to_base(binary_string, 1.7)
print(f"β進数 {binary_string} は10進数で {beta_number} です。")

# 二進数の文字列を定義
binary_string = '1010'

# 二進数を十進数に変換する関数を定義
def binary_to_decimal(binary_string):
    decimal_number = 0
    power = len(binary_string) - 1  # 最上位桁の指数

    for digit in binary_string:
        decimal_number += int(digit) * (2 ** power)
        power -= 1

    return decimal_number

# 二進数を十進数に変換して結果を出力
decimal_number = binary_to_decimal(binary_string)
print(f"二進数 {binary_string} は十進数で {decimal_number} です。")

import numpy as np
import matplotlib.pyplot as plt

# パラメータ設定
Fs = 1000  # サンプリング周波数
T = 1.0    # シミュレーション時間
t = np.linspace(0, T, int(Fs*T), endpoint=False)  # 時間軸
f = 5      # 入力信号の周波数
A = 0.5    # 入力信号の振幅

# アナログ入力信号生成
input_signal = A * np.sin(2 * np.pi * f * t)

# パイプラインADCのステージ数と分解能設定
num_stages = 4
bits_per_stage = 1

# 各ステージの出力と残差
stage_outputs = np.zeros((num_stages, len(input_signal)))
residuals = np.zeros((num_stages, len(input_signal)))

# パイプラインADCのシミュレーション
residual = input_signal
for stage in range(num_stages):
    # 各ステージのADC: 1ビットの比較
    stage_output = np.sign(residual)
    stage_outputs[stage] = stage_output
    
    # 各ステージのDAC: 1ビットのデジタル信号をアナログに変換
    dac_output = stage_output * A / (2 ** (stage + 1))
    
    # 残差の計算
    residual = residual - dac_output
    residuals[stage] = residual

# 最終的なデジタル出力の計算
final_output = np.sum(stage_outputs * (A / (2 ** np.arange(1, num_stages + 1)))[:, np.newaxis], axis=0)

# 結果のプロット
plt.figure(figsize=(12, 12))

# アナログ入力信号のプロット
plt.subplot(5, 1, 1)
plt.plot(t, input_signal, label='Input Signal')
plt.title('Analog Input Signal')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.grid()
plt.legend()

# 各ステージの出力信号のプロット
for stage in range(num_stages):
    plt.subplot(5, 1, stage + 2)
    plt.plot(t, stage_outputs[stage], label=f'Stage {stage + 1} Output')
    plt.plot(t, residuals[stage], label=f'Stage {stage + 1} Residual', linestyle='--')
    plt.title(f'Stage {stage + 1} Output and Residual')
    plt.xlabel('Time [s]')
    plt.ylabel('Amplitude')
    plt.grid()
    plt.legend()

# 最終的なデジタル出力信号のプロット
plt.subplot(5, 1, num_stages + 2)
plt.plot(t, final_output, label='Final Digital Output')
plt.title('Final Digital Output Signal')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.grid()
plt.legend()

plt.tight_layout()
plt.show()