ESP32 and Atmega32u4 (Arduino micro) via I2C

void loop()  
{ 
  Wire.beginTransmission(8); // The atmega32u4 address will be 8 
  Wire.write(stateOut);        
  Wire.endTransmission();     

  // Read the button to a variable. 
  if(digitalRead(23)==0) 
    stateOut =1; 
  else 
    stateOut=0; 

  delay(100); 
}

Programming the reception in the Atmega32u4

To simplify the reception, we will use the interruption of the TWI (I2C at Atmel). The interrupt is triggered when the module address is detected on reception, if data is received or if data is transmitted. The definitions are in the twi.h library in the avr files.

For receive we will use a 16 byte array even though in the first application we are transmitting a single byte. So we start by declaring our variables:

#define _I2C_RX_BUFFER_MAX_SIZE 16 

volatile uint8_t _i2c_rxBuffer[_I2C_RX_BUFFER_MAX_SIZE]; 
volatile uint8_t_i2c_rxBuffer_indexIn = 0; 
volatile uint8_t_i2c_newRxData = 0;

Then in the interrupt processing, we will do the processing according to the status register. If the slave address is received and the command is a Write, we initialize the receive index and ensure that the module will send an ACK after receiving the data.

If it is data that is received, it is placed in memory and the index is increased. If the index reaches the last element of the receive array, the configuration proceeds to generate a NACK for the next element received. An indicator is used to know that new data is received.

ISR(TWI_vect) 
{ 
switch ((TWSR & 0xF8)) 
{ 
  // Received module address and W 
  case TW_SR_SLA_ACK: 
    _i2c_rxBuffer_indexIn = 0; 
    // prepare for reception of 
    TWCR data |=(1<<TWEA); 
    break; 
  // Data received 
  case TW_SR_DATA_ACK: 
    // place in memory if the buffer is not full 
    if(_i2c_rxBuffer_indexIn < _I2C_RX_BUFFER_MAX_SIZE) 
      _i2c_rxBuffer[_i2c_rxBuffer_indexIn++] = TWDR; 

    // If the buffer is at the last element, generate a NACK at the next. 
    if(_i2c_rxBuffer_indexIn >= _I2C_RX_BUFFER_MAX_SIZE-1) 
      TWCR &= ~(1<<TWEA); 
    else 
      TWCR |=(1<<TWEA);

    _i2c_newRxData = 1; 
    break; 
  
  default: 
    TWCR |=(1<<TWEA); 
} 
// Either way, release the ISR 
TWCR flag |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN); 
}

For the initialization it is simple, because the slave mode does not configure the speed. You just have to make sure that the internal clock is at least 16x faster than the SCL. However, in slave mode, the module address must be configured.

void i2cInitSlaveMode(uint8_t add) 
{ 
  TWAR = (add<<1); // Place the slave address + Will not respond on the general address 
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); // enable ISR and I2c and ACK 
  sei(); 
}

In order to detect new data received outside the library, we will use the following two functions:

void i2cClearNewDataFlag() 
{ 
  cli(); 
  _i2c_newRxData = 0; 
  sei(); 
} 
uint8_t i2cNewDataAvailable() 
{ 
  return _i2c_newRxData; 
}

Finally, a function makes it possible to read a byte in the reception table.

uint8_t i2cReadBuffer(uint8_t add) 
{ 
  if(add < _I2C_RX_BUFFER_MAX_SIZE) 
    return _i2c_rxBuffer[add]; 
  return _i2c_rxBuffer[0]; 
}

The main function is very small. It checks if new data is received. If so, it will read the first byte in memory, it clears the indication that data is received, then it changes the state of the LED.

int main(void) 
{ 
i2cInitSlaveMode(8); 
DDRC |= (1<<7); 
while (1) 
{ 
  if(i2cNewDataAvailable()) 
  { 
   stateIn = i2cReadBuffer(0); 
   i2cClearNewDataFlag(); 
   if(stateIn & 1) 
    PORTC |= (1<<7); 
   else 
    PORTC &= ~(1<<7); 
  } 
  _delay_ms(1); 
} 
}

Addition of slave reading in the ESP32

Now that the ESP32 can send data to the Atmega32u4, we'll add the reverse.  

To trigger the reading of the slave, you must use the Wire.requestFrom(#address, #number of bytes to read) command. Then the reading is done with the Wire.read() function which returns 1 received byte at a time.

delayMicroseconds(10); 
Wire. requestFrom(8, 1); // Read 1 byte from module #8 
stateIn = Wire.read();

// Address received with read request 
case TW_ST_SLA_ACK: 
case TW_ST_ARB_LOST_SLA_ACK: 
  _i2c_txBuffer_indexOut = 0; // at the beginning we clear the index 
case TW_ST_DATA_ACK: 
  // Data transmission 
if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE) 
   TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++]; 
else 
   TWDR = 0; 
break; 
// Last NACK data, we do nothing 
case TW_ST_DATA_NACK: 
  break;

#include <Arduino.h> 
#include <Wire.h> 

void setup()  
{ 
  Wire.begin(); 
  pinMode(15,OUTPUT); 
} 

uint8_t stateOut = 0; 
uint8_t stateIn = 0; 

void loop()  
{ 
  Wire.beginTransmission(8); 
  Wire.write(stateOut); // sends value byte   
  Wire.endTransmission(); // stop transmitting   
  if(digitalRead(23)==0) 
    stateOut =1; 
  else 
    stateOut=0; 
  delayMicroseconds(10); 
  Wire. requestFrom(8, 1); // request 6 bytes from slave device #2 
  stateIn = Wire.read(); 
  digitalWrite(15,stateIn); 
  delay(100); 
}

#include "i2c.h" 
#include <avr/io.h> 
#include <util/twi.h> // for state defines 
#include <avr/interrupt.h> 

#define _I2C_TX_BUFFER_MAX_SIZE 16 
volatile uint8_t _i2c_txBuffer[_I2C_TX_BUFFER_MAX_SIZE ]; 
volatile uint8_t_i2c_txBuffer_indexOut = 0; 

#define _I2C_RX_BUFFER_MAX_SIZE 16 
volatile uint8_t _i2c_rxBuffer[_I2C_RX_BUFFER_MAX_SIZE]; 
volatile uint8_t_i2c_rxBuffer_indexIn = 0; 
volatile uint8_t_i2c_newRxData = 0; 

ISR(TWI_vect) 
{ 
switch ((TWSR & 0xF8)) 
{ 
  // Received module address and W 
  case TW_SR_SLA_ACK: 
    _i2c_rxBuffer_indexIn = 0; 
    // prepare for receiving the data
    TWCR |=(1<<TWEA); 
    break; 
  // Data received 
  case TW_SR_DATA_ACK: 
    // place in memory if the buffer is not full 
    if(_i2c_rxBuffer_indexIn < _I2C_RX_BUFFER_MAX_SIZE) 
      _i2c_rxBuffer[_i2c_rxBuffer_indexIn++] = TWDR; 

    // the buffer is full, stop the reception, otherwise prepare for the next reception 
    if(_i2c_rxBuffer_indexIn >= _I2C_RX_BUFFER_MAX_SIZE) 
      TWCR &= ~(1<<TWEA); 
    else 
      TWCR |=(1<<TWEA); 

    _i2c_newRxData = 1; 
    break; 
  // Address received with read request 
  case TW_ST_SLA_ACK: 
  case TW_ST_ARB_LOST_SLA_ACK: 
    _i2c_txBuffer_indexOut = 0; 
  box TW_ST_DATA_ACK:
    // Transmission of the first data 
    if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE) 
      TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++]; 
    else 
      TCDR = 0; 
    break; 
     // Last NACK data, we do nothing 
  case TW_ST_DATA_NACK: 
    break; 
  default: 
    TWCR |=(1<<TWEA); 
} 
// Either way, release the ISR 
TWCR flag |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN); 
} 

void i2cWriteBuffer(uint8_t add, uint8_t data) 
{ 
  if(add < _I2C_TX_BUFFER_MAX_SIZE) 
    _i2c_txBuffer[add] = data; 
} 

uint8_t i2cReadBuffer(uint8_t add) 
{
  if(add < _I2C_RX_BUFFER_MAX_SIZE) 
    return _i2c_rxBuffer[add]; 
  return _i2c_rxBuffer[0]; 
} 

void i2cClearNewDataFlag() 
{ 
  cli(); 
  _i2c_newRxData = 0; 
  sei(); 
} 
uint8_t i2cNewDataAvailable() 
{ 
  return _i2c_newRxData; 
} 

void i2cInitSlaveMode(uint8_t add ) 
{ 
  TWAR = (add<<1); // Place the slave address + Will not respond on the general address 
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); // enable ISR and I2c and ACK 
  sei(); 
}

#define F_CPU 16000000 
#include <avr/io.h> 
#include <util/delay.h> 
#include "i2cSlave.h" 

uint8_t stateIn = 0; 
uint8_t stateOut = 0; 

int main(void) 
{ 
  i2cInitSlaveMode(8); 
  DDRC |= (1<<7); 
  while (1) 
  { 
    if(PINB & (1<<4)) 
      stateOut = 0; 
    else 
      stateOut = 1; 
    i2cWriteBuffer(0,stateOut); 
    if(i2cNewDataAvailable()) 
    { 
      stateIn = i2cReadBuffer(0); 
      i2cClearNewDataFlag(); 
      if(stateIn & 1) 
        PORTC |= (1<<7); 
      else 
        PORTC &= ~(1<<7); 
    } 
  _delay_ms(1);

}