{"id":413,"date":"2020-05-16T01:25:23","date_gmt":"2020-05-16T01:25:23","guid":{"rendered":"https:\/\/marcjuneau.ca\/?p=413"},"modified":"2020-05-20T12:40:27","modified_gmt":"2020-05-20T12:40:27","slug":"esp32-et-atmega32u4-arduino-micro-via-i2c","status":"publish","type":"post","link":"https:\/\/marcjuneau.ca\/?p=413","title":{"rendered":"ESP32 et Atmega32u4 (Arduino micro) via I2C"},"content":{"rendered":"\n

Dans cet article, nous allons \u00e9changer des donn\u00e9es entre le ESP32 et le\u00a0 Atmega32u4 (Arduino micro) via un lien I2C. Le ESP32 sera programm\u00e9 dans PlatformIO dans le cadre Arduino alors que le Atmega32u4 sera programm\u00e9 sous Atmel studio avec les librairies C de base. Pour les r\u00f4les, le ESP32 sera le ma\u00eetre et le Atmega32U4 sera l’esclave.<\/p>\n

La fonctionnalit\u00e9 sera valid\u00e9e par un bouton et une DEL sur chacun des deux modules. Ainsi, lorsque l’on appuiera sur le bouton du ESP32, la DEL du Atmega32 sera allum\u00e9e et vise-versa.\u00a0<\/p>\n

Finalement, nous utiliserons l’analyseur logique (Digital Discovery) afin de visualiser le protocole I2C entre les deux modules.<\/p>\n

D\u00e9butons par le montage. Voici le sch\u00e9ma :<\/p>\n

\"\"<\/a><\/p>\n

Notez que le ESP32 n’est pas tol\u00e9rant au 5V sur les GPIO et que le Atmega32u4 supporte les niveaux logiques du 3V3. Une approche simple consiste donc d’utiliser des r\u00e9sistances tire-haut \u00e0 3V3.<\/p>\n

Lorsque l’on appuiera sur le bouton SW1, la valeur transmise du ESP32 au Atmega32u4 sera 1 et 0 lorsqu’il ne sera pas appuy\u00e9.<\/p>\n

1- Programmation de la transmission dans le ESP32<\/h5>\n

La librairie Wire dans arduino permet d’utiliser le lien I2C sans difficult\u00e9.\u00a0<\/p>\n

Dans la fonction setup<\/em>, nous d\u00e9butons par l’initialisation du I2C. Par d\u00e9faut, pour le ESP32, les broches SCL et SDA sont respectivement GPIO22 et GPIO21. L’appel de la m\u00e9thode begin() se fait donc sans param\u00e8tre.<\/p>\n

void\u00a0setup()\u00a0
{
\u00a0Wire.begin();\u00a0
}<\/pre>\n
Ensuite dans loop<\/em>, la lecture du bouton conserve l’\u00e9tat dans une variable (pour utilisation future) qui sera transmise sur le lien I2C. Pour la transmission, il suffit de d\u00e9marrer la transmission en pr\u00e9cisant l’adresse du module vis\u00e9 (ici nous utiliserons 8 pour le Atmega32u4). Ensuite, l’envoi de la donn\u00e9e se fait avec la m\u00e9thode write<\/em>, qui re\u00e7oit en param\u00e8tre la donn\u00e9e \u00e0 transmettre. Finalement, la transmission est termin\u00e9e \u00e0 l’aide de la m\u00e9thode endTransmission<\/em>, qui va \u00e9mettre la condition stop sur le I2C. Le d\u00e9lai de 100ms est seulement pour envoyer moins de donn\u00e9es durant l’exemple.<\/p>\n
uint8_t\u00a0stateOut\u00a0=\u00a00;<\/span><\/p>\n
\n
void loop()\u00a0
{
 \u00a0Wire.beginTransmission(8); \/\/ L'adresse du atmega32u4 sera 8
 \u00a0Wire.write(stateOut);\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 
 \u00a0Wire.endTransmission();\u00a0\u00a0\u00a0\u00a0 

 \u00a0\/\/ Lecture du bouton vers une variable.
  if(digitalRead(23)==0)
 \u00a0\u00a0\u00a0stateOut\u00a0=1;
 \u00a0else
 \u00a0\u00a0\u00a0stateOut\u00a0=0;

\u00a0\u00a0delay(100);
}<\/pre>\n
2 – Programmation de la r\u00e9ception dans le Atmega32u4<\/h5>\n
Pour simplifier la r\u00e9ception, nous utiliserons l’interruption du TWI (I2C chez Atmel). L’interruption est d\u00e9clench\u00e9e lorsque l’adresse du module est d\u00e9tect\u00e9e en r\u00e9ception, si une donn\u00e9e est re\u00e7ue ou si une donn\u00e9e est transmise. Les d\u00e9finitions sont dans la librairie twi.h dans les fichiers avr.<\/p>\n
Pour la r\u00e9ception, nous allons utiliser un tableau de 16 octets m\u00eame si dans la premi\u00e8re application, nous transmettons un seul octet. Nous d\u00e9butons donc par d\u00e9clarer nos variables :<\/p>\n
#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;

<\/pre>\n
Ensuite, dans le traitement de l’interruption, nous allons faire le traitement en fonction du registre d’\u00e9tat. Si l’adresse esclave est re\u00e7ue et que la commande est un Write, nous initialisons l’index de r\u00e9ception et nous nous assurons que le module va envoyer un ACK apr\u00e8s la r\u00e9ception des donn\u00e9es.<\/p>\n
Si c’est une donn\u00e9e qui est re\u00e7ue, elle est plac\u00e9e en m\u00e9moire et l’index est augment\u00e9. Si l’index arrive au dernier \u00e9l\u00e9ment du tableau de r\u00e9ception, la configuration passe \u00e0 la g\u00e9n\u00e9ration d’un NACK pour le prochain \u00e9l\u00e9ment re\u00e7u. Un indicateur est utilis\u00e9 afin de savoir qu’une nouvelle donn\u00e9e est re\u00e7ue.<\/p>\n
ISR(TWI_vect)
{
 switch ((TWSR & 0xF8))
 {
  \/\/ Adresse du module re\u00e7u et W
  case TW_SR_SLA_ACK :
    _i2c_rxBuffer_indexIn = 0;
    \/\/ pr\u00e9pare pour r\u00e9ception de la donn\u00e9e
    TWCR |=(1<<TWEA);
    break;
  \/\/ Donn\u00e9e re\u00e7ue
  case TW_SR_DATA_ACK:
    \/\/ place en m\u00e9moire 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 \u00e9l\u00e9ment, g\u00e9n\u00e9rer 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\u00e2che le flag du ISR
 TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN);
}<\/pre>\n
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.<\/p>\n
void i2cInitSlaveMode(uint8_t add )
{
  TWAR = (add<<1) ; \/\/ Place l'adresse du slave + Ne r\u00e9pondra pas sur l'adresse g\u00e9n\u00e9rale
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); \/\/ active le ISR et le I2c et le ACK
  sei();
}<\/pre>\n
Afin de d\u00e9tecter les nouvelles donn\u00e9es re\u00e7ues \u00e0 l’ext\u00e9rieur de la librairie, nous utiliserons les deux fonctions suivantes :<\/p>\n
void i2cClearNewDataFlag()
{
  cli();
  _i2c_newRxData = 0;
  sei();
}
uint8_t i2cNewDataAvailable()
{
  return _i2c_newRxData;
}<\/pre>\n
Finalement, une fonction permet de lire un octet dans le tableau de r\u00e9ception.<\/p>\n
uint8_t i2cReadBuffer(uint8_t add)
{
  if(add < _I2C_RX_BUFFER_MAX_SIZE)
    return _i2c_rxBuffer[add];
  return _i2c_rxBuffer[0];
}<\/pre>\n
La fonction main est tr\u00e8s petite. Elle regarde si une nouvelle donn\u00e9e est re\u00e7ue. Si c’est le cas, elle va lire le premier octet en m\u00e9moire, elle efface l’indication qu’une donn\u00e9e est re\u00e7ue, puis elle change l’\u00e9tat de la DEL.<\/p>\n
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);
 }
}<\/pre>\n
3- Ajout de la lecture du slave dans le ESP32<\/h5>\n
Maintenant que le ESP32 peut envoyer des donn\u00e9es vers le Atmega32u4, nous allons ajouter le sens inverse.\u00a0\u00a0<\/p>\n
Pour d\u00e9clencher la lecture de l’esclave, il faut utiliser la commande Wire.requestFrom(#adresse, #nombre d’octets \u00e0 lire). Ensuite la lecture se fait avec la fonction Wire.read() qui retourne 1 octet re\u00e7u \u00e0 la fois.<\/p>\n
\n
delayMicroseconds(10);
Wire.requestFrom(8, 1);\u00a0\u00a0\/\/ Lire 1 octet du module #8 
stateIn = Wire.read();<\/pre>\n
4- Ajout de la transmission dans le atmega32u4<\/h5>\n
Pour que le atmega32u4 r\u00e9ponde \u00e0 la demande de lecture du ma\u00eetre, il faut ajouter le support pour la condition o\u00f9 l’on re\u00e7oit l’adresse du module et la commande Read. Lorsque l’adresse est re\u00e7ue avec la commande Read, la premi\u00e8re \u00e9tape consiste \u00e0 remettre l’index de transmission \u00e0 0 et \u00e0 envoyer la premi\u00e8re donn\u00e9e. Ensuite, pour chaque r\u00e9ception d’un ACK par le ma\u00eetre, transmettre une autre donn\u00e9e. L’arr\u00eat se fait sur r\u00e9ception d’un NACK. Sinon, si la lecture d\u00e9passe le tableau de transmission, il va transmettre des 0. Voici le code pour cette section.<\/p>\n
\/\/ Adresse re\u00e7ue avec demande de lecture
case TW_ST_SLA_ACK :
case TW_ST_ARB_LOST_SLA_ACK :
  _i2c_txBuffer_indexOut = 0; \/\/ au d\u00e9but on clear l'index
case TW_ST_DATA_ACK :
  \/\/ Transmission de la donn\u00e9e
 if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE)
   TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++];
 else
   TWDR = 0; 
 break;
\/\/ Derni\u00e8re donn\u00e9e NACK, on fait rien
case TW_ST_DATA_NACK :
  break;<\/pre>\n
5- Lectures avec l’analyseur logique<\/h5>\n
Voici ce que l’on pourra observ\u00e9 sur l’analyseur logique avec les signaux SDA et SCL. La premi\u00e8re s\u00e9quence est lorsque le ESP32 transmet vers le Atmega32u4 et la seconde, est lorsque le ESP32 va lire le Atmega32u4.<\/p>\n
Si aucun bouton n’est appuy\u00e9<\/p>\n
\"Lors<\/a><\/p>\n
Si le bouton du ESP32 est appuy\u00e9<\/p>\n
\"\"<\/a><\/p>\n
Si le bouton du Atmega32u4 est appuy\u00e9<\/p>\n
\"\"<\/a><\/p>\n
\u00a0<\/p>\n
6- Codes complets<\/h5>\n
Voici donc le code complet pour le ESP32<\/p>\n
\n
#include\u00a0<Arduino.h>
#include <Wire.h>

void\u00a0setup()\u00a0
{
 \u00a0Wire.begin();\u00a0
 \u00a0pinMode(15,OUTPUT);
}

uint8_t\u00a0stateOut\u00a0=\u00a00;
uint8_t stateIn = 0;

void\u00a0loop()\u00a0
{
 \u00a0Wire.beginTransmission(8);
 \u00a0Wire.write(stateOut);\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\/\/\u00a0sends\u00a0value\u00a0byte\u00a0\u00a0
 \u00a0Wire.endTransmission();\u00a0\u00a0\u00a0\u00a0\u00a0\/\/\u00a0stop\u00a0transmitting\u00a0\u00a0
 \u00a0if(digitalRead(23)==0)
 \u00a0\u00a0\u00a0stateOut\u00a0=1;
 \u00a0else
 \u00a0\u00a0\u00a0stateOut\u00a0=0;
 \u00a0delayMicroseconds(10);
 \u00a0Wire.requestFrom(8,\u00a01);\u00a0\u00a0\u00a0\u00a0\/\/\u00a0request\u00a06\u00a0bytes\u00a0from\u00a0slave\u00a0device\u00a0#2
 \u00a0stateIn\u00a0=\u00a0Wire.read();
 \u00a0digitalWrite(15,stateIn);
 \u00a0delay(100);
}

<\/pre>\n
Le code complet pour le fichier i2cSlave.c<\/p>\n
#include \"i2c.h\"
#include <avr\/io.h>
#include <util\/twi.h> \/\/ pour les defines des \u00e9tats
#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\u00e7u et W
  case TW_SR_SLA_ACK :
    _i2c_rxBuffer_indexIn = 0;
    \/\/ pr\u00e9pare pour r\u00e9ception de la donn\u00e9e
    TWCR |=(1<<TWEA);
    break;
  \/\/ Donn\u00e9e re\u00e7ue
  case TW_SR_DATA_ACK:
    \/\/ place en m\u00e9moire 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\u00eater la r\u00e9ception, sinon pr\u00e9pare pour la prochaine r\u00e9ception
    if(_i2c_rxBuffer_indexIn >= _I2C_RX_BUFFER_MAX_SIZE)
      TWCR &= ~(1<<TWEA);
    else
      TWCR |=(1<<TWEA);

    _i2c_newRxData = 1;
    break;
  \/\/ Adresse re\u00e7ue 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\u00e8re donn\u00e9e
    if(_i2c_txBuffer_indexOut < _I2C_TX_BUFFER_MAX_SIZE)
      TWDR = _i2c_txBuffer[_i2c_txBuffer_indexOut++];
    else
      TCDR = 0;
    break;
     \/\/ Derni\u00e8re donn\u00e9e NACK, on fait rien
  case TW_ST_DATA_NACK :
    break;
  default :
    TWCR |=(1<<TWEA);
 }
 \/\/ Dans tous les cas, rel\u00e2che 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\u00e9pondra pas sur l'adresse g\u00e9n\u00e9rale
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); \/\/ active le ISR et le I2c et le ACK
  sei();
}<\/pre>\n
Le code complet pour le fichier main.c<\/p>\n
#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);
  }
}

<\/pre>\n
N’h\u00e9sitez pas \u00e0 donner vos commentaires et \u00e0 poser vos questions.<\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Dans cet article, nous allons \u00e9changer des donn\u00e9es entre le ESP32 et le\u00a0 Atmega32u4 (Arduino micro) via un lien I2C. Le ESP32 sera programm\u00e9 dans PlatformIO dans le cadre Arduino alors que le Atmega32u4 sera programm\u00e9 sous Atmel studio avec les librairies C de base. Pour les r\u00f4les, le ESP32Continue Reading<\/a><\/span><\/p>\n","protected":false},"author":1,"featured_media":417,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12,20,22],"tags":[],"class_list":["entry","author-mjuneau","post-413","post","type-post","status-publish","format-standard","has-post-thumbnail","category-arduino","category-esp32_cat","category-esp32-projets"],"_links":{"self":[{"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/posts\/413","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=413"}],"version-history":[{"count":14,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/posts\/413\/revisions"}],"predecessor-version":[{"id":439,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/posts\/413\/revisions\/439"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=\/wp\/v2\/media\/417"}],"wp:attachment":[{"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=413"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=413"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/marcjuneau.ca\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=413"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}