ESP32 et I2C

J'ai une LOLIN32-Lite, et je veux utiliser I2C pour communiquer avec un MPU 9250...
Mais les pins par défaut sont 21 et 22.
La lolin32 lite n'a pas la 21 et wire normalement permet de choisir ses pins

J'ai tenté

/*
 * https://github.com/asukiaaa/MPU9250_asukiaaa/blob/master/examples/GetData/GetData.ino
 * 
 * 
 */


#include <MPU9250_asukiaaa.h>

#ifdef _ESP32_HAL_I2C_H_
#define SDA_PIN 26
#define SCL_PIN 25
#endif

MPU9250 mySensor;

uint8_t sensorId;
float aX, aY, aZ, aSqrt, gX, gY, gZ, mDirection, mX, mY, mZ;

void setup() {
  while(!Serial);
  Serial.begin(115200);
  Serial.println("started");

#ifdef _ESP32_HAL_I2C_H_ // For ESP32
  Wire.begin(SDA_PIN, SCL_PIN); // SDA, SCL
#else
  Wire.begin();
#endif

  mySensor.setWire(&Wire);
  mySensor.beginAccel();
  mySensor.beginGyro();
  mySensor.beginMag();

  // You can set your own offset for mag values
  // mySensor.magXOffset = -50;
  // mySensor.magYOffset = -55;
  // mySensor.magZOffset = -10;

  sensorId = mySensor.readId();
}

void loop() {
  Serial.println("sensorId: " + String(sensorId));

  mySensor.accelUpdate();
  aX = mySensor.accelX();
  aY = mySensor.accelY();
  aZ = mySensor.accelZ();
  aSqrt = mySensor.accelSqrt();
  Serial.println("accelX: " + String(aX));
  Serial.println("accelY: " + String(aY));
  Serial.println("accelZ: " + String(aZ));
  Serial.println("accelSqrt: " + String(aSqrt));

  mySensor.gyroUpdate();
  gX = mySensor.gyroX();
  gY = mySensor.gyroY();
  gZ = mySensor.gyroZ();
  Serial.println("gyroX: " + String(gX));
  Serial.println("gyroY: " + String(gY));
  Serial.println("gyroZ: " + String(gZ));

  mySensor.magUpdate();
  mX = mySensor.magX();
  mY = mySensor.magY();
  mZ = mySensor.magZ();
  mDirection = mySensor.magHorizDirection();
  Serial.println("magX: " + String(mX));
  Serial.println("maxY: " + String(mY));
  Serial.println("magZ: " + String(mZ));
  Serial.println("horizontal direction: " + String(mDirection));

  Serial.println("at " + String(millis()) + "ms");
  Serial.println(""); // Add an empty line
  delay(500);
}

Compilation sans problème mais toutes les données sur le port série restent à 0 sauf les millisecondes...

Une solution ?
Merci d'avance

En lisant le code de la bibli que tu utilises, j'ai l'impression qu'il suppose que ton capteur I2C est à l'adresse 0x68 (ou peut-être 0x0C). L'as-tu vérifié avec un scanner ? Il y en a un pour le Lolin32 lite ici.

Si le scanner indique une autre adresse, je suppose qu'il faudra ajouter une ligne
mySensor.i2cWriteByte(adresse);dans le setup (à confirmer, le code est difficile à comprendre)

lesept:
En lisant le code de la bibli que tu utilises, j'ai l'impression qu'il suppose que ton capteur I2C est à l'adresse 0x68 (ou peut-être 0x0C). L'as-tu vérifié avec un scanner ? Il y en a un pour le Lolin32 lite ici.

Si le scanner indique une autre adresse, je suppose qu'il faudra ajouter une ligne

mySensor.i2cWriteByte(adresse);

dans le setup (à confirmer, le code est difficile à comprendre)

Merci de tenter de me dépanner
Le scanner avec le code

/* I2C slave Address Scanner
for 5V bus
 * Connect a 4.7k resistor between SDA and Vcc
 * Connect a 4.7k resistor between SCL and Vcc
for 3.3V bus
 * Connect a 2.4k resistor between SDA and Vcc
 * Connect a 2.4k resistor between SCL and Vcc

 */

#include <Wire.h>
#ifdef _ESP32_HAL_I2C_H_
#define SDA_PIN 26
#define SCL_PIN 25
#endif

void scan(){
Serial.println(" Scanning I2C Addresses");
uint8_t cnt=0;
for(uint8_t i=0;i<128;i++){
  Wire.beginTransmission(i);
  uint8_t ec=Wire.endTransmission(true);
  if(ec==0){
    if(i<16)Serial.print('0');
    Serial.print(i,HEX);
    cnt++;
  }
  else Serial.print("..");
  Serial.print(' ');
  if ((i&0x0f)==0x0f)Serial.println();
  }
Serial.print("Scan Completed, ");
Serial.print(cnt);
Serial.println(" I2C Devices found.");
}

bool i2cReady(uint8_t adr){
uint32_t timeout=millis();
bool ready=false;
while((millis()-timeout<100)&&(!ready)){
  Wire.beginTransmission(adr);
  ready=(Wire.endTransmission()==0);
  }
return ready;
}

void eepromSize(){
Serial.println("Discovering eeprom sizes 0x50..0x57");
uint8_t adr=0x50,i;
uint16_t size;
char buf[64];
while(adr<0x58){
  i=0;
  size = 0x1000; // Start at 4k
  i += sprintf_P(&buf[i],PSTR("0x%02X: "),adr);
  if(i2cReady(adr)) { // EEPROM answered
    uint8_t zeroByte;
    Wire.beginTransmission(adr);
    Wire.write((uint8_t)0); // set address ptr to 0, two bytes High
    Wire.write((uint8_t)0); // set address ptr to 0, two bytes Low
    uint8_t err=Wire.endTransmission();
    if(err==0){// worked
      err=Wire.requestFrom(adr,(uint8_t)1);
      if(err==1){// got the value of the byte at address 0
        zeroByte=Wire.read();
        uint8_t saveByte,testByte;
        do{
          if(i2cReady(adr)){
            Wire.beginTransmission(adr);
            Wire.write(highByte(size)); // set next test address
            Wire.write(lowByte(size));
            Wire.endTransmission();
            err=Wire.requestFrom(adr,(uint8_t)1);
            if(err==1){
              saveByte=Wire.read();
              Wire.beginTransmission(adr);
              Wire.write(highByte(size)); // set next test address
              Wire.write(lowByte(size));
              Wire.write((uint8_t)~zeroByte); // change it
              err=Wire.endTransmission();
              if(err==0){ // changed it
                if(!i2cReady(adr)){
                  i+=sprintf_P(&buf[i],PSTR(" notReady2.\n"));
                  Serial.print(buf);
                  adr++;
                  break;
                  }
                Wire.beginTransmission(adr);
                Wire.write((uint8_t)0); // address 0 byte High
                Wire.write((uint8_t)0); // address 0 byte Low
                err=Wire.endTransmission();
                if(err==0){
                  err=Wire.requestFrom(adr,(uint8_t)1);
                  if(err==1){ // now compare it
                    testByte=Wire.read();
                    }
                  else {
                    testByte=~zeroByte; // error out
                    }
                  }
                else {
                  testByte=~zeroByte;
                  }
                }
              else {
                testByte = ~zeroByte;
                }
              //restore byte
              if(!i2cReady(adr)){
                i+=sprintf_P(&buf[i],PSTR(" notReady4.\n"));
                Serial.print(buf);
                adr++;
                break;
                }
              
              Wire.beginTransmission(adr);
              Wire.write(highByte(size)); // set next test address
              Wire.write(lowByte(size));
              Wire.write((uint8_t)saveByte); // restore it
              Wire.endTransmission();
              }
            else testByte=~zeroByte;
            }
          else testByte=~zeroByte;
          if(testByte==zeroByte){
            size = size <<1;
            }
          }while((testByte==zeroByte)&&(size>0));
        if(size==0) i += sprintf_P(&buf[i],PSTR("64k Bytes"));
        else i+=sprintf_P(&buf[i],PSTR("%dk Bytes"),size/1024);
        if(!i2cReady(adr)){
          i+=sprintf_P(&buf[i],PSTR(" notReady3.\n"));
          Serial.print(buf);
          adr++;
          continue;
          }
        Wire.beginTransmission(adr);
        Wire.write((uint8_t)0); // set address ptr to 0, two bytes High
        Wire.write((uint8_t)0); // set address ptr to 0, two bytes Low
        Wire.write(zeroByte);  //Restore
        err=Wire.endTransmission();
        }
      else i+=sprintf_P(&buf[i],PSTR("Read 0 Failure"));
      }
    else i+=sprintf_P(&buf[i],PSTR("Write Adr 0 Failure"));
      
    }
  else i+=sprintf_P(&buf[i],PSTR("Not Present."));
  Serial.println(buf);
  adr++;
  }
}

void setup(){
Serial.begin(115200);
#ifdef _ESP32_HAL_I2C_H_ // For ESP32
  Wire.begin(SDA_PIN, SCL_PIN); // SDA, SCL
#else
  Wire.begin();
#endif

scan();
Serial.println();
eepromSize();
}

void loop(){}

donne :

ets Jun 8 2016 00:22:57

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:812
load:0x40078000,len:0
load:0x40078000,len:11572
entry 0x40078a5c
Scanning I2C Addresses
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
Scan Completed, 0 I2C Devices found.

Discovering eeprom sizes 0x50..0x57
0x50: Not Present.
0x51: Not Present.
0x52: Not Present.
0x53: Not Present.
0x54: Not Present.
0x55: Not Present.
0x56: Not Present.
0x57: Not Present.

J'ai corrigé comme
https://desire.giesecke.tk/index.php/2018/04/20/how-to-use-stickbreakers-i2c-improved-code/ l'indique.

J'ai des résistances de pull-up sur sda et scl de 3K pourtant jamais je vois de montage avec.
La doc
MPU-9250 Hookup Guide - SparkFun Learn porte-t-elle sur le même circuit que le mien ?

mySensor.i2cWriteByte(adresse);

...adresse ?

https://sites.google.com/site/hardzet/home/arduino/gy-9250-mpu-9250 montre un montage en SPI mais je n'ai pas trouvé un code pour tester...

Vala vala...

Tu as un problème de branchement, les pins que tu utilises ne sont pas bonnes pour l'I2C, ce qui fait que ton capteur n'est pas reconnu par l'I2C. Il faut que tu trouves les bonnes pins à utiliser (21 & 22 a priori, voir le lien que j'ai fourni) et que le scanner t'indique l'adresse.

Dans l'exemple du lien, le scanner renvoie :

Scanning I2C Addresses
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
20 21 .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
50 51 52 53 54 55 56 .. .. .. .. .. .. .. .. .. 
.. .. .. .. .. .. .. .. 68 .. .. .. .. .. .. .. 
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 
Scan Completed, 10 I2C Devices found.

Il trouve plusieurs objets branchés sur l'I2C, les adresses sont 20, 21, 50, etc.

Après, c'est vrai que je ne vois pas de pin 21 sur le schéma du pinout :


Mais ici on voit ce branchement : teste le si ça correspond à ta carte...

EDIT : ici, il branche SCL sur le 4 et SDA sur le 16.

lesept:
Tu as un problème de branchement, les pins que tu utilises ne sont pas bonnes pour l'I2C, ce qui fait que ton capteur n'est pas reconnu par l'I2C. Il faut que tu trouves les bonnes pins à utiliser (21 & 22 a priori, voir le lien que j'ai fourni) et que le scanner t'indique l'adresse.

Dans l'exemple du lien, le scanner renvoie :

Scanning I2C Addresses

.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
20 21 .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
50 51 52 53 54 55 56 .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. 68 .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
Scan Completed, 10 I2C Devices found.



Il trouve plusieurs objets branchés sur l'I2C, les adresses sont 20, 21, 50, etc.

Après, c'est vrai que je ne vois pas de pin 21 sur le schéma du pinout :
![|500x228](https://i.pinimg.com/originals/40/61/85/406185fb236c150010c5797851f3d35a.jpg)
Mais ici on voit ce branchement : teste le si ça correspond à ta carte...
![|500x478](https://i2.wp.com/www.esp32learning.com/wp-content/uploads/2017/11/lolin32-andhdc1008_bb.png?resize=696%2C666)

EDIT : [ici](http://www.lucadentella.it/en/2018/01/08/esp32lights/), il branche SCL sur le 4 et SDA sur le 16.

Oui lolin32 lite pas de pin 21...
et ici: c'est pas de l'arduino IDE :frowning:

Alors comment faire ?

Peu importe que ce soit l'IDE ou pas, tu branches SCL sur 4, SDA sur 16 et tu lances le scanner... S'il te trouve une adresse : Bingo !

Si tu veux en savoir plus sur l'I2C et sur le scanner lis ça.

Lis bien ma signature : "A force d'essayer on finit par réussir..."
Tu peux tester d'autres combinaisons...

EDIT : ici il dit qu'avec la pin 15 pour SDA et la pin 2 pour SCL sur un Lolin32 Lite, ça fonctionne :

On voit bien sur son diagramme SCL1 sur la 2 et SDA1 sur la 15. Ça pourrait peut-être aussi marcher avec SCL sur la 4 et SDA sur la 0 (SDA2 et SCL2 sur el diagramme), mais la 0 sert peut-être à autre chose (étiquette BOOT)