def rdwr(self, dev_addr, write_data_list, read_length):
logger.debug(
"rdwr i2c device %s addr:0x%x write length:%d data:%s read length:%d"
% (self._name, dev_addr, len(write_data_list),
logger.print_list2hex(write_data_list), read_length))
if not self.__open():
return False
write_length = len(write_data_list)
write_data = (ctypes.c_ubyte * write_length)(*write_data_list)
read_data = (ctypes.c_char * read_length)()
status = self._bus.sg_i2c_rdwr(self._fd, dev_addr, write_data,
write_length, read_data, read_length)
self.__close()
if (status < 0):
logger.warning(
"rdwr i2c device %s addr:0x%x write length:%d data:%s read length:%d fail"
% (self._name, dev_addr, len(write_data_list),
logger.print_list2hex(write_data_list), read_length))
return False
data = list(struct.unpack('%dB' % read_length, read_data.raw))
return data
def delete_object(self, path):
object_name = get_basename_by_path(path)
if getattr(self, object_name, None) != None:
logger.debug("delete object:%s"%(object_name))
setattr(self, object_name, None)
logger.debug('after delete object:%s'%(getattr(self, object_name)))
return None
def write_bytes(self, data):
""" write byte string data to uart
Args:
data(string) : a string of bytes data
Returns:
on success, return True
on error, return False
"""
if self.get_uart_status() is False:
self._close()
return False
elif self.__is_use is False:
return False
elif self.is_open is False:
self._open()
length = len(data)
logger.debug("write uart %s length:%d" % (self.name, length))
try:
writen_len = self.__ser.write(data)
except Exception as e:
logger.error("write uart %s length:%d error:%s" %
(self.name, length, repr(e)))
return False
if (writen_len != length):
logger.warning(
"write uart device:%s length fail,except length:%s, reality length:%s"
% (self.name, length, writen_len))
return False
return True
def __open(self):
logger.debug("open i2c device %s" % (self._name))
self._fd = self._bus.sg_i2c_open(self._name)
if self._fd <= 0:
logger.error("open i2c device %s fail" % (self._name))
return False
else:
return True
def open(self):
logger.debug('libsgfpaga path is %s' % (libname))
if libaxi4lite is None:
self._axi4lite = RPCAxi4lite(self._name, self._register_num)
else:
self._axi4lite = CAxi4lite(self._name, self._register_num)
return self._axi4lite.open()
def write(self, memory_addr, data):
""" Write datas to EEPROM
Args:
memory_addr: memory address
(0x0000-0xffff)
data: list type
[data1,...,data_n]
Returns:
bool: True | False, True for success, False for failed or to more data to write.
"""
write_len = len(data)
if memory_addr + write_len > self._chip_size:
logger.warning("no more then %s to write " %
(str(self._chip_size)))
return False
data = list(data)
write_addr = memory_addr
write_bytes = 0
logger.debug("cat24cxx write " + str(write_addr) + ' len ' +
str(write_len))
if write_len > self._page_size or (write_addr &
(self._page_size - 1)) != 0:
write_bytes = self._page_size - (write_addr &
(self._page_size - 1))
else:
write_bytes = write_len
while write_len > 0:
if self._device_type == "cat04" or self._device_type == "cat08" or self._device_type == "cat16":
device_addr = self._device_addr | (
(write_addr >> 8) & self._mask)
else:
device_addr = self._device_addr
mem_addr = self._memory_address_to_byte_list(write_addr)
#FPGA i2c bus a frame max size is 32 bytes data.
if write_bytes > (32 - 1 - len(mem_addr)):
write_bytes = 32 - 1 - len(mem_addr)
write_data = data[0:write_bytes]
ret = self.iic_bus.write(device_addr, mem_addr + write_data)
if not ret:
return False
del data[0:write_bytes]
write_len -= write_bytes
write_addr += write_bytes
if write_len > self._page_size:
write_bytes = self._page_size
else:
write_bytes = write_len
time.sleep(cat24cxx_list[self._device_type]["wdelay"])
return True
def spi_slave_enable(bus_name):
logger.debug("spi slave enable -->bus name:%s "%(bus_name))
try:
profile = Profile.get_bus_by_name(bus_name)
bus = SpiSlaveFactory.create_object(SpiSlaveFactory, profile["path"])
return bus.enable()
except Exception as e:
logger.error("execute module spi_slave_enable False:" + repr(e))
return False
def create_object(self, path, channel = None):
object_name = get_objectname_by_path(path)
if getattr(self, object_name, None) == None:
logger.debug("create new object:%s"%(object_name))
setattr(self, object_name, eval(self.object_type)(path, channel))
logger.debug("get object:%s"%(getattr(self, object_name)))
''' init '''
self.init_object(getattr(self, object_name), channel)
''' init end '''
return getattr(self, object_name)
def read(self, register_addr, read_length):
"""Read data from register
Returns:
list type: [data0,data1,...,data_n]
data_n (0x00-0xff)
"""
data = []
data.append(register_addr)
logger.debug("cat9555 device read addr:" + hex(register_addr) +
" len:" + str(read_length))
result = self.iic_bus.rdwr(self._device_addr, data, read_length)
return result
def i2c_config(bus_id, rate):
logger.debug("bus:%s, rate:%s" % (bus_id, rate))
"""
Args:
bus_id: str type, i2c bus id.
rate: int type.
Returns:
return None
"""
try:
profile = Profile.get_bus_by_name(bus_id)
bus = I2cBus(profile["path"])
return bus.config(rate)
except Exception as e:
logger.error("execute module i2c config False:" + repr(e))
return False
def read(self, addr, length):
if self._base_addr == 0:
logger.error("fpga device:%s not opened" % (self._name))
return False
read_data = (ctypes.c_char * length)()
status = self._libaxi4lite.sg_fpga_read(self._base_addr + addr,
read_data, length)
if (status < 0):
logger.info("read fpga device:%s addr:0x%x length:%s fail" %
(self._name, addr, length))
return False
data = list(struct.unpack('%dB' % length, read_data.raw))
logger.debug("read fpga device:%s addr:0x%x length:%s data : %s " %
(self._name, addr, length, logger.print_list2hex(data)))
return data
def write(self, addr, data, length):
if self._base_addr == 0:
logger.error("fpga device:%s not opened" % (self._name))
return False
logger.debug("write fpga device:%s addr:0x%x length:%d data: %s" %
(self._name, addr, length, logger.print_list2hex(data)))
write_data = (ctypes.c_ubyte * length)(*data)
status = self._libaxi4lite.sg_fpga_write(self._base_addr + addr,
write_data, length)
if (status < 0):
logger.warning(
"write fpga device:%s addr:0x%x length:%d data: %s fail" %
(self._name, addr, length, logger.print_list2hex(data)))
return False
return True
def voltage_get(self, channel, config):
""" get acd measure voltage result
It can be used, when ADC work in single mode
Args:
channel: ["chan0","chan1","chan2","chan3"]
config: channel configuration
{"P":AIN,"N":AIN}
AIN:["AIN0","AIN1","AIN2","AIN3","AIN4","Temp+","Temp-","AVDD1","AVSS","REF+","REF-"]
Returns:
if success:
(value,"mV")
if failed:
False
Raise:
KeyError
"""
#single measure: select the channel
if self.voltage_single_channel_select(channel, config) is False:
logger.warning("AD7175[%s] single channel select failed" %
(self.device_path))
return False
data = self.device.single_sample_code_get()
if data is False:
logger.warning("AD7175[%s] single sample code get failed" %
(self.device_path))
return False
logger.debug("AD7175[%s] channel %s code: " %
(self.device_path, channel) + str(data))
#check read data's channel if is you want to read
'''
if data[0] != 'NULL':
channels={"chan0":0x00,"chan1":0x01,"chan2":0x02,"chan3":0x03}
if data[0] != channels[channel]:
logger.warning("code: ",data[0],"log channel",channels[channel])
return False
'''
code = data[1]
volt = self.device.code_2_mvolt(code, self.vref, 24)
return volt
def write(self, register_addr, data_list):
""" Write data to register
Args:
register_addr: int
0x00-0x07
data_list :[data0,data1,...,datan]
data_n (0x00-0xff)
Returns:
bool: True | False, True for success, False for adc read failed
"""
logger.debug("cat9555 device write addr :" + hex(register_addr) +
" data:" + logger.print_list2hex(data_list))
write_data = []
write_data.append(register_addr)
write_data += data_list[0:2]
result = self.iic_bus.write(self._device_addr, write_data)
return result
def spi_slave_write(bus_name, address, write_data):
logger.debug("spi slave write -->bus name:%s, address:%s, write_data:%s "%(bus_name,address,write_data))
""" write data in spi bus
Args:
bus_name: str type, spi bus id.
address: int type
write_datas: list type.
Returns:
bool: The return value. True for success, False otherwise.
"""
try:
profile = Profile.get_bus_by_name(bus_name)
bus = SpiSlaveFactory.create_object(SpiSlaveFactory, profile["path"])
return bus.register_write(address, write_data)
except Exception as e:
logger.error("execute module spi_slave_write False:" + repr(e))
return False
def write(self, dev_addr, data):
logger.debug(
"write i2c device %s addr:0x%x length:%d data:%s" %
(self._name, dev_addr, len(data), logger.print_list2hex(data)))
if not self.__open():
return False
length = len(data)
write_data = (ctypes.c_ubyte * length)(*data)
status = self._bus.sg_i2c_write(self._fd, dev_addr, write_data, length)
self.__close()
if (status < 0):
logger.warning(
"write i2c device %s addr:0x%x length:%d data:%s fail" %
(self._name, dev_addr, len(data), logger.print_list2hex(data)))
return False
return True
def read(self, dev_addr, length):
logger.debug("read i2c device %s addr:0x%x length:%d" %
(self._name, dev_addr, length))
if not self.__open():
return False
# TODO performance
read_data = (ctypes.c_char * length)()
status = self._bus.sg_i2c_read(self._fd, dev_addr, read_data, length)
self.__close()
if (status < 0):
logger.warning("read i2c device %s addr:0x%x length:%d fail" %
(self._name, dev_addr, length))
return False
data = []
for i in range(length):
data.append(ord(read_data[i]) & 0xff)
return data
def spi_slave_read(bus_name, address, read_length):
logger.debug("spi slave read -->bus name:%s, address:%s, read_length:%s "%(bus_name,address,read_length))
""" read data in spi bus
Args:
bus_name: str type, spi bus id.
address: int type
read_length: int type.
Returns:
success : return data of list type.
if read fail, return False.
"""
try:
profile = Profile.get_bus_by_name(bus_name)
bus = SpiSlaveFactory.create_object(SpiSlaveFactory, profile["path"])
return bus.register_read(address, read_length)
except Exception as e:
logger.error("execute module spi_slave_read False:" + repr(e))
return False
def i2c_crol(bus_id, state):
logger.debug("bus:%s, state:%s" % (bus_id, state))
"""
Args:
bus_id: str type, i2c bus id.
state: (0,1),0:disable 1:enable.
Returns:
return None
"""
try:
profile = Profile.get_bus_by_name(bus_id)
#bus = I2cBus(profile["path"])
bus = I2cMasterFactory.create_object(I2cMasterFactory, profile["path"])
if state == 0:
logger.error("i2c_crol disable")
return bus.disable()
else:
return bus.enable()
except Exception as e:
logger.error("execute module i2c crol False:" + repr(e))
return False
def spi_slave_config(bus_name, spi_clk_cpha_cpol = 'Mode_0',spi_byte_cfg = '1'):
logger.debug("spi slave config -->bus name:%s, spi_clk_cpha_cpol:%s, spi_byte_cfg:%s "%(bus_name,spi_clk_cpha_cpol,spi_byte_cfg))
""" 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
"""
try:
profile = Profile.get_bus_by_name(bus_name)
bus = SpiSlaveFactory.create_object(SpiSlaveFactory, profile["path"])
return bus.config(spi_clk_cpha_cpol, spi_byte_cfg)
except Exception as e:
logger.error("execute module spi_slave_config False:" + repr(e))
return False
def read_bytes(self, length):
""" read bytes string data from uart
Args:
length(int) : the maximum number of read data bytes
Returns:
on success, return a string of bytes data
on error, return False
"""
if self.get_uart_status() is False:
self._close()
return False
elif self.__is_use is False:
return False
elif self.is_open is False:
self._open()
try:
data = self.__ser.read(length)
except Exception as e:
logger.error("read uart %s error:%s" % (self.name, repr(e)))
return False
logger.debug('read uart %s length:%d' % (self.name, len(data)))
return data
def send(self, msg):
msg = json.dumps(msg, separators=(',', ':'))
msg += '\r\n'
logger.debug('ddp send msg:' + str(msg))
return self.ddpsocket.send(msg.encode())
def recv(self, bufsize):
result = self.ddpsocket.recv(bufsize)
logger.debug('ddp recv:' + str(result))
return json.loads(result.decode())
def __close(self):
logger.debug("close i2c device %s" % (self._name))
self._bus.sg_i2c_close(self._fd)
return True
def _close(self):
if self.is_open:
logger.debug("uart close:" + str(self.name))
self.__ser.close()
return True
