############################################################################### # Prepare x stimuli for block generator x_re_arr = [] x_im_arr = [] bg_data_arr = [] for i in range(c_nof_inputs): x_re_stream = [] x_im_stream = [] for h in range(c_nof_frames): for j in range(c_frame_size_in): x_re_stream.append(Din[i][j][0]) #j*c_nof_inputs + i) x_im_stream.append(Din[i][j][1]) #j*c_nof_inputs + i) x_re_arr.append(x_re_stream) x_im_arr.append(x_im_stream) bg_data_arr.append(dsp_test.concatenate_two_lists(x_re_stream, x_im_stream, c_dsp_data_w)) # Write setting for the block generator: bg.write_block_gen_settings(samplesPerPacket=c_frame_size_in, blocksPerSync=c_blocks_per_sync, gapSize=0, memLowAddr=0, memHighAddr=c_stimuli_length_par-1, BSNInit=0) # Write the stimuli to the block generator and enable the block generator for i in range(c_nof_inputs): bg.write_waveform_ram(data=bg_data_arr[i], channelNr= i) bg.write_enable() # Poll the databuffer to check if the response is there. # Retry after 3 seconds so we don't issue too many MM reads in case of simulation. do_until_ge(db_re.read_nof_words, ms_retry=3000, val=c_output_length_par, s_timeout=3600) ###############################################################################
############################################################################### # # Write the Wideband Poly Phase Filter Bank input stimuli to the BG # ############################################################################### # Prepare xq stimuli order for block generator : list[time_nr * channel_nr] xq_real = [] xq_imag = [] for i in range(c_channel_length): for j in range(c_nof_input_channels): xq_real.append(xq_real_series[j][i]) xq_imag.append(xq_imag_series[j][i]) bg_vhdl_data = dsp_test.concatenate_two_lists(xq_real, xq_imag, g_in_dat_w) # Write setting for the block generator: bg.write_block_gen_settings(samplesPerPacket=c_frame_size, blocksPerSync=c_blocks_per_sync, gapSize=0, memLowAddr=0, memHighAddr=c_bg_ram_size-1, BSNInit=0) # Write the stimuli to the block generator and enable the block generator for i in range(g_wb_factor): send_data = [] for j in range(c_stimuli_length/g_wb_factor): send_data.append(bg_vhdl_data[g_wb_factor*j+i]) # bg.write_waveform_ram(data=send_data, channelNr= i) bg.write_enable() # Poll the diag_data_buffer to check if the response is there. # Retry after 3 seconds so we don't issue too many MM reads in case of simulation. #do_until_ge(db_re.read_nof_words, ms_retry=3000, val=c_stimuli_length/g_wb_factor, s_timeout=3600)
# Prepare stimuli order for block generator xf_real = [] xf_imag = [] for i in range(c_nof_streams): xf_real.append(dsp_test.create_waveform(sel=c_real_select, ampl=c_real_ampl, phase=c_real_phase, freq=c_real_freq, timeIndex=c_real_index, seed=c_real_seed, noiseLevel=c_real_noiselevel, length=c_channel_length)) xf_imag.append(dsp_test.create_waveform(sel=c_imag_select, ampl=c_imag_ampl, phase=c_imag_phase, freq=c_imag_freq, timeIndex=c_imag_index, seed=c_imag_seed, noiseLevel=c_imag_noiselevel, length=c_channel_length)) xq_real=[] xq_imag=[] for i in range(c_nof_streams): xq_real.append(dsp_test.adc_quantize_waveform(xf_real[i])) xq_imag.append(dsp_test.adc_quantize_waveform(xf_imag[i])) streams = [] for i in range(c_nof_streams): streams.append(dsp_test.concatenate_two_lists(xq_real[i], xq_imag[i], g_in_dat_w)) # Apply the alternated order due to the channels and create the wb_streams wb_stream = [] for h in range(g_nof_wb_streams): chnl_stream = [] for i in range(c_channel_length): for j in range(c_nof_input_channels): chnl_stream.append(streams[h*c_nof_input_channels + j][i]) wb_stream.append(chnl_stream) # Use the wb_streams to create the actual streams for the block generator # Write the stimuli to the block generator for h in range(g_nof_wb_streams): for i in range(g_wb_factor): send_data = []
# Prepare data stimuli # Create a real input signal. Imaginary input remains zero. xf_real_array=[] for i in range(c_nof_input_channels): xf_real_array.append(dsp_test.create_real_sinewave(ampl=1.0, phase=0.0, freq=16+12*i, noiseLevel=0, length=c_stimuli_length)) xf_real = [] for i in range(c_nof_integrations*c_nof_points): for j in range(c_nof_input_channels): xf_real.append(xf_real_array[j][i]) xf_imag = [] for i in range(c_stimuli_length): xf_imag.append(0) bg_vhdl_data = dsp_test.concatenate_two_lists(xf_real, xf_imag, c_in_dat_w) # Write the stimuli to the block generator and enable the block generator for i in range(c_wb_factor): send_data = [] for j in range(c_stimuli_length/c_wb_factor): send_data.append(bg_vhdl_data[c_wb_factor*j+i]) # bg.write_waveform_ram(data=send_data, channelNr= i) bg.write_enable() # Poll the databuffer to check if the response is there. # Retry after 3 seconds so we don't issue too many MM reads in case of simulation. do_until_ge(db_re.read_nof_writes, ms_retry=3000, val=2, s_timeout=3600) # Read out the statistics stats_all = []