TWI reading and writing basics

Question

Hello all,

I have pinged the sensor on the "twi bus" successfully, now I am following the post on the read/write function that is needed to actually read the data off the sensor. This is what I am reading at the moment: https://medium.com/vicara-hardware-university/setting-up-twi-on-nrf52xx-dcaf83a50baa

Indeed, I have the sensor's library , however, I am not really sure how to apply the following example and use the library.

/*
 * dev_addr -> Device address
 * reg_adddr -> Register address
 * data -> Buffer which holds data to be written
 * length -> Length of data to be written
 */
int8_t twi_write(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint16_t length)
{
    uint32_t err_code;

    uint8_t buffer[255] = {0};
    buffer[0] = reg_addr;
    memcpy(&buffer[1], data, length);
    m_xfer_done = false;
    err_code = nrf_drv_twi_tx(&m_twi, dev_addr, buffer, sizeof(length), false);
    APP_ERROR_CHECK(err_code);
    while (m_xfer_done == false);

   return err_code;
}

/*
 * dev_addr -> Device address
 * reg_adddr -> Register address
 * data -> Buffer where data read from TWI will be stored
 * length -> Length of data to be read
 */
int8_t twi_read(uint8_t dev_addr, uint8_t reg_addr, uint8_t *data, uint16_t length)
{
    uint32_t err_code;
    m_xfer_done = false;
    err_code = nrf_drv_twi_tx(&m_twi, dev_addr, &reg_addr, sizeof(reg_addr), true);
    APP_ERROR_CHECK(err_code);
    while (m_xfer_done == false);

    m_xfer_done = false;
    err_code = nrf_drv_twi_rx(&m_twi, dev_addr, data, length);
    APP_ERROR_CHECK(err_code);
    while (m_xfer_done == false);

    return err_code;

}

and obtain the data from the sensors registers.

BTW the library uses the i2c for the STM32 like this:

//STM32F specific I2C API call
#ifdef STM32F
	//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
		int 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.
		*/
		Error = HAL_I2C_Master_Transmit(&hi2c1, (Data->Slave_Address)<<1, WData, 3, 100);

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

	//Master sends I2C Read command and save the read data via pointer *Data.
	//The function returns HAL_OK (=0) when no error and -1 when there is error.
	int ReadI2C_Bus (struct TransferData *Data)
	{
		//Initialization of intial Error = 0
		int 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.
		*
		*/
		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 HAL_OK (= 0) when no error
		if (Error !=HAL_OK)
		{
			return -1;
		}
		else
		{
			return HAL_OK;
		}
	}

	//Master sends I2C Gesture Read command and save the read data via pointer *Data.
	//The function returns HAL_OK (=0) when no error and -1 when there is error.
    int ReadI2C_Bus_Gesture_Mode(struct GestureTransferData *Data)
	{
		//Initialization of intial Error = 0
		int 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.
		*
		*/
		Error = HAL_I2C_Master_Receive(&hi2c1,(Data->Slave_Address)<<1,Data->RData,6,100);

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

So, I need to port the nrf twi and its sdk, right ? to eventually use the library with the nrf52dk?

In addition, I would like to use the pooling rather than interrupt. I guess as well this is done in the main() but within the while(true) loop?

Any ideas, example how to do, approach this?

Best.

PS yeah , I am new to this, just realized that I should write the code to read off the sensor in the while (true) loop :) where I am now printing text , juhej!

MuRa · Accepted Answer

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);
}

MuRa · Answer

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

TWI reading and writing basics

Top Replies