ESP32 et Atmega32u4 (Arduino micro) via I2C

void loop() 
{
  Wire.beginTransmission(8); // L'adresse du atmega32u4 sera 8
  Wire.write(stateOut);        
  Wire.endTransmission();     

  // Lecture du bouton vers une variable.
  if(digitalRead(23)==0)
    stateOut =1;
  else
    stateOut =0;

  delay(100);
}

Programmation de la réception dans le Atmega32u4

Pour simplifier la réception, nous utiliserons l’interruption du TWI (I2C chez Atmel). L’interruption est déclenchée lorsque l’adresse du module est détectée en réception, si une donnée est reçue ou si une donnée est transmise. Les définitions sont dans la librairie twi.h dans les fichiers avr.

Pour la réception, nous allons utiliser un tableau de 16 octets même si dans la première application, nous transmettons un seul octet. Nous débutons donc par déclarer nos 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;

Ensuite, dans le traitement de l’interruption, nous allons faire le traitement en fonction du registre d’état. Si l’adresse esclave est reçue et que la commande est un Write, nous initialisons l’index de réception et nous nous assurons que le module va envoyer un ACK après la réception des données.

Si c’est une donnée qui est reçue, elle est placée en mémoire et l’index est augmenté. Si l’index arrive au dernier élément du tableau de réception, la configuration passe à la génération d’un NACK pour le prochain élément reçu. Un indicateur est utilisé afin de savoir qu’une nouvelle donnée est reçue.

ISR(TWI_vect)
{
 switch ((TWSR & 0xF8))
 {
  // Adresse du module reçu et W
  case TW_SR_SLA_ACK :
    _i2c_rxBuffer_indexIn = 0;
    // prépare pour réception de la donnée
    TWCR |=(1<<TWEA);
    break;
  // Donnée reçue
  case TW_SR_DATA_ACK:
    // place en mémoire si le buffer n'est pas plein
    if(_i2c_rxBuffer_indexIn < _I2C_RX_BUFFER_MAX_SIZE)
      _i2c_rxBuffer[_i2c_rxBuffer_indexIn++] = TWDR;

    //  Si le buffer est au dernier élément, générer un NACK au prochain.
    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);
 }
 // Dans tous les cas, relâche le flag du ISR
 TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN);
}

Pour l’initialisation c’est simple, car le mode esclave ne configure par la vitesse. Il faut simplement s’assurer que le l’horloge interne est au moins 16x plus rapide que le SCL. Par contre dans le mode esclave, il faut configurer l’adresse du module.

void i2cInitSlaveMode(uint8_t add )
{
  TWAR = (add<<1) ; // Place l'adresse du slave + Ne répondra pas sur l'adresse générale
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); // active le ISR et le I2c et le ACK
  sei();
}

Afin de détecter les nouvelles données reçues à l’extérieur de la librairie, nous utiliserons les deux fonctions suivantes :

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

Finalement, une fonction permet de lire un octet dans le tableau de réception.

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

La fonction main est très petite. Elle regarde si une nouvelle donnée est reçue. Si c’est le cas, elle va lire le premier octet en mémoire, elle efface l’indication qu’une donnée est reçue, puis elle change l’état de la DEL.

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

Ajout de la lecture du slave dans le ESP32

Maintenant que le ESP32 peut envoyer des données vers le Atmega32u4, nous allons ajouter le sens inverse.  

Pour déclencher la lecture de l’esclave, il faut utiliser la commande Wire.requestFrom(#adresse, #nombre d’octets à lire). Ensuite la lecture se fait avec la fonction Wire.read() qui retourne 1 octet reçu à la fois.

delayMicroseconds(10);
Wire.requestFrom(8, 1);  // Lire 1 octet du module #8 
stateIn = Wire.read();

// Adresse reçue avec demande de lecture
case TW_ST_SLA_ACK :
case TW_ST_ARB_LOST_SLA_ACK :
  _i2c_txBuffer_indexOut = 0; // au début on clear l'index
case TW_ST_DATA_ACK :
  // Transmission de la donnée
 if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE)
   TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++];
 else
   TWDR = 0; 
 break;
// Dernière donnée NACK, on fait rien
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> // pour les defines des états
#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))
 {
  // Adresse du module reçu et W
  case TW_SR_SLA_ACK :
    _i2c_rxBuffer_indexIn = 0;
    // prépare pour réception de la donnée
    TWCR |=(1<<TWEA);
    break;
  // Donnée reçue
  case TW_SR_DATA_ACK:
    // place en mémoire si le buffer n'est pas plein
    if(_i2c_rxBuffer_indexIn < _I2C_RX_BUFFER_MAX_SIZE)
      _i2c_rxBuffer[_i2c_rxBuffer_indexIn++] = TWDR;

    // le buffer est full, arrêter la réception, sinon prépare pour la prochaine réception
    if(_i2c_rxBuffer_indexIn >= _I2C_RX_BUFFER_MAX_SIZE)
      TWCR &= ~(1<<TWEA);
    else
      TWCR |=(1<<TWEA);

    _i2c_newRxData = 1;
    break;
  // Adresse reçue avec demande de lecture
  case TW_ST_SLA_ACK :
  case TW_ST_ARB_LOST_SLA_ACK :
    _i2c_txBuffer_indexOut = 0;
  case TW_ST_DATA_ACK :
    // Transmission de la première donnée
    if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE)
      TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++];
    else
      TCDR = 0;
    break;
     // Dernière donnée NACK, on fait rien
  case TW_ST_DATA_NACK :
    break;
  default :
    TWCR |=(1<<TWEA);
 }
 // Dans tous les cas, relâche le flag du ISR
 TWCR |= (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 l'adresse du slave + Ne répondra pas sur l'adresse générale
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); // active le ISR et le I2c et le 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);
  }
}