Pinos I2C do ESP32, pinos personalizados e um segundo barramento
Intermediário
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
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.
| Placa | SDA | SCL |
|---|---|---|
| ESP32 (o DevKit clássico) | GPIO 21 | GPIO 22 |
| ESP32-C3 | GPIO 8 | GPIO 9 |
| ESP32-S3 | GPIO 8 | GPIO 9 |
| ESP32-C6 | GPIO 23 | GPIO 22 |
#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.
#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 circuitoPerguntas
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.
Continuar
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.