Solved
I2C Slave transmit without HAL
I am writing a C++ I2C driver that would operate as a SLAVE device operating under
interrupt and without CLOCK STRETCHING using STM32H732zi nucleo board
My problem is that the first byte that I tried to transmit seems to always be
0xFF no matter what I do. I have tried to show code snippet here.
Can anyone see anything I might be doing wrong in the way I am handling the
interrupt service routine. I have tried different implementation and this seems
to show the most consistent behavior.
Even though the code seems to be partially work I noticed the odd behavior
the interrupt firing about 200 times which does not make sense to me especially
when I am the slave device is the only one on the bus with the master.
I found that if I test and clear the I2C_ISR_ADDR flag in the ISR then the
interrupt fires about 7 times since I am only send about 7 bytes but then
it only output all 0xFF.
//
// i2cinterface.h
//
#ifndef I2C_INTERFACE_H
#define I2C_INTERFACE_H
enum I2CEnum {
i2c1 = 0,
i2c2 = 1,
i2c3 = 2,
i2c4 = 3,
max_instances
};
class I2CInterface // : public CommsInterface
{
public:
I2CInterface(I2C_HandleTypeDef& i2c);
~I2CInterface();
bool Open(void);
static I2CInterface* instances[max_instances];
static void ISRHandler(I2CInterface* param);
void ProcessIncommingCommands(uint8_t);
private:
int state;
int txcount;
uint8_t *txdataptr;
I2C_HandleTypeDef m_hi2c;
};
#endif
/************************************************************/
///
/// \file - i2c_interface.cpp
///
/// \brief - Modbule used for impkement i2c interface
///
/// This is the main interface file for i2c
#include "main.h"
#include "i2c_interface.h"
extern I2C_HandleTypeDef hi2c2;
// test variables
uint8_t frequency[4] = {3,2,1,9};
uint8_t power[48] = {10,11,12,13,14,15,16,17,18,19,20}; // assume real code would have 48 bytes
uint8_t txbuf[64];
uint32_t g_isr[64];
uint32_t g_isr_count = 0;
// end test variables
I2CInterface* I2CInterface::instances[] = {nullptr,nullptr,nullptr,nullptr};
I2CInterface::I2CInterface (I2C_HandleTypeDef& hi2c)
{
m_hi2c = hi2c;
}
I2CInterface::~I2CInterface()
{
}
bool I2CInterface::Open(void)
{
bool retval = true;
if ( m_hi2c.Instance == I2C1 )
{
instances[i2c1] = this;
}
else if ( m_hi2c.Instance == I2C2 )
{
instances[i2c2] = this;
}
else if ( m_hi2c.Instance == I2C3 )
{
instances[i2c3] = this;
}
else if ( m_hi2c.Instance == I2C4 )
{
instances[i2c4] = this;
}
else
{
retval = false;
}
if ( retval )
{
return (retval && (HAL_I2C_EnableListen_IT(&m_hi2c) == HAL_OK));
}
return retval;
}
//
// Handle I2C interrupt events
//
uint8_t trace[128];
int trace_count = 0;
void I2CInterface::ISRHandler(I2CInterface* param)
{
I2C_TypeDef* Instance = param->m_hi2c.Instance;
trace_count++;
if ((( Instance->ISR & I2C_ISR_TXIS) == I2C_ISR_TXIS ) &&
(( Instance->ISR & I2C_ISR_DIR) == I2C_ISR_DIR ) )
{
g_isr[g_isr_count++] = Instance->ISR;
uint8_t data = param->txdataptr[param->txcount];
txbuf[param->txcount] = data;
Instance->TXDR = data;
param->txcount++;
}
if (( Instance->ISR & I2C_ISR_RXNE) == I2C_ISR_RXNE )
{
param->ProcessIncommingCommands(Instance->RXDR);
}
if (( Instance->ISR & I2C_ISR_NACKF) == I2C_ISR_NACKF )
{
Instance->ICR |= I2C_ICR_ADDRCF; // clear flag once only when nack received
Instance->ICR |= I2C_ICR_NACKCF;
Instance->ISR |= I2C_ISR_TXE; // flush TXDR
Instance->ICR |= I2C_ICR_OVRCF;
g_isr_count = param->state = 0;
}
if (( Instance->ISR & I2C_ISR_STOPF) == I2C_ISR_STOPF )
{
Instance->ICR |= I2C_ICR_STOPCF;
}
if (( Instance->ISR & I2C_ISR_OVR) == I2C_ISR_OVR )
{
Instance->ICR |= I2C_ICR_OVRCF;
}
}
void I2CInterface::ProcessIncommingCommands(uint8_t ch)
{
switch ( state )
{
case 0:
if ( ch == 2 )
{
state++;
txcount = 0;
}
break;
case 1:
switch ( ch )
{
case 0x31:
txdataptr = frequency; // point to buffer to transmit
break;
case 0x32:
txdataptr = power;
break;
}
break;
}
}
extern "C"
{
void I2C1_EV_IRQHandler(void)
{
I2CInterface::ISRHandler(I2CInterface::instances[i2c1]);
}
void I2C2_EV_IRQHandler(void)
{
I2CInterface::ISRHandler(I2CInterface::instances[i2c2]);
}
void I2C3_EV_IRQHandler(void)
{
I2CInterface::ISRHandler(I2CInterface::instances[i2c3]);
}
void I2C4_EV_IRQHandler(void)
{
I2CInterface::ISRHandler(I2CInterface::instances[i2c4]);
}
}
/************************************************************/
// mainTask.cpp
#include "main.h"
#include "app_main.h"
extern I2C_HandleTypeDef hi2c1;
void impTask(void *argument)
{
I2CInterface i2c(hi2c1);
i2c.Open();
while (1)
{
osDelay(500);
HAL_GPIO_TogglePin(GPIOB, LD2_Pin);
}
}