def __init__(self,name):
self.name = name
self.reg_num = 8192
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
def __init__(self,name):
self.name = name
self.reg_num = 256
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
rd_data = self.__axi4lite.read(0x04,4)
self.__clk_frequency = self.__data_deal.list_2_int(rd_data)
def __init__(self,name):
self.name = name
self.reg_num = 256
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__axi4_clk_frequency = 125000000
self.__data_deal = DataOperate()
self.__cache_size = 0
def __init__(self, name):
self.name = name
self.reg_num = 1024
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__measure_state = 0
self.__sample_rate = 125000000
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
rd_data = self.__axi4lite.read(0x0C, 2)
self.__tx_width = rd_data[0]
self.__rx_width = rd_data[1]
def __init__(self, name):
self.name = name
self.reg_num = 65536
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__k1_index = 0
self.__k1_data = 0
self.__k2_index = 0
self.__k2_data = 0
self.__decimation_data = 1
self.__base_frequency = 1000
class Axi4FskDecode():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def get_fsk_decode_state(self):
""" get_fsk_decode_state
Args:
None
Returns:
True | False: True -- FSK decode Parity bit is ok, False -- FSK decode Parity bit is error.
"""
# 0x12 bit0--Parity bit state
rd_data = self.__axi4lite.read(0x12, 1)
self.__axi4lite.write(0x12, [0x01], 1)
if (rd_data[0] == 0x01):
return False
else:
return True
def get_fsk_decode_data(self):
""" get_fsk_decode_data
Args:
None
Returns:
fsk_data(list): fsk decode data
"""
# 0x20 rd_fsk_data
# 0x21~0x22 fsk_data_len
rd_data = self.__axi4lite.read(0x21, 2)
fsk_data_len = self.__data_deal.list_2_int(rd_data)
fsk_data = []
if (fsk_data_len != 0):
fsk_data = self.__axi4lite.read_array(0x20, fsk_data_len, 8)
return fsk_data
class Axi4Ds18b20(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
rd_data = self.__axi4lite.read(0x04, 4)
self.__clk_frequency = self.__data_deal.list_2_int(rd_data)
def disable(self):
""" Disable function """
self.__axi4lite.write(0x11, [0x00], 1)
return None
def enable(self):
""" Enable function """
self.__axi4lite.write(0x11, [0x00], 1)
self.__axi4lite.write(0x11, [0x01], 1)
return None
def config_ds18b20(self, wr_data):
""" config_ds18b20 function
wr_data is list
"""
self.__axi4lite.write(0x14, wr_data, len(wr_data))
return None
def measure_disbale(self):
""" Disable function """
self.__axi4lite.write(0x10, [0x00], 1)
def measure_enable(self):
""" Enable function """
self.__axi4lite.write(0x10, [0x00], 1)
time.sleep(0.01)
self.__axi4lite.write(0x10, [0x01], 1)
def rd_data(self):
""" config_ds18b20 function
wr_data is list
"""
rd_data = self.__axi4lite.read(0x20, 2)
return rd_data
class Axi4AskDecode():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def get_ask_decode_data(self):
""" get_ask_decode_data
Args:
None
Returns:
ask_data(list): ask decode data
"""
# get_ask_decode_data
# 0x20 rd_ask_data
# 0x21~0x22 ask_data_len
rd_data = self.__axi4lite.read(0x21, 2)
ask_data_len = self.__data_deal.list_2_int(rd_data)
ask_data = []
if (ask_data_len != 0):
ask_data = self.__axi4lite.read_array(0x20, ask_data_len, 8)
return ask_data
class Axi4SignalSource(object):
def __init__(self,name):
self.name = name
self.reg_num = 1024
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__step_index = 0
def enable(self):
"""enable function"""
rd_data = self.__axi4lite.read(0x10,1)
wr_data = (rd_data[0] & 0xFE) | 0x00
self.__axi4lite.write(0x10, [wr_data],1)
wr_data = (rd_data[0] & 0xFE) | 0x01
self.__axi4lite.write(0x10, [wr_data],1)
return None
def disable(self):
"""disable function"""
rd_data = self.__axi4lite.read(0x10,1)
wr_data = (rd_data[0] & 0xFE) | 0x00
self.__axi4lite.write(0x10, [wr_data],1)
return None
def signal_type_set(self,signal_type):
""" set output signal type
Args:
signal_type(str): 'sine'--sine wave output
'square' -- square output
'AWG' -- arbitrary waveform output
Returns:
True | False
"""
self.__axi4lite.write(0x11, [0x00],1)
rd_data = self.__axi4lite.read(0x10,1)
if(signal_type == 'sine'):
signal_type_flag = 0x10
elif(signal_type == 'square'):
signal_type_flag = 0x00
elif(signal_type == 'AWG'):
signal_type_flag = 0x40
else:
logger.error('@%s: signal type set error'%(self.name))
return False
wr_data = (rd_data[0] & 0x0F) | signal_type_flag;
self.__axi4lite.write(0x10, [wr_data],1)
return True
def signal_time_set(self,signal_time):
""" set output signal duration
Args:
signal_time(int): signal output duration, unit is us
Returns:
True | False
"""
self.__axi4lite.write(0x11, [0x00],1)
wr_data = self.__data_deal.int_2_list(signal_time, 4)
self.__axi4lite.write(0x40,wr_data,len(wr_data))
return True
def swg_paramter_set(self,sample_rate,signal_frequency,vpp_scale,square_duty,offset_volt = 0):
""" set standard waveform(sine or square) parameter
Args:
sample_rate(int): external DAC sample rate, unit is SPS
signal_frequency(int): output signal frequency, unit is Hz
vpp_scale(float): full scale ratio, (0.000~0.999)
square_duty(float): duty of square, (0.001~0.999)
offset_volt(flaot): offset volt,(-0.99999~0.99999)
Returns:
None
"""
self.__axi4lite.write(0x11, [0x00],1)
freq_ctrl = int(pow(2,32) * signal_frequency / sample_rate)
wr_data = self.__data_deal.int_2_list(freq_ctrl, 4)
self.__axi4lite.write(0x20,wr_data,len(wr_data))
vpp_ctrl = int((pow(2,16)-1) * vpp_scale)
wr_data = self.__data_deal.int_2_list(vpp_ctrl, 2)
self.__axi4lite.write(0x24,wr_data,len(wr_data))
duty_ctrl = int((sample_rate/signal_frequency)*square_duty)
wr_data = self.__data_deal.int_2_list(duty_ctrl, 4)
self.__axi4lite.write(0x28,wr_data,len(wr_data))
offset_volt_hex = int(offset_volt*pow(2,23))
wr_data = self.__data_deal.int_2_list(offset_volt_hex, 3)
self.__axi4lite.write(0x2C, wr_data, len(wr_data))
return None
def signal_output(self):
"""signal output enable"""
self.__axi4lite.write(0x11, [0x01],1)
return None
def _awg_step_set(self,sample_rate,start_volt,stop_volt,duration_ms):
self.__axi4lite.write(0x11, [0x00],1)
sample_cycle = 1000/sample_rate;
duration_step = duration_ms/sample_cycle;
duration_step_cnt = int(duration_step/pow(2,16)) + 1
volt_step = (stop_volt-start_volt)/duration_step_cnt
for i in range(0,duration_step_cnt):
wr_data = []
start_volt_temp = i *volt_step + start_volt
step_duration_temp = int(duration_step/duration_step_cnt)
step_ovlt_temp = volt_step*pow(2,16)/step_duration_temp
start_volt_hex = int(start_volt_temp*pow(2,15))
step_ovlt_hex = int(step_ovlt_temp*pow(2,15))
wr_list = self.__data_deal.int_2_list(step_duration_temp, 2)
wr_data.extend(wr_list)
wr_list = self.__data_deal.int_2_list(step_ovlt_hex, 4)
wr_data.extend(wr_list)
wr_list = self.__data_deal.int_2_list(start_volt_hex, 2)
wr_data.extend(wr_list)
wr_data.append(self.__step_index)
self.__axi4lite.write(0x30, wr_data, len(wr_data))
self.__axi4lite.write(0x39, [0x01], 1)
self.__step_index = self.__step_index + 1
return None
def awg_parameter_set(self,sample_rate,awg_step):
""" set arbitrary waveform parameter
Args:
sample_rate(int): external DAC sample rate, unit is SPS
awg_step(list): arbitrary waveform step, list unit is (start_volt,stop_volt,duration_ms)
start_volt(float) -- step start volt (-1 ~ +1)
stop_volt(float) -- step stop volt (-1 ~ +1)
duration_ms(float) -- durarion time
Returns:
None
"""
self.__step_index = 0
for awg_step_temp in awg_step:
self._awg_step_set(sample_rate, awg_step_temp[0], awg_step_temp[1], awg_step_temp[2])
self.__axi4lite.write(0x3A, [(self.__step_index - 1)], 1)
return None
def _test_register(self,test_data):
wr_data = self.__data_deal.int_2_list(test_data,4)
self.__axi4lite.write(0x00,wr_data,len(wr_data))
rd_data = self.__axi4lite.read(0x00,len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if(test_out != test_data):
logger.error('@%s: Test Register read data error. '%(self.name))
return False
return None
class Axi4Ad717x(object):
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
def register_read(self, reg_addr):
""" Read value from ADC chip register
Args:
reg_addr: ADC chip register address(0x00-0xff)
Returns:
register value: (0x00-0xffffffff)
"""
rd_data = self.__axi4lite.read(0x26, 1)
if (rd_data[0] & 0x01 == 0x00):
logger.warning('AD717X Bus is busy now')
return False
com_data = (0x3F & reg_addr) | 0x40
wr_data = [com_data, 0x01]
self.__axi4lite.write(0x24, wr_data, len(wr_data))
rd_data = [0x00]
timeout_cnt = 0
while (rd_data[0] & 0x01 == 0x00) and (timeout_cnt < 1000):
time.sleep(0.001)
timeout_cnt = timeout_cnt + 1
rd_data = self.__axi4lite.read(0x26, 1)
if (timeout_cnt == 1000):
logger.warning('AD717X read register wait timeout')
return False
rd_data = self.__axi4lite.read(0x28, 4)
rd_data = rd_data[0] | (rd_data[1] << 8) | (rd_data[2] << 16) |\
(rd_data[3] << 24)
return rd_data
def register_write(self, reg_addr, reg_data):
""" Write value to ADC chip register
Args:
reg_addr: ADC chip reg (0x00-0xff)
reg_data: register value(0x00-0xffffffff)
Returns:
True | False
"""
rd_data = self.__axi4lite.read(0x26, 1)
if (rd_data[0] & 0x01 == 0x00):
logger.warning('AD717X Bus is busy now')
return False
wr_data = self.__data_deal.int_2_list(reg_data, 4)
com_data = (0x3F & reg_addr)
wr_data.append(com_data)
wr_data.append(0x01)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
rd_data = [0x00]
timeout_cnt = 0
while (rd_data[0] & 0x01 == 0x00) and (timeout_cnt < 1000):
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x26, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 1000):
logger.warning('AD717X write register wait finish timeout')
return False
return True
def single_sample_code_get(self):
""" ADC chip single sample
Returns:
(channel,sample_code)
"""
rd_data = self.register_read(0x01)
wr_data = rd_data & 0xFF0F | 0x0000
self.register_write(0x01, wr_data)
rd_data = self.register_read(0x01)
if ((rd_data & 0x00F0) != 0):
logger.warning("AXI4 AD717X 0x01 ==%s" % (hex(rd_data)))
return False
wr_data = rd_data & 0xFF0F | 0x0010
self.register_write(0x01, wr_data)
reg_data = self.register_read(0x04)
rd_data = self.__axi4lite.read(0x26, 1)
if (rd_data[0] & 0x08 == 0x08):
sample_channel = (reg_data & 0x0000000F)
sample_data = (reg_data & (0xFFFFFF00)) >> 8
else:
sample_channel = 'Null'
sample_data = reg_data & (0x00FFFFFF)
return (sample_channel, sample_data)
def continue_sample_mode(self):
""" ADC chip work in continue sample mode,cpu can not control the bus
Returns:
True | False
"""
rd_data = self.register_read(0x01)
wr_data = rd_data & 0xFF0F | 0x0000
self.register_write(0x01, wr_data)
rd_data = self.register_read(0x02)
reg_data = rd_data & 0xFF7F | 0x0080
rd_data = self.__axi4lite.read(0x26, 1)
if (rd_data[0] & 0x01 == 0x00):
logger.warning('Error: AD717X Bus is busy now')
return False
wr_data = self.__data_deal.int_2_list(reg_data, 4)
com_data = (0x3F & 0x02)
wr_data.append(com_data)
wr_data.append(0x01)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
return True
def single_sample_mode(self):
""" ADC chip exit continue sample mode,cpu can control the bus
"""
wr_data = [0x44, 0x01]
state = self.__axi4lite.write(0x24, wr_data, len(wr_data))
return state
def reset(self):
""" Reset ADC chip
"""
wr_data = [0xFF, 0x01]
state = self.__axi4lite.write(0x24, wr_data, len(wr_data))
return state
def chip_id_set(self, chip_id):
""" set chip_id
Args:
chip_id(int): chip id, 0~8
Returns:
True|False
"""
wr_data = [chip_id]
state = self.__axi4lite.write(0x13, wr_data, len(wr_data))
return state
def continue_sample_capture(self):
""" read continue sampld data
Args:
None
Returns:
sample_data(list): sample data
"""
rd_data = self.__axi4lite.read(0x26, 1)
sample_state = rd_data[0] & 0x04
if (sample_state == 0):
logger.warning('AD717X not in continue sample mode')
return False
self.__axi4lite.write(0x11, [0x01], 1)
rd_data = self.__axi4lite.read(0x12, 1)
if (rd_data[0] & 0x02 == 0x00):
logger.warning('AD717X capture fifo reset failt')
return False
self.__axi4lite.write(0x11, [0x00], 1)
time_out = 0
while time_out < 300:
rd_data = self.__axi4lite.read(0x12, 1)
if rd_data[0] & 0x01 == 0x01:
break
else:
time_out = time_out + 1
time.sleep(0.01)
if time_out == 3000:
logger.error('@%s: capture data time out' % (self.name))
return False
receive_list = self.__axi4lite.read_array(0x60, 2048, 32)
return receive_list
class Axi4SignalMeter(object):
def __init__(self, name):
self.name = name
self.reg_num = 1024
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__measure_state = 0
self.__sample_rate = 125000000
def enable(self):
""" Enable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = (rd_data[0] & 0xFE) | 0x00
self.__axi4lite.write(0x10, [wr_data], 1)
wr_data = (rd_data[0] & 0xFE) | 0x01
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def disable(self):
""" Disable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = (rd_data[0] & 0xFE) | 0x00
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def amplitude_interval_set(self, test_interval_ms):
""" when measuring VPP, test_interval_ms is the measured time period for each measuring
Args:
test_interval_ms(int): the time of measured time period
Returns:
None
"""
wr_data = self.__data_deal.int_2_list(test_interval_ms, 2)
self.__axi4lite.write(0x18, wr_data, len(wr_data))
return None
def upframe_enable(self, frame_type, frame_channel, sample_rate_khz):
""" set the parameter of data frame, and enable frame upload function
Args:
frame_type(int): the type of frame, 0~255
frame_channel(int): the channel of frame 0~15
sample_rate_khz(int): the sample rate of frame data
Returns:
None
"""
wr_data = [frame_type]
self.__axi4lite.write(0xF4, wr_data, len(wr_data))
wr_data = self.__data_deal.int_2_list(sample_rate_khz, 3)
wr_data.append(frame_channel * 16)
self.__axi4lite.write(0xF0, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = (rd_data[0] & 0xFD) | 0x02
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def upframe_disable(self):
""" disable frame upload function
Args:
None
Returns:
None
"""
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = (rd_data[0] & 0xFD) | 0x00
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def measure_start(self, time_ms, sample_rate):
""" start measure access
Args:
time_ms(int): measure time, unit is ms
sample_rate(int): data sample rate, unit is SPS
Returns:
True | False
"""
self.__sample_rate = sample_rate
wr_data = self.__data_deal.int_2_list(time_ms, 2)
self.__axi4lite.write(0x11, wr_data, len(wr_data))
self.__axi4lite.write(0x14, [0x00], 1)
self.__axi4lite.write(0x13, [0x01], 1)
rd_data = self.__axi4lite.read(0x14, 1)
timeout = 0
while (rd_data[0] != 0x01) and (timeout < (time_ms + 1000)):
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout = timeout + 1
if (timeout == (time_ms + 1000)):
logger.error('@%s: Measure time out' % (self.name))
self.__measure_state = 0
return False
self.__measure_state = 1
return True
def uploade_start(self, time_ms, sample_rate):
wr_data = self.__data_deal.int_2_list(time_ms, 2)
self.__axi4lite.write(0x11, wr_data, len(wr_data))
self.__axi4lite.write(0x14, [0x00], 1)
self.__axi4lite.write(0x13, [0x01], 1)
def frequency_measure(self, measure_type):
""" get the frequency of input signal
Args:
measure_type(str): select the method of frequency measurent
'HP' is high precision measurement, it can be use when FPGA IP enable the frequency measurent function
'LP' is low precision measurement, it can be use when FPGA IP enable the duty measurent function
Returns:
freq(float): the frequency of input signal, unit is Hz
"""
if (self.__measure_state == 0):
return (0, 'Hz')
if (measure_type == 'HP'):
freq = self._frequency_hp_measure()
elif (measure_type == 'LP'):
freq = self._frequency_lp_measure()
else:
logger.error('@%s: Measure type error' % (self.name))
return False
return (freq, 'Hz')
def duty_measure(self):
""" get the duty of input signal
Args:
None
Returns:
duty(float): the duty of input signal, unit is %, 1%~99%
"""
if (self.__measure_state == 0):
rd_data = self.__axi4lite.read(0x10, 1)
if (rd_data[0] & 0x04 == 0x04):
return (100, '%')
else:
return (0, '%')
rd_data = self.__axi4lite.read(0x50, 8)
duty_all = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x58, 8)
duty_high = self.__data_deal.list_2_int(rd_data)
duty = (duty_high / duty_all) * 100
return (duty, '%')
def amplitude_measure(self):
""" get the amplitude of input signal
Args:
None
Returns:
amp_data(float): the normalized average amplitude of input signal, unit is V, 0V~2V
max_data(float): the normalized max level of input signal, unit is V,-1V ~ +1V
min_data(float): the normalized min level of input signal, unit is V,-1V ~ +1V
"""
rd_data = self.__axi4lite.read(0x70, 8)
amp_max = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x78, 8)
amp_min = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x80, 4)
amp_cnt = self.__data_deal.list_2_int(rd_data)
max_data = amp_max / (amp_cnt * pow(2, 15))
min_data = amp_min / (amp_cnt * pow(2, 15))
amp_data = max_data - min_data
return (amp_data, 'V', max_data, 'V', min_data, 'V')
def rms_measure(self):
""" get the RMS of input signal
Args:
None
Returns:
rms_data(float): the normalized rms of input signal, unit is V, 0V~1V
max_data(float): the normalized average level of input signal, unit is V, -1V~+1V
"""
rd_data = self.__axi4lite.read(0x90, 8)
rms_square_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x98, 8)
rms_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0xA0, 4)
rms_cnt = self.__data_deal.list_2_int(rd_data)
rms_data = math.sqrt(rms_square_sum / rms_cnt) / pow(2, 15)
avg_data = (rms_sum / rms_cnt) / pow(2, 15)
return (rms_data, 'V', avg_data, 'V')
def _test_register(self, test_data):
wr_data = self.__data_deal.int_2_list(test_data, 4)
self.__axi4lite.write(0x00, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x00, len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if (test_out != test_data):
logger.error('@%s: Test Register read data error. ' % (self.name))
return False
return None
def _frequency_hp_measure(self):
rd_data = self.__axi4lite.read(0x15, 2)
sys_divide = self.__data_deal.list_2_int(rd_data)
if (sys_divide == 0):
sys_divide = 1
rd_data = self.__axi4lite.read(0x20, 8)
freq_x_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x28, 8)
freq_y_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x30, 8)
freq_xy_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x38, 8)
freq_xx_sum = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x40, 4)
freq_N = self.__data_deal.list_2_int(rd_data)
k_1 = freq_N * freq_xy_sum - freq_y_sum * freq_x_sum
k_2 = freq_N * freq_xx_sum - freq_x_sum * freq_x_sum
freq = sys_divide * self.__sample_rate * k_2 / k_1
return freq
def _frequency_lp_measure(self):
rd_data = self.__axi4lite.read(0x50, 8)
duty_all = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x60, 4)
duty_N = self.__data_deal.list_2_int(rd_data)
freq = duty_N * self.__sample_rate / duty_all
return freq
class Axi4SpiSlave(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__axi4_clk_frequency = 125000000
self.__data_deal = DataOperate()
self.__data_width = 4
def disable(self):
""" Disable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = rd_data[0] & 0xF0
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def enable(self):
""" Enable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = rd_data[0] & 0xF0
self.__axi4lite.write(0x10, [wr_data], 1)
wr_data = rd_data[0] & 0xF0 | 0x01
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def config(self, spi_clk_cpha_cpol='Mode_0', spi_byte_cfg='1'):
""" Set spi bus parameter
Args:
spi_byte_cfg(str): '1' --spi slave receive data or send data is 1byte
'2' --spi slave receive data or send data is 2byte
'3' --spi slave receive data or send data is 3byte
'4' --spi slave receive data or send data is 4byte
spi_clk_cpha_cpol(str): 'Mode_0' --CPHA=0, CPOL=0, when CS is high, the SCLK is low, first edge sample
'Mode_1' --CPHA=0, CPOL=1, when CS is high, the SCLK is high, first edge sample
'Mode_2' --CPHA=1, CPOL=0, when CS is high, the SCLK is low, second edge sample
'Mode_3' --CPHA=1, CPOL=1, when CS is high, the SCLK is high, second edge sample
Returns:
None
"""
mode_set_data = self.__axi4lite.write(0x11, [0x00], 1)
if (spi_clk_cpha_cpol == 'Mode_0'):
mode_set_data = 0x00
elif (spi_clk_cpha_cpol == 'Mode_1'):
mode_set_data = 0x01
elif (spi_clk_cpha_cpol == 'Mode_2'):
mode_set_data = 0x02
elif (spi_clk_cpha_cpol == 'Mode_3'):
mode_set_data = 0x03
else:
logger.error('@%s: Mode select error' % (self.name))
return False
self.__axi4lite.write(0x11, [mode_set_data], 1)
self.__axi4lite.write(0x12, [0x01], 1)
if (spi_byte_cfg == '1'):
set_byte = 0x01
elif (spi_byte_cfg == '2'):
set_byte = 0x02
elif (spi_byte_cfg == '3'):
set_byte = 0x03
elif (spi_byte_cfg == '4'):
set_byte = 0x04
else:
logger.error('@%s: byte select error' % (self.name))
return False
self.__axi4lite.write(0x12, [set_byte], 1)
self.__data_width = set_byte
return None
def register_read(self, address, read_length):
read_data = []
for i in range(0, read_length):
wr_data = self.__data_deal.int_2_list(address, 2)
self.__axi4lite.write(0x14, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x24, 4)
read_data_temp = self.__data_deal.list_2_int(rd_data)
if (read_data_temp < 0):
read_data_temp = read_data_temp + pow(2, 32)
read_data_temp = read_data_temp >> 8 * (4 - self.__data_width)
read_data.append(read_data_temp)
address = address + 1
return read_data
def register_write(self, address, write_data):
for i in range(0, len(write_data)):
write_data_temp = write_data[i] << 8 * (4 - self.__data_width)
wr_data = self.__data_deal.int_2_list(write_data_temp, 4)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
wr_data = self.__data_deal.int_2_list(address, 2)
self.__axi4lite.write(0x14, wr_data, len(wr_data))
self.__axi4lite.write(0x16, [0x01], 1)
address = address + 1
return None
class Axi4SampleMultiplex(object):
def __init__(self, name):
self.name = name
self.reg_num = 1024
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
""" Enable function """
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
""" Disable function """
self.__axi4lite.write(0x10, [0x00], 1)
return None
def measure_time_set(self, time_ms):
""" Set measure time
Args:
time_ms(int): mircosecond of measure
Returns:
None
"""
wr_data = self.__data_deal.int_2_list(time_ms, 2)
self.__axi4lite.write(0x11, wr_data, len(wr_data))
return None
def measure_state_get(self):
""" Get measure state
Args:
None
Returns:
measure_state(str): 'BUSY' | 'IDLE'
"""
rd_data = self.__axi4lite.read(0x13, 1)
if (rd_data[0] & 0x10 == 0x00):
measure_state = 'BUSY'
else:
measure_state = 'IDLE'
return measure_state
def measure_start(self):
""" Start measure
Args:
None
Returns:
False | True
"""
measure_state = self.measure_state_get()
if (measure_state == 'BUSY'):
logger.error('@%s: bus busy...' % (self.name))
return False
self.__axi4lite.write(0x13, [0x01], 1)
return True
def sample_parameter_set(self,
sample_rate,
switch_wait_ns,
switch_sample_count,
frame_type=0x20,
frame_channel=0x0):
""" Set sample parameter
Args:
sample_rate(int): ADC Chip sample rate, unit is Hz
switch_wait_ns(int): The waiting time after switching the sampling channel, unit is ns
switch_sample_count(int): The number of sampled data after switching the sampling channel
frame_type(int): The upload frame type.
frame_channel(int): freame channel (0~15)
Returns:
None
"""
sample_cycle = 1000000000 / sample_rate
ch_wait = int(switch_wait_ns / sample_cycle) - 3
data_temp = ch_wait + switch_sample_count * pow(
2, 16) + frame_channel * pow(2, 28)
wr_data = self.__data_deal.int_2_list(data_temp, 4)
self.__axi4lite.write(0x1c, wr_data, len(wr_data))
frame_sample_rate = int(1000000 / ((ch_wait + 3) * sample_cycle))
wr_data = self.__data_deal.int_2_list(frame_sample_rate, 3)
wr_data.append(frame_type)
self.__axi4lite.write(0x14, wr_data, len(wr_data))
return None
def sample_channel_set(self, ch_sel):
""" Set sample channel
Args:
ch_sel(list): select the sample channle
Returns:
None
"""
if (len(ch_sel) == 0):
logger.error('@%s: CH Sel Error' % (self.name))
return
wr_data = [(len(ch_sel) - 1)]
self.__axi4lite.write(0x18, wr_data, len(wr_data))
rw_addr = 0x40
for i in ch_sel:
wr_data = [i]
self.__axi4lite.write(rw_addr, wr_data, len(wr_data))
rw_addr = rw_addr + 1
return None
def channel_attached_set(self, ch_attached):
""" Set extra information for each sample channel
Args:
ch_attached(list): extra information for each sample channel
Returns:
None
"""
if (len(ch_attached) == 0):
logger.error('@%s: CH Sel Error' % (self.name))
return
rw_addr = 0x80
for i in ch_attached:
wr_data = [i]
self.__axi4lite.write(rw_addr, wr_data, len(wr_data))
rw_addr = rw_addr + 1
return None
def interrupt_time_get(self, clk_freq, ch_num):
""" get the posedge time and negedge time of trigger signal
Args:
clk_freq(int): the frequency of reference clock, unit is Hz
ch_num(int): the channel number of trigger
Returns:
pos_time(int): trigger posedge time
neg_time(int): trigger negedge time
"""
if ((ch_num > 64) | (ch_num < 0)):
logger.error('@%s: CH Num Error' % (self.name))
return
clk_cycle = 1000000000 / clk_freq
wr_data = self.__data_deal.int_2_list(ch_num, 1)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
rd_data = [0, 0, 0, 0]
rd_data = self.__axi4lite.read(0x24, len(rd_data))
pos_time = self.__data_deal.list_2_int(rd_data) * clk_cycle
rd_data = self.__axi4lite.read(0x28, len(rd_data))
neg_time = self.__data_deal.list_2_int(rd_data) * clk_cycle
return (pos_time, neg_time)
def trigger_clear(self):
""" clear the trigger for signal """
self.__axi4lite.write(0x2C, [0x0, 0x0], 2)
return None
def posedge_trigger_set(self):
""" set the posedge trigger for signal """
rd_data = self.__axi4lite.read(0x2C, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x2C, rd_data, 1)
return None
def negedge_trigger_set(self):
""" set the negedge trigger for signal """
rd_data = self.__axi4lite.read(0x2C, 1)
rd_data[0] = rd_data[0] | 0x02
self.__axi4lite.write(0x2C, rd_data, 1)
return None
def high_spread_trigger_set(self):
""" set the high level insufficient trigger for signal """
rd_data = self.__axi4lite.read(0x2C, 1)
rd_data[0] = rd_data[0] | 0x04
self.__axi4lite.write(0x2C, rd_data, 1)
def low_spread_trigger_set(self):
""" set the low level insufficient trigger for signal """
rd_data = self.__axi4lite.read(0x2C, 1)
rd_data[0] = rd_data[0] | 0x08
self.__axi4lite.write(0x2C, rd_data, 1)
def high_thresdhold_level_set(self, normalize_volt):
""" set the threasdhold for posedge triggger
Args:
normalize_volt(long): normalize volt. -1 ~ +1
Returns:
None
"""
threshold_level = int(normalize_volt * pow(2, 15))
if (threshold_level < 0):
threshold_level = threshold_level + pow(2, 16)
wr_data = self.__data_deal.int_2_list(threshold_level, 2)
self.__axi4lite.write(0x30, wr_data, 2)
return None
def volt_normalize(self, signal_volt, signal_full_scale):
""" Calculate VPP normalization
Args:
signal_volt(float): the volt of signal, unit is mv
signal_full_scale(float): the full scale vpp of signal output, unit is mv
Returns:
volt_scale(float): normalized volt, (-1.00 ~ +1.00)
"""
volt_scale = signal_volt * 2 / signal_full_scale
return (volt_scale)
def set_low_thresdhold_level(self, normalize_volt):
""" set the threasdhold for negedge triggger
Args:
normalize_volt(long): normalize volt. -1 ~ +1
Returns:
None
"""
threshold_level = int(normalize_volt * pow(2, 15))
if (threshold_level < 0):
threshold_level = threshold_level + pow(2, 16)
wr_data = self.__data_deal.int_2_list(threshold_level, 2)
self.__axi4lite.write(0x34, wr_data, 2)
return None
def set_high_spread_time(self, spread_ms):
""" set the threasdhold for high level insufficient triggger
Args:
normalize_volt(long): normalize volt. -1 ~ +1
Returns:
None
"""
read_data = self.__axi4lite.read(0x14, 3)
sample_rate = self.__data_deal.list_2_int(read_data)
sample_cycle = 1000000 / sample_rate
spread_cnt = int(spread_ms * 1000000 / sample_cycle)
wr_data = self.__data_deal.int_2_list(spread_cnt, 2)
self.__axi4lite.write(0x32, wr_data, 2)
return None
def set_low_spread_time(self, spread_ms):
""" set the threasdhold for low level insufficient triggger
Args:
normalize_volt(long): normalize volt. -1 ~ +1
Returns:
None
"""
read_data = self.__axi4lite.read(0x14, 3)
sample_rate = self.__data_deal.list_2_int(read_data)
sample_cycle = 1000000 / sample_rate
spread_cnt = int(spread_ms * 1000000 / sample_cycle)
wr_data = self.__data_deal.int_2_list(spread_cnt, 2)
self.__axi4lite.write(0x36, wr_data, 2)
return None
def trigger_state_get(self, channel_num):
""" get trigger state of each channel
Args:
channel_num(list): the number of channel
Returns:
state_out(list): the state of channel
"""
read_data = self.__axi4lite.read(0x38, 2)
state_data = self.__data_deal.list_2_int(read_data)
state_out = []
for i in range(channel_num):
state_temp = state_data >> i
if ((state_temp % 2) == 1):
state_out.append('T')
else:
state_out.append('N')
return state_out
def _test_register(self, test_data):
wr_data = self.__data_deal.int_2_list(test_data, 4)
self.__axi4lite.write(0x00, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x00, len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if (test_out != test_data):
logger.error('@%s: Test Register read data error. ' % (self.name))
return False
return None
class Axi4TimeDetect_v1(object):
def __init__(self,name):
self.name = name
self.reg_num = 256
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
rd_data = self.__axi4lite.read(0x04,4)
self.__clk_frequency = self.__data_deal.list_2_int(rd_data)
def disable(self):
""" Disable function """
self.__axi4lite.write(0x10,[0x00],1)
return None
def enable(self):
""" Enable function """
self.__axi4lite.write(0x10,[0x00],1)
self.__axi4lite.write(0x10,[0x01],1)
return None
def measure_disbale(self):
""" Disable function """
self.__axi4lite.write(0x11,[0x00],1)
def measure_enable(self):
""" Enable function """
self.__axi4lite.write(0x11,[0x00],1)
time.sleep(0.01)
self.__axi4lite.write(0x11,[0x01],1)
def start_edge_set(self,start_edge_type='A-POS'):
""" Set width measure start_edge_type
Args:
start_edge_type(str): 'A-POS' -- signal A posedge
'A-NEG' -- signal A negedge
'B-POS' -- signal B posedge
'B-NEG' -- signal B negedge
'A-P**N' -- signal A posedge or A negedge
'B-P**N' -- signal B posedge or B negedge
Returns:
None
"""
self.__axi4lite.write(0x12,[0x00],1)
if(start_edge_type == 'A-POS'):
start_edge_data = 0x00
elif(start_edge_type == 'A-NEG'):
start_edge_data = 0x01
elif(start_edge_type == 'B-POS'):
start_edge_data = 0x02
elif(start_edge_type == 'B-NEG'):
start_edge_data = 0x03
elif(start_edge_type == 'A-P**N'):
start_edge_data = 0x04
elif(start_edge_type == 'B-P**N'):
start_edge_data = 0x05
else:
logger.error('@%s: Parameter Error'%(self.name))
return False
wr_data = start_edge_data;
self.__axi4lite.write(0x12, [wr_data], 1)
return None
def stop_edge_set(self,stop_edge_type='B-POS'):
""" Set width measure stop_edge_type
Args:
stop_edge_type(str): 'A-POS' -- signal A posedge
'A-NEG' -- signal A negedge
'B-POS' -- signal B posedge
'B-NEG' -- signal B negedge
'A-P**N' -- signal A posedge or A negedge
'B-P**N' -- signal B posedge or B negedge
Returns:
None
"""
self.__axi4lite.write(0x13,[0x00],1)
if(stop_edge_type == 'B-POS'):
stop_edge_data = 0x00
elif(stop_edge_type == 'B-NEG'):
stop_edge_data = 0x01
elif(stop_edge_type == 'A-POS'):
stop_edge_data = 0x02
elif(stop_edge_type == 'A-NEG'):
stop_edge_data = 0x03
elif(stop_edge_type == 'A-P**N'):
stop_edge_data = 0x04
elif(stop_edge_type == 'B-P**N'):
stop_edge_data = 0x05
else:
logger.error('@%s: Parameter Error'%(self.name))
return False
wr_data = stop_edge_data;
self.__axi4lite.write(0x13, [wr_data], 1)
return None
def detect_time_get(self,detect_time_ms):
""" get measure data
Args:
None
Returns:
detect_data(float): the data is start_edge_type to stop_edge_type time, unit is us
"""
rd_data = self.__axi4lite.read(0x20, 1)
detect_time_out=0
while rd_data[0]!=0x01 and (detect_time_out<detect_time_ms+1000):
time.sleep(0.001)
detect_time_out+=1
rd_data = self.__axi4lite.read(0x20, 1)
if(detect_time_out== detect_time_ms+1000):
logger.error('@%s: Detect time out'%(self.name))
return False
else:
rd_data=self.__axi4lite.read(0x24,4)
detect_time=self.__data_deal.list_2_int(rd_data)
clk_period = 1000.0/self.__clk_frequency
detect_data= clk_period*detect_time
self.__axi4lite.write(0x11,[0x00],1)
return ('detect_time',detect_data,'us')
class Axi4I2cSlave(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4_clk_frequency = 125000000
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__data_width = 4
def enable(self):
"""enable function"""
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""disable function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def config(self,
bit_rate_hz=400000,
slave_address=0x48,
address_bytes=1,
data_bytes=1):
""" config ii2 slave
Args:
bit_rate_hz(int): iic bus bit rate, unit is Hz
slave_address(int): iic slave device address
address_bytes(int): iic register addresss bytes
data_bytes(int): iic register data bytes
Returns:
None
"""
self.disable()
bit_clk_count = self.__axi4_clk_frequency / bit_rate_hz
bit_clk_delay = int(bit_clk_count / 8)
byte_ctrl = address_bytes * 16 + data_bytes
wr_data = [slave_address, byte_ctrl]
bit_clk_delay_temp = self.__data_deal.int_2_list(bit_clk_delay, 2)
wr_data.extend(bit_clk_delay_temp)
self.__axi4lite.write(0x30, wr_data, len(wr_data))
self.__data_width = data_bytes
self.enable()
return None
def register_read(self, address, read_length):
read_data = []
for i in range(0, read_length):
wr_data = self.__data_deal.int_2_list(address, 2)
self.__axi4lite.write(0x38, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x3C, 4)
read_data_temp = self.__data_deal.list_2_int(rd_data)
if (read_data_temp < 0):
read_data_temp = read_data_temp + pow(2, 32)
read_data_temp = read_data_temp >> 8 * (4 - self.__data_width)
read_data.append(read_data_temp)
address = address + 1
return read_data
def register_write(self, address, write_data):
for i in range(0, len(write_data)):
write_data_temp = write_data[i] << 8 * (4 - self.__data_width)
wr_data = self.__data_deal.int_2_list(write_data_temp, 4)
self.__axi4lite.write(0x34, wr_data, len(wr_data))
wr_data = self.__data_deal.int_2_list(address, 2)
self.__axi4lite.write(0x38, wr_data, len(wr_data))
self.__axi4lite.write(0x3A, [0x01], 1)
address = address + 1
return None
def _axi4_clk_frequency_set(self, clk_frequency):
self.__axi4_clk_frequency = clk_frequency
class Axi4SpiProgCore():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x10, rd_data, 1)
return None
def disable(self):
"""Disable this FPGA function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] & 0xFE
self.__axi4lite.write(0x10, rd_data, 1)
return None
def spi_module_config(self, spi_clk_mode, spi_clk_freq):
""" jtag tck freq set
Args:
spi_clk_mode(int): 0~3 ==> SPI MODE 0~3
spi_clk_freq(int): 2000~62500000 Hz
Returns:
None
"""
# spi_mode_reg addr: 0x10--bit4 CPHA;0x10--bit5 CPOL;
# Mode 0: CPOL=0,CPHA=0; Mode 1: CPOL=0,CPHA=1;Mode 2: CPOL=1,CPHA=0; Mode 3: CPOL=1,CPHA=1
# spi_clk_freq_reg addr: 0x20~0x21
# set spi clk mode reg
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = (rd_data[0] & 0xCF) | ((spi_clk_mode & 0x03) << 4)
self.__axi4lite.write(0x10, rd_data, 1)
# set spi clk freq reg
rd_data = self.__axi4lite.read(0x01, 3)
base_clk_freq = self.__data_deal.list_2_int(rd_data)
freq_div = int(((base_clk_freq * 1000) / (spi_clk_freq * 2)) - 2)
if (freq_div < 0):
freq_div = 0
wr_data = self.__data_deal.int_2_list(freq_div, 2)
self.__axi4lite.write(0x20, wr_data, 2)
return None
def spi_normal_fifo_clr(self):
""" spi_normal_fifo_clr, clear spi normal fifo data.
Args:
None
Returns:
None
"""
# fifo clr addr: 0x12--bit0
self.__axi4lite.write(0x12, [0x01], 1)
return None
def spi_dma_fifo_clr(self):
""" spi_dma_fifo_clr, Reserved function, Don't use it temporarily.
Args:
None
Returns:
None
"""
# fifo clr addr: 0x12--bit1
self.__axi4lite.write(0x12, [0x02], 1)
return None
def spi_cs_ctrl(self, cs_ch, level):
""" spi_cs_ctrl
Args:
cs_ch(int): 0~7 -- cs channel
level(string): 'L' or 'H' ~~ 'L'--low level,'H'~high level
Returns:
None
"""
# cs reg addr: 0x13,bit0~bit7 ==> cs0~cs7
rd_data = self.__axi4lite.read(0x13, 1)
if level == 'L':
rd_data[0] = rd_data[0] & (~(0x01 << cs_ch))
else:
rd_data[0] = rd_data[0] | (0x01 << cs_ch)
self.__axi4lite.write(0x13, rd_data, 1)
read_data = self.__axi4lite.read(0x13, 1)
print("CS_CFG_DATA:", read_data)
return None
def spi_extend_io_ctrl(self, ext_io_ch, level):
""" spi_extend_io_ctrl
Args:
ext_io_ch(int): 0~7 -- ext_io channel
level(string): 'L' or 'H' ~~ 'L'--low level,'H'~high level
Returns:
None
"""
# extend_io reg addr: 0x15,bit0~bit7 ==> ext_io0~ext_io7
rd_data = self.__axi4lite.read(0x15, 1)
if level == 'L':
rd_data[0] = rd_data[0] & (~(0x01 << ext_io_ch))
else:
rd_data[0] = rd_data[0] | (0x01 << ext_io_ch)
self.__axi4lite.write(0x15, rd_data, 1)
return None
def spi_arbitrary_n_clk(self, clk_cycle_num):
""" spi_arbitrary_n_clk
Args:
clk_cycle_num(int): 1~8
level(string): 'L' or 'H' ~~ 'L'--low level,'H'~high level
Returns:
None
"""
# n clk & spi operate mode addr: 0x16
# [0]--arbitrary_n_clk enable bit, [3:1]--clk_cycle_num
rd_data = self.__axi4lite.read(0x16, 1)
rd_data[0] = (rd_data[0] & 0xF0) | (0x01 | ((clk_cycle_num - 1) << 1))
self.__axi4lite.write(0x16, rd_data, 1)
return None
def spi_normal_write(self, wr_data):
""" spi_normal_write
Args:
wr_data(list): spi write data list(byte), len 1~2048
Returns:
True | False
"""
# wr data addr: 0x80
# spi_ctrl addr: 0x16_bit4--spi operate mode sel, 0--normal operate mdoe,1--dma operate mode
# spi_ctrl addr: 0x16_bit5--varify mode en bit, 0--enable,1--disable
# config to spi normal operate mode
self.__axi4lite.write(0x16, [0x00], 1)
# wr data to normal wr_fifo
# self.__axi4lite.write_byte_array(0x80, wr_data, len(wr_data), 8)
self.__axi4lite.write_array(0x80, wr_data, len(wr_data), 8)
# spi tran start
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100000:
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100000):
return False
# spi fifo clr
self.spi_normal_fifo_clr()
return True
def spi_normal_read(self, read_len):
""" spi_normal_read
Args:
read_len(int): 1~2048
Returns:
spi_read_data(list): spi read data list(byte), len 1~2048
"""
# rd data addr:0x80
# spi_ctrl addr: 0x16_bit4--spi operate mode sel, 0--normal operate mdoe,1--dma operate mode
# spi_ctrl addr: 0x16_bit5--varify mode en bit, 0--enable,1--disable
# config to spi normal operate mode
self.__axi4lite.write(0x16, [0x00], 1)
# wr data to normal wr_fifo, invalid data
wr_data = []
for i in range(read_len):
wr_data.append(0xAA)
# wr_data.append([0xAA])
# self.__axi4lite.write_byte_array(0x80, wr_data, read_len, 8)
self.__axi4lite.write_array(0x80, wr_data, read_len, 8)
# spi tran start
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100000:
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100000):
return False
# spi rd data ==> rd data addr:0x80
# spi_read_data = self.__axi4lite.read_byte_array(0x80, read_len, 8)
spi_read_data = self.__axi4lite.read_array(0x80, read_len, 8)
return spi_read_data
def spi_normal_write_read(self, wr_data):
""" spi_normal_write_read
Args:
wr_data(list): spi write data list(byte), len 1~2048
Returns:
spi_read_data(list): spi read data list(byte), len 1~2048
"""
# rd data addr:0x80
# spi_ctrl addr: 0x16_bit4--spi operate mode sel, 0--normal operate mdoe,1--dma operate mode
# spi_ctrl addr: 0x16_bit5--varify mode en bit, 0--enable,1--disable
# config to spi normal operate mode
self.__axi4lite.write(0x16, [0x00], 1)
# wr data to normal wr_fifo
# self.__axi4lite.write_byte_array(0x80, wr_data, len(wr_data), 8)
self.__axi4lite.write_array(0x80, wr_data, len(wr_data), 8)
# spi tran start
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100000:
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100000):
return False
# spi rd data ==> rd data addr:0x80
# spi_read_data = self.__axi4lite.read_byte_array(0x80, len(wr_data), 8)
spi_read_data = self.__axi4lite.read_array(0x80, len(wr_data), 8)
return spi_read_data
def spi_dma_write(self, write_len):
""" spi_dma_write,Reserved function, Don't use it temporarily.
Args:
write_len(int): 1~256
Returns:
True | False
"""
# write_len: 1~256
# operate len addr: 0x24
# spi_ctrl addr: 0x16_bit4--spi operate mode sel, 0--normal operate mdoe,1--dma operate mode
# spi_ctrl addr: 0x16_bit5--varify mode en bit, 0--enable,1--disable
# config to spi dma operate mode
self.__axi4lite.write(0x16, [0x10], 1)
# config dma mode operate len
self.__axi4lite.write(0x24, [(write_len - 1)], 1)
# spi tran start
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100000:
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100000):
return False
return True
def spi_dma_varify(self, varify_len):
""" spi_dma_write,Reserved function, Don't use it temporarily.
Args:
varify_len(int): 1~256
Returns:
True | False
"""
# operate len addr: 0x24
# spi_ctrl addr: 0x16_bit4--spi operate mode sel, 0--normal operate mdoe,1--dma operate mode
# spi_ctrl addr: 0x16_bit5--varify mode en bit, 0--enable,1--disable
# config to spi dma operate mode and enable varify mode
self.__axi4lite.write(0x16, [0x30], 1)
# config dma mode operate len
self.__axi4lite.write(0x24, [varify_len - 1], 1)
# spi tran start
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100000:
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100000):
return False
if ((rd_data[0] & 0x02) == 0x02):
return False
return True
class Axi4SwdCore():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x10, rd_data, 1)
return None
def disable(self):
"""Disable this FPGA function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] & 0xFE
self.__axi4lite.write(0x10, rd_data, 1)
return None
def swd_freq_set(self, freq_data):
""" Set swd clk freq parameter
Args:
freq_data(int): swd bus clock frequency, unit is Hz
Returns:
None
"""
# read base clk freq: KHz
rd_data = self.__axi4lite.read(0x01, 3)
base_clk_freq = self.__data_deal.list_2_int(rd_data)
# set swd freq
swd_freq_div = int(((base_clk_freq * 1000) / (freq_data * 2)) - 2)
if (swd_freq_div < 0):
swd_freq_div = 0
wr_data = self.__data_deal.int_2_list(swd_freq_div, 2)
self.__axi4lite.write(0x04, wr_data, len(wr_data))
return None
def swd_rst_pin_ctrl(self, level):
""" swd debug rst ctrl
Args:
level(string): 'L'--Low level,'H'--High level
Returns:
None
"""
# 0x12--bit7: rst_pin_level_ctrl, 0--high level; 1--low level
rd_data = self.__axi4lite.read(0x12, 1)
if level == 'H':
rd_data[0] = rd_data[0] & 0x7F
else:
rd_data[0] = rd_data[0] | 0x80
self.__axi4lite.write(0x12, rd_data, 1)
return None
def swd_switch_timing_gen(self, timing_data):
""" swd_switch_timing_gen
Args:
timing_data(list): timing_data, bit order: first_byte_bit0-->bit7,second_byte_bit0-->bit7,...,last_byte_bit0-->bit7
Returns:
False | True
"""
# 0x30--wr switch timing data
self.__axi4lite.write_array(0x30, timing_data, len(timing_data), 8)
# 0x12--bit0 = 1 : start switch timing output
rd_data = self.__axi4lite.read(0x12, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x12, rd_data, 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100:
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100):
logger.error('swd switch timing wait time out\n')
return False
return True
def swd_wr_operate(self, swd_req_data, swd_wr_data):
""" swd_wr_operate
Args:
swd_req_data(byte): swd_req_data
swd_wr_data(list): swd_wr_data
Returns:
False | SWD RETURN ACK DATA(byte)
"""
# wr req data
self.__axi4lite.write(0x23, [swd_req_data], 1)
# wr wr_data
self.__axi4lite.write(0x24, swd_wr_data, 4)
# start swd wr operate
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100:
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100):
logger.error('swd wr operate wait time out\n')
return False
# return ACK data(addr: 0x2C):
rd_data = self.__axi4lite.read(0x2C, 1)
return rd_data[0]
def swd_rd_operate(self, swd_req_data):
""" swd_rd_operate
Args:
swd_req_data(byte): swd_req_data
Returns:
False | swd_rd_data(list):
Format, five bytes in total,
the first four bytes are swd rd data,
the last byte is ack data in bit0~bit2, and bit7 is swd rd data parity bit.
"""
# rd req data
self.__axi4lite.write(0x23, [swd_req_data], 1)
# start swd rd operate
self.__axi4lite.write(0x11, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 100:
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 100):
logger.error('swd rd operate wait time out\n')
return False
# return rd_data(addr: 0x28~0x2B) + ACK data(addr: 0x2C, [2:0]--ack data, [7]--swd rd data parity bit)
swd_rd_data = self.__axi4lite.read(0x28, 5)
return swd_rd_data
class Axi4Gpio(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def reset(self):
""" All gpio reset to 0 """
wr_data = [0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]
reg_addr = 0x10
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
reg_addr = 0x20
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
reg_addr = 0x30
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
reg_addr = 0x40
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
def gpio_set(self, gpio_out):
""" set gpio level
Args:
gpio_out(list): the unit of list is (gpio_number,gpio_level)
gpio_number for 0 to 127
set gpio_level to 1, the gpio output high level
set gpio_level to 0, the gpio output low level
Returns:
NONE
"""
ch0_data = []
ch1_data = []
ch2_data = []
ch3_data = []
for gpio_out_temp in gpio_out:
gpio_out_temp = list(gpio_out_temp)
if (gpio_out_temp[0] < 32):
ch0_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 64):
gpio_out_temp[0] = gpio_out_temp[0] - 32
ch1_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 96):
gpio_out_temp[0] = gpio_out_temp[0] - 64
ch2_data.append(gpio_out_temp)
else:
gpio_out_temp[0] = gpio_out_temp[0] - 96
ch3_data.append(gpio_out_temp)
if (len(ch0_data) > 0):
self._gpio_output_set('ch0', ch0_data)
if (len(ch1_data) > 0):
self._gpio_output_set('ch1', ch1_data)
if (len(ch2_data) > 0):
self._gpio_output_set('ch2', ch2_data)
if (len(ch3_data) > 0):
self._gpio_output_set('ch3', ch3_data)
return None
def gpio_ctrl(self, gpio_ctrl):
""" set gpio to input or output
Args:
gpio_ctrl(list): the unit of list is (gpio_number,gpio_ctrl)
gpio_number for 0 to 127
set gpio_ctrl to 1, the gpio is set to input
set gpio_ctrl to 0, the gpio is set to output
Returns:
NONE
"""
ch0_data = []
ch1_data = []
ch2_data = []
ch3_data = []
for gpio_out_temp in gpio_ctrl:
gpio_out_temp = list(gpio_out_temp)
if (gpio_out_temp[0] < 32):
ch0_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 64):
gpio_out_temp[0] = gpio_out_temp[0] - 32
ch1_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 96):
gpio_out_temp[0] = gpio_out_temp[0] - 64
ch2_data.append(gpio_out_temp)
else:
gpio_out_temp[0] = gpio_out_temp[0] - 96
ch3_data.append(gpio_out_temp)
if (len(ch0_data) > 0):
self._gpio_ctrl_set('ch0', ch0_data)
if (len(ch1_data) > 0):
self._gpio_ctrl_set('ch1', ch1_data)
if (len(ch2_data) > 0):
self._gpio_ctrl_set('ch2', ch2_data)
if (len(ch3_data) > 0):
self._gpio_ctrl_set('ch3', ch3_data)
return None
def gpio_get(self, gpio_input, gpio_type='in'):
""" get gpio state
Args:
gpio_input(list) : the unit of list is (gpio_number,gpio_level)
gpio_number for 0 to 127
set gpio_level to 255
gpio_type(str) : select the gpio type
'in' --- select input gpio
'out' --- select output gpio
Returns:
gpio_input_data(list) : the unit of list is (gpio_number,gpio_level)
gpio_number for 0 to 127
when gpio is high level, the gpio_level is 1
when gpio is low level, the gpio_level is 0
"""
ch0_data = []
ch1_data = []
ch2_data = []
ch3_data = []
for gpio_out_temp in gpio_input:
gpio_out_temp = list(gpio_out_temp)
if (gpio_out_temp[0] < 32):
ch0_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 64):
gpio_out_temp[0] = gpio_out_temp[0] - 32
ch1_data.append(gpio_out_temp)
elif (gpio_out_temp[0] < 96):
gpio_out_temp[0] = gpio_out_temp[0] - 64
ch2_data.append(gpio_out_temp)
else:
gpio_out_temp[0] = gpio_out_temp[0] - 96
ch3_data.append(gpio_out_temp)
gpio_input_data = []
if (len(ch0_data) > 0):
ch0_data_get = self._gpio_input_get('ch0', ch0_data)
gpio_input_data.extend(ch0_data_get)
if (len(ch1_data) > 0):
ch1_data_get = self._gpio_input_get('ch1', ch1_data)
gpio_input_data.extend(ch1_data_get)
if (len(ch2_data) > 0):
ch2_data_get = self._gpio_input_get('ch2', ch2_data)
gpio_input_data.extend(ch2_data_get)
if (len(ch3_data) > 0):
ch3_data_get = self._gpio_input_get('ch3', ch3_data)
gpio_input_data.extend(ch3_data_get)
return gpio_input_data
def _gpio_output_set(self, gpio_channel, gpio_out):
if (gpio_channel == 'ch0'):
reg_addr = 0x10
elif (gpio_channel == 'ch1'):
reg_addr = 0x20
elif (gpio_channel == 'ch2'):
reg_addr = 0x30
elif (gpio_channel == 'ch3'):
reg_addr = 0x40
else:
logger.error('@%s: GPIO Channel set rror' % (self.name))
return False
rd_data = self.__axi4lite.read(reg_addr, 4)
reg_data_int = self.__data_deal.list_2_int(rd_data)
if (reg_data_int < 0):
reg_data_int = reg_data_int + pow(2, 32)
reg_data_int_shift = reg_data_int
for gpio_out_temp in gpio_out:
reg_data_int_shift = self.__data_deal.cyclic_shift(
'R', reg_data_int_shift, 32, gpio_out_temp[0])
if (gpio_out_temp[1] == 1):
reg_data_int_shift = reg_data_int_shift & 0xFFFFFFFE | 0x00000001
elif (gpio_out_temp[1] == 0):
reg_data_int_shift = reg_data_int_shift & 0xFFFFFFFE
else:
logger.error('@%s: GPIO output set error' % (self.name))
return False
reg_data_int_shift = self.__data_deal.cyclic_shift(
'L', reg_data_int_shift, 32, gpio_out_temp[0])
wr_data = self.__data_deal.int_2_list(reg_data_int_shift, 4)
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
def _gpio_ctrl_set(self, gpio_channel, gpio_ctrl):
if (gpio_channel == 'ch0'):
reg_addr = 0x14
elif (gpio_channel == 'ch1'):
reg_addr = 0x24
elif (gpio_channel == 'ch2'):
reg_addr = 0x34
elif (gpio_channel == 'ch3'):
reg_addr = 0x44
else:
logger.error('@%s: GPIO Channel set error' % (self.name))
return False
rd_data = self.__axi4lite.read(reg_addr, 4)
reg_data_int = self.__data_deal.list_2_int(rd_data)
if (reg_data_int < 0):
reg_data_int = reg_data_int + pow(2, 32)
reg_data_int_shift = reg_data_int
for gpio_ctrl_temp in gpio_ctrl:
reg_data_int_shift = self.__data_deal.cyclic_shift(
'R', reg_data_int_shift, 32, gpio_ctrl_temp[0])
if (gpio_ctrl_temp[1] == 1):
reg_data_int_shift = reg_data_int_shift & 0xFFFFFFFE | 0x00000001
elif (gpio_ctrl_temp[1] == 0):
reg_data_int_shift = reg_data_int_shift & 0xFFFFFFFE
else:
logger.error('@%s: GPIO control set error' % (self.name))
return False
reg_data_int_shift = self.__data_deal.cyclic_shift(
'L', reg_data_int_shift, 32, gpio_ctrl_temp[0])
wr_data = self.__data_deal.int_2_list(reg_data_int_shift, 4)
self.__axi4lite.write(reg_addr, wr_data, len(wr_data))
def _gpio_input_get(self, gpio_channel, gpio_input, gpio_type='in'):
if (gpio_type == 'in'):
if (gpio_channel == 'ch0'):
reg_addr = 0x18
elif (gpio_channel == 'ch1'):
reg_addr = 0x28
elif (gpio_channel == 'ch2'):
reg_addr = 0x38
elif (gpio_channel == 'ch3'):
reg_addr = 0x48
else:
logger.error('@%s: GPIO Channel set error' % (self.name))
return False
else:
if (gpio_channel == 'ch0'):
reg_addr = 0x10
elif (gpio_channel == 'ch1'):
reg_addr = 0x20
elif (gpio_channel == 'ch2'):
reg_addr = 0x30
elif (gpio_channel == 'ch3'):
reg_addr = 0x40
else:
logger.error('@%s: GPIO Channel set error' % (self.name))
return False
rd_data = self.__axi4lite.read(reg_addr, 4)
reg_data_int = self.__data_deal.list_2_int(rd_data)
if (reg_data_int < 0):
reg_data_int = reg_data_int + pow(2, 32)
if (len(gpio_input) > 32):
logger.error('@%s: GPIO number set error' % (self.name))
return False
for gpio_input_index in range(0, len(gpio_input)):
reg_data_int_shift = self.__data_deal.cyclic_shift(
'R', reg_data_int, 32, gpio_input[gpio_input_index][0])
if ((reg_data_int_shift & 0x00000001) == 0x00000001):
gpio_input[gpio_input_index] = (
gpio_input[gpio_input_index][0], 1)
else:
gpio_input[gpio_input_index] = (
gpio_input[gpio_input_index][0], 0)
reg_data_int_shift = self.__data_deal.cyclic_shift(
'L', reg_data_int, 32, gpio_input[gpio_input_index][0])
return gpio_input
class Axi4Sysreg(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def version_get(self):
""" Get FPGA version
Args:
None
Returns:
fpga_version(str): fpga version(0.0~15.15)
"""
rd_data = self.__axi4lite.read(0x10, 1)
if (rd_data == False):
return False
fpga_version_h = (rd_data[0] & 0xF0) >> 4
if (fpga_version_h < 10):
fpga_version_h_str = '0' + str(fpga_version_h)
else:
fpga_version_h_str = str(fpga_version_h)
fpga_version_l = (rd_data[0] & 0x0F)
if (fpga_version_l < 10):
fpga_version_l_str = '0' + str(fpga_version_l)
else:
fpga_version_l_str = str(fpga_version_l)
fpga_version = fpga_version_h_str + '.' + fpga_version_l_str
return fpga_version
def uct_set(self, uct_second, uct_mircosecond):
""" Set uct
Args:
uct_second(int): second time
uct_mircosecond(int): mircosecond time(0~999)
Returns:
None
"""
uct_1 = self.__data_deal.int_2_list(uct_mircosecond, 2)
uct_2 = self.__data_deal.int_2_list(uct_second, 4)
wr_data = uct_1 + uct_2
self.__axi4lite.write(0x40, wr_data, len(wr_data))
self.__axi4lite.write(0x46, [0x01], 1)
return None
def uct_get(self):
""" Get uct
Args:
None
Returns:
uct_second(int): second time
uct_mircosecond(int): mircosecond time
"""
self.__axi4lite.write(0x47, [0x01], 1)
rw_addr = 0x48
rd_data = self.__axi4lite.read(rw_addr, 6)
print(rd_data)
if (rd_data == False):
return False
uct_mircosecond = self.__data_deal.list_2_int(rd_data[0:1])
uct_second = self.__data_deal.list_2_int(rd_data[2:5])
return (uct_second, uct_mircosecond)
def external_register_write(self, reg_addr, reg_data):
""" write external register
Args:
reg_addr(int): register address, 0x80~0x9F
reg_data(list): register write data
Returns:
None
"""
self.__axi4lite.write(reg_addr, reg_data, len(reg_data))
return None
def external_register_read(self, reg_addr, read_length):
""" write external register
Args:
reg_addr(int): register address, 0x80~0x9F
read_length(int): read data bytes
Returns:
reg_data(list): register read data
"""
reg_data = self.__axi4lite.read(reg_addr, read_length)
return reg_data
class Axi4AidBusSniffer():
def __init__(self,name):
self.name = name
self.reg_num = 8192
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10,[0x01],1)
return None
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10,[0x00],1)
return None
def rece_aid_req_data(self):
""" rece_aid_req_data, Format:0x00+FB,0x00+SB,...,0x00+LB,0xFF+Frame_Number
Args:
None
Returns:
aid_req_data(list): Format:0x00+FB,0x00+SB,...,0x00+LB,0xFF+Frame_Number,len 0~2048(len=0 --> no aid request data)
"""
# 0x20~0x23: aid_rece_timeout_cnt
# 0x80: aid_req_fifo_rd & aid_req_fifo_rdata
# 0x81~0x82: aid_req_fifo_dcnt
# query fifo data len
rd_data = self.__axi4lite.read(0x81,2)
aid_req_len = self.__data_deal.list_2_int(rd_data)
# rece aid req data
aid_req_data = []
if(aid_req_len != 0):
aid_req_data = self.__axi4lite.read_array(0x80, aid_req_len, 8)
return aid_req_data
def rece_aid_resp_data(self):
""" rece_aid_resp_data, Format:0x00+FB,0x00+SB,...,0x00+LB,0xFF+Frame_Number
Args:
None
Returns:
aid_resp_data(list): Format:0x00+FB,0x00+SB,...,0x00+LB,0xFF+Frame_Number,len 0~2048(len=0 --> no aid response data)
"""
# 0x20~0x23: aid_rece_timeout_cnt
# 0x84: aid_resp_fifo_rd & aid_resp_fifo_rdata
# 0x85~0x86: aid_resp_fifo_dcnt
# query fifo data len
rd_data = self.__axi4lite.read(0x85,2)
aid_resp_len = self.__data_deal.list_2_int(rd_data)
# rece aid resp data
aid_resp_data = []
if(aid_resp_len != 0):
aid_resp_data = self.__axi4lite.read_array(0x84, aid_resp_len, 8)
return aid_resp_data
class Axi4I2c(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4_clk_frequency = 125000000
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.config()
rd_data = self.__axi4lite.read(0x12, 2)
self._cache_size = self.__data_deal.list_2_int(rd_data)
def config(self, bit_rate_hz=400000):
""" config ii2 master
Args:
bit_rate_hz(int): iic bus bit rate, unit is Hz
Returns:
None
"""
self.disable()
bit_rate_ctrl = bit_rate_hz * 8 * pow(2,
32) / self.__axi4_clk_frequency
wr_data = self.__data_deal.int_2_list(int(bit_rate_ctrl), 4)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
self.enable()
return None
def write(self, dev_addr, data):
""" iis write
Args:
dev_addr(int): iic slave address
data(list): iic write data, length < 65
Returns:
False | True
"""
op_code = dev_addr * 2
send_data = [op_code] + data
send_list = []
for i in range(0, len(send_data)):
send_list.append(send_data[i])
if i == 0:
send_list.append(0x80)
elif i == (len(send_data) - 1):
send_list.append(0x20)
else:
send_list.append(0x00)
receive_list = self._iic_control(send_list)
if receive_list == False:
self.enable()
return False
i = 0
while (i < len(receive_list)):
if (receive_list[i + 1] & 0x01 == 0x01):
logger.error('@%s: receive no ACK' % (self.name))
return False
i = i + 2
return True
def read(self, dev_addr, length):
""" iis read
Args:
dev_addr(int): iic slave address
length(int): iic read data length, length < 65
Returns:
receive_list_out(list): iic read data
if error, return False
"""
op_code = dev_addr * 2 + 0x01
send_list = [op_code, 0x80]
for i in range(0, length):
send_list.append(0x00)
if i == (length - 1):
send_list.append(0x70)
else:
send_list.append(0x40)
receive_list = self._iic_control(send_list)
if receive_list == False:
self.enable()
return False
i = 0
receive_list_out = []
while i < len(receive_list):
receive_list_out.append(receive_list[i])
if (i != len(receive_list) - 2):
if (receive_list[i + 1] & 0x01) == 0x01:
logger.error('@%s: receive no ACK' % (self.name))
return False
i = i + 2
i = 0
while i >= 0:
del receive_list_out[i]
i = i - 1
return receive_list_out
def rdwr(self, dev_addr, write_data_list, read_length):
""" iis write and read
Args:
dev_addr(int): iic slave address
write_data_list(list): iic write data, length < 65
read_length(int): iic read data length, length < 65
the length of write_data_list + read_length < 65
Returns:
receive_list_out(list): iic read data
if error, return False
"""
op_code = dev_addr * 2
send_data = [op_code] + write_data_list
send_list = []
for i in range(0, len(send_data)):
send_list.append(send_data[i])
if i == 0:
send_list.append(0x80)
else:
send_list.append(0x00)
op_code = dev_addr * 2 + 0x1
send_list.append(op_code)
send_list.append(0x80)
for i in range(0, read_length):
send_list.append(0x00)
if i == (read_length - 1):
send_list.append(0x70)
else:
send_list.append(0x40)
receive_list = self._iic_control(send_list)
if receive_list == False:
self.enable()
return False
i = 0
receive_list_out = []
while i < len(receive_list) - 1:
receive_list_out.append(receive_list[i])
if (i != len(receive_list) - 2):
if (receive_list[i + 1] & 0x01) == 0x01:
logger.error('@%s: receive no ACK' % (self.name))
return False
i = i + 2
i = 1 + len(write_data_list)
while i >= 0:
del receive_list_out[i]
i = i - 1
return receive_list_out
def _iic_control(self, send_list):
time_out = 0
send_cache_depth = self.__axi4lite.read(0x1C, 1)
if (send_cache_depth[0] > 0):
logger.error('@%s: send cache not empty' % (self.name))
return False
recieve_cache_depth = self.__axi4lite.read(0x1E, 1)
if (recieve_cache_depth[0] > 0):
logger.error('@%s: receive cache not empty' % (self.name))
return False
if (len(send_list) > self._cache_size * 2):
logger.error('@%s: send data too much' % (self.name))
return False
self.__axi4lite.write_array(0x14, send_list, len(send_list), 16)
while time_out < 3000:
recieve_cache_depth = self.__axi4lite.read(0x1E, 1)
if recieve_cache_depth[0] == (len(send_list)) / 2:
break
else:
time_out = time_out + 1
time.sleep(0.001)
if time_out == 3000:
logger.error('@%s: receive data enough' % (self.name))
return False
receive_bytes_cnt = 2 * recieve_cache_depth[0]
receive_list = self.__axi4lite.read_array(0x18, receive_bytes_cnt, 16)
return receive_list
def _axi4_clk_frequency_set(self, clk_frequency):
self.__axi4_clk_frequency = clk_frequency
def enable(self):
"""enable function"""
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""disable function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
class AXI4_Frame_Test(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def _test_register(self, test_data):
wr_data = self.__data_deal.int_2_list(test_data, 16)
self.__axi4lite.write(0x00, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x00, 8)
check_data = self.__data_deal.list_2_int(rd_data)
if (check_data != test_data):
logger.error('@ %s: Test Register read data error.' % (self.name))
return False
#print('Peripherals register test pass')
return True
def enable(self):
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return True
def disbale(self):
self.__axi4lite.write(0x10, [0x00], 1)
return True
def frame_gen_set(self, frame_id, frame_length):
wr_data_int = frame_length * pow(2, 16) + frame_id
wr_data = self.__data_deal.int_2_list(wr_data_int, 4)
self.__axi4lite.write(0x2C, wr_data, len(wr_data))
return True
def frame_test_start(self):
self.__axi4lite.write(0x11, [0x01], 1)
return True
def frame_test_stop(self):
self.__axi4lite.write(0x11, [0x00], 1)
return True
def tx_state_get(self):
rd_data = self.__axi4lite.read(0x20, 4)
frame_count = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x24, 8)
frame_time_cnt = self.__data_deal.list_2_int(rd_data)
frame_time = float(frame_time_cnt) * 8 / 1000000000
return (frame_time, frame_count)
def rx_state_get(self):
rd_data = self.__axi4lite.read(0x30, 4)
frame_count = self.__data_deal.list_2_int(rd_data)
rd_data = self.__axi4lite.read(0x34, 8)
frame_time_cnt = self.__data_deal.list_2_int(rd_data)
frame_time = float(frame_time_cnt) * 8 / 1000000000
rd_data = self.__axi4lite.read(0x3C, 4)
error_count = self.__data_deal.list_2_int(rd_data)
return (frame_time, frame_count, error_count)
class Axi4JtagCore():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def jtag_freq_set(self, freq_data):
""" jtag tck freq set
Args:
freq_data(int): jtag tck freq set,Hz(1000~25000000)
Returns:
None
"""
rd_data = self.__axi4lite.read(0x01, 3)
base_clk_freq = self.__data_deal.list_2_int(rd_data)
# set jtag freq
jtag_freq_div = int(((base_clk_freq * 1000) / (freq_data * 2)) - 2)
if (jtag_freq_div < 0):
jtag_freq_div = 0
wr_data = self.__data_deal.int_2_list(jtag_freq_div, 2)
self.__axi4lite.write(0x04, wr_data, len(wr_data))
return None
def jtag_rst_pin_ctrl(self, level):
""" jtag rst pin ctrl
Args:
level(string): 'H'--high level,'L'--low level
Returns:
None
"""
rd_data = self.__axi4lite.read(0x13, 1)
if level == 'H':
rd_data[0] = rd_data[0] & 0x7F
else:
rd_data[0] = rd_data[0] | 0x80
self.__axi4lite.write(0x13, rd_data, 1)
return None
def jtag_logic_rst(self):
""" jtag_logic_rst, the JTAG state machine reset logic.
Args:
None
Returns:
None
"""
rd_data = self.__axi4lite.read(0x13, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x13, rd_data, 1)
rd_data[0] = rd_data[0] & 0xFE
self.__axi4lite.write(0x13, rd_data, 1)
return None
def jtag_tran_operate(self, ir_bit_len, ir_data, dr_bit_len, dr_data):
""" jtag tran operate, shift IR&DR
Args:
ir_bit_len(int): 0~32, when ir_bit_len is 0, no ir operation.
ir_data(list): ir shift data, at most 4 byte data. Shift starts at first byte bit0.
dr_bit_len(int): 0~16384, when dr_bit_len is 0, no dr operation.
dr_data(list): dr shift data, at most 2048 bytes. Shift starts at first byte bit0.
Returns:
dr_shift_in_data(list): dr_bit_len valid bits, start first byte bit0.
"""
# ir_len(0x20~0x21),dr_len(0x22~0x23)
ir_bit_len_list = self.__data_deal.int_2_list(ir_bit_len, 2)
dr_bit_len_list = self.__data_deal.int_2_list(dr_bit_len, 2)
self.__axi4lite.write(0x20, ir_bit_len_list + dr_bit_len_list, 4)
# ir_data(0x24~0x27)
if (ir_bit_len != 0):
self.__axi4lite.write(0x24, ir_data, len(ir_data))
# start jtag tran operate
self.__axi4lite.write(0x11, [0x01], 1)
# dr_data(0x28~0x2B)
dr_data_len = len(dr_data)
wr_data_len = 0
wr_data = []
if (dr_bit_len != 0):
if ((dr_data_len % 4) != 0):
wr_data = ((4 - (dr_data_len % 4)) * [0x00])
wr_data = dr_data + wr_data
wr_data_len = len(wr_data)
self.__axi4lite.write_array(0x28, wr_data, wr_data_len, 32)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x14, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 10000:
time.sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 10000):
logger.error('jtag tran operate wait time out')
return False
# rd dr data(0x28~0x2B)
# wr_dr_dcnt(0x2C~0x2D),rd_dr_dcnt(0x2E~0x2F)
dr_shift_in_data = []
if (dr_bit_len != 0):
dr_shift_in_data = self.__axi4lite.read_array(
0x28, wr_data_len, 32)
return dr_shift_in_data[0:dr_data_len]
class Axi4FftAnalyzer(object):
def __init__(self, name):
self.name = name
self.reg_num = 65536
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__k1_index = 0
self.__k1_data = 0
self.__k2_index = 0
self.__k2_data = 0
self.__all_power = 0
self.__fft_power_data = []
self.__sample_rate = 0
self.__freq_resolution = 0
self.__bandwidth_index = 0
self.__decimation_data = 1
self.__base_frequency = 1000
def enable(self):
"""enable function"""
self.disable()
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] | 0x01
self.__axi4lite.write(0x10, rd_data, 1)
return None
def disable(self):
"""disable function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] & 0xFE
self.__axi4lite.write(0x10, rd_data, 1)
return None
def upload_enable(self):
"""enable data upload function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] | 0x02
self.__axi4lite.write(0x10, rd_data, 1)
return None
def upload_disable(self):
"""disbale data upload function"""
rd_data = self.__axi4lite.read(0x10, 1)
rd_data[0] = rd_data[0] & 0xFD
self.__axi4lite.write(0x10, rd_data, 1)
return None
def measure_paramter_set(self, bandwidth_hz, sample_rate, decimation_type):
""" Set measure paramter
Args:
bandwidth_hz(int): Bandwidth limit, unit is Hz
sample_rate(int): signal sample rate, unit is Hz
decimation_type(str): signal decimation type
'auto' -- automatic detection
'1'/'2'/........
Returns:
False | True
"""
self._decimation_factor_set(decimation_type)
self.__sample_rate = sample_rate / self.__decimation_data
self.__freq_resolution = sample_rate / (8192 * self.__decimation_data)
self.__bandwidth_index = int(bandwidth_hz / self.__freq_resolution)
return True
def measure_start(self):
""" start measure
Args:
None
Returns:
False | True
"""
self.__axi4lite.write(0x14, [0x00], 1)
self.__axi4lite.write(0x13, [0x01], 1)
rd_data = [0]
timeout_cnt = 0
while (rd_data[0] == 0x00) and timeout_cnt < 3000:
sleep(0.001)
rd_data = self.__axi4lite.read(0x14, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 3000):
logger.error('@%s: wait time out' % (self.name))
return False
self._get_fft_data()
self._base_index_find()
return True
def thdn_measure(self):
""" measure thd+n
Args:
None
Returns:
thdn_data(float): thd+n
"""
fundamental_power = 0
for i in range(self.__k1_index - 4, self.__k2_index + 4):
fundamental_power = fundamental_power + self.__fft_power_data[i]
thdn_data = 10 * math.log10(
(self.__all_power - fundamental_power) / fundamental_power)
return (thdn_data, 'dB')
def singal_measure(self):
""" measure frequency and vpp
Args:
None
Returns:
amp_data(float): Normalized amplitude (0.000~0.999)
freq_data(float): signal frequency, unit is Hz
"""
k1_data = math.sqrt(self.__k1_data)
k2_data = math.sqrt(self.__k2_data)
b_data = (k2_data - k1_data) / (k2_data + k1_data)
a_data = 2.95494514 * pow(b_data, 1) + 0.17671943 * pow(
b_data, 3) + 0.09230694 * pow(b_data, 5)
amp_data = (k1_data +
k2_data) * (3.20976143 + 0.9187393 * pow(a_data, 2) +
0.14734229 * pow(a_data, 4)) / 8192
amp_data = amp_data / 4096
freq_data = (0.5 + a_data + self.__k1_index) * (self.__sample_rate /
8192)
self.__base_frequency = freq_data
return (amp_data, 'V', freq_data, 'Hz')
def vpp_measure(self, signal_frequency):
""" measure the amplitude of the input frequency signal
Args:
signal_frequency(int): measure signal frequency, unit is hz
Returns:
amp_data(float): Normalized amplitude (0.000~0.999)
"""
k1_index = int(signal_frequency / self.__freq_resolution)
k2_index = k1_index + 1
k1_data = self.__fft_power_data[k1_index]
k2_data = self.__fft_power_data[k2_index]
k1_data = math.sqrt(k1_data)
k2_data = math.sqrt(k2_data)
b_data = (k2_data - k1_data) / (k2_data + k1_data)
a_data = 2.95494514 * pow(b_data, 1) + 0.17671943 * pow(
b_data, 3) + 0.09230694 * pow(b_data, 5)
amp_data = (k1_data +
k2_data) * (3.20976143 + 0.9187393 * pow(a_data, 2) +
0.14734229 * pow(a_data, 4)) / 8192
amp_data = amp_data / 4096
return (amp_data, "V")
def thd_measure(self, harmonic_num):
""" measure thd
Args:
harmonic_num(int): harmonic num, <11
Returns:
amp_data(float): Normalized amplitude (0.000~0.999)
thd_data(float): thd data
"""
harmonic_freq = []
harmonic_vpp = []
harmonic_power = []
harmonic_all_power = 0
for i in range(1, harmonic_num):
freq_data = i * self.__base_frequency
harmonic_freq.append(freq_data)
k1_index = int(freq_data / self.__freq_resolution)
k2_index = k1_index + 1
power_temp = 0
for j in range(k1_index - 4, k2_index + 4):
power_temp = power_temp + self.__fft_power_data[j]
harmonic_power.append(power_temp)
harmonic_all_power = harmonic_all_power + power_temp
k1_data = self.__fft_power_data[k1_index]
k2_data = self.__fft_power_data[k2_index]
if ((k1_data != 0) or (k2_data != 0)):
k1_data = math.sqrt(k1_data)
k2_data = math.sqrt(k2_data)
b_data = (k2_data - k1_data) / (k2_data + k1_data)
a_data = 2.95494514 * pow(b_data, 1) + 0.17671943 * pow(
b_data, 3) + 0.09230694 * pow(b_data, 5)
amp_data = (k1_data + k2_data) * (
3.20976143 + 0.9187393 * pow(a_data, 2) +
0.14734229 * pow(a_data, 4)) / 8192
else:
amp_data = 0
harmonic_vpp.append(amp_data)
thd_data = 10 * math.log10(
(harmonic_all_power - harmonic_power[0]) / harmonic_power[0])
harmonic_all_amp_square = 0
for i in range(1, harmonic_num - 1):
harmonic_all_amp_square = harmonic_all_amp_square + pow(
harmonic_vpp[i], 2)
thd_data1 = 20 * math.log10(
math.sqrt(harmonic_all_amp_square) / harmonic_vpp[0])
return (thd_data, 'dB', thd_data1, 'dB')
def _decimation_factor_set(self, decimation_type):
if (decimation_type is 'auto'):
decimation_type_data = 0xFF
else:
decimation_type_data = int(decimation_type)
self.__axi4lite.write(0x15, [decimation_type_data], 1)
self.__axi4lite.write(0x17, [0x01], 1)
rd_data = [0]
timeout_cnt = 0
while (rd_data[0] == 0x00) and timeout_cnt < 3000:
sleep(0.001)
rd_data = self.__axi4lite.read(0x17, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 3000):
logger.error('@%s: wait time out' % (self.name))
return False
rd_data = self.__axi4lite.read(0x16, 1)
self.__decimation_data = rd_data[0]
return True
def _base_index_find(self):
max_data = max(self.__fft_power_data)
max_index = self.__fft_power_data.index(max_data)
max_left_index = max_index - 1
max_left_data = self.__fft_power_data[max_left_index]
max_right_index = max_index + 1
max_right_data = self.__fft_power_data[max_right_index]
if (max_left_data > max_right_data):
second_index = max_left_index
second_data = max_left_data
else:
second_index = max_right_index
second_data = max_right_data
if (max_index > second_index):
self.__k1_index = second_index
self.__k1_data = second_data
self.__k2_index = max_index
self.__k2_data = max_data
else:
self.__k2_index = second_index
self.__k2_data = second_data
self.__k1_index = max_index
self.__k1_data = max_data
self.__all_power = sum(self.__fft_power_data[8:self.__bandwidth_index])
return None
def _get_fft_data(self):
fft_data = []
self.__fft_power_data = []
rd_data = self.__axi4lite.read(0x84, 4)
fft_data_cnt = self.__data_deal.list_2_int(rd_data)
if (fft_data_cnt != 0):
fft_data = self.__axi4lite.read_array(0x80, fft_data_cnt * 4, 32)
for i in range(int(fft_data_cnt / 2)):
self.__fft_power_data.append(
self.__data_deal.list_2_int(fft_data[i * 8:i * 8 + 6]))
# print(self.__fft_power_data)
return self.__fft_power_data
def _test_register(self, test_data):
wr_data = self.__data_deal.int_2_list(test_data, 4)
self.__axi4lite.write(0x00, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x00, len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if (test_out != test_data):
logger.error('@%s: Test Register read data error. ' % (self.name))
return False
return None
class Axi4SpiAdc(object):
def __init__(self,name):
self.name = name
self.reg_num = 256
self.__axi4_clk_frequency = 125000000
self.__axi4lite=Axi4lite(self.name,self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail'%(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""enable function"""
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""disable function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def sample_rate_set(self,sample_rate):
""" set adc sample rate
Args:
sample_rate(int): ADC sample rate, unit is SPS
Returns:
None
"""
freq_hz_ctrl = int(sample_rate*pow(2,32)/self.__axi4_clk_frequency)
wr_data = self.__data_deal.int_2_list(freq_hz_ctrl, 4)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
return None
def sample_data_get(self):
""" get sample data
Args:
None
Returns:
sample_volt(float): normalize volt (-1~+1)
"""
rd_data = self.__axi4lite.read(0x24,4)
sample_data = self.__data_deal.list_2_int(rd_data)
sample_volt = sample_data/pow(2,31)
return sample_volt
def _test_register(self,test_data):
wr_data = self.__data_deal.int_2_list(test_data,4)
self.__axi4lite.write(0x00,wr_data,len(wr_data))
rd_data = self.__axi4lite.read(0x00,len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if(test_out != test_data):
logger.error('@%s: Test Register read data error. '%(self.name))
return False
return None
def _set_axi4_clk_frequency(self,clk_frequency):
self.__axi4_clk_frequency = clk_frequency
return None
class Axi4SpiDac(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4_clk_frequency = 125000000
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
self.__sclk_frequency = 10000000
def enable(self):
"""enable function"""
self.__axi4lite.write(0x10, [0x00], 1)
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""disable function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def dac_mode_set(self, dac_mode):
""" set dac mode data
Args:
dac_mode(int): dac mode data
Returns:
None
"""
wr_data = [dac_mode]
self.__axi4lite.write(0x11, wr_data, len(wr_data))
return None
def spi_sclk_frequency_set(self, sclk_freq_hz):
""" set spi bus sclk frequency
Args:
sclk_freq_hz(int): spi bus sclk frequency, unit is Hz
Returns:
None
"""
self.__sclk_frequency = sclk_freq_hz
freq_hz_ctrl = int(sclk_freq_hz * pow(2, 32) /
self.__axi4_clk_frequency)
wr_data = self.__data_deal.int_2_list(freq_hz_ctrl, 4)
self.__axi4lite.write(0x24, wr_data, len(wr_data))
return None
def sample_rate_set(self, sample_rate):
""" set dac sample rate
Args:
sample_rate(int): DAC sample rate, unit is SPS
Returns:
None
"""
freq_hz_ctrl = int(sample_rate * pow(2, 32) / self.__sclk_frequency)
wr_data = self.__data_deal.int_2_list(freq_hz_ctrl, 4)
self.__axi4lite.write(0x20, wr_data, len(wr_data))
return None
def _test_register(self, test_data):
wr_data = self.__data_deal.int_2_list(test_data, 4)
self.__axi4lite.write(0x00, wr_data, len(wr_data))
rd_data = self.__axi4lite.read(0x00, len(wr_data))
test_out = self.__data_deal.list_2_int(rd_data)
if (test_out != test_data):
logger.error('@%s: Test Register read data error. ' % (self.name))
return False
return None
def _set_axi4_clk_frequency(self, clk_frequency):
self.__axi4_clk_frequency = clk_frequency
return None
class Axi4HdqSlave(object):
def __init__(self, name):
self.name = name
self.reg_num = 256
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__axi4_clk_frequency = 125000000
self.__data_deal = DataOperate()
def disable(self):
""" Disable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = rd_data[0] & 0xF0
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def enable(self):
""" Enable function """
rd_data = self.__axi4lite.read(0x10, 1)
wr_data = rd_data[0] & 0xF0
self.__axi4lite.write(0x10, [wr_data], 1)
wr_data = rd_data[0] & 0xF0 | 0x01
self.__axi4lite.write(0x10, [wr_data], 1)
return None
def hdq_receive_wr_addr(self):
""" get hdq_master input wr_addr and wr flag
Args:
None
Returns:
the hdq_wr_addr and wr flag of input hdq_master
"""
rd_data = self.__axi4lite.read(0x11, 1)
hdq_wr_addr = self.__data_deal.list_2_int(rd_data)
return hdq_wr_addr
def hdq_receive_wr_data(self):
""" get hdq_master input wr_data
Args:
None
Returns:
the hdq_wr_data and wr flag of input hdq_master
"""
rd_data = self.__axi4lite.read(0x12, 1)
hdq_wr_data = self.__data_deal.list_2_int(rd_data)
return hdq_wr_data
def hdq_recevice_rd_addr(self):
""" get hdq_master input rd_addr and wr flag
Args:
None
Returns:
the hdq_rd_addr and wr flag of input hdq_master
"""
rd_data = self.__axi4lite.read(0x13, 1)
hdq_rd_addr = self.__data_deal.list_2_int(rd_data)
return hdq_rd_addr
def hdq_sent_rd_data(self, wr_data):
""" to hdq_master output rd_data
Args:
the hdq_rd_data :hdq_slave send to hdq master
Returns:
None
"""
self.__axi4lite.wite(0x14, [wr_data], 1)
return None
class Axi4PowerPwmCore():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def read_adc_sample_data(self):
""" read_adc_sample_data
Args:
None
Returns:
adc_value: the normalized min level of input signal, unit is V,-1V ~ +1V
the true voltage value needs to be multiplied by the reference range.
"""
# 0x38~0x3B [31:0]--adc_data:
rd_data = self.__axi4lite.read(0x38, 4)
adc_value = self.__data_deal.list_2_int(rd_data) / pow(2, 31)
return adc_value
def power_pwm_output_disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def power_pwm_output_enable(self,
pwm_mode,
pid_en,
adc_dec_param,
p_param,
i_param,
d_param,
pwm0_duty,
pwm1_duty,
pwm_minimum_duty=0.05,
pwm_maximum_duty=0.95,
pwm_error_duty=0.01,
adc_tran_pwm_param=72):
""" power_pwm_en
Args:
pwm_mode(bool): 0-singal,1-double
pid_en(bool): For enable PID modulation.
adc_dec_param(int): 0~65535, ADC sampling decimation coefficient.
p_param(float): -0.9999~+0.9999, PID proportional parameters.
i_param(float): -0.9999~+0.9999, PID integral parameter.
d_param(float): -0.9999~+0.9999, PID differential parameter.
pwm0_duty(float): 0.05~0.95, pwm0_param = pwm0_duty * 624, pwm0 duty parameter.
pwm1_duty(float): 0.05~0.95, pwm0_param = pwm0_duty * 624, pwm1 duty parameter.
pwm_minimum_duty(float): 0.05~0.95, pwm_minimum_param = pwm_minimum_duty * 624, for PID modulation, limit minimum PWM duty output
pwm_maximum_duty(float): 0.05~0.95, pwm_minimum_param = pwm_maximum_duty * 624, for PID modulation, limit maximum PWM duty output
pwm_error_duty(float): 0.05~0.95, pwm_error_param = pwm_maximum_duty * 624, For PID modulation, The error exceeding this value will start the PID modulation
adc_tran_pwm_param(int): (3.5*5/24)*(adc/2^15)*(125000/200) ≈> adc/72 => adc_tran_pwm_param = 72
3.5 => Attenuation coefficient,
5 => ADC input range,+-5V
24 => Voltage output range
125000 => FPGA IP base frequency, KHZ
200 => PWM frequency, KHZ
Returns:
None
"""
self.power_pwm_output_disable()
# cfg param
wr_data = self.__data_deal.int_2_list(int(adc_dec_param), 2)
self.__axi4lite.write(0x20, wr_data, 2)
wr_data = self.__data_deal.int_2_list(int(p_param * pow(2, 17)), 3)
self.__axi4lite.write(0x24, wr_data, 3)
wr_data = self.__data_deal.int_2_list(int(i_param * pow(2, 17)), 3)
self.__axi4lite.write(0x28, wr_data, 3)
wr_data = self.__data_deal.int_2_list(int(d_param * pow(2, 17)), 3)
self.__axi4lite.write(0x2C, wr_data, 3)
wr_data = self.__data_deal.int_2_list(int(pwm0_duty * 624), 2)
self.__axi4lite.write(0x30, wr_data, 2)
wr_data = self.__data_deal.int_2_list(int(pwm1_duty * 624), 2)
self.__axi4lite.write(0x34, wr_data, 2)
wr_data = self.__data_deal.int_2_list(int(pwm_minimum_duty * 624), 2)
self.__axi4lite.write(0x40, wr_data, 2)
wr_data = self.__data_deal.int_2_list(int(pwm_maximum_duty * 624), 2)
self.__axi4lite.write(0x44, wr_data, 2)
wr_data = self.__data_deal.int_2_list(int(pwm_error_duty * 624), 2)
self.__axi4lite.write(0x48, wr_data, 2)
# # start pwm
# self.__axi4lite.write(0x11,[0x01],1)
# cfg mode info
wr_data = 0x01 | pwm_mode << 4 | pid_en << 5
self.__axi4lite.write(0x10, [wr_data], 1)
return None
class Axi4AskEncode():
def __init__(self, name):
self.name = name
self.reg_num = 8192
self.__axi4lite = Axi4lite(self.name, self.reg_num)
if self.__axi4lite.open() is False:
logger.error('open %s device register number %d fail' %
(self.name, self.reg_num))
self.__data_deal = DataOperate()
def enable(self):
"""Enable this FPGA function"""
self.__axi4lite.write(0x10, [0x01], 1)
return None
def disable(self):
"""Disable this FPGA function"""
self.__axi4lite.write(0x10, [0x00], 1)
return None
def set_ask_data_frequency(self, ask_data_freq):
""" set_ask_date_frequency
Args:
ask_data_freq(int): ask data frequency,100~100000Hz
Returns:
None
"""
rd_data = self.__axi4lite.read(0x04, 4)
base_freq = self.__data_deal.list_2_int(rd_data)
data_freq_cnt = int(base_freq / ask_data_freq / 2) - 2
wr_data = self.__data_deal.int_2_list(data_freq_cnt, 3)
self.__axi4lite.write(0x14, wr_data, len(wr_data))
return None
def send_ask_decode_data(self, ask_send_data):
""" send_ask_decode_data, include checksum data
Args:
ask_send_data(list): ask send data
Returns:
True | False
"""
# 0x12-[0]: ask_encode_start 1 -- valid
# 0x13-[0]: ask_encode_state 0--busy,1--ready
# 0x20: ask_fifo_wr & ask_fifo_wdata
# 0x21~0x22: ask_wr_data_len
ask_data_len = len(ask_send_data)
if (ask_data_len == 0):
return False
# send ask data to ask data_fifo
self.__axi4lite.write_array(0x20, ask_send_data, ask_data_len, 8)
# ask encode start
self.__axi4lite.write(0x12, [0x01], 1)
# query state
timeout_cnt = 0
rd_data = self.__axi4lite.read(0x13, 1)
while (rd_data[0] == 0x00) and timeout_cnt < 1000:
time.sleep(0.01)
rd_data = self.__axi4lite.read(0x13, 1)
timeout_cnt = timeout_cnt + 1
if (timeout_cnt == 1000):
return False
return True
