TWI reading and writing basics

RE: TWI reading and writing basics

MuRa — Mon, 23 May 2022 09:02:24 GMT

What a simple "solution"! Just to let you know, that if I have used the "no_stop" parameter as true , but only when calling the "reading" of the twi ! Indeed, on the write it does not applicable, so it is only used on "reading" ...

RE: TWI reading and writing basics

MuRa — Tue, 03 May 2022 11:44:37 GMT

Yes, and the nrf_drv_twi_rx(), is this ok?

Attaching the whole API for the sensor...

Best.

extern const nrf_drv_twi_t m_twi;
extern volatile bool m_xfer_done;

//nRF52DK specific I2C API call
#ifdef nRF52DK
	//All of the I2C API functions (For Example: HAL_I2C_Master_Transmit()) are being called from stm32f4xx_hal.h

	//hi2c1 - The variable to the I2C handler which is needed later in the Write and Read I2C function.
	//hi2c1 is defined in the stm32f4xx_hal.h and being called here via extern I2C_HandleTypeDef hi2c1;.
	//extern I2C_HandleTypeDef hi2c1;

	//Master sends I2C write command via pointer *Data from the Sensor API.
	//The function returns HAL_OK (=0) when there is no error and -1 when there is an error.
	int WriteI2C_Bus(struct TransferData *Data)
	{
		//Initialization of intial Error = 0
		ret_code_t Error = 0;

		//Define an array of 3 Bytes to be sent as I2C Write Command as shown in Fig. 10 in the Datasheet Page 7
		uint8_t WData[3]={Data->RegisterAddress, Data->WData[0], Data->WData[1]};

		//Send I2C Write Command as shown in Fig. 10 in the Datasheet Page 7 with Error checking.
		/*Format defined by STM:
		*HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout).
		*HAL_I2C_Master_Transmit() is used for transmitting data to the I2C device. It takes following arguments:
		*
		*I2C_HandleTypeDef *hi2c - is the pointer to the i2c handler. hi2c1 is defined in the stm32f4xx_hal.h and being called here via extern I2C_HandleTypeDef *hi2c1;.
		*uint16_t DevAddress - is the Address of the I2C device (Need to be shifted by 1 to left since the input of function expects 8 bits).
		*uint8_t *pData  - is the pointer to the data to be transmitted.
		*uint16_t Size  - is the size of the transmitted data in bytes.
		*uint32_t Timeout - timeout in millisecond in case of any error.
		*Return Error.
		*/
		m_xfer_done = false;

		Error = nrf_drv_twi_tx(&m_twi, Data->Slave_Address, WData, 3, false);  
                               
                APP_ERROR_CHECK(Error);
		while (m_xfer_done == false );
		//Error = HAL_I2C_Master_Transmit(&hi2c1, (Data->Slave_Address)<<1, WData, 3, 100);

		//Return -1 when there is error and return NRF_SUCCESS (= 0) when no error
		if (Error != NRF_SUCCESS)
		{
			return -1;
		}
		else
		{
			return NRF_SUCCESS;
		}
	}

	//Master sends I2C Read command and save the read data via pointer *Data.
	//The function returns NRF_SUCCESS (=0) when no error and -1 when there is error.
	int ReadI2C_Bus (struct TransferData *Data)
	{
		//Initialization of intial Error = 0
		ret_code_t Error = 0;

		//Send I2C Read Command as shown in Fig. 10 in the Datasheet Page 7 with Error checking.
		/*Format defined by STM:
		*HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c1, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout).
		*HAL_I2C_Mem_Read () is used for reading data from the I2C device. It has been used instead of HAL_I2C_Master_Receive() because it sends restart condition
		*while the latter which sends stop condition and thus not working. It takes following arguments:
		*
		*I2C_HandleTypeDef *hi2c - is the pointer to the i2c handler.
		*uint16_t DevAddress - is the Address of the I2C device (Need to be shifted by 1 to left since the input of function expects 8 bits).
		*uint16_t MemAddress - is the Internal memory address in the slave which is the register address.
		*uint16_t MemAddSize - the size of memory address (in Byte) which is the size of register address (In the case of Vishay's Sensor always 1 Byte).
		*uint8_t *pData  - is the pointer to the data to be received.
		*uint16_t Size  - is the size of the received data in bytes.
		*uint32_t Timeout - timeout in millisecond in case of any error.
		*Return Error.
		*
		*/
		m_xfer_done = false;
		Error = nrf_drv_twi_tx(&m_twi, Data->Slave_Address, &Data->RegisterAddress, 1, false);
		APP_ERROR_CHECK(Error);
	
		while (m_xfer_done == false );
	
		m_xfer_done = false;
		
		/* Read from register */
		Error = nrf_drv_twi_rx(&m_twi, Data->Slave_Address, Data->RData, 2);
		APP_ERROR_CHECK(Error);
	
		while (m_xfer_done == false );
		
		//Error = HAL_I2C_Mem_Read(&hi2c1, (Data->Slave_Address)<<1, Data->RegisterAddress, 1,Data->RData,2,100);

		//Return -1 when there is error and return NRF_SUCCESS (= 0) when no error
		if (Error !=NRF_SUCCESS)
		{
			return -1;
		}
		else
		{
			return NRF_SUCCESS;
		}
	}

	//Master sends I2C Gesture Read command and save the read data via pointer *Data.
	//The function returns NRF_SUCCESS (=0) when no error and -1 when there is error.
    int ReadI2C_Bus_Gesture_Mode(struct GestureTransferData *Data)
	{
		//Initialization of intial Error = 0
		ret_code_t Error = 0;

		//Send I2C Gesture Read Command as shown in the Application Note Page 19 with Error checking.
		/*Format defined by STM:
		*HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout).
		*HAL_I2C_Master_Receive () is used for reading data from the I2C device. It has been used instead of HAL_I2C_Mem_Read() because no restart condition is *needed.
		*It takes following arguments:
		*
		*I2C_HandleTypeDef *hi2c - is the pointer to the i2c handler. hi2c1 is defined in the stm32f4xx_hal.h and being called here via extern I2C_HandleTypeDef *hi2c1;.
		*uint16_t DevAddress - is the Address of the I2C device (Need to be shifted by 1 to left since the input of function expects 8 bits).
		*uint8_t *pData  - is the pointer to the data to be received.
		*uint16_t Size  - is the size of the received data in bytes (For Gesture Stream 6 Bytes are needed).
		*uint32_t Timeout - timeout in millisecond in case of any error.
		*Return Error.
		*
		*/
		/*m_xfer_done = false;
		err_code = nrf_drv_twi_tx(&m_twi, Data->Slave_Address, &Data->RegisterAddress, 1, false);
		APP_ERROR_CHECK(err_code);
	
		while (m_xfer_done == false );*/
	
		m_xfer_done = false;
		
		/* Read from register */
		Error = nrf_drv_twi_rx(&m_twi, Data->Slave_Address, Data->RData, 6);
		APP_ERROR_CHECK(Error);
	
		while (m_xfer_done == false );
		
		//Error = HAL_I2C_Master_Receive(&hi2c1,(Data->Slave_Address)<<1,Data->RData,6,100);

		//Return -1 when there is error and return NRF_SUCCESS (= 0) when no error
		if (Error != NRF_SUCCESS)
		{
			return -1;
		}
		else
		{
			return NRF_SUCCESS;
		}
	}
#endif

RE: TWI reading and writing basics

Kenneth — Mon, 25 Apr 2022 13:17:08 GMT

Are you calling nrf_drv_twi_tx() in your application?

Kenneth

RE: TWI reading and writing basics

MuRa — Mon, 25 Apr 2022 11:52:11 GMT

Hello Kenneth thank you for your reply, sorry for being such a beginner, but I had a look and so far I am seeing this code within the "nrf_drw_twi.h" when debugged :

__STATIC_INLINE
ret_code_t nrf_drv_twi_tx(nrf_drv_twi_t const * p_instance,
                          uint8_t               address,
                          uint8_t const *       p_data,
                          uint8_t               length,
                          bool                  no_stop)
{
    ret_code_t result = 0;
    if (NRF_DRV_TWI_USE_TWIM)
    {
        result = nrfx_twim_tx(&p_instance->u.twim,
                                address, p_data, length, no_stop);
    }
    else if (NRF_DRV_TWI_USE_TWI)
    {
        result = nrfx_twi_tx(&p_instance->u.twi,
                               address, p_data, length, no_stop);
    }
    return result;
}

Indeed, it seems that " no_stop " is used , so, do I have to change this, and into what? Not really sure how to implement what is expected from the above instruction of the Read I2C protocol ...

Any help is much appreciated!

Best.

PS this is my twi_init()

void twi_init(void) {
  ret_code_t err_code;

  const nrf_drv_twi_config_t twi_config = {
      .scl = 26, // Add you SCL Pin Here
      .sda = 27, // Add you SDA Pin Here
      .frequency = NRF_DRV_TWI_FREQ_100K,
      .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
      .clear_bus_init = false};

  err_code = nrf_drv_twi_init(&m_twi, &twi_config, twi_handler, NULL);
  APP_ERROR_CHECK(err_code);

  nrf_drv_twi_enable(&m_twi);
}

RE: TWI reading and writing basics

Kenneth — Mon, 25 Apr 2022 07:17:26 GMT

If you are referring to my answer here:
https://devzone.nordicsemi.com/f/nordic-q-a/84978/twi-reading-and-writing-basics/363652#363652

Then that is already available in the twi driver, it's just calling the twi api with the no_stop bit set or cleared according to your expecations. I suggest to have a logic analyzer at hand so you can see the transacations on byte level, with the start, stop and re-start conditions.

Kenneth

RE: TWI reading and writing basics

MuRa — Thu, 21 Apr 2022 09:27:30 GMT

Hello Kenneth!

Thank you for your reply, information,

would you please be so kind and let me know,

do I have to implement the function you are referring or it can be found in the existing drivers?

In that case where, where it has to be implemented or where it can be found?

Thank you in advance for your answer.

best.

RE: TWI reading and writing basics

Kenneth — Tue, 19 Apr 2022 14:09:58 GMT

[quote user="mu234"]For the Read I2C protocol, it is important that the restart condition is being sent before the second slave address and please ensure that no Stop condition being sent before the restart condition because some I2C library sends stop condition before restart condition ???[/quote]

This is typically handled by the no_stop parameter, e.g.:

/**
 * @brief Function for sending data to a TWI slave.
 *
 * The transmission will be stopped when an error occurs. If a transfer is ongoing,
 * the function returns the error code @ref NRF_ERROR_BUSY.
 *
 * @param[in] p_instance Pointer to the driver instance structure.
 * @param[in] address    Address of a specific slave device (only 7 LSB).
 * @param[in] p_data     Pointer to a transmit buffer.
 * @param[in] length     Number of bytes to send.
 * @param[in] no_stop    If set, the stop condition is not generated on the bus
 *                       after the transfer has completed successfully (allowing
 *                       for a repeated start in the next transfer).
 *
 * @retval NRF_SUCCESS                  If the procedure was successful.
 * @retval NRF_ERROR_BUSY               If the driver is not ready for a new transfer.
 * @retval NRF_ERROR_INTERNAL           If an error was detected by hardware.
 * @retval NRF_ERROR_INVALID_ADDR       If the EasyDMA is used and memory adress in not in RAM.
 * @retval NRF_ERROR_DRV_TWI_ERR_ANACK  If NACK received after sending the address in polling mode.
 * @retval NRF_ERROR_DRV_TWI_ERR_DNACK  If NACK received after sending a data byte in polling mode.
 */
__STATIC_INLINE
ret_code_t nrf_drv_twi_tx(nrf_drv_twi_t const * p_instance,
                          uint8_t               address,
                          uint8_t const *       p_data,
                          uint8_t               length,
                          bool                  no_stop);

RE: TWI reading and writing basics

MuRa — Wed, 13 Apr 2022 09:48:28 GMT

Thank you and I am looking forward to the reply.

Indeed, happy Easter holidays!

RE: TWI reading and writing basics

Sigurd Hellesvik — Wed, 13 Apr 2022 07:17:25 GMT

Our experts on this are out of office due to the Easter Holiday.

We will have a closer look at this case during next week.

Regards,
Sigurd Hellesvik

RE: TWI reading and writing basics

MuRa — Thu, 07 Apr 2022 11:48:04 GMT

Hello All

the library was compiled and the TWI is added, the sensor is connected to the nrf52dk and pullups are across the SCK, SDA ... However, I am getting strange behavior.

In general, the sensor readings freeze at some point, interestingly only when the barrier is introduced not at all channels, one is not affected, actually it looks like the first "goes" to the second, and eventually first and third freeze, while the second works normally :) all the way. The reset is pressed to start from the beginning...

Please have a look at the picture (JScope) and please comment whether the nRF TWI driver fulfils the following write and read I2C protocols. For the Read I2C protocol, it is important that the restart condition is being sent before the second slave address and please ensure that no Stop condition being sent before the restart condition because some I2C library sends stop condition before restart condition ???

Best.

RE: TWI reading and writing basics

MuRa — Wed, 23 Feb 2022 09:44:14 GMT

Hi Ahmed

thank your for your input, of course, here is the datasheet vcnl4035x01.pdf (vishay.com) and I have the sensor on this address #define VCNL4035_ADDR 0x60 I have as well attached the init that I am using :

/**
 * @brief UART initialization.
 */
void twi_init (void)
{
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_vcnl4035_config = {
       .scl                = 27,
       .sda                = 26,
       .frequency          = NRF_DRV_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };

    err_code = nrf_drv_twi_init(&m_twi, &twi_vcnl4035_config, twi_handler, NULL);
    APP_ERROR_CHECK(err_code);

    nrf_drv_twi_enable(&m_twi);
}

Here is the TWI handler , I guess this is the call back function ?

/**
 * @brief TWI events handler.
 */
void twi_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
    switch (p_event->type)
    {
        case NRF_DRV_TWI_EVT_DONE:
            if (p_event->xfer_desc.type == NRF_DRV_TWI_XFER_RX)
            {
                data_handler(m_sample);
            }
            m_xfer_done = true;
            break;
        default:
            break;
    }
}

Anyway, here is the library to make things easier VCNL4035X01 Fully Integrated Proximity and Ambient Light Sensor With I²C Interface and Interrupt Function for Gesture Applications | Vishay I have downloaded the code, trying to use it!

RE: TWI reading and writing basics

ahmad@mikrostartech.com — Wed, 23 Feb 2022 07:22:50 GMT

Hi ,

The macros defined in the code needs to be according to your sensor . This code is written for the LM75 (a digital temperature sensor with i2c/twi interface) . If you can share datasheet or part number of your sensor may be I can help.

All the examples given in the SDK use a relative part to the sdk directories so one way is to clone the whole sdk (obviously removing all the other examples) and compile or just clone the certain example in the examples directory in the same directory so the relative path is not disturbed .

Regards ,

Ahmed

RE: TWI reading and writing basics

MuRa — Mon, 21 Feb 2022 12:19:51 GMT

Hi and thank you for your input, it really helps. Indeed, this example should be a good start and I will have a go, however, can this example as well be use to use the library , how, or is this just to use for predefined registers? Such as these:

#define LM75B_REG_TEMP 0x00U
#define LM75B_REG_CONF 0x01U
#define LM75B_REG_THYST 0x02U
#define LM75B_REG_TOS 0x03U

For example, the library defines all the registers including the values and methods, etc. So, it is of importance to use the library... However, you mentioned I can use the "twi_write and twi_read function" as posted above , can you be more specific, maybe an example of how to actually do this 🙂

Thank you in advance.

PS while cloning the "project" I got an error when compiling, namely "C:/components/libraries/log/src/nrf_log_backend_rtt.c does not exist." do I have to clone it together with the whole directory path?

RE: TWI reading and writing basics

ahmad@mikrostartech.com — Mon, 21 Feb 2022 11:47:15 GMT

Hello MuRa ,

I am assuming you are starting a new project if that is the case you can clone the example twi_sensor shipped with the nrf52 sdk (your sdk52 \examples\peripheral). You'll find twi initialization twi_init() in which you need to set your sda and scl pin accordingly to your sensor and soc pins or you can use the default twi pins for you devkit. From there you can use your twi_write and twi_read function you just mentioned in your question. I hope it helped.