def read(self, first_address, count): dat_buffer = [] bytes_already_read = 0 while bytes_already_read != count: read_len = min(MAX_WPILIB_I2C_READ_BYTES, count - bytes_already_read) with self.mutex: try: # first transfer address and length we want to read register_address = first_address + bytes_already_read self.i2c.transfer( 0x32, [I2C.Message([register_address, read_len])]) # now read the data # NOTE: these two statements should theoretically be able to be combined into a single transaction, # but when I tried, it didn't work read_msg = I2C.Message(bytearray(read_len), read=True) self.i2c.transfer(0x32, [read_msg]) #print("Read %d bytes at register %d: %s" % (read_len, register_address, binascii.hexlify(read_msg.data))) if not read_msg.data: break dat_buffer.extend(read_msg.data) bytes_already_read = len(dat_buffer) except Exception: traceback.print_exc() break if bytes_already_read != count: raise IOError("Read error") return dat_buffer
def run(i2c, time, steps, Filename): f = open(Filename + "_input.txt", "w+") time = float(time) volt = 0x0000 while (int(volt) < 26214): i2c.transfer( 0x11, [I2C.Message([0x3F, volt >> 8, volt & 0xFF00 >> 8], read=False)]) volt = volt + steps os.system( "cat /sys/bus/iio/devices/iio:device0/in_voltage8_vpvn_raw >>" + Filename + "_output.txt") f.write('%0.2f\n' % (float(volt))) f.flush() os.fsync(f.fileno()) sleep(time) if (int(volt) > 26214 - steps - 1): while (int(volt) > 0): volt = volt - steps i2c.transfer(0x11, [ I2C.Message([0x3F, volt >> 8, volt & 0xFF00 >> 8], read=False) ]) print('%.2f' % (float(volt))) os.system( "cat /sys/bus/iio/devices/iio:device0/in_voltage8_vpvn_raw >>" + Filename + "_output.txt") f.write('%0.2f\n' % (float(volt))) f.flush() os.fsync(f.fileno()) sleep(time)
def pmbus_read(dev_addr, reg_addr, n_bytes): i2c = I2C("/dev/i2c-0") write = I2C.Message([reg_addr]) read = I2C.Message([0x0] * n_bytes, read=True) i2c.transfer(dev_addr, [write, read]) i2c.close() return bytes(bytearray(read.data)).encode('hex')
def get_eeprom(self, eeprom_address=0x50): # Dua transfer I2C terpisah jika ukuran buffer kecil q1 = [I2C.Message([0x00, 0x00]), I2C.Message([0x00] * 4000, read=True)] q2 = [I2C.Message([0x0f, 0xa0]), I2C.Message([0x00] * 4000, read=True)] self.i2c.transfer(eeprom_address, q1) self.i2c.transfer(eeprom_address, q2) return np.array(q1[1].data + q2[1].data)
def bootloader_enter(ser, address, rst_gpio, inverted): # send payload req = bytearray(REQ_ENTER) chunks = os.path.getsize(FILE) chunks = int(math.ceil(float(chunks) / BLOCK_SIZE)) print('Need to send %s chunks' % chunks) crc = get_crc() req.extend([chunks, crc, crc]) # I2c transaction with bootloader request and ACK nand respond # toggle reset via sysFS GPIO rst_gpio.write(inverted) sleep(0.5) rst_gpio.write(not inverted) sleep(0.01) snd = [I2C.Message(req)] rcv = [I2C.Message([0x00, 0x00], read=True)] ser.transfer(address, snd) sleep(0.01) # give some time to process the block ser.transfer(address, rcv) if bytearray(rcv[0].data) != bytearray(ACK): print("Bootloader NACK") sys.exit(1) return ser
def bmr458_mon(dev_addr, reg_addr): i2c = I2C("/dev/i2c-1") write = I2C.Message([reg_addr]) read = I2C.Message([0x0] * 2, read=True) i2c.transfer(dev_addr, [write, read]) i2c.close() return bytes(bytearray(read.data)).encode('hex')
def Reset(self): """Reset the Notecard.""" chunk_len = 0 while not self.lock(): pass try: while True: time.sleep(.001) reg = bytearray(2) reg[0] = 0 reg[1] = chunk_len readlen = chunk_len + 2 buf = bytearray(readlen) if use_periphery: msgs = [I2C.Message(reg), I2C.Message(buf, read=True)] self.i2c.transfer(self.addr, msgs) buf = msgs[1].data elif use_micropython: self.i2c.writeto(self.addr, reg, False) self.i2c.readfrom_into(self.addr, buf) else: self.i2c.writeto_then_readfrom(self.addr, reg, buf) available = buf[0] if available == 0: break chunk_len = min(available, self.max) finally: self.unlock() pass
def get_eeprom(self, eeprom_address=0x50): query = [ I2C.Message([0x00, 0x00]), I2C.Message([0x00] * 8000, read=True) ] self.i2c.transfer(eeprom_address, query) return np.array(query[1].data)
def __get_eeprom(self, eeprom_address=0x50): # Two separate I2C transfers in case the buffer size is small q1 = [I2C.Message([0x00, 0x00]), I2C.Message([0x00]*4000, read=True)] q2 = [I2C.Message([0x0f, 0xa0]), I2C.Message([0x00]*4000, read=True)] self.i2c.transfer(eeprom_address, q1) self.i2c.transfer(eeprom_address, q2) return np.array(q1[1].data + q2[1].data)
def read_byte(self, address): msgs = [I2C.Message([address], read=False)] self.transfer(msgs) msgs = [I2C.Message([address], read=True)] ret_msg = self.transfer(msgs) return (ret_msg[0].data[0])
def get_eeprom(self, eeprom_address=0x50): # My Raspberry pi keeps timing-out here, so we split it into # two different transfers:... q1 = [I2C.Message([0x00, 0x00]), I2C.Message([0x00]*4000, read=True)] q2 = [I2C.Message([0x0f, 0xa0]), I2C.Message([0x00]*4000, read=True)] self.i2c.transfer(eeprom_address, q1) self.i2c.transfer(eeprom_address, q2) return np.array(q1[1].data + q2[1].data)
def minipod_reg_wr(i2c_bus_addr, dev_addr, page_addr, reg_addr, reg_value): i2c = I2C("/dev/i2c-1") i2c.transfer(TCA9548_U93_ADDR, [I2C.Message([i2c_bus_addr])]) # select I2C Bus i2c.transfer(dev_addr, [I2C.Message([127, page_addr])]) # set the page i2c.transfer(dev_addr, [I2C.Message([reg_addr, reg_value])]) # write to reg_addr i2c.close()
def firefly_reg_wr(i2c_bus_addr,firefly_refdes,dev_addr,reg_page,reg_addr,reg_value): firefly_select(firefly_refdes) i2c = I2C("/dev/i2c-0") i2c.transfer(TCA9548_U165_ADDR, [I2C.Message([i2c_bus_addr])]) # select i2c bus i2c.transfer(dev_addr, [I2C.Message([127,reg_page])]) # select the register page i2c.transfer(dev_addr, [I2C.Message([reg_addr,reg_value])]) # write the value to registers i2c.close()
def __wait_for_data(self): query = [I2C.Message([0x02]), I2C.Message([0x00], read=True)] done = False while not done: self.i2c.transfer(self.address, query) if not (query[1].data[0]%2 == 1): time.sleep(0.005) else: done = True
def Transaction(self, req): """Perform a Notecard transaction and return the result.""" req_json = prepareRequest(req, self._debug) rsp_json = "" while not self.lock(): pass try: self._sendPayload(req_json) chunk_len = 0 received_newline = False start = time.time() transaction_timeout_secs = 10 while True: time.sleep(.001) reg = bytearray(2) reg[0] = 0 reg[1] = chunk_len readlen = chunk_len + 2 buf = bytearray(readlen) if use_periphery: msgs = [I2C.Message(reg), I2C.Message(buf, read=True)] self.i2c.transfer(self.addr, msgs) buf = msgs[1].data elif use_micropython: self.i2c.writeto(self.addr, reg, False) self.i2c.readfrom_into(self.addr, buf) else: self.i2c.writeto_then_readfrom(self.addr, reg, buf) available = buf[0] good = buf[1] data = buf[2:2 + good] if good > 0 and buf[-1] == 0x0a: received_newline = True try: rsp_json += "".join(map(chr, data)) except: pass chunk_len = min(available, self.max) if chunk_len > 0: continue if received_newline: break if (time.time() >= start + transaction_timeout_secs): raise Exception("notecard request or response was lost") time.sleep(0.05) finally: self.unlock() if self._debug: print(rsp_json.rstrip()) rsp = json.loads(rsp_json) return rsp
def test_repstart(): i2c = I2C("/dev/i2c-1") write = I2C.Message([0x88]) read = I2C.Message([0x0]*2, read=True) # read 2 bytes msgs = [write, read] i2c.transfer(0x7F, msgs) value = msgs[1].data[1]*256 + msgs[1].data[0] return hex(value)
def __read_top_and_bottom_blocks(self): read_block = [I2C.Message([0x0A]), I2C.Message([0x00]*258, read=True)] self.i2c.transfer(self.address, read_block) top_data = np.array(copy.copy(read_block[1].data)) read_block = [I2C.Message([0x0B]), I2C.Message([0x00]*258, read=True)] self.i2c.transfer(self.address, read_block) bottom_data = np.array(copy.copy(read_block[1].data)) return top_data, bottom_data
def tca6424_reg_rd(i2c_bus_addr,dev_addr,reg_addr): i2c = I2C("/dev/i2c-0") i2c.transfer(TCA9548_U165_ADDR, [I2C.Message([i2c_bus_addr])]) # select i2c bus read = I2C.Message([0x0]*1, read=True) i2c.transfer(dev_addr, [I2C.Message([reg_addr])]) # set reg_addr i2c.transfer(dev_addr, [read]) i2c.close() print('read back is 0x{0:x}' .format(read.data[0])) return read.data[0]
def get_temp_humid(self): """ get_temp_humid() Get the temperature and humidity from the sensor. Returns an array with two integers - temp. [0] and humidity [1] """ # Loop sentinel values failCount = 0 # Commands to get data temp and humidity data from AM2315 cmd_data = bytearray((self.cmdReadReg, 0x00, 0x04)) # If we have failed more than twice to read the data, or have finished getting data break the loop. while (failCount < 2): try: cmd_msgs = [I2C.Message(cmd_data)] self.__i2c_master.transfer(self.i2c_addr, cmd_msgs) # Wait for the sensor to supply data to read. time.sleep(0.01) # Now read 8 bytes from the AM2315. read_data = bytearray( (0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)) read_msgs = [I2C.Message(read_data, read=True)] self.__i2c_master.transfer(self.i2c_addr, read_msgs) # Break the string we want out of the array the transaction returns. rawTH = bytearray(read_msgs[0].data) # Confirm the command worked by checking the response for the command we executed # and the number of bytes we asked for. if ((rawTH[0] == self.cmdReadReg) or (rawTH[0] == self.cmdReadReg + 0x80)) and (rawTH[1] == 0x04): # And the MSB and LSB for each value together to yield our raw values. humidRaw = (rawTH[2] << 8) | rawTH[3] # Get signed int from AND'd temperature bytes. tempRaw = self.get_signed((rawTH[4] << 8) | rawTH[5]) # The return data is scaled up by 10x, so compensate. return (tempRaw / 10.0, humidRaw / 10.0) # No connection yet except AttributeError: pass # We usually fail to read data 50% of the time because the sensor goes to sleep, so try twice. except IOError: if failCount > 1: raise IOError( "am2315 IO Error: failed to read from sensor.") else: failCount = failCount + 1 return None, None
def i2c_read_reg(devregaddr): """ 使用periphery i2c库读取功能测试 """ # 构造数据结构 # 第一个Message为要读取的设备地址 # 第二个Message用于存放读取回来的消息,注意其中添加的read=True msgs = [I2C.Message([devregaddr]), I2C.Message([0x00], read=True)] # 发送消息,发送到i2cSlaveAddr i2c.transfer(I2CSLAVEADDR, msgs) print("从寄存器 0x{:02x} 读取出: 0x{:02x}".format(devregaddr, msgs[1].data[0]))
def minipod_reg_rd(i2c_bus_addr, dev_addr, page_addr, reg_addr): i2c = I2C("/dev/i2c-1") i2c.transfer(TCA9548_U93_ADDR, [I2C.Message([i2c_bus_addr])]) # select i2c bus read = I2C.Message([0x0], read=True) i2c.transfer(dev_addr, [I2C.Message([127, page_addr])]) # set the page i2c.transfer(dev_addr, [I2C.Message([reg_addr])]) # set reg_addr i2c.transfer(dev_addr, [read]) i2c.close() return read.data[0]
def firefly_reg_rd(i2c_bus_addr,firefly_refdes,dev_addr,reg_page,reg_addr): firefly_select(firefly_refdes) i2c = I2C("/dev/i2c-0") i2c.transfer(TCA9548_U165_ADDR, [I2C.Message([i2c_bus_addr])]) # select i2c bus read = I2C.Message([0x0]*1, read=True) i2c.transfer(dev_addr, [I2C.Message([127,reg_page])]) # select the register page i2c.transfer(dev_addr, [I2C.Message([reg_addr])]) # set reg_addr i2c.transfer(dev_addr, [read]) i2c.close() print('read back is 0x{0:x}' .format(read.data[0])) return read.data[0]
def ltc2499_current_mon(dev_addr, reg_addr0, reg_addr1): i2c = I2C("/dev/i2c-1") i2c.transfer(dev_addr, [I2C.Message([reg_addr1, reg_addr0])]) sleep(0.5) read = I2C.Message([0x0] * 4, read=True) i2c.transfer(dev_addr, [read]) adc_code = bytes(bytearray(read.data)).encode('hex') i2c.close() resolution = 2500. / 0x80000000 if (int(adc_code, 16) < 0x40000000): amplitude = 0 else: amplitude = (int(adc_code, 16) - 0x40000000) * resolution return amplitude / 40
def read_sensor(): address = 0x06 register = 0x01 command = 0x03 unused = 0x00 sensor_id = detect_line_follower() if sensor_id == 2: raise NotImplementedError( 'line follower (black board) is not supported with the line_follower.line_sensor module\n\ please use the di_sensors.easy_line_follower.EasyLineFollower class to interface with both line followers (black + red boards)\n\ check https://di-sensors.readthedocs.io documentation to find out more') try: i2c = I2C('/dev/i2c-' + str(bus_number)) read_bytes = 10 * [0] msg1 = [I2C.Message([register, command] + 3 * [unused])] msg2 = [I2C.Message(read_bytes, read=True)] # we meed to do 2 transfers so we can avoid using repeated starts # repeated starts don't go hand in hand with the line follower i2c.transfer(address, msg1) i2c.transfer(address, msg2) except I2CError as error: return 5 * [-1] # unpack bytes received and process them # bytes_list = struct.unpack('10B',read_results[0]) output_values = [] input_values = msg2[0].data for step in range(5): # calculate the 16-bit number we got sensor_buffer[step].append(input_values[2 * step] * 256 + input_values[2 * step + 1]) # if there're too many elements in the list # then remove one if len(sensor_buffer[step]) > max_buffer_length: sensor_buffer[step].pop(0) # eliminate outlier values and select the most recent one filtered_value = statisticalNoiseReduction(sensor_buffer[step], 2)[-1] # append the value to the corresponding IR sensor output_values.append(filtered_value) return output_values
def get_co2(self): try: # Set the FCR register self.write_register(self.FCR, 0x07) # cmd_data = bytearray((self.FCR, 0x07)) # cmd_msgs = [I2C.Message(cmd_data)] # self.__i2c_master.transfer(self.i2c_addr, cmd_msgs) # Read TXLVL register msgs = [I2C.Message([self.TXLVL]), I2C.Message([0x00], read=True)] self.__i2c_master.transfer(self.i2c_addr, msgs) txlvl = msgs[1].data[0] # Verify TXLVL if txlvl >= len(self.cmd_measure): # Send Command Bytes to THR Register cmd_data = bytearray([self.THR] + self.cmd_measure) cmd_msgs = [I2C.Message(cmd_data)] self.__i2c_master.transfer(self.i2c_addr, cmd_msgs) # Wait for the sensor to supply data to read. time.sleep(0.1) # Now read 9 bytes from the MHZ16. read_data = bytearray( (0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)) read_msgs = [I2C.Message(read_data, read=True)] self.__i2c_master.transfer(self.i2c_addr, read_msgs) # Break the string we want out of the array the transaction returns. response = bytearray(read_msgs[0].data) ## Compute checksum checksum = 0 for i in range(0, 9): checksum += response[i] # Confirm the command worked by checking the response for the command we executed # and validating checksum if (response[0] == 0xFF) and (response[1] == 0x9C) and (checksum % 256 == 0xFF): return (response[2] << 24) + (response[3] << 16) + ( response[4] << 8) + response[5] except IOError: raise IOError("mhz16 IO Error: failed to read from sensor.") return None
def get_eeprom(self, eeprom_address=0x50): """Get dump of EEPROM configuration data from the HTPA device. Keyword Arguments: eeprom_address {hexadecimal} -- Communication address (default: {0x50}) Returns: np.array(bytes) -- EEPROM bytes """ # Two separate I2C transfers in case the buffer size is small q1 = [I2C.Message([0x00, 0x00]), I2C.Message([0x00]*4000, read=True)] q2 = [I2C.Message([0x0f, 0xa0]), I2C.Message([0x00]*4000, read=True)] self.i2c.transfer(eeprom_address, q1) self.i2c.transfer(eeprom_address, q2) return np.array(q1[1].data + q2[1].data)
def do_i2c_block_write(i2c, block): page, register, value = block # change page if page changes if page != do_i2c_block_write.page: set_page(i2c, page) do_i2c_block_write.page = page print(' Writing : {0:02x}{1:02x}'.format(register, value)) i2c.transfer(SI5345_U137_ADDR, [I2C.Message([register, value])])
def detect_line_follower(): """ returns 0 - for no line follower detected 1 - for detecting the line follower (red board) 2 - for detecting the line follower (black board) """ i2c = I2C('/dev/i2c-' + str(bus_number)) address = 0x06 # see if the device is up and running device_on = False try: read_byte = [0] msg1 = [I2C.Message(read_byte, read=True)] i2c.transfer(address, msg1) device_on = True except: pass if device_on is True: # then it means we have a line follower connected # we still don't know whether it is the black one or the red one board = 1 try: read_bytes = 20 * [0] msg1 = [I2C.Message([0x12])] msg2 = [I2C.Message(read_bytes, read=True)] i2c.transfer(address, msg1) i2c.transfer(address, msg2) name = "" for c in range(20): if msg2[0].data[c] != 0: name += chr(msg2[0].data[c]) else: break if name == 'Line Follower': board = 2 except: pass return board else: return 0
def write(self, address, pointer_reg, data_array): """ Performs a standard I2C write opreation on a particular address. Requires the 7-bit I2C address, the pointer register, and a data array of the data package to send. """ msgs = [I2C.Message([pointer_reg, data_array], read=False)] self.handle.transfer(address, msgs)
def ltc2499_temp_mon(dev_addr, reg_addr0, reg_addr1): # two delays as the chip is slow sleep(0.5) i2c = I2C("/dev/i2c-1") i2c.transfer(dev_addr, [I2C.Message([reg_addr1, reg_addr0])]) # Reg for read sleep(0.5) read = I2C.Message([0x0] * 4, read=True) i2c.transfer(dev_addr, [read]) i2c.close() adc_code = int(bytes(bytearray(read.data)).encode('hex'), 16) resolution = 2500. / 0x80000000 amplitude = (adc_code - 0x40000000) * resolution if (adc_code == 0x3FFFFFFF): amplitude = -1 temperature = 326 - 0.5 * amplitude return temperature