Hi Massimiliano Cialdi ,
After my test, the master can send more than 256 bytes with LPI2C_MasterSend, but you need to configure the related slave also can receive that data.
The following , I send out 260bytes.
You can find my I2C bus really sendout the correct data.
Wish it helps you!
Have a great day,
Kerry
-------------------------------------------------------------------------------
Note:
- If this post answers your question, please click the "Mark Correct" button. Thank you!
- We are following threads for 7 weeks after the last post, later replies are ignored
Please open a new thread and refer to the closed one, if you have a related question at a later point in time.
-------------------------------------------------------------------------------
consider the LPI2C_MasterReceive():
/*!
* brief Performs a polling receive transfer on the I2C bus.
*
* param base The LPI2C peripheral base address.
* param rxBuff The pointer to the data to be transferred.
* param rxSize The length in bytes of the data to be transferred.
* retval #kStatus_Success Data was received successfully.
* retval #kStatus_LPI2C_Busy Another master is currently utilizing the bus.
* retval #kStatus_LPI2C_Nak The slave device sent a NAK in response to a byte.
* retval #kStatus_LPI2C_FifoError FIFO under run or overrun.
* retval #kStatus_LPI2C_ArbitrationLost Arbitration lost error.
* retval #kStatus_LPI2C_PinLowTimeout SCL or SDA were held low longer than the timeout.
*/
status_t LPI2C_MasterReceive(LPI2C_Type *base, void *rxBuff, size_t rxSize)
{
status_t result;
uint8_t *buf;
assert(rxBuff);
/* Handle empty read. */
if (!rxSize)
{
return kStatus_Success;
}
/* Wait until there is room in the command fifo. */
result = LPI2C_MasterWaitForTxReady(base);
if (result)
{
return result;
}
/* Issue command to receive data. */
base->MTDR = kRxDataCmd | LPI2C_MTDR_DATA(rxSize - 1);
#if LPI2C_WAIT_TIMEOUT
uint32_t waitTimes = LPI2C_WAIT_TIMEOUT;
#endif
/* Receive data */
buf = (uint8_t *)rxBuff;
while (rxSize--)
{
/* Read LPI2C receive fifo register. The register includes a flag to indicate whether */
/* the FIFO is empty, so we can both get the data and check if we need to keep reading */
/* using a single register read. */
uint32_t value;
do
{
/* Check for errors. */
result = LPI2C_MasterCheckAndClearError(base, LPI2C_MasterGetStatusFlags(base));
if (result)
{
return result;
}
value = base->MRDR;
#if LPI2C_WAIT_TIMEOUT
} while ((value & LPI2C_MRDR_RXEMPTY_MASK) && (--waitTimes));
if (waitTimes == 0)
{
return kStatus_LPI2C_Timeout;
}
#else
} while (value & LPI2C_MRDR_RXEMPTY_MASK);
#endif
*buf++ = value & LPI2C_MRDR_DATA_MASK;
}
return kStatus_Success;
}
line 35 contains the MTDR register's assegment using LPI2C_MTDR_DATA macro.
that macro is defined as:
#define LPI2C_MTDR_DATA_MASK (0xFFU)
#define LPI2C_MTDR_DATA_SHIFT (0U)
#define LPI2C_MTDR_DATA(x) (((uint32_t)(((uint32_t)(x)) << LPI2C_MTDR_DATA_SHIFT)) & LPI2C_MTDR_DATA_MASK)
and the RT1051 Ref Man states:
and the MTDR register is describer here:
Since DATA field is 8bit, it cannot store numbers greater than 255, so no more of 256 bytes can be received.
I tried to receive 400 bytes, and the LPI2C_MasterReceive() hangs in an infinite loop (lines 49~66) after receiving 144 bytes, that is exactly 400-256 (in hexadecimal: 0x190 & 0xff = 0x90 = 144).
Please try, and fix it (or better document the APIs)
best regards
Max
I already told you I didn't change the SDK code. I just used the APIs that the SDK provides differently.
static int32_t MemRead(uint16_t addr, void *data, uint32_t len)
{
int32_t ret = MEM_OP_OK;
if(0 == len){
return ret;
}
if(kStatus_Success == LPI2C_MasterStart(MEM_I2C_PERIPH, I2C_EEPROM_ADDRESS, kLPI2C_Write)){
uint8_t a[2];
a[0] = (addr>>8)&0xff;
a[1] = (addr>>0)&0xff;
if(kStatus_Success != LPI2C_MasterSend(MEM_I2C_PERIPH, a, 2)){
ret = MEM_OP_FAIL;
goto read_end;
}
uint32_t ToGo = len;
uint32_t chunk;
uint8_t *pData8 = data;
uint32_t idxData = 0;
while(ToGo > 0){
chunk = ToGo > 256 ? 256 : ToGo;
if(kStatus_Success != LPI2C_MasterRepeatedStart(MEM_I2C_PERIPH, I2C_EEPROM_ADDRESS, kLPI2C_Read)){
ret = MEM_OP_FAIL;
goto read_end;
}
if(kStatus_Success != LPI2C_MasterReceive(MEM_I2C_PERIPH, &pData8[idxData], chunk)){
ret = MEM_OP_FAIL;
goto read_end;
}
ToGo -= chunk;
idxData += chunk;
}
}
read_end:
if(kStatus_Success == LPI2C_MasterStop(MEM_I2C_PERIPH)){
if(MEM_OP_FAIL == ret){
return MEM_OP_FAIL;
}else{
return MEM_OP_OK;
}
}else{
return MEM_OP_FAIL;
}
}
I use this function (which should not be part of the HAL provided by the SDK) to read, via i2c, from an EEProm memory, for example 24C64.
You can see (lines 15~31) that there are more repeated starts for readings of more than 256 bytes.
This works because the device is an EEprom memory, that require the address of memory location that are going to be read.
There is a set of devices that instead requires the sequential reading of all registers (e.g. some sensors, or complex devices with multiple functions). For these devices the readings always take place from the first register and go in sequence. It is not possible to address the single register, in other words it is not possible to make random readings. At the beginning of each reading transaction they restart from the first register. And the start of the transaction is given by a start or a repeated start.
Assuming the registers are all 8-bit and assuming the device has 300 registers, how can I read all 300 registers in a single transaction? Remember that each start/repeated start condition restarts the reading from the first register. So adopting the solution I adopted for the memory (ie use repeated start) I could read only the first 256 registers and never the following.
best regards
Max
