# Source: https://github.com/TraoreMorike/Raspberry-Pico---I2C-Slave ### i2cSlave.py from machine import mem32 from RP2040_I2C_Registers import* class i2c_slave: """ RP2040 I2C Slave implementation using direct register access. This class implements an I2C slave interface for the RP2040 microcontroller, allowing it to receive and transmit data as an I2C peripheral device. """ I2C0_BASE = 0x40044000 I2C1_BASE = 0x40048000 IO_BANK0_BASE = 0x40014000 # Atomic Register Access mem_rw = 0x0000 # Normal read/write access mem_xor = 0x1000 # XOR on write mem_set = 0x2000 # Bitmask set on write mem_clr = 0x3000 # Bitmask clear on write def get_Bits_Mask(self, bits, register): """ This function return the bit mask based on bit name """ bits_to_clear = bits bit_mask = sum([key for key, value in register.items() if value in bits_to_clear]) return bit_mask def RP2040_Write_32b_i2c_Reg(self, register, data, atr=0): """ Write RP2040 I2C 32bits register """ # < Base Addr > | < Atomic Register Access > | < Register > mem32[self.i2c_base | atr | register] = data def RP2040_Set_32b_i2c_Reg(self, register, data): """ Set bits in RP2040 I2C 32bits register """ # < Base Addr > | 0x2000 | < Register > self.RP2040_Write_32b_i2c_Reg(register, data, atr=self.mem_set) def RP2040_Clear_32b_i2c_Reg(self, register, data): """ Clear bits in RP2040 I2C 32bits register """ # < Base Addr > | 0x3000 | < Register > self.RP2040_Write_32b_i2c_Reg(register, data, atr=self.mem_clr) def RP2040_Read_32b_i2c_Reg(self, offset): """ Read RP2040 I2C 32bits register """ return mem32[self.i2c_base | offset] def RP2040_Get_32b_i2c_Bits(self, offset, bit_mask): return mem32[self.i2c_base | offset] & bit_mask def __init__(self, i2cID=0, sda=0, scl=1, slaveAddress=0x41, enable_clock_stretch=True): self.scl = scl self.sda = sda self.slaveAddress = slaveAddress self.i2c_ID = i2cID if self.i2c_ID == 0: self.i2c_base = self.I2C0_BASE else: self.i2c_base = self.I2C1_BASE """ I2C Slave Mode Intructions https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf """ # 1. Disable the DW_apb_i2c by writing a ‘0’ to IC_ENABLE.ENABLE self.RP2040_Clear_32b_i2c_Reg(I2C_OFFSET["I2C_IC_ENABLE"], self.get_Bits_Mask("ENABLE", I2C_IC_ENABLE)) # 2. Write to the IC_SAR register (bits 9:0) to set the slave address. # This is the address to which the DW_apb_i2c responds. self.RP2040_Clear_32b_i2c_Reg(I2C_OFFSET["I2C_IC_SAR"], self.get_Bits_Mask("IC_SAR", I2C_IC_SAR)) self.RP2040_Set_32b_i2c_Reg(I2C_OFFSET["I2C_IC_SAR"], self.slaveAddress & self.get_Bits_Mask("IC_SAR", I2C_IC_SAR)) # 3. Write to the IC_CON register to specify which type of addressing is supported (7-bit or 10-bit by setting bit 3). # Enable the DW_apb_i2c in slave-only mode by writing a ‘0’ into bit six (IC_SLAVE_DISABLE) and a ‘0’ to bit zero # (MASTER_MODE). # Disable Master mode self.RP2040_Clear_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CON"], self.get_Bits_Mask("MASTER_MODE", I2C_IC_CON)) # Enable slave mode self.RP2040_Clear_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CON"], self.get_Bits_Mask("IC_SLAVE_DISABLE", I2C_IC_CON)) # Enable clock strech if enable_clock_stretch: self.RP2040_Set_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CON"], self.get_Bits_Mask("RX_FIFO_FULL_HLD_CTRL", I2C_IC_CON)) # 4. Enable the DW_apb_i2c by writing a ‘1’ to IC_ENABLE.ENABLE. self.RP2040_Set_32b_i2c_Reg(I2C_OFFSET["I2C_IC_ENABLE"], self.get_Bits_Mask("IC_ENABLE", I2C_IC_ENABLE)) # Reset GPIO0 function mem32[ self.IO_BANK0_BASE | self.mem_clr | ( 4 + 8 * self.sda) ] = 0x1f # Set GPIO0 as IC0_SDA function mem32[ self.IO_BANK0_BASE | self.mem_set | ( 4 + 8 * self.sda) ] = 0x03 # Reset GPIO1 function mem32[ self.IO_BANK0_BASE | self.mem_clr | ( 4 + 8 * self.scl) ] = 0x1f # Set GPIO1 as IC0_SCL function mem32[ self.IO_BANK0_BASE | self.mem_set | ( 4 + 8 * self.scl) ] = 3 class I2CStateMachine: I2C_RECEIVE = 0 I2C_REQUEST = 1 I2C_FINISH = 2 I2C_START = 3 I2C_IDLE = 4 class I2CTransaction: def __init__(self, address: int, data_byte: list): self.address = address self.data_byte = data_byte def handle_event(self): """Optimized event detection by reading interrupt status register once""" # Read entire interrupt status register in one operation intr_stat = self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_INTR_STAT"]) # Check for restart condition if intr_stat & self.get_Bits_Mask("R_RESTART_DET", I2C_IC_INTR_STAT): self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_RESTART_DET"]) # Handle restart logic here # Check other conditions using the same intr_stat value # I2C Master has abort the transactions if (intr_stat & self.get_Bits_Mask("R_TX_ABRT", I2C_IC_INTR_STAT)): # Clear int self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_TX_ABRT"]) return i2c_slave.I2CStateMachine.I2C_FINISH # Last byte transmitted by I2C Slave but NACK from I2C Master if (intr_stat & self.get_Bits_Mask("R_RX_DONE", I2C_IC_INTR_STAT)): # Clear int self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_RX_DONE"]) return i2c_slave.I2CStateMachine.I2C_FINISH # Start condition detected by I2C Slave if (intr_stat & self.get_Bits_Mask("R_START_DET", I2C_IC_INTR_STAT)): # Clear start detection self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_START_DET"]) return i2c_slave.I2CStateMachine.I2C_START # Stop condition detected by I2C Slave if (intr_stat & self.get_Bits_Mask("R_STOP_DET", I2C_IC_INTR_STAT)): # Clear stop detection self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_STOP_DET"]) return i2c_slave.I2CStateMachine.I2C_FINISH # Check if RX FIFO is not empty if (self.RP2040_Get_32b_i2c_Bits(I2C_OFFSET["I2C_IC_STATUS"], self.get_Bits_Mask("RFNE", I2C_IC_STATUS))): return i2c_slave.I2CStateMachine.I2C_RECEIVE # Check if Master is requesting data if (intr_stat & self.get_Bits_Mask("R_RD_REQ", I2C_IC_INTR_STAT)): # Shall Wait until transfer is done, timing recommended 10 * fastest SCL clock period # for 100 Khz = (1/100E3) * 10 = 100 uS # for 400 Khz = (1/400E3) * 10 = 25 uS return i2c_slave.I2CStateMachine.I2C_REQUEST # Add at the end return i2c_slave.I2CStateMachine.I2C_IDLE def is_Master_Req_Read(self): """ Return status if I2C Master is requesting a read sequence """ # Check RD_REQ Interrupt bit (master wants to read data from the slave) status = self.RP2040_Get_32b_i2c_Bits(I2C_OFFSET["I2C_IC_RAW_INTR_STAT"], self.get_Bits_Mask("RD_REQ", I2C_IC_RAW_INTR_STAT)) if status : return True return False """ def is_Master_Req_Seq_Write(self): # Return true if I2C Master is requesting a sequential data writing # Check whether is FIRST_DATA_BYTE bit is active in IC_DATA_CMD. first_data_byte_stat = self.RP2040_Get_32b_i2c_Bits(I2C_OFFSET["I2C_IC_DATA_CMD"], self.get_Bits_Mask("FIRST_DATA_BYTE", I2C_IC_DATA_CMD)) # Check whether is STOP_DET_IFADDRESSED bit is active in IC_CON. stop_stat = self.RP2040_Get_32b_i2c_Bits(I2C_OFFSET["I2C_IC_CON"], self.get_Bits_Mask("STOP_DET_IFADDRESSED", I2C_IC_CON)) if (stop_stat): # Clear stop bit int self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_STOP_DET"]) # Master sequential write true if FIRST_DATA_BYTE bit is active and no stop condition detected. if first_data_byte_stat and not(stop_stat): return True return False """ def Slave_Write_Data(self, data): """ Write 8bits of data at destination of I2C Master """ # Send data self.RP2040_Write_32b_i2c_Reg(I2C_OFFSET["I2C_IC_DATA_CMD"], data & self.get_Bits_Mask("DAT", I2C_IC_DATA_CMD)) self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_CLR_RD_REQ"]) def Available(self): """ Return true if data has been received from I2C Master """ # Get RFNE Bit (Receive FIFO Not Empty) return self.RP2040_Get_32b_i2c_Bits(I2C_OFFSET["I2C_IC_STATUS"], self.get_Bits_Mask("RFNE", I2C_IC_STATUS)) def Read_Data_Received(self): """ Return data from I2C Master """ return self.RP2040_Read_32b_i2c_Reg(I2C_OFFSET["I2C_IC_DATA_CMD"]) & self.get_Bits_Mask("DAT", I2C_IC_DATA_CMD) def deinit(self): """Disable the I2C slave and release pins""" # Disable I2C interface self.RP2040_Clear_32b_i2c_Reg(I2C_OFFSET["I2C_IC_ENABLE"], self.get_Bits_Mask("ENABLE", I2C_IC_ENABLE)) # Reset GPIO pins back to default state mem32[self.IO_BANK0_BASE | self.mem_clr | (4 + 8 * self.sda)] = 0x1f mem32[self.IO_BANK0_BASE | self.mem_clr | (4 + 8 * self.scl)] = 0x1f if __name__ == "__main__": import machine from machine import mem32 def main(): data_buf = [] addr = 0x00 # Create I2C slave instance s_i2c = i2c_slave(0, sda=0, scl=1, slaveAddress=0x41, enable_clock_stretch=True) state = i2c_slave.I2CStateMachine.I2C_IDLE currentTransaction = i2c_slave.I2CTransaction(addr, data_buf) counter = 0 print("I2C Slave test") try: while True: state = s_i2c.handle_event() if state == s_i2c.I2CStateMachine.I2C_START: pass if state == s_i2c.I2CStateMachine.I2C_RECEIVE: if currentTransaction.address == 0x00: # First byte received is the register address currentTransaction.address = s_i2c.Read_Data_Received() # Read all data byte received until RX FIFO is empty while (s_i2c.Available()): currentTransaction.data_byte.append(s_i2c.Read_Data_Received()) # Virtually Increase register address # s_i2c.I2CTransaction.address += 1 if state == s_i2c.I2CStateMachine.I2C_REQUEST: # Send some dummy data back while (s_i2c.is_Master_Req_Read()): counter += 1 s_i2c.Slave_Write_Data(counter) # Virtually Increase register address # s_i2c.I2CTransaction.address += 1 print ("Sendind data : ", counter) if state == s_i2c.I2CStateMachine.I2C_FINISH: print ("Register : ", currentTransaction.address ,"Received : ", currentTransaction.data_byte) currentTransaction.address = 0x00 currentTransaction.data_byte = [] state= s_i2c.I2CStateMachine.I2C_IDLE except KeyboardInterrupt: s_i2c.deinit() # Clean up when done print("I2C slave stopped") main()