2x I2C-Bus am ESP32

Mi Ke · 6. September 2021

Hallo Reiner,

danke für die Info, das hatte ich auch so aus KaiR’s Beitrag verstanden und ich habe es jetzt auch so umgesetzt.

Ich hatte sowie die unten aufgeführten Codebeispiele zeigen auch schon mit 2 Bussen gespielt. Nur scheinbar scheinen die Library’s dies nicht 100% zu unterstützen und versuchen trotzdem den 1. Bus, sprich den mit Wire bezeichneten anzusprechen was dann zum versagen einiger Komponenten führt.

2 BME280 Sensoren konnte ich auch schon an 2 verschiedenen Bussen nutzen. Un im I2C Scann werden auch alle Adressen in den entsprechenden Bussen gefunden. In meinem Fall war glaube ich der RTC der Übeltäter.

Die über den Link gezeigten Beispiele und Erklärungen sind gut verständlich gezeigt. Vielen Dank!

Reiner · 6. September 2021

Alle Boards, die ich mit Pullups gesehen habe, verwenden höherwertige Widerstände. 4k7-10k. Dies ist meist der maximaler Wert, der verwendet werden sollte.
Die Spezifikation für I2C ist, dass das Gerät in der Lage sein muss, Strom auf 3 mA zu senken. Bei einer 3,3-Volt-Versorgung beträgt somit der minimale Gruppenwiderstand 1k1. Dies würde bedeuten, dass Sie ein paar Module auf die Linie setzen könnten und immer noch innerhalb der Spezifikation liegen.

Dual I2C:

https://randomnerdtutorials.co…ommunication-arduino-ide/

Mi Ke · 5. September 2021

Hallo KaiR,

danke für deine ausführliche Darstellung.

Daraufhin habe ich mal nachgemessen.

Tatsächlich hat das RTC Modul einen 4.7kOhm anstatt eines 10k Widerstandes, was bei den 4 Modulen den Bus entsprechend belastet und natürlich Fehlverhalten durch redeten des Busses hervorruft.

Da ich momentan keine Lösung für 2 I2C Busse sehe habe ich die Leitung der 4.7k Widerstände am RTC Modul unterbrochen. Damit funktioniert es erst einmal

KaiR · 5. September 2021

Deine erste Frage lässt sich wie folgt beantworten:

Kommt drauf an.

Der Punkt ist der das, wie Du ja schon beschrieben hast, jedes Breakout Pullupwiderstände hat. Diese liegen am I2C Bus parallel zueinander. Das heißt, je mehr Breakouts am Bus hängen, desto kleiner wird der Gesamtwiderstand der Pullups.

Nun werden die Leitungen (SDA/SCL) dadurch auf LOW gebracht, indem diese i.d.R. über einen Transistor/Fet im Controller/Breakout mit GND verbunden werden. Der Transistor/Fet arbeitet als Schalter der jedoch einen Innenwiderstand hat, an dem eine Spannung abfällt. Dadurch wird im I2C Bus LOW nie = 0V sein sondern immer ein wenig darüber liegen.

Je geringer der Gesamtwiderstand der Pullups ist, desto mehr Strom wird durch den jeweiligen Transistor/Fet fließen. Mit steigendem Strom steigt auch die Spannung an seinem Innenwiderstand. Dadurch steigt die LOW Spannung weg von fast Null in Richtung Betriebsspannung. Das heißt, "LOW wird immer weniger LOW".

Bei I2C darf der LOW Pegel nur max. 0,4V betragen. Es sollten nur max. 3mA Strom fließen. Daraus lässt sich ermitteln, wie viele Breakouts du anschließen kannst:

(VCC - 0,4) / 3mA = minimal zulässiger Gesamtwiderstand.

Da Du geschrieben hast einen ESP32 zu benutzen, gehe ich mal von einer Betriebsspannung von 3,3V aus:

(3,3V-0,4V) / 3*10^-3 A ≈ 967Ω ist der (Gesamt-)Pullupwiderstand der mindestens vorhanden sein muss.

Da Du ebenfalls geschrieben hast, dass jedes deiner Breakouts 10kΩ Widerstände hat und 10 * 10 kΩ parallel 1 kΩ entsprechen, kannst du im Prinzip 10 Breakouts anschließen. Um auf Nummer sicher zu gehen, geh auf acht. Dann hast Du noch 1,25 kΩ Gesamtwiderstand und damit etwas Sicherheitspuffer. Fünf Breakouts sollten in diesem Punkt keinerlei Probleme machen.

Bei 5V Betriebsspannung liegt die Grenze des Gesamtwiderstandes bei ca. 1,53 kΩ. Da hättest Du bei sechs Breakouts einen Gesamtwiderstand von 1,67V, was noch ausreichend ist.

Blöd ist es, wenn ein Breakout dazwischen ist, welches nur 4,7 kΩ oder gar nur 2,2 kΩ Pullups hat. Da ja bekanntlich der Gesamtwiderstand parallel geschalteter Widerstände kleiner ist als der kleinste in der Parallelschaltung vorhandene Widerstand, kann sich die Zahl der maximal koppelbaren Breakouts drastisch verkleinern. Bei 5V Betriebsspannung wäre man beispielsweise mit zwei Breakouts á 10 kΩ und einmal 2,2 kΩ (=1,527kΩ) schon an bzw. knapp unter der Grenze von 1,53 kΩ. Da kann es sein, dass es mal funktioniert und mal nicht (je nach Temperatur). Mit 3.3V Betriebsspannung würde es noch reichen.

Natürlich muss man auch die Länge der Leitung berücksichtigen die man benötigt, um die Breakouts miteinander zu verbinden. Diese sollte so kurz wie möglich sein. Die Gesamtkapazität der Leitungen darf 400 pF nicht überschreiten. Das ist erst einmal ein etwas abstrakter Wert. Man kann aber sagen, mit zunehmender Länge der Leitungen, steigt auch die Kapazität auf dem I2C-Bus. Ist die Leitung zu lang, funktioniert es nicht mehr richtig. Aber es dürfte nichts "kaputt" gehen". Man müsste in dem Fall die Leitung kürzen oder einen I2C Bus Extender (Buffer) Baustein benutzen.

Die anderen Fragen kann ich Dir so nicht beantworten, weil ich das selber noch nicht durchexerziert habe, ich keine Zeit habe mir das genauer anzuschauen und/oder ich es nicht weiß.

So nun muss ich weg... schönen Tag noch

Mi Ke · 4. September 2021

nach einigen Versuchen mit einem RTC Modul, zwei BME280, einem OLED Display und einerSD Karte an einem I2C Bus kamen mir einige Bedenken was den Abschluss des Busses über Pullup Widerstände angeht. Jedes dieser Module hat einen 10KOhm am SDA und SCL gegen VCC. Es funktioniert zwar aber ich möchte hier nicht unbedingt Gefahr laufen etwas zu beschädigen.

Deshalb hatte ich über Wege nachgedacht 2 I2C Busse zu verwenden. Kein Problem dachte ich. Arduino bringt ja entsprechend über die Wire Library die Funktion TwoWire mit.

Im Scan funktioniert das auch wir erwartet. Alle Member des Busses melden sich brav.

C

#include <Arduino.h>
#include <Wire.h>
//I2C Pins
#define SDA1 32
#define SCL1 33
#define SDA2 21
#define SCL2 22
// TwoWire I2Cone = TwoWire(0);
// TwoWire I2Ctwo = TwoWire(1);
extern TwoWire Wire1;
void setup(){
Serial.begin(115200);
Wire.begin(SDA1,SCL1);
Wire1.begin(SDA2,SCL2);
Serial.println(0, "I2C scanner. Scanning bus 0...");
for (byte i = 8; i < 127; i++)
{
Wire.beginTransmission(i);
if (Wire.endTransmission() == 0)
{
Serial.println("Found address: " + String(i,HEX));
// check address
if ((i == 32) or (i == 39))
{
// found device, do something..
}
delay(1);
}
}
Wire.endTransmission();
Serial.println(0, "I2C scanner. Scanning bus 1...");
for (byte i = 8; i < 127; i++)
{
Wire1.beginTransmission(i);
if (Wire1.endTransmission() == 0)
{
Serial.println("Found address: " + String(i,HEX));
// check address
if (i == 64)
{
// found device, do something..
}
delay(1);
}
}
Wire1.endTransmission();
Serial.println("I2C device check DONE.");
}
void loop(){
}

Alles anzeigen

als Ergebnis bekomme ich die gewünschten Adressen im entsprechenden Bus

Code

2C scanner. Scanning bus 0...
Found address: 76
Found address: 77
I2C scanner. Scanning bus 1...
Found address: 3c
Found address: 57
Found address: 68
I2C device check DONE.

Ok, dann versuch ichmal Display und RTC am Wire2 zum laufen zu bringen, leider mit bescheidenem Erfolg Das Datum wird zuerst ausgelesen und wechselt dann ständig .

C

#include <Arduino.h>
#include <Wire.h>
#include <RTClib.h>
#include <U8g2lib.h>
// Zeitvariable
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
//I2C Pins
#define SDA1 32
#define SCL1 33
#define SDA2 21
#define SCL2 22
extern TwoWire Wire1;
// Display
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL2, /* data=*/ SDA2);
// RTC Modul
RTC_DS3231 RTC;
void setup() {
Serial.begin(115200);
Wire1.begin(SDA2,SCL2,100000);
Wire.begin(SDA1,SCL1,100000);
u8g2.begin();
if (! RTC.begin(&Wire1)) {
Serial.println("Couldn't find RTC");
Serial.flush();
abort();
}
}
void loop(){
DateTime now = RTC.now();
Serial.print(now.year(), DEC);
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(" (");
Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
Serial.print(") ");
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.println();
u8g2.clearBuffer(); // clear the internal memory
u8g2.setFont(u8g2_font_ncenB08_tr);
u8g2.setCursor(5,20);
u8g2.print("DISPLAY 1");
u8g2.setCursor(5,60);
u8g2.print(daysOfTheWeek[now.dayOfTheWeek()]);
u8g2.sendBuffer(); // transfer internal memory to the display
Serial.println((String)now.hour());
delay(2000);
}

Alles anzeigen

Code

2021/9/4 (Saturday) 15:37:49
15
2000/0/0 (Sunday) 0:0:0
0
2037/53/40 (Friday) 0:8:22
0
2000/0/21 (Friday) 4:7:15
4
2008/22/0 (Sunday) 0:0:0
0
2007/15/38 (Wednesday) 40:19:0
40
2000/0/0 (Sunday) 21:9:4
21
2019/0/8 (Tuesday) 0:0:0
0
2009/4/7 (Tuesday) 38:6:40
38

Alles anzeigen

mit einer anderen Library habe ich schon gespielt, leider mit ähnlichem Erfolg

C

#include <Arduino.h>
#include <Wire.h>
#include <RtcDS3231.h>
#include <U8g2lib.h>
// Zeitvariable
String time2 = "" ;
//I2C Pins
#define SDA1 32
#define SCL1 33
#define SDA2 21
#define SCL2 22
extern TwoWire Wire1;
// Display
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL2, /* data=*/ SDA2);
// RTC Modul
RtcDS3231<TwoWire> RTC(Wire1);
//Zeit berechnen incl. Sommer- und Winterumrechnung
#define countof(a) (sizeof(a) / sizeof(a[0]))
void printDateTime(const RtcDateTime& dt){
byte DST = 0;
byte yy = dt.Year() % 100; // adjust your functions call
byte mm = dt.Month();
byte dd = dt.Day();
byte x1 = 31 - (yy + yy / 4 - 2) % 7; //last Sunday March
byte x2 = 31 - (yy + yy / 4 + 2) % 7; // last Sunday October
if ((mm > 3 && mm < 10) || (mm == 3 && dd >= x1) || (mm == 10 && dd < x2))DST = 1;
/* int Stunde = 0;
if (DST==1) Stunde = 1; */
char rtctime[20];
snprintf_P(rtctime,
countof(rtctime),
PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
dt.Month(),
dt.Day(),
dt.Year(),
dt.Hour()+DST,
dt.Minute(),
dt.Second() );
time2= (String) rtctime;
}
void setup() {
Serial.begin(115200);
Wire1.begin(SDA2,SCL2,100000);
Wire.begin(SDA1,SCL1,100000);
u8g2.begin();
RTC.begin();
RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
RtcDateTime now = RTC.GetDateTime();
}
void loop(){
RtcDateTime now = RTC.GetDateTime();
printDateTime(now);
u8g2.clearBuffer(); // clear the internal memory
u8g2.setFont(u8g2_font_ncenB08_tr);
u8g2.setCursor(5,20);
u8g2.print("DISPLAY 1");
u8g2.setCursor(5,60);
u8g2.print(time2);
u8g2.sendBuffer(); // transfer internal memory to the display
Serial.println((String)time2);
delay(2000);
}

Alles anzeigen

Jetzt habe ich einige Fragen:

1. wieviele Member kann ich gefahrlos in den Bus hängen?

2. gibt es eine funktionierende Library für RTC (DS3231) wo ich SDA und SCL Pin zuweisen kann?

3. gibt es eine solche für BME280?

4. Hab ich einen Denkfehler im Code?

5. kann man das auch anders lösen

Teilen