Sending Data From ESP32 to ArduinoUno

Hallo,

ich sitze gerade dran und suche nach einer Möglichkeit, eine Datei von einem ESP32 an ein ArduinoUno zu senden.

Ich habe ein Code geschrieben um ein Bluetooth Signal auf zu nehmen, die Stärke abzuspeichern und würde nun gerne dieses Signal an den ArduinoUno weiter schicken.

Dabei soll nun dieser von 2 verschiedenen ESP32 diese Signale bekommen und abgleichen.

Mein Problem ist es nun, überhaupt etwas von dem ESP32 an den ArduinoUno zu schicken.

Bitte Bittte helft mir, ich habe so vieles nun versucht.
Mir reicht ein sketch, der Hello World versendet. Mir ist es ganz egal was.
Aber ganz wichtig, vom ESP32 zum ArduinoUno.

Ich danke euch ehrlich sehr.

Da wäre es sinnvoll, uns das mitzuteilen.
Möglichkeiten wären I2C (Multimaster, da 2 ESP32), Serial (Softwareserial am UNO)

oder UNO weg lassen und beide ESP32 per I2C kommunizieren lassen. Einer ist Master und fordert den Wert vom zweiten an. Der kann die Auswertung auch mit machen. Was soll der UNO dabei?

Gruß Tommy

der Uno ist das schwächste Glied.
Warum kannst du den Uno nicht gegen einen dritten ESP32 austauschen?

Basierend auf dieser Quelle habe ich mal was mit I²C aus meiner Bastelkiste geholt:

Zwei ESP32 als Sender, die sich in der Variablen daten.absender unterscheiden:

/* ESP32 als I2C-Sender
  GPIO21 I2C SDA
  GPIO22 I2C SCL
*/
#include <Wire.h>
const byte empfaengeradr = 11;

union Data
{
  byte asArray[20];
  struct
  {
    char text[19];
    byte absender;
  };
};

Data daten;

void setup()
{
  Wire.begin();
  Serial.begin(115200);
  daten.absender = 1;  // für ESP 1
  //daten.absender = 2;  // für ESP 2
}

void loop()
{
  snprintf( daten.text, sizeof(daten.text), "Hello World!" );
  writeValues(empfaengeradr, daten);      //Daten senden
  Serial.print("ESP ");
  Serial.print(daten.absender);
  Serial.print(" sendet: ");
  Serial.println(daten.text);

  delay(1000);
}

void writeValues(byte empfaenger, union Data& values)
{
  Wire.beginTransmission(empfaenger);
  Wire.write(values.asArray, sizeof(values));
  Wire.endTransmission();
}

Ein UNO als Empfänger:

// UNO als I2C-Empfänger
#include <Wire.h>
const byte empfaengeradr = 11;

union Data
{
  byte asArray[20];
  struct
  {
    char text[19];
    byte absender;
  };
};

Data values;

void setup() 
{
  Serial.begin(19200);
  Serial.println("\nStart");

  Wire.begin(empfaengeradr);
  Wire.onReceive(receiveHandler);
}

void loop() 
{
}

void receiveHandler(int numBytes)
{
  if (Wire.available() > 0)
  {
    for (unsigned int i = 0; i < sizeof(values); i++)
      values.asArray[i] = Wire.read();
  }

  Serial.print("Empfangen von ESP ");
  Serial.print(values.absender);
  Serial.print(": ");
  Serial.println(values.text);
}

Ausgabe UNO:

Empfangen von ESP 1: Hello World!
Empfangen von ESP 2: Hello World!

Zufrieden?


Anmerkung: Anstelle der Begriffe I²C-Master und I²C-Slave habe ich Sender und Empfänger gewählt. Möglicherweise gibt es zutreffendere Begriffe.

EDIT: Programm Kommentar entfernt und Feld auf 20 Byte reduziert.

Wie stellst Du sicher, dass sich nicht beide "Sender" ins Gehege kommen?
Evtl. musst Du das struct noch packen.

Es wäre gut, wenn der TO mal die Fragen beantwortet.

Gruß Tommy

Wire soll doch Multi-Master unterstützen, dann muß ich mich nicht darum kümmern. Oder ist das eine Illusion?

Wie wahr! Ohne die Aufgabenstellung genauer zu kennen, ist eine Vertiefung dieses Themas sinnlos. Schließlich gibt es ja eine ganze Handvoll Schnittstellen, alle mit Vor- und Nachteilen.

Ja, wenn man verschiedene Prozessorarchitekturen verbinden muss man da unter Umständen aufpassen. Wenn man nur AVR Prozessoren hat ist sowas egal. Aber 32-Bit Prozessoren arbeiten immer in 4 Byte Blöcken:

kann ich denn einen Motor auch mit einem esp32 steuern?

und das hat geklappt bei dir?

hast das dann auf pin 1 und pin 0 vom uno verbunden?

Ohne level shifter oder wie? direkt?

Nein oder, hat das wirklich geklappt?

Is das cool, ich muss das versuchen.

Was wenn ich das mit softwareSerial mach also einen anderen pin beim uno noch als empfänger und sender benutzen will, geht das auch?

SoftwareSerial links(2,3);
SoftwareSerial rechts(7,8);

Ich bin dir ehrlich sehr dankbar

Also entschuldige.

Ich würde gerne ein Bluetooth Signal Empfangen und zwar über zwei Esp32 und dann an den Uno weiter geben.
Diese werden beim uno dann verglichen und es wird ein Motor angesteuert.

Und bei mir klappen die Codes aber es kam bis jetzt nur Kauderwelsch an.

Der uno ist für die Ansteuerung eines Motors und den Vergleich der beiden Werte.

Folgend mein Code nur mal um etwas mit dem uno zu empfangen, habe nun auch ein level shifter aber ich glaube, ich habe trotzdem ein Fehler..

Code Sender Esp32 Links:
#define RXp2 16
#define TXp2 17

void setup() {
// put your setup code here, to run once:
//Serial.begin(115200);
Serial2.begin(115200, SERIAL_8E1, RXp2, TXp2);
}
void loop() {

Serial2.println("12");
delay(1000);

}

Code Uno zum empfangen:

#include <SoftwareSerial.h>

SoftwareSerial links(2,3); //rx, tx
SoftwareSerial rechts(7,8); //rx, tx

void setup()
{
Serial.begin(9600);
links.begin(9600);
rechts.begin(9600);

}

void loop()
{

Serial.println("Nachricht angekommen von links: ");
Serial.println(links.read());
// delay(1000);
// Serial.println("Nachricht angekommen von rechts: ");
// Serial.println(rechts.readString());

delay(1000);

}

Ja. Natürlich über Treiber.

Ja, sonst hätte ich es als ungetestet markiert.

Nö, neben dem USB-Anschluß gibt es SCL und SDA, was A5 und A4 entspricht. Ich habe ja I²C genutzt.

Ja, direkt, weil der ESP32 inoffiziell auch 5 V an den digitalen IOs verträgt. Du machst das aber bitte mit LevelShifter.

Keine gute Idee, weil dann immer nur ein Eingangssignal ausgewertet werden kann.

Besser wäre ein µC wie der Mega2560 mit mehreren UARTs in Hardware.

Hast Du an die PullUp-Widerstände gedacht?

Für Programmlistings verwende bitte CodeTags!

Das paßt nicht zusammen. SoftwareSerial kann auch nur bis 9600 Baud,

Also ich habe deinen Code mal getest und bei mir kommt nur das Wort Start.

Aber wenn ich den ESP32 selbst plotte, kommt ESP1 sendet: Hello World

Aber übertragen macht er nicht und ich habe 2 verschiedene Esp32 dafür versucht.. wo mache ich einen Fehler, da es ja bei dir geht?

aber verdrahtet habe ich einmal mit level shifter und einmal ohne vielleicht ist ja der esp32 kaputt.. Aber der ist eigentlich relativ neu...

Vielleicht mein Arduino IDE aber dann würde ja der Kompiler schon maulen hmm

Ich habe verdrahtet, Standart RX zu Tx und Tx zu Rx und GND zu GND

Wie schließe ich dann den Level shifter an?
Also ich habe es versucht und bei dem Code von dir steht ne baud Rate von 19200 beim Uno und 115200 beim esp ist das, weil sie unterschiedliche Prozessoren nutzen?

Also dann eher einen Atmega nutzen um die beiden daten heraus zu lesen oder eben einen 3. esp32 ?

kannst du mir mit der verdrahtung helfen, auch wenn ich es auf A5 und A4 anschließe, kommt kein Signal zum Plotten beim Uno heraus

Ich danke dir ehrlich sehr.
Ich schaue seit tagen, wo ich das wissen her bekomme und versuche so vieles aber nichts funktioniert.

Jetzt habe ich es mal mit LevelShifter angeschlossen:

Die gelbe LED und das schwarze Kabel links unten gehören nicht dazu!

ESP32 - LevelSifter
3V3 - LV
GND - GND (fehlt bei mir, macht der HUB)
GPIO21 - A3
GPIO22 - A4

UNO - LevelSifter
5V - HV
GND - GND
SDA - B3
SCL - B4

Serieller Monitor vom UNO:

Empfangen von ESP 1: Hello World!

Es geht einfach wirklich... ich habe es gerade angeschlossen im moment.

Ok, ich danke dir sooo sehr erstmal.

Nun 1. Woher wusstest du die pins beim esp32?
sind es beim uno immer scl und sda?

  1. ich habe vorhin schon mal versucht von einem esp32 zu einem anderen die daten zu schicken, da du ja meintest ich solle einfach ein 3. esp32 nehmen um das ganze zu vergleichen.

  2. um eine Zahl zu versenden geht das doch genauso oder ich müsste sonst strin benutzen oder?
    3.1 ich werde herum versuchen, das ist schon mal der ober mega super hammer. wirklich danke

Ich weiß nur die Tags hier nichts, sonst würde ich das gerne hier hinein stellen.

Darf ich das so kurz?

HardwareSerial Sender(1);  

#define Sender_Txd_pin 13
#define Sender_Rxd_pin 12

void setup() {
  //Serial.begin(Baud Rate, Data Protocol, Txd pin, Rxd pin);
  Serial.begin(115200);                                             
  Sender.begin(115200, SERIAL_8N1, Sender_Txd_pin, Sender_Rxd_pin); 
}

void loop() {
  while(Sender.available()){
    Sender.write("Hello World");                              
  }
  delay(2000);
}
                             
  

und zum empfangen

HardwareSerial Receiver(2); 

#define Receiver_Txd_pin 27
#define Receiver_Rxd_pin 14

void setup() {
  //Serial.begin(Baud Rate, Data Protocol, Txd pin, Rxd pin);
  Serial.begin(115200);                                                   
  Receiver.begin(115200, SERIAL_8N1, Receiver_Txd_pin, Receiver_Rxd_pin); 
}

void loop() {
 while (Receiver.available()) {                        
    char RxdChar = Receiver.read(); 
    Serial.println(RxdChar);              
  };
  delay(2000);
}

Aber ich bekomme die nachricht nicht drüben angezeigt, habe ich wieder falsch verkabelt?

Danke erneut das is so lieb

Schau nach was available() macht

Nein. Das ist nicht so einfach. Es gibt Methoden um entweder ein Byte zu senden oder ein Array. Auch hier gilt dass do mal die Doku ansehen solltest:
https://www.arduino.cc/en/Reference/WireWrite

Siehe #4 wie man beliebige Daten als Array behandeln kann

Hi Serenifly,

danke für deine Antwort sau lieb.

Ich habe dein link aber dort ist nichts von arrays, ich werde aber weiter nachsehen, da das ein hammer tipp ist. Also vielen Dank

Aber der Code funktioniert nur spuckt er es untereinander aus statt nebeneinander...

Ich habe es auch schon damit hinbekommen... und mit dem while, war ich der meinung er macht das so lange, die verbindung besteht oder er was empfängt oder?

Musst mal den code versuchen, der geht wirklich aber eben untereinander...
hmm ich muss mehr daran arbeiten und eure tipps einbeziehen

Dann nimm mal print anstelle von println.

Gruß Tommy

jetzt geht wieder gar nichts also ich glaube, ich habe heute zu lang dran gesessen, seit heut morgen bis jetzt.. Ich brauch ne kurze pause. :smiley:

Aber so lange eine Frage, wie versende ich denn eine Global definierte Variable von einem esp zu einem anderen ich habe das auch versucht und eigentlich hat es auch funktioniert

ich hab das heut morgen mit einem esp32 simuliert und es an sich selbst senden lassen, da der zweite noch nicht da war..

Der Code sieht so aus:

// Sending/Receiving example
#include <BLEDevice.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>


HardwareSerial Sender(2);   // Define a Serial port instance called 'Sender' using serial port 1
HardwareSerial Receiver(1); // Define a Serial port instance called 'Receiver' using serial port 2

#define Receiver_Txd_pin 27
#define Receiver_Rxd_pin 14
#define Sender_Txd_pin 13
#define Sender_Rxd_pin 12

int rechtsstarke ;
int beaconInRange ;
int scanTime = 1;     // In Sekunden, weniger als 1 ist nicht möglich schon getestet



BLEScan *pBLEScan;

class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks
{
  void onResult(BLEAdvertisedDevice advertisedDevice)
  {
 
  
    if (advertisedDevice.getName() == "HMSoft") //statt if muss glaube ich while hier hin
    {
      int ble_rssi = advertisedDevice.getRSSI();
      Serial.println("RSSI: " + String(ble_rssi));
    rechtsstarke = ble_rssi;
      Sender.begin(115200, SERIAL_8N1, Sender_Txd_pin, Sender_Rxd_pin); // Define and start Sender serial port
       Sender.println("RSSO: " + String(rechtsstarke)) ;
    }
  }
};

void setup() {
  //Serial.begin(Baud Rate, Data Protocol, Txd pin, Rxd pin);
  Serial.begin(115200);       
 Serial.println("Scanning...");

  BLEDevice::init("");
  pBLEScan = BLEDevice::getScan(); //Neuer Scan wird angelegt
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true); //Scannt die ganze Zeit durchgehend
  pBLEScan->setInterval(4); //Wenn dies hier zu klein ist, dann scheint es, als würde er langsamer werden
  pBLEScan->setWindow(3); // Dies muss weniger sein als das Intervall                                        // Define and start serial monitor
  
  Receiver.begin(115200, SERIAL_8N1, Receiver_Txd_pin, Receiver_Rxd_pin); // Define and start Receiver seri
 // Sender.begin(115200, SERIAL_8N1, Sender_Txd_pin, Sender_Rxd_pin); // Define and start Sender serial port

}

void loop() {
 //   Sender.println("RSSO: " + String(rechtsstarke)) ;
     while (Receiver.available()) {                         // Wait for the Receiver to get the characters
    
    String rechtsstarke1 = Receiver.readStringUntil('\n');
    Serial.println(rechtsstarke1);// Display the result on the serial monitor

  }
    pBLEScan->clearResults(); // Ergebnisse löschen um den Speicher nicht voll zu machen
//rechtsstarke = 1;
}

kann ich das denn auch dann an einen anderen übersenden, eigentlich doch schon oder, da er das an sich selbst als simulation eines anderen ja auch schickt?

ahja und rechtsstarke steht für die rechte Stärke ich hab auch linksstarke und will diese werte dann beim 3. esp vergleichen..