def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# Multi Tile Synchronization
rft.awg_sa_cmd.sync_dac_tiles()
rft.awg_sa_cmd.sync_adc_tiles()
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
rft.awg_sa_cmd.start_wave_sequence()
# 終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd, awg_list)
# エラーチェック
print("Check for errors")
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
print("Generating graph images.")
nu = ndarrayutil.NdarrayUtil
for awg_id in awg_list:
for step_id in range(2):
# キャプチャデータ取得
awg_id_to_wave_samples = {}
wave_data = rft.awg_sa_cmd.read_capture_data(awg_id,
step_id=step_id)
awg_id_to_wave_samples[awg_id] = nu.bytes_to_real_32(wave_data)
# キャプチャデータ出力
output_graphs(
(awg_id, step_id, awg_id_to_wave_samples[awg_id]))
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(awgsa.AwgId.AWG_0)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
wave_seq_0 = set_wave_sequence(rft.awg_sa_cmd, 1)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, wave_seq_0)
# 波形出力 & キャプチャスタート
rft.awg_sa_cmd.start_wave_sequence()
# 終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
r_data_0 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_0,
step_id=0)
r_data_1 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_0,
step_id=1)
nu = ndarrayutil.NdarrayUtil
r_sample_0 = nu.bytes_to_real_32(r_data_0)
r_sample_1 = nu.bytes_to_real_32(r_data_1)
output_graphs((awgsa.AwgId.AWG_0, 0, r_sample_0),
(awgsa.AwgId.AWG_0, 1, r_sample_1))
# 送信波形をグラフ化
rft.awg_sa_cmd.get_waveform_sequence(awgsa.AwgId.AWG_0).save_as_img(
PLOT_DIR +
"waveform/awg_{}_waveform.png".format(awgsa.AwgId.AWG_0))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
#"""
# AWG 有効化
rft.awg_sa_cmd.enable_awg(awgsa.AwgId.AWG_0, awgsa.AwgId.AWG_1)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
(wave_seq_0, wave_seq_1) = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, wave_seq_0, wave_seq_1)
# デジタル出力シーケンス設定
set_digital_output_sequence(rft.awg_sa_cmd)
# 波形出力 & キャプチャスタート
rft.awg_sa_cmd.start_wave_sequence()
# 終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd)
#"""
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
check_skipped_digital_output(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
#"""
# キャプチャデータ取得
r_data_0 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_0, step_id = 0)
r_data_1 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_0, step_id = 1)
r_data_2 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_1, step_id = 0)
nu = ndarrayutil.NdarrayUtil
r_sample_0 = nu.bytes_to_real_32(r_data_0)
r_sample_1 = nu.bytes_to_real_32(r_data_1)
r_sample_2 = nu.bytes_to_real_32(r_data_2)
output_graphs(
(awgsa.AwgId.AWG_0, 0, r_sample_0),
(awgsa.AwgId.AWG_0, 1, r_sample_1),
(awgsa.AwgId.AWG_1, 0, r_sample_2))
#"""
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
(wave_seq_0, wave_seq_1) = set_wave_sequence(rft.awg_sa_cmd)
# Real 波形出力
# Python スクリプト内で計算したサンプル値を保持するオブジェクトを取得
waveform_0 = wave_seq_0.get_waveform_sequence()
waveform_0.save_as_img(PLOT_DIR + "user_def_seq_0_waveform.png")
step_id_to_samples = waveform_0.get_samples_by_step_id()
output_samples(PLOT_DIR + "user_def_seq_0_waveform.txt",
step_id_to_samples)
# ハードウェア内部の RAM に格納されたサンプル値を保持するオブジェクトを取得
waveform_0 = rft.awg_sa_cmd.get_waveform_sequence(awgsa.AwgId.AWG_0)
waveform_0.save_as_img(PLOT_DIR + "actual_seq_0_waveform.png")
step_id_to_samples = waveform_0.get_samples_by_step_id()
output_samples(PLOT_DIR + "actual_seq_0_waveform.txt",
step_id_to_samples)
# I/Q 波形出力
# Python スクリプト内で計算したサンプル値を保持するオブジェクトを取得
waveform_1 = wave_seq_1.get_waveform_sequence()
waveform_1.save_as_img(PLOT_DIR + "user_def_seq_1_waveform.png")
waveform_1.save_as_img(PLOT_DIR + "user_def_seq_1_waveform_merged.png",
iq_separation=False)
step_id_to_i_samples = waveform_1.get_i_samples_by_step_id()
step_id_to_q_samples = waveform_1.get_q_samples_by_step_id()
output_samples(PLOT_DIR + "user_def_seq_1_i_waveform.txt",
step_id_to_i_samples)
output_samples(PLOT_DIR + "user_def_seq_1_q_waveform.txt",
step_id_to_q_samples)
# ハードウェア内部の RAM に格納されたサンプル値を保持するオブジェクトを取得
waveform_1 = rft.awg_sa_cmd.get_waveform_sequence(awgsa.AwgId.AWG_1)
waveform_1.save_as_img(PLOT_DIR + "actual_seq_1_waveform.png")
waveform_1.save_as_img(PLOT_DIR + "actual_seq_1_waveform_merged.png",
iq_separation=False)
step_id_to_i_samples = waveform_1.get_i_samples_by_step_id()
step_id_to_q_samples = waveform_1.get_q_samples_by_step_id()
output_samples(PLOT_DIR + "actual_seq_1_i_waveform.txt",
step_id_to_i_samples)
output_samples(PLOT_DIR + "actual_seq_1_q_waveform.txt",
step_id_to_q_samples)
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
start_awg_and_capture(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
print("Get capture data.")
nu = ndarrayutil.NdarrayUtil
awg_id_to_wave_samples = {}
for awg_id in awg_list:
wave_data = rft.awg_sa_cmd.read_capture_data(awg_id, step_id=0)
awg_id_to_wave_samples[awg_id] = nu.bytes_to_real_32(wave_data)
# キャプチャデータ出力
print("Output capture data.")
for awg_id, wave_samples in awg_id_to_wave_samples.items():
output_graphs((awg_id, 0, wave_samples))
print("Done.")
return
def initServer(self):
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
handler.setLevel(LOG_LEVEL)
logger.setLevel(LOG_LEVEL)
logger.addHandler(handler)
self.rft = client.RftoolClient(logger)
self.rft.connect(ZCU111_IP_ADDR)
self.wr_size = 0
self.wr_pos = 0
self.rd_size = 0
self.rd_pos = 0
self.buf_mem = bytearray(BUF_MEM_SIZE)
yield None
def main():
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES,
dac_freq=DAC_FREQ,
carrier_freq=10.67,
amplitude=-30000.)
sin_data = wgen.sinwave()
pulse_data = wgen.pulsewave()
tri_data = wgen.triwave()
saw_data = wgen.sawwave()
awg_data = sin_data
mac_wav_data = sin_data + pulse_data + tri_data + saw_data
adc_cap_len = ADC_SAMPLES * 2 # 16-bit signed integer
dac_words = int(DAC_SAMPLES / 8)
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(0, tile, block, 0.0, 0.0, 2, 2, 0,
3, 0)
rft.command.ResetNCOPhase(0, tile, block)
rft.command.UpdateEvent(0, tile, block, 1)
rft.command.SetupFIFO(0, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, 1)
rft.command.SetFabClkOutDiv(0, tile, 2)
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(0, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, 1)
rft.command.SetFabClkOutDiv(1, tile, 1)
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
print("Send DAC AWG waveform data / parameters.")
## Write waveform data / trigger parameters for DAC AWG
rft.if_data.WriteDataToMemory(1, CH_AWG_CAP, len(awg_data), awg_data)
dac_awg_params = np.array([0, dac_words] * 16, dtype="<i4")
dac_awg_params_b = nu.real_to_bytes_32(dac_awg_params)
rft.if_data.WriteDataToMemory(5, CH_AWG_CAP, len(dac_awg_params_b),
dac_awg_params_b)
print("Send waveform data for DAC Waveform selector.")
## Write waveform data / trigger parameters for DAC Waveform selector
# 4 patterns output
rft.if_data.WriteDataToMemory(1, CH_TEST_MAC, len(mac_wav_data),
mac_wav_data)
print("Set trigger parameters.")
# Set parameters for ADC/DAC-BRAM Bridge controller
rft.command.SetTriggerInfo(0, ((0x1 << CH_TEST_MAC) |
(0x1 << CH_AWG_CAP)), ADC_SAMPLES, 0)
rft.command.SetTriggerLatency(0, 48)
rft.command.SetTriggerCycle(32768 * 32, 1)
rft.command.SetMACConfig(0xFF,
0x00) # all ADC channels is 12-bit format
# do not trigger all DACs when MAC is overrange
print("Start Trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
# Get RFDC ADC interrupt flags / overvoltage detection
adc_test_ch_flags = rft.command.GetIntrStatus(0,
(CH_TEST_MAC >> 1) & 0x3,
CH_TEST_MAC & 0x1)[3]
adc_cap_ch_flags = rft.command.GetIntrStatus(0,
(CH_AWG_CAP >> 1) & 0x3,
CH_AWG_CAP & 0x1)[3]
check_adc_overvoltage(adc_test_ch_flags, CH_TEST_MAC)
check_adc_overvoltage(adc_cap_ch_flags, CH_AWG_CAP)
print("Receive ADC MAC channel capture data.")
# Get ADC capture data of test channel
adc_mac_capdata = rft.if_data.ReadDataFromMemory(
0, CH_TEST_MAC * 2, adc_cap_len)
adc_awg_force_captures = []
for sel_pattern in [0, 1, 2, 3]:
print("Set force DAC Waveform selector output pattern {}".format(
sel_pattern))
dac_sel_params = np.array([sel_pattern * dac_words, dac_words] *
16,
dtype="<i4")
dac_sel_params_b = nu.real_to_bytes_32(dac_sel_params)
rft.if_data.WriteDataToMemory(5, CH_TEST_MAC,
len(dac_sel_params_b),
dac_sel_params_b)
print("Start Trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
# Get RFDC ADC interrupt flags / overvoltage detection
adc_test_ch_flags = rft.command.GetIntrStatus(
0, (CH_TEST_MAC >> 1) & 0x3, CH_TEST_MAC & 0x1)[3]
check_adc_overvoltage(adc_test_ch_flags, CH_TEST_MAC)
adc_cap_ch_flags = rft.command.GetIntrStatus(
0, (CH_AWG_CAP >> 1) & 0x3, CH_AWG_CAP & 0x1)[3]
check_adc_overvoltage(adc_cap_ch_flags, CH_AWG_CAP)
print("Receive ADC capture data for DAC Waveform selector output.")
adc_awg_capdata_force = rft.if_data.ReadDataFromMemory(
0, CH_AWG_CAP * 2, adc_cap_len)
adc_awg_capsample_force = np.array(
nu.bytes_to_real(adc_awg_capdata_force)) / 16
check_low_input_signal(adc_awg_capsample_force, CH_AWG_CAP)
adc_awg_force_captures.append(adc_awg_capsample_force)
print("Disconnect from server.")
adc_mac_capsample = np.array(
nu.bytes_to_real(adc_mac_capdata)) / 16 # conv. 12-bit integer
check_low_input_signal(adc_mac_capsample, CH_TEST_MAC)
print("Prepare MAC multiplied coefficients for self-test.")
require_mac_val = [-25165824, -8388608, 8388608, 25165824]
mac_cap_sq_sum = np.dot(1. * adc_mac_capsample, adc_mac_capsample)
multiplied_samples = [
np.round((rq / mac_cap_sq_sum) * adc_mac_capsample).astype("<i4")
for rq in require_mac_val
]
# print("mac_cap_sq_sum: {}".format(mac_cap_sq_sum))
# print("require_mac_val / mac_cap_sq_sum = {}".format(np.array(require_mac_val) / mac_cap_sq_sum))
print("MAC multiplied coefficients .max={0}, min={1}".format(
np.max(multiplied_samples), np.min(multiplied_samples)))
multiplied_data = [nu.real_to_bytes_32(smp) for smp in multiplied_samples]
mac_comp_coeff = np.array([-16777216, 0, 16777216], dtype="<i4")
mac_comp_coeff_b = nu.real_to_bytes_32(mac_comp_coeff)
with client.RftoolClient(logger=logger) as rft:
print("Re-connect to ZCU111 RFTOOL server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
# Clear all ADC interrupt flags
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
print("Send ADC MAC result comparation coefficient data.")
## Write comparation coefficients for ADC MAC
rft.if_data.WriteDataToMemory(4, CH_TEST_MAC * 2,
len(mac_comp_coeff_b), mac_comp_coeff_b)
print("Set DAC Waveform selector parameters.")
dac_sel_params = np.array(
[
0 * dac_words,
dac_words, # sine
1 * dac_words,
dac_words, # pulse
2 * dac_words,
dac_words, # triangle
3 * dac_words,
dac_words, # sawtooth
] * 4,
dtype="<i4")
dac_sel_params_b = nu.real_to_bytes_32(dac_sel_params)
rft.if_data.WriteDataToMemory(5, CH_TEST_MAC, len(dac_sel_params_b),
dac_sel_params_b)
rft.command.SetTriggerCycle(3, 1)
adc_awg_result_captures = []
adc_mac_actual_captures = []
for sel_pattern in [0, 1, 2, 3]:
print(
"Send ADC MAC multiplied coefficient data where DAC Waveform selector output to be pattern {}."
.format(sel_pattern))
## Write Multiplied coefficients for ADC MAC
rft.if_data.WriteDataToMemory(3, CH_TEST_MAC * 2,
len(multiplied_data[sel_pattern]),
multiplied_data[sel_pattern])
print("Start trigger BRAM Bridge controller.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
mac_ovrrange = rft.command.GetAccumulateOverrange()
check_mac_overrange(mac_ovrrange, CH_TEST_MAC)
# Get RFDC ADC interrupt flags / overvoltage detection
adc_test_ch_flags = rft.command.GetIntrStatus(
0, (CH_TEST_MAC >> 1) & 0x3, CH_TEST_MAC & 0x1)[3]
check_adc_overvoltage(adc_test_ch_flags, CH_TEST_MAC)
adc_cap_ch_flags = rft.command.GetIntrStatus(
0, (CH_AWG_CAP >> 1) & 0x3, CH_AWG_CAP & 0x1)[3]
check_adc_overvoltage(adc_cap_ch_flags, CH_AWG_CAP)
print(
"Receive ADC capture data for DAC Waveform selector output validation."
)
# Get ADC capture data of test channel
adc_awg_result_capdata = rft.if_data.ReadDataFromMemory(
0, CH_AWG_CAP * 2, adc_cap_len)
adc_awg_result_capsample = np.array(
nu.bytes_to_real(adc_awg_result_capdata)) / 16
check_low_input_signal(adc_awg_result_capsample, CH_AWG_CAP)
adc_awg_result_captures.append(adc_awg_result_capsample)
print("Receive ADC MAC channel actual capture data.")
# Get ADC capture data of test channel
adc_mac_actual_capdata = rft.if_data.ReadDataFromMemory(
0, CH_TEST_MAC * 2, adc_cap_len)
adc_mac_actual_capsample = np.array(
nu.bytes_to_real(adc_mac_actual_capdata)) / 16
check_low_input_signal(adc_mac_actual_capsample, CH_TEST_MAC)
adc_mac_actual_captures.append(adc_mac_actual_capsample)
print("Disconnect from server.")
time_dac = np.linspace(0.,
DAC_SAMPLES / DAC_FREQ,
DAC_SAMPLES,
endpoint=False) # us
time_adc = np.linspace(0.,
ADC_SAMPLES / DAC_FREQ,
ADC_SAMPLES,
endpoint=False) # us
validation_res = False
os.makedirs(PLOT_DIR, exist_ok=True)
for sel_pattern in [0, 1, 2, 3]:
print("Validation DAC Waveform selector output pattern {}".format(
sel_pattern))
expected_mac_result = np.dot(adc_mac_capsample,
multiplied_samples[sel_pattern])
print(" Expected MAC Result = {}".format(expected_mac_result))
actual_mac_result = np.dot(adc_mac_actual_captures[sel_pattern],
multiplied_samples[sel_pattern])
print(" Actual last MAC Result = {}".format(actual_mac_result))
adc_awg_error = np.abs(adc_awg_result_captures[sel_pattern] -
adc_awg_force_captures[sel_pattern])
adc_awg_error_sum = np.sum(adc_awg_error)
print(" DAC Waveform selector output error sum. = {}".format(
adc_awg_error_sum))
if adc_awg_error_sum < ERR_THRESHOLD:
print(
"Validate DAC Waveform selector output pattern {} successful.".
format(sel_pattern))
else:
print("Validate DAC Waveform selector output pattern {} failed.".
format(sel_pattern))
validation_res = True
print("Generate graph image.")
fig = plt.figure(figsize=(8, 6), dpi=300)
plt.xlabel("Time [us]")
plt.title(
"ADC capture DAC Sel. output Pattern {2} ({0} samples, {1} Msps)".
format(ADC_SAMPLES, ADC_FREQ, sel_pattern))
plt.plot(time_adc,
adc_awg_force_captures[sel_pattern],
linewidth=0.8,
label="Expected")
plt.plot(time_adc,
adc_awg_result_captures[sel_pattern],
linewidth=0.8,
label="Actual")
plt.legend()
plt.savefig(PLOT_DIR +
"adc_cap_dacsel_pattern_{}.png".format(sel_pattern))
fig = plt.figure(figsize=(8, 6), dpi=300)
plt.xlabel("Time [us]")
plt.title(
"ADC capture DAC AWG output Pattern {2} ({0} samples, {1} Msps)".
format(ADC_SAMPLES, ADC_FREQ, sel_pattern))
plt.plot(time_adc, adc_mac_capsample, linewidth=0.8, label="Expected")
plt.plot(time_adc,
adc_mac_actual_captures[sel_pattern],
linewidth=0.8,
label="Actual")
plt.legend()
plt.savefig(PLOT_DIR +
"adc_cap_awg_pattern_{}.png".format(sel_pattern))
print("Done.")
return validation_res
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
if fpga_design != MTS:
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# Multi Tile Synchronization
if fpga_design == MTS:
rft.awg_sa_cmd.sync_dac_tiles()
rft.awg_sa_cmd.sync_adc_tiles()
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
start_awg_and_capture(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
print("Get capture data.")
nu = ndarrayutil.NdarrayUtil
awg_id_to_wave_samples = {}
for awg_id in awg_list:
wave_data = rft.awg_sa_cmd.read_capture_data(awg_id, step_id=0)
awg_id_to_wave_samples[awg_id] = nu.bytes_to_real_32(wave_data)
# キャプチャデータ出力
print("Output capture data.")
for awg_id, wave_samples in awg_id_to_wave_samples.items():
start = int(OUTPUT_START * ADC_FREQ / 1000)
end = start + int(OUTPUT_DURATION * ADC_FREQ / 1000)
output_graphs((awg_id, 0, wave_samples[start:end], "whole"))
for awg_id, wave_samples in awg_id_to_wave_samples.items():
start = int(CLIPPING_START * ADC_FREQ / 1000)
end = start + int(CLIPPING_DURATION * ADC_FREQ / 1000)
output_graphs((awg_id, 0, wave_samples[start:end], "part"))
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR +
"waveform/actual_awg_{}_waveform.png".format(awg_id))
awg_id_to_wave_sequence[awg_id].get_waveform_sequence(
).save_as_img(
PLOT_DIR +
"waveform/user_def_awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main(num_trig):
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES,
dac_freq=DAC_FREQ,
carrier_freq=20.,
amplitude=30000.0)
sin_wave = nu.bytes_to_real(wgen.sinwave())
amplitude = np.linspace(-1., 1., DAC_SAMPLES, endpoint=False)
w_data = (sin_wave * amplitude).reshape(1, -1)[0].astype("<i2").tobytes()
del sin_wave, amplitude
w_size = len(w_data) # for 16bit signed integer
r_size = ADC_SAMPLES * 4 # for 32bit signed integer
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(0, tile, block, 0.0, 0.0, 2, 2, 0,
3, 0)
rft.command.ResetNCOPhase(0, tile, block)
rft.command.UpdateEvent(0, tile, block, 1)
rft.command.SetupFIFO(0, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(0, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(0, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(1, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerInfo(0, 0xFF, ADC_SAMPLES, 0)
rft.command.SetTriggerInfo(1, 0xFF, DAC_SAMPLES, 0)
rft.command.SetTriggerLatency(0, 97)
rft.command.SetTriggerLatency(1, 0)
rft.command.SetTriggerCycle(32768, 1) # trigger 32768 times
rft.command.SetAccumulateMode(0) # disable accumulation
print("Configure PMOD.")
# 4 つの PMOD 出力データ (0xAA, 0xBB, 0xCC, xDD) を設定
rft.if_data.WriteDataToMemory(2, 0, 4, b"\xAA\xBB\xCC\xDD")
rft.command.SetPMODConfig(
bit_to_enable=0xFF, # 全 PMOD の出力 bit を有効にする
num_samples=4, # 出力されるサンプル数 (1サンプル = 8 bit)
latency=0, # トリガーレイテンシ
divratio=32, # 1 サンプルの出力が保持される長さ (DAC tile 1 のサンプリングレートに依存)
polarity=0x0F) # 下位 4 bit の PMOD 出力を反転する
print("Start trigger.")
rft.command.StartTrigger() # for ADC calibration
wait_trig_done(rft.command)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerCycle(num_trig, 1)
rft.command.SetAccumulateMode(1) # enable accumulation
print("Start trigger.")
rft.command.StartTrigger() # for ADC accumualtion
wait_trig_done(rft.command)
r_data = []
for ch in [0, 1]:
print("Receive waveform data from ADC Ch.{} BlockRAM".format(ch))
r_data.append(rft.if_data.ReadDataFromMemory(0, ch, r_size))
print("Check interrupt flags.")
for ch in range(8): # ADC
check_intr_flags(rft.command, 0, ch)
for ch in range(8): # DAC
check_intr_flags(rft.command, 1, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data)
del w_data
print("- ADC sample data")
r_sample = np.array([nu.bytes_to_real_32(rd) for rd in r_data])
del r_data
print("Generating graph image.")
os.makedirs(PLOT_DIR + str(num_trig) + "/", exist_ok=True)
print("- entire DAC")
plot_graph_entire(
DAC_FREQ, w_sample, "C0",
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
PLOT_DIR + str(num_trig) + "/bram_send.png")
print("- crop DAC")
plot_graph_crop(
DAC_FREQ, w_sample, "C0", "DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ), PLOT_DIR + str(num_trig) + "/bram_send_crop.png")
print("- FFT DAC")
plot_graph_fft(
DAC_FREQ, w_sample, "C0",
"DAC FFT, {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
PLOT_DIR + str(num_trig) + "/bram_send_fft.png")
for ch in [0, 1]:
print("- entire ADC Ch.{}".format(ch))
plot_graph_entire(
ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples, {} Msps({} times accum.)".format(
ADC_SAMPLES, ADC_FREQ, str(num_trig)),
PLOT_DIR + str(num_trig) + "/bram_recv_{}.png".format(ch))
print("- crop ADC Ch.{}".format(ch))
plot_graph_crop(
ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples{}, {} Msps({} times accum.)".format(
ADC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0],
CROP_PLOT[1]), ADC_FREQ,
str(num_trig)),
PLOT_DIR + str(num_trig) + "/bram_recv_{}_crop.png".format(ch))
print("- FFT ADC Ch.{}".format(ch))
plot_graph_fft(
ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC FFT {} samples, {} Msps({} times accum.)".format(
ADC_SAMPLES, ADC_FREQ, str(num_trig)),
PLOT_DIR + str(num_trig) + "/bram_recv_{}_fft.png".format(ch))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
start_awg_and_capture(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータの取得と出力
nu = ndarrayutil.NdarrayUtil
for awg_id in awg_list:
print("Get capture {} data.".format(awg_id))
for step_id in [0, 1]:
wave_data = rft.awg_sa_cmd.read_capture_data(awg_id,
step_id=step_id)
wave_samples = nu.bytes_to_real_32(wave_data)
num_output_samples = int(
8 * (ADC_FREQ / awg_to_freq[awg_id][step_id]))
wave_samples = wave_samples[0:num_output_samples]
output_graphs((awg_id, step_id, wave_samples))
# スペクトラム取得
num_frames = 1
start_sample_idx = 0 # FFT 開始サンプルのインデックス
fft_size = rft.awg_sa_cmd.get_fft_size()
for awg_id in awg_list:
print("Get capture {} spectrums.".format(awg_id))
for step_id in [0, 1]:
spectrum = rft.awg_sa_cmd.get_spectrum(
awg_id,
step_id=step_id,
start_sample_idx=start_sample_idx,
num_frames=num_frames,
is_iq_data=False)
output_spectrum_data(awg_id, step_id, spectrum, num_frames,
fft_size)
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# Multi Tile Synchronization
rft.awg_sa_cmd.sync_dac_tiles()
rft.awg_sa_cmd.sync_adc_tiles()
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
rft.awg_sa_cmd.start_wave_sequence()
# 終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd, awg_list)
# エラーチェック
print("Check for errors")
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
print("Get capture data.")
nu = ndarrayutil.NdarrayUtil
awg_id_to_wave_samples = {}
for awg_id in awg_list:
wave_data = rft.awg_sa_cmd.read_capture_data(awg_id, step_id=0)
awg_id_to_wave_samples[awg_id] = nu.bytes_to_real_32(wave_data)
# キャプチャデータ出力
print("Output capture data.")
for awg_id, wave_samples in awg_id_to_wave_samples.items():
output_graphs((awg_id, 0, wave_samples))
# スペクトラム取得
print("Get spectrums.")
num_frames = 1
start_sample_idx = 1024 # FFT 開始サンプルのインデックス
fft_size = rft.awg_sa_cmd.get_fft_size()
awg_id_to_spectrum = {}
for awg_id in awg_list:
awg_id_to_spectrum[awg_id] = rft.awg_sa_cmd.get_spectrum(
awg_id,
step_id=1,
start_sample_idx=start_sample_idx,
num_frames=num_frames,
is_iq_data=False)
print("Output spectrums.")
# スペクトラム出力
output_spectrum_data(awg_id_to_spectrum, num_frames, 1, fft_size)
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
nu = ndarrayutil.NdarrayUtil
print("Generating waveform data.")
r_cycles = np.round(CHUNK_SAMPLES * 20.0 / EFF_DAC_FREQ) # aprox. 20 MHz
omega = 2. * np.pi * np.linspace(
0., r_cycles, CHUNK_SAMPLES, endpoint=False)
amplitude = np.linspace(-20000., 20000., DATA_DEVIDES, endpoint=False)
sin_wave = np.sin(omega)
cos_wave = np.cos(omega)
interleaved_wave = np.array([sin_wave, cos_wave]).T.reshape(1, -1)
w_data = np.multiply(interleaved_wave,
np.array([amplitude]).T).reshape(
1, -1)[0].astype("<i2").tobytes()
del r_cycles, sin_wave, cos_wave, amplitude, interleaved_wave
w_size = len(w_data)
r_size = ADC_SAMPLES * 4
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(0, tile, block, NCO_FREQ,
NCO_PHASE, 2, 2, 0, 3, 0)
rft.command.ResetNCOPhase(0, tile, block)
rft.command.UpdateEvent(0, tile, block, 1)
rft.command.SetupFIFO(0, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(0, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(0, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, NCO_FREQ,
NCO_PHASE, 2, 2, 0, 2, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(1, tile,
1 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} DynamicRAM".format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerInfo(1, 0xC0, DAC_SAMPLES, 1)
rft.command.SetTriggerInfo(0, 0x03, ADC_SAMPLES, 1)
rft.command.SetTriggerLatency(1, 0)
rft.command.SetTriggerLatency(0, 40)
print("Start trigger.")
rft.command.StartTrigger()
print("Receive waveform data from ADC Ch.{} DynamicRAM".format(0))
r_data_0 = rft.if_data.ReadDataFromMemory(0, 0, r_size)
print("Receive waveform data from ADC Ch.{} DynamicRAM".format(1))
r_data_1 = rft.if_data.ReadDataFromMemory(0, 1, r_size)
print("Check interrupt flags.")
for ch in range(8): # ADC
check_intr_flags(rft.command, 0, ch)
for ch in range(8): # DAC
check_intr_flags(rft.command, 1, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_complex(w_data)
del w_data
print("- ADC sample data")
r_sample = [nu.bytes_to_complex(r_data_0), nu.bytes_to_complex(r_data_1)]
del r_data_0, r_data_1
print("Generating graph image.")
os.makedirs(PLOT_DIR, exist_ok=True)
print("- entire DAC")
plot_graph_entire(
EFF_DAC_FREQ, w_sample, "C0",
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
"dram_iq_send.png")
print("- crop DAC")
plot_graph_crop(
EFF_DAC_FREQ, w_sample, "C0",
"DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ), "dram_iq_send_crop.png")
print("- FFT DAC")
plot_graph_fft(
EFF_DAC_FREQ, w_sample, "C0",
"DAC FFT (size:{} peak-holded), {} samples, {} Msps({}x DUC)".format(
FFT_SIZE, DAC_SAMPLES, DAC_FREQ,
DUC_DDC_FACTOR), "dram_iq_send_fft.png")
for ch in range(2):
print("- entire ADC Ch.{}".format(ch))
plot_graph_entire(
EFF_ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples, {} Msps({}x DDC)".format(
ADC_SAMPLES, ADC_FREQ,
DUC_DDC_FACTOR), "dram_iq_recv_{}.png".format(ch))
print("- crop ADC Ch.{}".format(ch))
plot_graph_crop(
EFF_ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples{}, {} Msps({}x DDC)".format(
ADC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0],
CROP_PLOT[1]), ADC_FREQ,
DUC_DDC_FACTOR), "dram_iq_recv_{}_crop.png".format(ch))
print("- FFT ADC Ch.{}".format(ch))
plot_graph_fft(
EFF_ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC FFT (size:{} peak-holded), {} samples, {} Msps({}x DDC)".
format(FFT_SIZE, ADC_SAMPLES, ADC_FREQ,
DUC_DDC_FACTOR), "dram_iq_recv_{}_fft.png".format(ch))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
start_awg_and_capture(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータのアドレスとサイズを指定してキャプチャデータを取得する
print("Get capture data.")
nu = ndarrayutil.NdarrayUtil
awg_id_to_wave_samples = {}
for awg_id in awg_list:
(addr, size) = rft.awg_sa_cmd.get_capture_section_info(awg_id,
step_id=0)
capture_data_0 = rft.awg_sa_cmd.read_dram(addr, size)
(addr, size) = rft.awg_sa_cmd.get_capture_section_info(awg_id,
step_id=1)
capture_data_1 = rft.awg_sa_cmd.read_dram(addr, size)
awg_id_to_wave_samples[awg_id] = (
nu.bytes_to_real_32(capture_data_0),
nu.bytes_to_real_32(capture_data_1))
# キャプチャデータ出力
print("Output capture data.")
for awg_id, wave_samples in awg_id_to_wave_samples.items():
output_graphs((awg_id, 0, wave_samples[0]),
(awg_id, 1, wave_samples[1]))
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
nu = ndarrayutil.NdarrayUtil
print("Generating waveform data.")
r_cycles = np.round(CHUNK_SAMPLES * 20.0 / DAC_FREQ) # aprox. 20 MHz
sin_wave = np.array([
np.sin(2. * np.pi *
np.linspace(0., r_cycles, CHUNK_SAMPLES, endpoint=False))
])
amplitude = np.linspace(-30000,
30000,
DATA_DEVIDES,
endpoint=False,
dtype="int16")
w_data_0 = np.multiply(sin_wave,
np.array([amplitude]).T).reshape(
1, -1)[0].astype("<i2").tobytes()
w_data_1 = np.multiply(sin_wave,
np.array([-amplitude]).T).reshape(
1, -1)[0].astype("<i2").tobytes()
del r_cycles, sin_wave, amplitude
w_size = len(w_data_0)
print("Processing sample data.")
print("- DAC sample data")
w_sample = [nu.bytes_to_real(w_data_0), nu.bytes_to_real(w_data_1)]
print("Generating graph image.")
os.makedirs(PLOT_DIR, exist_ok=True)
for ch in range(2):
print("- entire DAC Ch.{}".format(ch + 6))
plot_graph_entire(
DAC_FREQ, w_sample[ch], "C{}".format(ch),
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
"dram_send_{}.png".format(ch))
print("- crop DAC Ch.{}".format(ch + 6))
plot_graph_crop(
DAC_FREQ, w_sample[ch], "C{}".format(ch),
"DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0],
CROP_PLOT[1]),
DAC_FREQ), "dram_send_{}_crop.png".format(ch))
print("- FFT DAC Ch.{}".format(ch + 6))
plot_graph_fft(
DAC_FREQ, w_sample[ch], "C{}".format(ch),
"DAC FFT (size:{} peak-holded), {} samples, {} Msps".format(
FFT_SIZE, DAC_SAMPLES,
DAC_FREQ), "dram_send_{}_fft.png".format(ch))
del w_sample
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(1, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
print("Send waveform data to DAC Ch.{} DynamicRAM".format(6))
rft.if_data.WriteDataToMemory(1, 6, w_size, w_data_0)
print("Send waveform data to DAC Ch.{} DynamicRAM".format(7))
rft.if_data.WriteDataToMemory(1, 7, w_size, w_data_1)
print("Setting trigger information.")
rft.command.SetTriggerInfo(1, 0xC0, DAC_SAMPLES, 0)
rft.command.SetTriggerInfo(0, 0x00, 0, 0)
rft.command.SetTriggerLatency(1, 0)
kpmon_thread = threading.Thread(target=keypress_mon)
kpmon_thread.start()
print("\r\n --- Press Enter to stop triggering --- \r\n")
while not is_keypressed:
rft.command.StartTrigger()
time.sleep(1.)
print("Check interrupt flags.")
for ch in range(8): # DAC
check_intr_flags(rft.command, 1, ch)
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# AWG の波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# トリガモードの設定
for awg_id, trigger_mode in awg_to_trigger_mode.items():
rft.awg_sa_cmd.set_trigger_mode(awg_id, trigger_mode)
# AWG 4 にマニュアルトリガを発行して, 波形の出力を開始する.
start_awg_and_capture(rft.awg_sa_cmd)
# 外部トリガ設定 & 起動
# 外部トリガモジュールは起動後すぐに, 出力中の AWG 4 の波形を読み取って外部トリガを発行する.
# その結果, AWG 0 ～ 3, 5 ～ 7 が起動して波形の出力とキャプチャが始まる.
start_external_trigger(rft.awg_sa_cmd)
# 波形キャプチャ終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd, *awg_list)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd, awg_id_to_wave_sequence)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd,
awg_id_to_wave_sequence)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
print("Get capture data.")
nu = ndarrayutil.NdarrayUtil
awg_id_to_wave_samples = {}
for awg_id, wave_sequence in awg_id_to_wave_sequence.items():
step_id_list = wave_sequence.get_step_id_list()
wave_data = rft.awg_sa_cmd.read_capture_data(
awg_id, step_id=step_id_list[0])
awg_id_to_wave_samples[awg_id] = nu.bytes_to_real_32(wave_data)
# キャプチャデータ出力
print("Output capture data.")
for awg_id, wave_samples in awg_id_to_wave_samples.items():
output_graphs((awg_id, 0, wave_samples))
# スペクトラム取得
print("Get spectrums.")
num_frames = 1
start_sample_idx = 16 # FFT 開始サンプルのインデックス
fft_size = rft.awg_sa_cmd.get_fft_size()
awg_id_to_spectrum = {}
for awg_id, wave_sequence in awg_id_to_wave_sequence.items():
if (wave_sequence.num_wave_steps() >= 2):
step_id_list = wave_sequence.get_step_id_list()
awg_id_to_spectrum[awg_id] = rft.awg_sa_cmd.get_spectrum(
awg_id,
step_id=step_id_list[1],
start_sample_idx=start_sample_idx,
num_frames=num_frames,
is_iq_data=False)
# スペクトラム出力
print("Output spectrums.")
output_spectrum_data(awg_id_to_spectrum, num_frames, 1, fft_size)
# 送信波形をグラフ化
for awg_id in awg_list:
if awg_to_trigger_mode[awg_id] == awgsa.TriggerMode.MANUAL:
continue
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(
PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
shutdown_all_tiles(rft.command)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
startup_all_tiles(rft.command)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(*awg_list)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
awg_id_to_wave_sequence = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, awg_id_to_wave_sequence)
# 波形出力 & キャプチャスタート
start_awg_and_capture(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
print("Get capture data.")
awg_id_to_wave_data = {}
for awg_id in awg_list:
awg_id_to_wave_data[awg_id] = rft.awg_sa_cmd.read_capture_data(awg_id, step_id = 0)
# キャプチャデータ出力
print("Output capture data.")
num_frames = 1
start_sample_idx = 1024 # FFT 開始サンプルのインデックス
fft_size = rft.awg_sa_cmd.get_fft_size()
output_capture_data(awg_id_to_wave_data, num_frames, start_sample_idx, fft_size)
# スペクトラム取得
print("Get spectrums.")
awg_id_to_spectrum = {}
for awg_id in awg_list:
awg_id_to_spectrum[awg_id] = rft.awg_sa_cmd.get_spectrum(
awg_id, step_id = 0,
start_sample_idx = start_sample_idx, num_frames = num_frames, is_iq_data = True)
# スペクトラム出力
print("Output spectrums.")
output_spectrum_data(awg_id_to_spectrum, num_frames, 0, fft_size)
# 送信波形をグラフ化
for awg_id in awg_list:
rft.awg_sa_cmd.get_waveform_sequence(awg_id).save_as_img(PLOT_DIR + "waveform/awg_{}_waveform.png".format(awg_id))
print("Done.")
return
def main():
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
# 送信する波の形状をサンプリングレートによらず一定にするため, dac_freq = 4096.0 で固定
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES,
dac_freq=4096.0,
carrier_freq=1.0,
amplitude=30000.0)
sin_wave = nu.bytes_to_real(wgen.sinwave())
amplitude = np.linspace(-1., 1., DAC_SAMPLES, endpoint=False)
w_data = (sin_wave * amplitude).reshape(1, -1)[0].astype("<i2").tobytes()
del sin_wave, amplitude
w_size = len(w_data) # for 16bit signed integer
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("set sampling rate.")
set_dac_sampling_rate(rft.command, DAC_FREQ)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(DAC, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(DAC, tile, block)
rft.command.UpdateEvent(DAC, tile, block, 1)
rft.command.SetupFIFO(DAC, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(DAC, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(DAC, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(DAC, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in range(8):
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(DAC, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerInfo(DAC, 0xFF, DAC_SAMPLES, USE_REAL)
rft.command.SetTriggerLatency(DAC, 0)
rft.command.SetTriggerCycle(1, 1)
print("Start trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
print("Check interrupt flags.")
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data)
del w_data
print("Generating graph image.")
os.makedirs(PLOT_DIR, exist_ok=True)
print("- entire DAC")
plot_graph_entire(
DAC_FREQ, w_sample, CHUNK_DAC_PLOT, "C0",
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES,
DAC_FREQ), "bram_send.png")
print("- crop DAC")
plot_graph_crop(
DAC_FREQ, w_sample, "C0", "DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ), "bram_send_crop.png")
print("- FFT DAC")
plot_graph_fft(
DAC_FREQ, w_sample, "C0",
"DAC FFT, {} samples, {} Msps".format(DAC_SAMPLES,
DAC_FREQ), "bram_send_fft.png")
print("Done.")
return
def main():
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES, dac_freq=DAC_FREQ,
carrier_freq=30.0, amplitude=30000.0)
w_data = wgen.sinwave()
w_size = len(w_data) # for 16bit signed integer
r_size = ADC_SAMPLES * 4 * 2 # for two 32bit signed integer values (I Data and Q Data)
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("set sampling rate.")
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(ADC, tile, block, 10, 45.0,
2, 2, 16, 3, 0)
rft.command.ResetNCOPhase(ADC, tile, block)
rft.command.UpdateEvent(ADC, tile, block, 1)
rft.command.SetupFIFO(ADC, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block, 1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(ADC, tile, 2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1]:
rft.command.IntrClr(ADC, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(ADC, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(DAC, tile, block, 0.0, 0.0,
2, 1, 16, 4, 0)
rft.command.ResetNCOPhase(DAC, tile, block)
rft.command.UpdateEvent(DAC, tile, block, 1)
rft.command.SetupFIFO(DAC, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(DAC, tile, 2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(DAC, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(DAC, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(DAC, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerInfo(ADC, 0xFF, ADC_SAMPLES, USE_IQ)
rft.command.SetTriggerInfo(DAC, 0xFF, DAC_SAMPLES, USE_REAL)
rft.command.SetTriggerLatency(ADC, 45)
rft.command.SetTriggerLatency(DAC, 0)
rft.command.SetTriggerCycle(1, 1)
rft.command.SetAccumulateMode(0) # disable accumulation
print("Start trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
r_data = []
for ch in [0, 1]:
print("Receive waveform data from ADC Ch.{} BlockRAM".format(ch))
r_data.append(rft.if_data.ReadDataFromMemory(ADC, ch, r_size))
print("Check interrupt flags.")
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data)
del w_data
print("- ADC sample data")
r_sample = np.array([nu.bytes_to_complex_32(rd) for rd in r_data])
del r_data
print("Generating graph image.")
os.makedirs(PLOT_DIR, exist_ok=True)
print("- entire DAC")
plot_graph_entire(
DAC_FREQ,
w_sample,
1,
"C0",
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
"bram_send.png"
)
print("- crop DAC")
plot_graph_crop(
DAC_FREQ,
w_sample,
"C0",
"DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES,
" (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ),
"bram_send_crop.png"
)
print("- FFT DAC")
plot_graph_fft(
DAC_FREQ,
w_sample,
"C0",
"DAC FFT, {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
"bram_send_fft.png"
)
for ch in range(2):
print("- entire ADC Ch.{}".format(ch))
plot_graph_entire_iq(
ADC_FREQ,
r_sample[ch],
1,
"C{}".format(ch + 1),
"ADC waveform {} samples, {} Msps".format(ADC_SAMPLES, ADC_FREQ),
"bram_recv_{}.png".format(ch)
)
print("- crop ADC Ch.{}".format(ch))
plot_graph_crop_iq(
ADC_FREQ,
r_sample[ch],
"C{}".format(ch + 1),
"ADC waveform {} samples{}, {} Msps".format(
ADC_SAMPLES,
" (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
ADC_FREQ),
"bram_recv_{}_crop.png".format(ch)
)
print("- FFT ADC Ch.{}".format(ch))
plot_graph_fft_iq(
ADC_FREQ,
r_sample[ch],
"C{}".format(ch + 1),
"ADC FFT {} samples, {} Msps".format(ADC_SAMPLES, ADC_FREQ),
"bram_recv_{}_fft.png".format(ch)
)
print("Done.")
return
def main(num_trig):
nu = ndarrayutil.NdarrayUtil
print("Generating waveform data.")
r_cycles = np.round(CHUNK_SAMPLES * 20 / DAC_FREQ) # aprox. 20 MHz
sin_wave = np.array([
np.sin(2. * np.pi *
np.linspace(0., r_cycles, CHUNK_SAMPLES, endpoint=False))
])
amplitude_0 = np.linspace(-30000,
30000,
DATA_DEVIDES,
endpoint=False,
dtype="int16")
amplitude_1 = np.linspace(-3000,
3000,
DATA_DEVIDES,
endpoint=False,
dtype="int16")
w_data_0 = np.multiply(sin_wave,
np.array([amplitude_0]).T).reshape(
1, -1)[0].astype("<i2").tobytes()
del r_cycles, sin_wave, amplitude_0, amplitude_1
w_size = len(w_data_0)
r_size = ADC_SAMPLES * 4
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(ADC, tile, block, 0.0, 0.0, 2, 2,
0, 3, 0)
rft.command.ResetNCOPhase(ADC, tile, block)
rft.command.UpdateEvent(ADC, tile, block, 1)
rft.command.SetupFIFO(ADC, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(ADC, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1]:
rft.command.IntrClr(ADC, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(ADC, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(DAC, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(DAC, tile, block)
rft.command.UpdateEvent(DAC, tile, block, 1)
rft.command.SetupFIFO(DAC, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(DAC, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(DAC, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(DAC, tile, 1)
print("Send waveform data to DAC Ch.{} DynamicRAM".format(DAC_CH))
rft.if_data.WriteDataToMemory(DAC, DAC_CH, w_size, w_data_0)
rft.command.SetAccumulateMode(0) # disable accumulation
print("Setting trigger information.")
active_dac_ch_list = 1 << DAC_CH
active_adc_ch_list = 1 << ADC_CH
rft.command.SetTriggerInfo(DAC, active_dac_ch_list, DAC_SAMPLES,
USE_REAL)
rft.command.SetTriggerInfo(ADC, active_adc_ch_list, ADC_SAMPLES,
USE_REAL)
rft.command.SetTriggerLatency(
DAC, calc_trigger_wait_count(DAC_TRIGGER_LATENCY))
rft.command.SetTriggerLatency(
ADC, calc_trigger_wait_count(ADC_TRIGGER_LATENCY))
rft.command.SetTriggerCycle(2,
calc_trigger_wait_count(TRIGGER_INTERVAL))
print("Start trigger.")
rft.command.StartTrigger() # for ADC calibration
wait_trig_done(rft.command)
rft.command.SetAccumulateMode(1) # enable accumulation
rft.command.ClearDRAM(ADC)
rft.command.SetTriggerCycle(num_trig,
calc_trigger_wait_count(TRIGGER_INTERVAL))
rft.command.StartTrigger()
wait_trig_done(rft.command)
print("Receive waveform data from ADC Ch.{} DynamicRAM".format(ADC_CH))
r_data_0 = rft.if_data.ReadDataFromMemory(ADC, ADC_CH, r_size)
print("Check interrupt flags.")
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data_0)
del w_data_0
print("- ADC sample data")
r_sample = nu.bytes_to_real_32(r_data_0)
del r_data_0
print("Generating graph image.")
outputdir = PLOT_DIR + str(num_trig) + "/"
os.makedirs(outputdir, exist_ok=True)
print("- entire DAC Ch.{}".format(DAC_CH))
plot_graph_entire(
DAC_FREQ, w_sample, "C{}".format(DAC_CH),
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
outputdir + "dram_send_{}.png".format(DAC_CH))
print("- crop DAC Ch.{}".format(DAC_CH))
plot_graph_crop(
DAC_FREQ, w_sample, "C{}".format(DAC_CH),
"DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ), outputdir + "dram_send_{}_crop.png".format(DAC_CH))
print("- FFT DAC Ch.{}".format(DAC_CH))
plot_graph_fft(
DAC_FREQ, w_sample, "C{}".format(DAC_CH),
"DAC FFT (size:{} peak-holded), {} samples, {} Msps".format(
FFT_SIZE, DAC_SAMPLES,
DAC_FREQ), outputdir + "dram_send_{}_fft.png".format(DAC_CH))
print("- entire ADC Ch.{}".format(ADC_CH))
plot_graph_entire(
ADC_FREQ, r_sample, "C{}".format(ADC_CH),
"ADC waveform {} samples, {} Msps({} times accum.)".format(
ADC_SAMPLES, ADC_FREQ,
str(num_trig)), outputdir + "dram_recv_{}.png".format(ADC_CH))
print("- crop ADC Ch.{}".format(ADC_CH))
plot_graph_crop(
ADC_FREQ, r_sample, "C{}".format(ADC_CH),
"ADC waveform {} samples{}, {} Msps({} times accum.)".format(
ADC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0],
CROP_PLOT[1]), ADC_FREQ,
str(num_trig)), outputdir + "dram_recv_{}_crop.png".format(ADC_CH))
print("- FFT ADC Ch.{}".format(ADC_CH))
plot_graph_fft(
ADC_FREQ, r_sample, "C{}".format(ADC_CH),
"ADC FFT (size:{} peak-holded), {} samples, {} Msps({} times accum.)".
format(FFT_SIZE, ADC_SAMPLES, ADC_FREQ, str(num_trig)),
outputdir + "dram_recv_{}_fft.png".format(ADC_CH))
print("Done.")
return
def main(num_trig):
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES,
dac_freq=DAC_FREQ,
carrier_freq=64.,
amplitude=-30000.0)
w_data = wgen.sinwave()
w_size = len(w_data) # for 16bit signed integer
r_size = ADC_SAMPLES * 4 # for 32bit signed integer
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(0, tile, block, 0.0, 0.0, 2, 2, 0,
3, 0)
rft.command.ResetNCOPhase(0, tile, block)
rft.command.UpdateEvent(0, tile, block, 1)
rft.command.SetupFIFO(0, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(0, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(0, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, DUC_DDC_FACTOR)
rft.command.SetFabClkOutDiv(1, tile,
2 + int(np.log2(DUC_DDC_FACTOR)))
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerInfo(0, 0xFF, ADC_SAMPLES, 0)
rft.command.SetTriggerInfo(1, 0xFF, DAC_SAMPLES, 0)
rft.command.SetTriggerLatency(0, 97)
rft.command.SetTriggerLatency(1, 0)
rft.command.SetTriggerCycle(32768, 1) # trigger 32768 times
rft.command.SetAccumulateMode(0) # disable accumulation
print("Start trigger.")
rft.command.StartTrigger() # for ADC calibration
wait_trig_done(rft.command)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
for ch in [6, 7]:
print("Send waveform data to DAC Ch.{} BlockRAM".format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
print("Setting trigger information.")
rft.command.SetTriggerCycle(num_trig, 1)
rft.command.SetAccumulateMode(1) # enable accumulation
print("Start trigger.")
rft.command.StartTrigger() # for ADC accumualtion
wait_trig_done(rft.command)
r_data = []
for ch in [0, 1]:
print("Receive waveform data from ADC Ch.{} BlockRAM".format(ch))
r_data.append(rft.if_data.ReadDataFromMemory(0, ch, r_size))
print("Check interrupt flags.")
for ch in range(8): # ADC
check_intr_flags(rft.command, 0, ch)
for ch in range(8): # DAC
check_intr_flags(rft.command, 1, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data)
del w_data
print("- ADC sample data")
r_sample = np.array([nu.bytes_to_real_32(rd) for rd in r_data])
del r_data
print("Generating graph image.")
os.makedirs(PLOT_DIR + str(num_trig) + "/", exist_ok=True)
# print("- entire DAC")
# plot_graph_entire(
# DAC_FREQ,
# w_sample,
# "C0",
# "DAC waveform {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
# PLOT_DIR + str(num_trig) + "/bram_send.png"
# )
#
print("- crop DAC")
plot_graph_crop(
DAC_FREQ, w_sample, "C0", "DAC waveform {} samples{}, {} Msps".format(
DAC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0], CROP_PLOT[1]),
DAC_FREQ), PLOT_DIR + str(num_trig) + "/bram_send_crop.png")
#
# print("- FFT DAC")
# plot_graph_fft(
# DAC_FREQ,
# w_sample,
# "C0",
# "DAC FFT, {} samples, {} Msps".format(DAC_SAMPLES, DAC_FREQ),
# PLOT_DIR + str(num_trig) + "/bram_send_fft.png"
# )
for ch in [0, 1]:
# print("- entire ADC Ch.{}".format(ch))
# plot_graph_entire(
# ADC_FREQ,
# r_sample[ch],
# "C{}".format(ch + 1),
# "ADC waveform {} samples, {} Msps({} times accum.)".format(ADC_SAMPLES, ADC_FREQ, str(num_trig)),
# PLOT_DIR + str(num_trig) + "/bram_recv_{}.png".format(ch)
# )
print("- crop ADC Ch.{}".format(ch))
plot_graph_crop(
ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples{}, {} Msps({} times accum.)".format(
ADC_SAMPLES, " (crop {}-{})".format(CROP_PLOT[0],
CROP_PLOT[1]), ADC_FREQ,
str(num_trig)),
PLOT_DIR + str(num_trig) + "/bram_recv_{}_crop.png".format(ch))
# print("- FFT ADC Ch.{}".format(ch))
# plot_graph_fft(
# ADC_FREQ,
# r_sample[ch],
# "C{}".format(ch + 1),
# "ADC FFT {} samples, {} Msps({} times accum.)".format(ADC_SAMPLES, ADC_FREQ, str(num_trig)),
# PLOT_DIR + str(num_trig) + "/bram_recv_{}_fft.png".format(ch)
# )
print("Done.")
return
def main():
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
set_adc_sampling_rate(rft.command, ADC_FREQ)
set_dac_sampling_rate(rft.command, DAC_FREQ)
setup_dac(rft.command)
setup_adc(rft.command)
# 初期化
rft.awg_sa_cmd.initialize_awg_sa()
# AWG 有効化
rft.awg_sa_cmd.enable_awg(awgsa.AwgId.AWG_0)
# ADC キャリブレーション
calibrate_adc(rft.awg_sa_cmd)
# 波形シーケンス設定
wave_seq_0 = set_wave_sequence(rft.awg_sa_cmd)
# キャプチャシーケンス設定
set_capture_sequence(rft.awg_sa_cmd, wave_seq_0)
# 波形出力 & キャプチャスタート
rft.awg_sa_cmd.start_wave_sequence()
# 終了待ち
wait_for_sequence_to_finish(rft.awg_sa_cmd)
# エラーチェック
check_skipped_step(rft.awg_sa_cmd)
check_capture_data_fifo_oevrflow(rft.awg_sa_cmd)
for ch in range(8):
check_intr_flags(rft.command, ADC, ch)
for ch in range(8):
check_intr_flags(rft.command, DAC, ch)
# キャプチャデータ取得
iq_data_0 = rft.awg_sa_cmd.read_capture_data(awgsa.AwgId.AWG_0,
step_id=0)
# キャプチャデータ出力
num_frames = 3
start_sample_idx = 0 # FFT 開始サンプルのインデックス
fft_size = rft.awg_sa_cmd.get_fft_size()
awg_id_to_iq_data = {awgsa.AwgId.AWG_0: iq_data_0}
awg_id_to_wave_seq = {awgsa.AwgId.AWG_0: wave_seq_0}
output_capture_data(awg_id_to_iq_data, awg_id_to_wave_seq, num_frames,
start_sample_idx, fft_size)
# スペクトラム取得
spectrum_0 = rft.awg_sa_cmd.get_spectrum(
awgsa.AwgId.AWG_0,
step_id=0,
start_sample_idx=start_sample_idx,
num_frames=num_frames,
is_iq_data=True)
# スペクトラム出力
awg_id_to_spectrum = {awgsa.AwgId.AWG_0: spectrum_0}
output_spectrum_data(awg_id_to_spectrum, num_frames, fft_size)
# 送信波形をグラフ化
rft.awg_sa_cmd.get_waveform_sequence(awgsa.AwgId.AWG_0).save_as_img(
PLOT_DIR + "waveform/actual_seq_0_waveform.png")
print("Done.")
return
def main():
wgen = wavegen.WaveGen(logger=logger)
nu = ndarrayutil.NdarrayUtil
print("Generate waveform data.")
wgen.set_parameter(num_sample=DAC_SAMPLES,
dac_freq=DAC_FREQ,
carrier_freq=20.0,
amplitude=-30000.0)
w_data = wgen.sinwave()
w_size = len(w_data) # for 16-bit signed integer
r_size = ADC_SAMPLES * 2 # for 16-bit signed integer
mac_comp_coeff = np.array(
[-1, 0, 1], dtype="<i4") # MAC result comparation coefficients
mac_comp_coeff_b = nu.real_to_bytes_32(mac_comp_coeff)
dac_trig_params = np.array(
[0, DAC_SAMPLES / 8] * 16,
dtype="<i4") # start of word:0, num of word:DAC_SAMPLES/8
dac_trig_params_b = nu.real_to_bytes_32(dac_trig_params)
with client.RftoolClient(logger=logger) as rft:
print("Connect to RFTOOL Server.")
rft.connect(ZCU111_IP_ADDR)
rft.command.TermMode(0)
print("Configure Bitstream.")
config_bitstream(rft.command, BITSTREAM)
print("Setup ADC.")
for tile in [0, 1, 2, 3]:
for block in [0, 1]:
rft.command.SetMixerSettings(0, tile, block, 0.0, 0.0, 2, 2, 0,
3, 0)
rft.command.ResetNCOPhase(0, tile, block)
rft.command.UpdateEvent(0, tile, block, 1)
rft.command.SetupFIFO(0, tile, 0)
for block in [0, 1]:
rft.command.SetDither(tile, block,
1 if ADC_FREQ > 3000. else 0)
rft.command.SetDecimationFactor(tile, block, 1)
rft.command.SetFabClkOutDiv(0, tile, 2)
for block in [0, 1]:
rft.command.IntrClr(0, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(0, tile, 1)
print("Setup DAC.")
for tile in [0, 1]:
for block in [0, 1, 2, 3]:
rft.command.SetMixerSettings(1, tile, block, 0.0, 0.0, 2, 1,
16, 4, 0)
rft.command.ResetNCOPhase(1, tile, block)
rft.command.UpdateEvent(1, tile, block, 1)
rft.command.SetupFIFO(1, tile, 0)
for block in [0, 1, 2, 3]:
rft.command.SetInterpolationFactor(tile, block, 1)
rft.command.SetFabClkOutDiv(1, tile, 1)
for block in [0, 1, 2, 3]:
rft.command.IntrClr(1, tile, block, 0xFFFFFFFF)
rft.command.SetupFIFO(1, tile, 1)
print("Clear BlockRAM.")
rft.command.ClearBRAM()
# Write waveform data to DAC channel 0, 1 (Tile 1 Block 2, 3) BRAM region
for ch in [0, 1]:
print("Send waveform data to Feedback system Ch.{} DAC BlockRAM".
format(ch))
rft.if_data.WriteDataToMemory(1, ch, w_size, w_data)
# Write MAC result comparation coefficients for ADC channel 0 I part, 0 Q part, 1 I part, 1 Q part
for ch in [0, 1, 2, 3]:
print(
"Send waveform data to Feedback system Ch.{} MAC result comparation coefficients."
.format(ch))
rft.if_data.WriteDataToMemory(4, ch, len(mac_comp_coeff_b),
mac_comp_coeff_b)
print(
"Send waveform data to Feedback system Ch.{} DAC trigger parameters."
.format(0))
rft.if_data.WriteDataToMemory(5, 0, len(dac_trig_params_b),
dac_trig_params_b)
print(
"Send waveform data to Feedback system Ch.{} DAC trigger parameters."
.format(1))
rft.if_data.WriteDataToMemory(5, 1, len(dac_trig_params_b),
dac_trig_params_b)
print("Setting trigger information.")
rft.command.SetTriggerInfo(
0, 0x03, ADC_SAMPLES, 0
) # enable ADC channel 0(Tile 0 Block 0), channel 1(Tile 0 Block 1)
# to trigger DAC channel 0(Tile 1 Block 2), channel 1(Tile 1 Block 3)
rft.command.SetTriggerLatency(
0, 66) # ADC trigger latency (approx. 0.22us = 66/300MHz)
rft.command.SetMACConfig(0x00,
0xFF) # all ADC channels is 16-bit format
# force trigger all DACs regardless of MAC overrange
rft.command.SetTriggerCycle(32768, 1) # trigger 32768 times
print("Start trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
time.sleep(1.)
print("Setting trigger information.")
rft.command.SetTriggerCycle(3, 1) # trigger 3 times
print("Start trigger.")
rft.command.StartTrigger()
wait_trig_done(rft.command)
# Read I(Real) data from ADC Tile 0 Block 0, 1 RAM region
r_data = []
for ch in [0, 2]:
print(
"Receive waveform data from Feedback system Ch.{} ADC capture BlockRAM"
.format(ch))
r_data.append(rft.if_data.ReadDataFromMemory(0, ch, r_size))
print("Check interrupt flags.")
for ch in range(8): # ADC
check_intr_flags(rft.command, 0, ch)
for ch in range(8): # DAC
check_intr_flags(rft.command, 1, ch)
print("Processing sample data.")
print("- DAC sample data")
w_sample = nu.bytes_to_real(w_data)
del w_data
print("- ADC sample data")
r_sample = [nu.bytes_to_real(r_data[ch]) for ch in [0, 1]]
del r_data
print("Generating graph image.")
os.makedirs(PLOT_DIR, exist_ok=True)
print("- DAC waveform")
plot_graph(
DAC_FREQ, w_sample, "C0",
"DAC waveform {} samples, {} Msps".format(DAC_SAMPLES,
DAC_FREQ), "bram_send.png")
for ch in range(2):
print("- ADC waveform Ch.{}".format(ch))
plot_graph(
ADC_FREQ, r_sample[ch], "C{}".format(ch + 1),
"ADC waveform {} samples, {} Msps".format(ADC_SAMPLES, ADC_FREQ),
"bram_recv_{}.png".format(ch))
print("Done.")
return
