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