Problem mit I2C Bus

Hallo,

ich probier schon seit einigen Tagen den Aufbau eines funktionierenden I2C Bus System.
Ich würde gerne mit vom SLAVE 2 6 Werte zu übertragen.
Die kommunikation von Slave1 und Slave2 funktioniert bereits.

Jedoch schaffe ich es nicht diese mit dem Slave 3 auszulesen.

I2C Bus:
Slave 1= ESP-01
Slave 2 = Arduino UNO
Salve 3 = Arduino Mini

Hier meine Codes:

Arduino UNO

#include <Wire.h>
#include <AccelStepper.h>
 
#define Cocktail1
#define Cocktail2

int Cocktail = 0;             // Cocktailauswahl (1,2,3...)

byte sendeDaten= 0;           // Ãœbertragungsbyte

int cocktail1;                // Empfangenes Cocktailauswahlbyte
int cocktail_rdy;             // Status Cocktail Fertig 
//int cocktail2;


char DATEN[6] = {};       // Ãœbertragungsstring "Daten" welcher im Setup definiert wird
int cocktail_go;              //  Status Cocktail in Bearbeitung

void setup()
{
DATEN[0]=0;  //Daten für das erste Byte
DATEN[1]=0;  //Daten für das zweite Byte
DATEN[2]=0;  //...
DATEN[3]=0;  //...
DATEN[4]=0;  //...
DATEN[5]=0;  //...

  Wire.begin(0);  //Kanal 16 wird festgelegt (Kanal 32 bei ESP8266)
  Wire.onReceive(receiveEvent); // register event  für das Empfangen von Daten
  Wire.onRequest(requestEvent); // register to send Data für das Senden der Daten
  Serial.begin(115200);  
{
 Serial.print("Bearbeitung= ");
Serial.println(cocktail_go);
}
  
}

void loop()
{
}

void receiveEvent(int howMany) //Empfange Daten mit I2C Bus
  {
     while(Wire.available())
    {
      cocktail1 = Wire.read();  //Empfange Cocktailauswahl
  
   if (cocktail1 == 1) {
    Cocktail = 1;
    cocktail_rdy=0;
   }
   
  else if (cocktail1 ==2){
    Cocktail = 2;
    cocktail_rdy=0;
  }
  else {
  Cocktail = 0;
 }

}
  {  
  //Ãœbergabebestätigung
        if (Cocktail > 0) {
    DATEN[0] = 1;
           }
           else {
    DATEN[0] = 0;
           }
} 
}

void requestEvent() //Sende Daten mit I2C Bus (6 Bytes werden gesendet in einem String)
{
 
  DATEN[1] = cocktail_go; //Cocktail ist in Bearbeitung 
  DATEN[2] = cocktail_rdy; //Cocktail-X ist fertig gemixt
  Wire.write((byte*)DATEN, 6); // Schreibe Daten
}

Arduino MINI

#include <Wire.h>
#define  MSGSIZE  6 // (Länge des Arrays)

int anti = 0;


byte DATEN[MSGSIZE];           // Ãœbertragungsstring "Daten" welcher im Setup definiert wird

// diese Daten können ausgewertet werden
int value1; 
int value2;
int value3; 
int value4; 
int value5; 
int value6;

void setup() {

{   
  Wire.begin(64);  //Kanal 18 wird festgelegt (Kanal 32 bei ESP8266)
  Wire.onReceive(receiveEvent); // register event  für das Empfangen von Daten
  Wire.onRequest(requestEvent); // register to send Data für das Senden der Daten
  Serial.begin(115200);
}  

}

void loop() {

value1 = DATEN[0];
value2 = DATEN[1];
value3 = DATEN[2];
value4 = DATEN[3];
value5 = DATEN[4];
value6 = DATEN[5];


  if (DATEN[3] == 1) {
         anti = 1;
           }
   
          else if (DATEN[3] == 2){
            anti = 2;
        }
        else {
       anti = 0;
 }

  }

// Auswahl 
switch  {

  case 1: // 
  case 2: // 
  case 3: // 
  
void receiveEvent(in16_t byteCount) //Empfange Daten

{
while(Wire.available()) {
Wire.readBytes( (byte*)&DATEN, 6);  
}

void requestEvent() //Sende Daten mit I2C Bus (6 Bytes werden gesendet in einem String)
{}

dave_neub:
I2C Bus:
Slave 1= ESP-01
Slave 2 = Arduino UNO
Salve 3 = Arduino Mini

Der I2C-Bus benötigt einen Master, nur Slaves geht nicht.

  Wire.begin(0);  //Kanal 16 wird festgelegt (Kanal 32 bei ESP8266)

Die Adresse 0 hat nach meiner Erinnerung eine Sonderbedeutung, würde ich nicht wählen.

(Kanal 32 bei ESP8266)
...
Slave 1= ESP-01

Der ESP kennt keinen Slave Modus.
Er kann nur Master sein

Die Adresse 0 hat nach meiner Erinnerung eine Sonderbedeutung,

Richtig, das ist die General Call Adresse.
Darauf dürfen alle horchen, aber keiner Antworten.

combie:
Der ESP kennt keinen Slave Modus.

Damit sind UNO und Mini automatisch Slave. Wenn die direkt miteinander kommunizieren können sollen, geht das, indem ein Slave als Master agiert.

Mehrere Master ergeben eine spannende Konstellation :slight_smile:

Hallo,

das mit den Master und Slave ist schon verwirrend. Vor 200 Jahren wusste jeder wie das ging.

1 Master ... alle anderen Sklaven

Master Fragt Sklave 1 ..... haste was zu melden ..... Sklave 1 sagt nein.
Master Fragt Sklave 2 ..... haste was zu melden ..... Sklave 2 sagt ja. Diese nachricht muss zu Sklave 1 "BAL"
Master Sagt zu Sklave 1 ...... Sklave 2 sagt das zu dir . "BAL" ..... Sklave 2 sagt "OK"
Master Sagt zu Sklave 2 ...... Sklave 1 sagt das zu dir . "OK" ..... Sklave 1 sagt "OK"

ganz klare Zustände. Nur etwas umständlich.

agmue:
Damit sind UNO und Mini automatisch Slave. Wenn die direkt miteinander kommunizieren können sollen, geht das, indem ein Slave als Master agiert.

Mehrere Master ergeben eine spannende Konstellation :slight_smile:

Da geht es doch per IRQ. Ein Slave meldet, dass er was zu sagen hat und der Master holt es ab.

Bei den paar Daten doch kein Problem.

Tip: verwende als Datenstruktur eine Union aus einem struct und einem Byte Array gleicher Größe:

#pragma pack(push, 1)

union Data
{
   struct
   {
      int value1;
      int value2;
   };
   byte asArray[2 * sizeof(int)];
};

#pragma pack(pop)

So hast du ansprechende Namen und kannst die Variablen als Array behandeln und sie umzukopieren. Und es funktioniert mit beliebigen Datentypen

Wobei du mit dem 32-Bit Prozessor etwas aufpassen musst! Auf dem hat int 4 Byte. Auf dem Arduino aber nur 2 Byte. 2 Byte auf dem ESP ist short! 4 Byte auf dem Arduino ist long.

Oder du machst dir etwas Gedanken über den Werte-Bereich. Für 0-255 reicht auch Byte.

Master gibt es nur während einer Datenübertragung. Wer ein anderes Gerät mit seiner Adresse anspricht, ist Master, und wer antwortet ist Slave.