Aprender

Pinos I2C do ESP32, pinos personalizados e um segundo barramento

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
ESP32-C3: um BME280 e um BMP280 no mesmo barramento I2Cao vivo0.000 s 0.00x
Clique para abrir no editor
Dois sensores, dois endereços, um par de fios no GPIO 8 e 9.

O ESP32 não tem pinos I2C fixos. Seus controladores I2C chegam aos pads pela matriz de GPIO, então Wire.begin() usa os pinos padrão da placa e Wire.begin(sda, scl) usa quaisquer dois que você indicar. No ESP32 DevKit clássico os padrões são GPIO 21 para SDA e GPIO 22 para SCL. O chip tem dois controladores I2C, então pode rodar dois barramentos separados ao mesmo tempo.

O circuito acima é um ESP32-C3 com dois sensores de pressão nos pinos padrão, GPIO 8 e 9: um BME280 no endereço 0x76 e um BMP280 no 0x77. Ele imprimiu "0x76: BME280, id 0x60" e "0x77: BMP280, id 0x58", dois dispositivos compartilhando dois fios porque seus endereços diferem. Abaixo estão os pinos padrão de cada ESP32, pinos personalizados e um segundo barramento para quando dois dispositivos têm o mesmo endereço.

Os pinos I2C padrão de cada ESP32

SDA e SCL são constantes que o core define para cada placa, e Wire.begin() sem argumentos as usa. Impressos em cada placa aqui, foram 21 e 22 no ESP32 clássico, 8 e 9 no ESP32-C3 e no ESP32-S3, e 23 e 22 no ESP32-C6. Esses são os pinos que a maioria dos tutoriais de módulos assume, e os primeiros a tentar.

Com um OLED SSD1306 e um backpack de LCD no GPIO 21 e 22 do DevKit, o scanner abaixo imprimiu "Wire: found 0x27" e "Wire: found 0x3C". Os mesmos dois módulos movidos para o GPIO 16 e 17 imprimiram "Wire: nothing" até o Wire.begin() virar Wire.begin(16, 17), e então encontrou os dois de novo.

Os pinos I2C padrão, os que o Wire.begin() usa sem argumentos
PlacaSDASCL
ESP32 (o DevKit clássico)GPIO 21GPIO 22
ESP32-C3GPIO 8GPIO 9
ESP32-S3GPIO 8GPIO 9
ESP32-C6GPIO 23GPIO 22
Um scanner I2C em pinos personalizados
#include <Wire.h>

void scan(TwoWire &bus, const char *name) {
  int found = 0;
  for (byte address = 1; address < 127; address++) {
    bus.beginTransmission(address);
    if (bus.endTransmission() == 0) {
      Serial.print(name);
      Serial.print(": found 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
      found++;
    }
  }
  if (found == 0) {
    Serial.print(name);
    Serial.println(": nothing");
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(16, 17);   // SDA, SCL
  scan(Wire, "Wire");
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Quais pinos podem ser SDA e SCL

O dado vem primeiro em Wire.begin(sda, scl), que é a ordem contrária à de algumas outras bibliotecas, então um módulo que responde nos pinos padrão e não nos seus geralmente está apenas com os fios trocados. GPIO 33 e 32 funcionaram também. As duas linhas são open drain, então cada pino precisa de um driver de saída: com SCL no GPIO 34, um pino só de entrada, o scanner não encontrou nada.

Deixe de fora GPIO 6 a 11, que são a flash, GPIO 1 e 3, que são a porta serial USB, e os pinos de strapping 0, 2, 5, 12 e 15, que os resistores de pull-up de um módulo podem manter no nível errado na inicialização. No Mokxi, Wire é um software que dirige os dois pinos, igual em toda placa, e não um modelo do controlador I2C do ESP32, então ele mostra quais pinos e endereços funcionam, e o timing é o dele. Uma varredura dos 126 endereços levou 18314 microssegundos no padrão de 100 kHz e 9241 depois de Wire.setClock(400000).

Dois dispositivos com o mesmo endereço: um segundo barramento I2C

Dois módulos idênticos num mesmo barramento respondem ao mesmo endereço ao mesmo tempo, e o sketch não consegue distingui-los. Dois OLEDs SSD1306 no GPIO 21 e 22 imprimiram só "Wire: found 0x3C". Alguns módulos têm um jumper para um segundo endereço; quando não têm, ou quando você precisa de mais deles do que há endereços, dê ao segundo o seu próprio barramento.

O core do ESP32 chama o segundo controlador de Wire1. O Wire.h do Mokxi ainda não declara Wire1, e um sketch que o usa para com use of undeclared identifier 'Wire1'; did you mean 'Wire'?. Criar o seu próprio barramento funciona nos dois: TwoWire I2Ctwo = TwoWire(1); e I2Ctwo.begin(25, 26, 400000), com SDA, SCL e o clock. Com um OLED em cada barramento, o scanner imprimiu "Wire: found 0x3C" e "I2Ctwo: found 0x3C".

Uma biblioteca que usa um barramento o recebe como ponteiro quando o objeto é criado. Com Adafruit_SSD1306 right(128, 64, &I2Ctwo, -1); os dois displays iniciaram: cada begin(SSD1306_SWITCHCAPVCC, 0x3C) imprimiu 1. Bibliotecas que só usam Wire não conseguem alcançar um segundo barramento, o que vale a pena conferir antes de ligar um.

Dois OLEDs em 0x3C em dois barramentos
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

TwoWire I2Ctwo = TwoWire(1);
Adafruit_SSD1306 left(128, 64, &Wire, -1);
Adafruit_SSD1306 right(128, 64, &I2Ctwo, -1);

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  I2Ctwo.begin(25, 26);
  Serial.println(left.begin(SSD1306_SWITCHCAPVCC, 0x3C));
  Serial.println(right.begin(SSD1306_SWITCHCAPVCC, 0x3C));
  left.clearDisplay();
  left.setTextColor(SSD1306_WHITE);
  left.setTextSize(2);
  left.print("Wire");
  left.display();
  right.clearDisplay();
  right.setTextColor(SSD1306_WHITE);
  right.setTextSize(2);
  right.print("I2Ctwo");
  right.display();
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Resistores de pull-up e módulos de 5 V

As linhas do I2C só são puxadas para baixo pelos dispositivos; um resistor até a alimentação as puxa para cima. A maioria das placas de expansão já traz os seus, geralmente de 4,7 k ou 10 k, e é por isso que dois módulos no mesmo barramento normalmente funcionam de primeira. Os pull-ups internos do ESP32 ficam na casa das dezenas de kilo-ohms, fracos demais para qualquer coisa que não seja um barramento curto a 100 kHz. Com um chip solto e sem módulo, coloque 4,7 k de cada linha para o 3,3 V.

Os pinos do ESP32 não toleram 5 V. Um módulo alimentado com 5 V puxa SDA e SCL até 5 V pelos seus próprios resistores, então alimente-o com 3,3 V quando ele funcionar assim, como a maioria dos OLEDs e sensores, ou coloque um conversor de nível entre ele e a placa.

Abra este circuito no editor. ESP32-C3: um BME280 e um BMP280 no mesmo barramento I2C, ligados como no circuito que roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Quais são os pinos I2C de um ESP32?

GPIO 21 (SDA) e GPIO 22 (SCL) no ESP32 DevKit clássico, GPIO 8 e 9 no C3 e no S3, e GPIO 23 e 22 no C6. Qualquer outro pino de saída funciona com Wire.begin(sda, scl).

Como uso dois barramentos I2C em um ESP32?

Declare um segundo barramento com TwoWire I2Ctwo = TwoWire(1); inicie-o com I2Ctwo.begin(sda, scl) e passe &I2Ctwo para a biblioteca do dispositivo ligado nele. O core também o pré-declara como Wire1.

Posso ligar vários dispositivos I2C em um ESP32?

Sim, nos mesmos dois fios, desde que cada um tenha um endereço diferente. Dois dispositivos com o mesmo endereço precisam de um segundo barramento ou de um jumper de endereço.

Preciso de resistores de pull-up para I2C em um ESP32?

Sim, mas a maioria dos módulos já os tem. Para um chip solto, adicione 4,7 k de SDA e SCL para o 3,3 V; os pull-ups internos são fracos demais para confiar.

Por que meu scanner I2C no ESP32 não encontra nada?

Confira os pinos primeiro: o módulo está em pinos diferentes dos que Wire.begin() indica, SDA e SCL estão trocados, ou um deles é um pino somente de entrada. Depois, alimentação e terra.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.