Skip to content

F
FMC ADC 100M 14b 4cha - Testing
Commit 44181710 authored by Matthieu Cattin's avatar Matthieu Cattin
Browse files
Options

Move plot all channels test to test17.

parent c02b3dbb
Hide whitespace changes
Inline Side-by-side
Showing with 40 additions and 305 deletions
test/fmcadc100m14b4cha/python/test17.py
View file @ 44181710
......@@ -12,7 +12,6 @@ import time
import os
from numpy import *
from pylab import *
from ctypes import *
from ptsexcept import *
......@@ -25,14 +24,13 @@ from PAGE.SineWaveform import *
"""
test17: Calibration
test17: Plot all channels
Note: Requires test00.py to run first to load the firmware!
"""
GN4124_CSR = 0x0
USB_DEVICE = "/dev/ttyUSB0"
# Calibration box vendor and device IDs
BOX_USB_VENDOR_ID = 0x10c4 # Cygnal Integrated Products, Inc.
BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
......@@ -40,7 +38,6 @@ BOX_USB_DEVICE_ID = 0xea60 # CP210x Composite Device
AWG_USB_VENDOR_ID = 0x0403 # Future Technology Devices International, Ltd
AWG_USB_DEVICE_ID = 0x6001 # FT232 USB-Serial (UART) IC
RS232_BAUD = 57600
NB_CHANNELS = 4
AWG_SET_SLEEP = 1
......@@ -53,7 +50,7 @@ ACQ_TIMEOUT = 10
MAX_FIRMWARE_RELOAD = 10
PRE_TRIG_SAMPLES = 1000
POST_TRIG_SAMPLES = 100000
POST_TRIG_SAMPLES = 50000
NB_SHOTS = 1
ACQ_LENGTH = 50000 # in samples
......@@ -131,10 +128,10 @@ def acquisition_all(fmc, spec_fmc):
trig_pos = fmc.get_trig_pos()
#print('Trigger position; 0x%X')%(trig_pos)
channels_data = spec_fmc.get_data((trig_pos<<3), ACQ_LENGTH*8)
#channels_data = spec_fmc.get_data(0x0, ACQ_LENGTH*8)
return channels_data
def plot_all(data, mean, ylimit):
sample = arange(len(data)/4)
clf()
......@@ -153,7 +150,6 @@ def plot_all(data, mean, ylimit):
show()
return 0
# Converts two's complement hex to signed
def hex2signed(value):
if(value & 0x8000):
......@@ -167,36 +163,21 @@ def digital2volt(value, full_scale, nb_bit):
return float(value) * float(full_scale)/2**nb_bit
# Converts volts to digital value with half full range offset
# Converts volts to digital value
def volt2digital(value, full_scale, nb_bit):
digital = (value + full_scale/2) * 2**nb_bit/full_scale
if(digital > 2**nb_bit - 1):
digital = 2**nb_bit - 1
if(digital < 0):
digital = 0
#print('volt2digital: %2.9f > %2.9f')%(value,digital)
return int(digital)
# Converts volts to digital value
def volt2digital_without_offset(value, full_scale, nb_bit):
digital = (value) * 2**nb_bit/full_scale
if(digital > 2**nb_bit - 1):
digital = ~(1<<nb_bit)
if(digital < 0):
digital = (1<<nb_bit)
#print('volt2digital: %2.9f > %2.9f')%(value,digital)
return int(digital)
def set_offset_dac(fmc, dac_fs, dac_nbits, channel, offset_volt, dac_corr_flag=False):
def set_offset_dac(fmc, dac_fs, dac_nbits, channel, offset_volt):
dac_v = offset_volt
dac_d = volt2digital(dac_v,dac_fs,dac_nbits)
#print('DAC value: 0x%X (%fV)')%(dac_d, dac_v)
if(True == dac_corr_flag):
fmc.set_dc_offset_corrected(channel,dac_d)
else:
fmc.set_dc_offset(channel,dac_d)
fmc.set_dc_offset(channel,dac_d)
time.sleep(DAC_SET_SLEEP)
......@@ -208,53 +189,6 @@ def get_mean_value(adc_fs, adc_nbits, acq):
return mean_v
def set_box_dac_range(box, fmc, box_out, dac_value, in_range, dac_corr_flag=False):
# Set calibration box output
box.select_output(box_out)
time.sleep(BOX_SET_SLEEP)
# Set offset DACs
for channel in range(1,NB_CHANNELS+1):
set_offset_dac(fmc, DAC_FS, DAC_NBITS, channel, dac_value, dac_corr_flag)
# Set channels input range
for channel in range(1,NB_CHANNELS+1):
fmc.set_input_range(channel, in_range)
time.sleep(SSR_SET_SLEEP)
def channels_mean(spec_fmc, fmc, ADC_FS, print_flag, plot_flag=False):
# Measures value on each channel
acq_d = acquisition_all(fmc, spec_fmc)
acq_d = [hex2signed(item) for item in acq_d]
acq_v = [digital2volt(item,ADC_FS,ADC_NBITS) for item in acq_d]
mean_v = get_mean_value(ADC_FS, ADC_NBITS, acq_d)
if(True == print_flag):
print('\n')
for channel in range(1,NB_CHANNELS+1):
print('Channel %d: mean voltage = %2.9fV')%(channel, mean_v[channel-1])
if(True == plot_flag):
plot_all(acq_v, mean_v, ADC_FS/2.0)
return mean_v
# Calculates ADC + input stage gain
def calc_ga(Vm1, Vm2, Vref1):
return ((Vm2-Vm1)/Vref1)
# Calculates ADC + input stage offset
def calc_oa(Vm2, Vm3, Vm4):
return (Vm2 + Vm3 - Vm4)
# Calculates DAC gain
def calc_gd(Vm1, Vm2, Vm3, Vref1, Vref2):
return ((Vref1*(Vm3-Vm1))/(Vref2*(Vm1-Vm2)))
# Calculates DAC offset
def calc_od(Vm1, Vm2, Vm3, Vm4, Vref1):
return ((Vref1*(Vm1-Vm2-Vm3+Vm4))/(Vm1-Vm2))
def main (default_directory = '.'):
# Load firmware to FPGA
......@@ -267,8 +201,6 @@ def main (default_directory = '.'):
usb_tty = find_usb_tty.CttyUSB()
awg_tty = usb_tty.find_usb_tty(AWG_USB_VENDOR_ID, AWG_USB_DEVICE_ID)
box_tty = usb_tty.find_usb_tty(BOX_USB_VENDOR_ID, BOX_USB_DEVICE_ID)
#print "AWG:%s"%awg_tty[0]
#print "BOX:%s"%box_tty[0]
gen = Agilent33250A(device=awg_tty[0], bauds=RS232_BAUD)
sine = SineWaveform()
box = calibr_box.CCalibr_box(box_tty[0])
......@@ -280,10 +212,10 @@ def main (default_directory = '.'):
fmc_adc_init(spec, fmc)
# Connect to AWG
gen.connect()
#gen.connect()
# Switch AWG output OFF
gen.output = False
#gen.output = False
# Measure FMC and carrier temperature
print('SPEC temperature: %3.3f°C') % spec_fmc.get_temp()
......@@ -296,245 +228,48 @@ def main (default_directory = '.'):
fmc.dc_offset_reset()
############################################################################
# 100mV range calibration
############################################################################
print('\n100mV range calibration\n----------------------------------')
# ADC full scale is 100mV
ADC_FS = 0.1
# Reference voltage for calibration
Vref1 = 0.040948 # should be taken from box cailbration data in CP2103 EEPROM
Vref2 = 0.04096 # reference voltage to set offset DAC
REPEAT = 5
#---------------------------------------------------------------------------
# Measure 1
# Channel input = 0V, offset DAC = 0V
#---------------------------------------------------------------------------
print('\nMeasurement 1: channel input = 0V, offset DAC = 0V')
set_box_dac_range(box, fmc, 'AWG', 0.0, 'CAL_100mV')
vm1 = []
for i in range(REPEAT):
vm1.append(channels_mean(spec_fmc, fmc, ADC_FS, False))
Vm1 = [mean([row[n] for row in vm1]) for n in range(NB_CHANNELS)]
for channel in range(1,NB_CHANNELS+1):
print('Channel %d: Vm1=%02.9fV')%(channel, Vm1[channel-1])
#---------------------------------------------------------------------------
# Measure 2
# Channel input = Vref = 0.04096V, offset DAC = 0V
#---------------------------------------------------------------------------
print('\nMeasurement 2: channel input = Vref = %1.7fV, offset DAC = 0V')%(Vref1)
set_box_dac_range(box, fmc, '100mV', 0.0, '100mV')
vm2 = []
for i in range(REPEAT):
vm2.append(channels_mean(spec_fmc, fmc, ADC_FS, False))
Vm2 = [mean([row[n] for row in vm2]) for n in range(NB_CHANNELS)]
for channel in range(1,NB_CHANNELS+1):
print('Channel %d: Vm2=%02.9fV')%(channel, Vm2[channel-1])
#---------------------------------------------------------------------------
# Measure 3
# Channel input = 0V, offset DAC = Vref = 0.04096V
#---------------------------------------------------------------------------
print('\nMeasurement 3: channel input = 0V, offset DAC = Vref = %1.7fV')%(Vref2)
set_box_dac_range(box, fmc, 'AWG', Vref2, 'CAL_100mV')
vm3 = []
for i in range(REPEAT):
vm3.append(channels_mean(spec_fmc, fmc, ADC_FS, False))
Vm3 = [mean([row[n] for row in vm3]) for n in range(NB_CHANNELS)]
for channel in range(1,NB_CHANNELS+1):
print('Channel %d: Vm3=%02.9fV')%(channel, Vm3[channel-1])
#---------------------------------------------------------------------------
# Measure 4
# Channel input = Vref = 0.04096, offset DAC = Vref = 0.04096
#---------------------------------------------------------------------------
print('\nMeasurement 4: channel input = Vref = %1.7fV, offset DAC = Vref = %1.7fV')%(Vref1, Vref2)
set_box_dac_range(box, fmc, '100mV', Vref2, '100mV')
vm4 = []
for i in range(REPEAT):
vm4.append(channels_mean(spec_fmc, fmc, ADC_FS, False))
Vm4 = [mean([row[n] for row in vm4]) for n in range(NB_CHANNELS)]
for channel in range(1,NB_CHANNELS+1):
print('Channel %d: Vm4=%02.9fV')%(channel, Vm4[channel-1])
#---------------------------------------------------------------------------
# Calculate gain and offset parameters
# ga = ADC + input stage gain
# oa = ADC + input stage offset
# gd = DAC gain
# od = DAC offset
#---------------------------------------------------------------------------
print('\n100mV range correction parameters\n----------------------------------')
ga = []
for channel in range(1,NB_CHANNELS+1):
ga.append(calc_ga(Vm1[channel-1], Vm2[channel-1], Vref1))
print('Channel %d ADC gain coeff: %02.9f')%(channel, ga[channel-1])
oa = []
for channel in range(1,NB_CHANNELS+1):
oa.append(calc_oa(Vm2[channel-1], Vm3[channel-1], Vm4[channel-1]))
print('Channel %d ADC offset : %02.9f')%(channel, oa[channel-1])
gd = []
for channel in range(1,NB_CHANNELS+1):
gd.append(calc_gd(Vm1[channel-1], Vm2[channel-1], Vm3[channel-1], Vref1, Vref2))
print('Channel %d DAC gain coeff: %02.9f')%(channel, gd[channel-1])
od = []
for channel in range(1,NB_CHANNELS+1):
od.append(calc_od(Vm1[channel-1], Vm2[channel-1], Vm3[channel-1], Vm4[channel-1], Vref1))
print('Channel %d DAC offset : %02.9f')%(channel, od[channel-1])
#---------------------------------------------------------------------------
# Write DAC gain and offset corerection value to fmc class
#---------------------------------------------------------------------------
print('\nApply DAC correction\n----------------------------------')
print('DACs are precise enough.\nDo not apply any correction.')
"""
dac_gain_corr = [1/item for item in gd]
dac_offset_corr = [-item for item in od]
fmc.set_dac_corr(dac_gain_corr, dac_offset_corr)
for channel in range(1,NB_CHANNELS+1):
print('CH%d DAC offset correction:%1.9f')%(channel,dac_offset_corr[channel-1])
print('CH%d DAC gain correction :%1.9f')%(channel,dac_gain_corr[channel-1])
#---------------------------------------------------------------------------
# Test
#---------------------------------------------------------------------------
print('\nChannel input = 0V, offset DAC = 0V\n----------------------------------')
#raw_input('...')
set_box_dac_range(box, fmc, 'AWG', 0.0, 'CAL_100mV', True)
mean_v = channels_mean(spec_fmc, fmc, ADC_FS, True)
#plot_all(acq_v, mean_v, ADC_FS/2.0)
"""
#---------------------------------------------------------------------------
# Write ADC + input stage gain and offset correction to hardware
#---------------------------------------------------------------------------
print('\nApply ADC offset correction\n----------------------------------')
#fmc.print_adc_core_config()
#adc_gain_corr = [int(round((1/item)*0x8000)) for item in ga]
adc_gain_corr = [0x8000] * 4
adc_offset_corr = [-(volt2digital_without_offset(item,ADC_FS,ADC_NBITS)) for item in oa]
#adc_offset_corr = [0] * 4
for channel in range(1,NB_CHANNELS+1):
fmc.set_adc_gain_offset_corr(channel, adc_gain_corr[channel-1], adc_offset_corr[channel-1])
#fmc.print_adc_core_config()
for channel in range(1,NB_CHANNELS+1):
print('CH%d ADC offset correction write:0x%.8X read:0x%.8X')%(channel,adc_offset_corr[channel-1],fmc.get_adc_offset_corr(channel))
print('CH%d ADC gain correction write:0x%.8X read:0x%.8X')%(channel,adc_gain_corr[channel-1],fmc.get_adc_gain_corr(channel))
#---------------------------------------------------------------------------
# Test
#---------------------------------------------------------------------------
print('\nChannel input = 0V, offset DAC = 0V\n----------------------------------')
#raw_input('...')
set_box_dac_range(box, fmc, 'AWG', 0.0, 'CAL_100mV', True)
mean_v = channels_mean(spec_fmc, fmc, ADC_FS, True)
#---------------------------------------------------------------------------
# Write ADC + input stage gain and offset correction to hardware
#---------------------------------------------------------------------------
print('\nApply ADC gain correction\n----------------------------------')
#fmc.print_adc_core_config()
select = raw_input('Select input range [1=10V, 2=1V, 3=100mV]:')
if('1' == select):
print('10V input range selected')
ADC_FS = 10.0
in_range = '10V'
elif('2' == select):
print('1V input range selected')
ADC_FS = 1.0
in_range = '1V'
elif('3' == select):
print('100mV input range selected')
ADC_FS = 0.1
in_range = '100mV'
else:
print('10V input range selected')
ADC_FS = 10.0
in_range = '10V'
adc_gain_corr = [int(round((1/item)*0x8000)) for item in ga]
#adc_gain_corr = [0x8000] * 4
adc_offset_corr = [-(volt2digital_without_offset(item,ADC_FS,ADC_NBITS)) for item in oa]
#adc_offset_corr = [0] * 4
# Set calibration box to AWG
box.select_output('AWG')
time.sleep(BOX_SET_SLEEP)
# All offset DACs to 0V
for channel in range(1,NB_CHANNELS+1):
fmc.set_adc_gain_offset_corr(channel, adc_gain_corr[channel-1], adc_offset_corr[channel-1])
#fmc.print_adc_core_config()
set_offset_dac(fmc, DAC_FS, DAC_NBITS, channel, 0.0)
# Set channel input range
for channel in range(1,NB_CHANNELS+1):
print('CH%d ADC offset correction write:0x%.8X read:0x%.8X')%(channel,adc_offset_corr[channel-1],fmc.get_adc_offset_corr(channel))
print('CH%d ADC gain correction write:0x%.8X read:0x%.8X')%(channel,adc_gain_corr[channel-1],fmc.get_adc_gain_corr(channel))
#---------------------------------------------------------------------------
# Test
#---------------------------------------------------------------------------
print('\nChannel input = 0V, offset DAC = 0V\n----------------------------------')
#raw_input('...')
set_box_dac_range(box, fmc, 'AWG', 0.0, 'CAL_100mV', True)
mean_v = channels_mean(spec_fmc, fmc, ADC_FS, True)
#---------------------------------------------------------------------------
# Test
#---------------------------------------------------------------------------
print('\nChannel input = 0V, offset DAC = Vref = 0.04096V\n----------------------------------')
#raw_input('...')
set_box_dac_range(box, fmc, 'AWG', 0.04096, 'CAL_100mV', True)
mean_v = channels_mean(spec_fmc, fmc, ADC_FS, True)
#---------------------------------------------------------------------------
# Test
#---------------------------------------------------------------------------
print('\nChannel input = Vref = 0.04096V, offset DAC = 0V\n----------------------------------')
#raw_input('...')
set_box_dac_range(box, fmc, '100mV', 0.0, '100mV', True)
mean_v = channels_mean(spec_fmc, fmc, ADC_FS, True)
fmc.set_input_range(channel, in_range)
time.sleep(SSR_SET_SLEEP)
# Measures value on each channel
acq_d = acquisition_all(fmc, spec_fmc)
acq_d = [hex2signed(item) for item in acq_d]
acq_v = [digital2volt(item,ADC_FS,ADC_NBITS) for item in acq_d]
mean_v = get_mean_value(ADC_FS, ADC_NBITS, acq_d)
plot_all(acq_v, mean_v, ADC_FS/2.0)
# Open all switches, reset offset DAC to mid-scale (0V)
for channel in range(1,NB_CHANNELS+1):
fmc.set_input_range(channel, 'OPEN')
fmc.set_input_term(channel, 'OFF')
fmc.dc_offset_reset()
# Close AWG
gen.close()
#gen.close()
# Check if an error occured during frequency response test
#if(error != 0):
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment