Go Down

Topic: wire.read() (Read 840 times) previous topic - next topic

1udo1

Hallo,

der erste Nano sendet als Slave den Wert von "val". Die Variable wird incrementiert. Die Anzeige ist auf dem seriellen Monitor im Slave-Sketch richtig.

... aber

im Master, als Empfänger, werden nur Nullen angezeigt.

Habe vieles probiert, bin aber ratlos, warum der Master nicht den Wert vom Slave darstellt.

Kann jemand helfen?

Code: [Select]



// Sender Slave mit Adresse #8

#include <Wire.h>
byte val=0;

void setup()
{
  Wire.begin(8);               
        Serial.begin(9600);
}

void loop()
{
  Wire.beginTransmission(40);
  Wire.write(val);           
  Wire.endTransmission();
   
  val++; 
     
        Serial.print(val);          // werte werden auf dem seiellen Monitor richtig angezeigt
        Serial.println();

  if(val == 64)
  {
        val = 0;   
  }
  delay(1000);
}

//################################################################



// Empfänger Master mit Standard Adresse  #40

#include <Wire.h>
volatile byte c;

void setup()
{
  Wire.begin();       
  Serial.begin(9600);
}

void loop()
{
  Wire.requestFrom(8, 1);   
  while (Wire.available())
       {

    byte c = Wire.read();

    Serial.print(c);          // es werden nur Nullen im seriellen Monitor angzeigt
                Serial.println();
        }
  delay(100);
}


DrDiettrich

Probiere erst mal die Beispiele für Master und Slave aus. So wie Du Dir das vorstellst, funktioniert die Übertragung nicht. Nur der Master fordert Daten an, der Slave stellt die Daten in der Callback-Funktion zur Verfügung, siehe onRequest().

HotSystems

Und hier findest du I2C-Master/Slave sehr gut beschrieben.
Wenn du alle Beispiele durchspielst, sollte dir das klar sein.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

Serenifly

Klar geht das nicht. Auf dem Slave braucht du den Request Event Handler um auf den Master zu antworten. So wie du es machst sendet der Slave einfach ständig

Dann musst du noch beachten dass du in dem Event Handler nur einmal write() machen kannst. Das ist nicht richtig dokumentiert. Man kann also entweder ein Byte oder ein Array senden. Für Multi-Byte Variablen kann man hier eine Union aus einer Variablen oder einem anonymen struct und einem Byte Array verwenden. Und dann das Array senden.

1udo1

Hallo ihr Drei,

Danke für Eure Antworten. Ich habe mir Eure Tips notiert und werde sie nachvollziehen.

Habe mittlerweile eine andere Version editiert. Sie funktioniert. Und weil sie funktioniert, stelle ich sie hier in den Chat rein. Der eine oder andere Anfänger,-- wie ich, sind immer froh, wenn man eine funktionierende Version als Vorlage nutzen kann. So mache ich das auch.

Code: [Select]


// master Sender

#include <Wire.h>

int x=0 ;

void setup()
{
    Wire.begin(1);
}

void loop()
{
                x++;

  if(x == 20)
  {
       x = 0;   
  }
  delay(200);
                        digitalWrite(11, HIGH);
                  delay(200);
                  digitalWrite(11, LOW);
                  delay(200);

                  Wire.beginTransmission(2); // sendet an Slave
                  Wire.write(x);
                  Wire.endTransmission();
}


//#####################################################


// slave Empfänger

#include <Wire.h>

int y ;

void setup()
{
  Serial.begin(9600);
  Wire.begin(2);
  Wire.onReceive(receiveEvent); // register event
  pinMode(11, OUTPUT);
    digitalWrite(11, HIGH);
}


void loop ()
{
             if(y==10)
            {
               digitalWrite(11, LOW);
            }

                if(y==15)
                {
                   digitalWrite(11, HIGH);
                }
}

void receiveEvent(int howMany)
{
  y = Wire.read();    // receive byte as an integer

         Serial.print(y);         
         Serial.println();
         delay(800);
}




HotSystems

Habe mittlerweile eine andere Version editiert. Sie funktioniert.
Prima, dass du es zum Laufen bekommen hast.

Nur dass du jetzt einen komplett anderen Weg (den normalen) gegangen bist.

Du nutzt den Master zum Senden deiner Daten und der Slave soll diese empfangen.
So ist es sicher die einfachste Lösung, aber nicht die, die du in deinem Eingangspost beschrieben hast.

Aber egal, es scheint ja zu funktionieren ;) und das ist wichtig.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

Go Up