UDP Datenübertragung > Link für grundlegende Arduino-Fragen?

Hallo zusammen,

ich würde gern ein für mich größeres Projekt verwirklichen.
Ich möchte ein paar Räume meines Hauses Temperatur überwachen und die Werte auf einem zentralen Display ausgeben. So eine Art Smarthome light.

Genutzt werden soll dazu die bestehende Netzwerkstruktur im Haus auf der auch mein Internet läuft.

In der Vergangenheit habe ich Arduino Projekte für den Modellbau verwirklicht welche zum Beispiel auch ein I²C Schnittstellen beinhaltet haben. Also gaaanz bei 0 fang ich nicht an. Die Sensordaten holen und verarbeiten bekomm ich glaub hin.

Jetzt habe ich mich schon VERSUCHT einzulesen und bereits mit einem Netzwerkshield (ENC28J60) experimentiert.

Grundlegendes, dass ich eine IP vergeben muss, das es unterschiedliche Protokolle gibt und das UDP für eine Datenübertragung am besten wäre habe ich schon herausfinden können (hoffe ich zumindest)

Aber nun stockt es bei mir.
Die Kernfrage ist: Wie bekomme ich die Daten von Arduino A zu Arduino B und wieder zurück?

Welche Bibliotheken bzw. Befehle werden da benutzt bzw. sind empfehlenswert? Wo kann ich das alles nachlesen?
Irgendwie dreh ich mich im Kreis und finde keinen Ansatz.

Über einen Link oder Tipps wäre ich dankbar.

Grüße!

Wenn du mit Arduino und deinem gesuchten Begriff googelst, findest du so einiges.
Z.B. Dies hier.

Mein Tipp: verwende WLan und die Module ESP8266 oder ESP32, da sparst du viel Arbeit.

Da hast Du Dir das ungünstigste ausgesucht, was möglich war. Das Teil ist selbst strohdumm und der Prozessor muss alles selbst machen. W5100 bzw. W5500 sind da besser und belasten den Prozessor nicht so sehr.

Hast Du als Alternative mal an WLAN mit den ESP8266/ESP32 gedacht? Bei Fips findest Du Beispiele dazu, auch eine Abhandlung über UDP.
Die kannst Du auch mit der Arduino-IDE programmieren.

Gruß Tommy

was meinst du mit "und wieder zurück".
Du sendest Daten von A zu B. Was willst du "zurück"? Besonders bei UDP ... da gibts kein "Zurück". "Zurück" müsstest du bei UDP selber implementieren.

"am besten" ... lässt sich so nicht sagen. UDP unterscheided sich von TCP.
Z.B. erlaubt UDP Broadcast und Multicast (also das senden einer Meldung an mehrere Teilnehmer). Aber dafür ist die Übertragung nicht transportgesichert (es gibt kein "zurück").

Bei TCP sendest die Nachricht an einen Teilnehmer (unicast), der dir aber dann auch mitteilt, dass die Nachricht angekommen ist (oder auch mehr).

wurde schon geschrieben, ich möchte es aber unterstreichen, der ENC ist die schlechtere Wahl zum Wiznet W5100/W5500.

Vorab, danke für die schnellen Antworten...

Ehrlich gesagt nein. Ich dachte mit WLAN sei es um einiges komplizierter... :roll_eyes:
Danke für den Link!

Ja dachte schon an einen "beidseitigen Transfer".
So von wegen A sendet an B den Temperaturwert. Dieser wird am Display ausgegeben und man kann etwas steuern und an A zurück senden.

Ok, Danke!

Ich werd mich mal weiter einlesen.

Wovor ich etwas "Angst" habe ist eine neue Programmiersprche...
Wäre das beim ESP32 nicht bereits so?

Bin jetzt nicht der Mega Crack und meist froh wenn ich meinen einfachen Projekte sinnvoll zum laufen bekomm. Was ja bis jetzt eigentlich immer funktioniert hat. :cold_sweat:

Das geht natürlich auch bei UDP.
Allerdings nicht automatisch, so Art Quittung.
Du musst dafür selbst ein "Protokoll" erstellen.
Ich nutze es bei mir auch für einfache Informationen zwischen den ESP32 und ESP8266. Auch in beide Richtungen. Aber eben selbst aufgebaut.

Was die "Programmiersprache" ist, ist es C++, ob für einen Arduino oder die ESP.

Hallo,
wenn Du mehrere "Sensoren" verwenden willst und eine Zentrale solltest Du es schon so aufbauen das die Zentrale sich geordnet die Messwerte holen geht. Wenn die Sensoren unkontrolliert senden wann sie wollen könnte es bei UDP Probleme geben wenn da mehrere gleichzeitig senden wollen. In dem Fall macht dann TCP oder HTP mehr eventuell Sinn da ist das Protokoll schon drin
Heinz

Ich stimme @Rentner voll zu
Mit UDP: Die Zentrale sollte sich die Messwerte anfordern

Sonst TCP.

Nein überhaupt nicht. Der ESP8266 und auch der ESP32 lassen sich mit der dir bekannten Arduino-IDE mit genau derselben Programmiersprache programmieren.
Einziger Unterschied es kommen neue Befehle für das WLAN / WiFi dazu.
Aber da hat man ja bei jeder neuen library

Die Internetseiten von FIPS haben eine Menge Code-Beispiele.
Als ich da drübergschaut habe dachte ich oh Gott soooviel und jeweils schon richtig komplexe Projekte.
Dann habe ich aufgehört zu suchen. Wenn einer der FIPS-Kenner einen direkten Link zu einem
kleinen Demo-Code send / receive UDP oder TCP posten kann dann doch bitte hier posten. Aber stundenlang in komplexen codes sich was zusammensuchen müssen? NEIN DANKE!

@Tommy56 hat den passenden Link weiter unten gepostet. Schön kompaktes Beispiel

Wenn die WLANVerbindung steht ist das eigentliche Senden sehr schnell programmiert

    Udp.beginPacket(remoteIP, remotePort);
    Udp.write((const uint8_t*)UDP_Msg_SS.c_str(), UDP_Msg_SS.length() );  
    Udp.endPacket();

Das UDP_Msg_SS.c_str() ist die Variable in der die UDP-Nachricht drin steht

Das hier ist ein Demo-Code um ein einzelnes byte per UDP zu senden
Siehe die Zeile mit UDP.write(buttonState);

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
  
// Set WiFi credentials
#define WIFI_SSID "TheOtherESP"
#define WIFI_PASS "flashmeifyoucan"
 
// UDP
WiFiUDP UDP;
IPAddress remote_IP(192,168,4,1);
#define UDP_PORT 4210
#define flashButton 0
 
void setup() {
 
  // Setup IO
  pinMode(flashButton, INPUT_PULLUP);   
  // Setup serial port
  Serial.begin(115200);
  Serial.println();
  
  // Begin WiFi
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  WiFi.mode(WIFI_STA);
  
  // Connecting to WiFi...
  Serial.print("Connecting to ");
  Serial.print(WIFI_SSID);
  // Loop continuously while WiFi is not connected
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(100);
    Serial.print(".");
  }
  
  // Connected to WiFi
  Serial.println();
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
 
  // Begin UDP port
  UDP.begin(UDP_PORT);
  Serial.print("Opening UDP port ");
  Serial.println(UDP_PORT);
  
}
  
void loop() {
 
  // Read button
  char buttonState = digitalRead(2);
 
  // Send Packet
  UDP.beginPacket(remote_IP, UDP_PORT);
  UDP.write(buttonState);
  UDP.endPacket();
  delay(100);   
}

und das der Code der die UPD-Nachricht empfängt

// NodeMCU mit LED an D7
// Als UDP-Slave, der vom NodeMCU 1 seine Befehle bekommt
// für UDP-Server
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#define LED D7

WiFiUDP Udp;
unsigned int localUdpPort = 4210;  // local port to listen on
char befehl[10];  // buffer for incoming packets
boolean ledStatus = false;

// <= 31 Zeichen
char *ssid = "Meine_WLAN_SSID";
// >= 8 oder <= 63 Zeichen oder NULL
char *password = "geheimesPasswort";

void setup() {
  Serial.begin(115200);
  //Serial.setDebugOutput(true);
  Serial.println();
  Serial.println("Start");
  digitalWrite(LED, LOW);
  pinMode(LED, OUTPUT);

  Serial.print("Connecting to "); Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Udp.begin(localUdpPort);
  Serial.print("\n connected UDP-Server bereit an IP: ");
  Serial.print(WiFi.localIP());
  Serial.println("UDP-Server bereit.");
}

void loop() {
int packetSize, len;
  // UDP
  packetSize = Udp.parsePacket();
  // Da ist was da
  if (packetSize) {
    Serial.print("Empfangen "); Serial.print(packetSize);
    Serial.print(" von IP "); Serial.print(Udp.remoteIP());
    Serial.print(" Port "); Serial.println(Udp.remotePort());
    len = Udp.read(befehl, 10);
    ledStatus = befehl[0]; // erstes Byte 0 oder 1
    if (ledStatus) {
      digitalWrite(LED, HIGH);
      Serial.println("LED einschalten");
    }
    else {
      digitalWrite(LED, LOW);
      Serial.println("LED ausschalten");
    }
  }
}

Ich habe die Demo-Codes jetzt gerade eben nicht neu getestet. Möglich dass noch einige Kleinigkeiten klemmen. Aber die kannst du dann hier fragen.

Hier der Link
FIPS UDP-Demo-Code
den @Tommy56 auch gepostet hat. Vielen Dank dafür !

vgs

Das " Esp8266 UDP Spezial" ist genau das. Lesen muss man schon selbst. Und schrei hier nicht so rum.

Gruß Tommy

Ich nutze seit vielen Jahren UDP mit Rundruf (Broadcast) auf diversen Arduino-Boards (Due mit Ethernet- und WLAN-Shield, ESP32, ESP8266,..) aber auch auf dem PC (Windows und Linux), Smartphone und Tablet (Android). Also sowohl WLAN als auch Ethernet im selben Netzwerk mit beliebigen Geräten.

Der Zugriff erfolgt über sog. Sockets, im Prinzip nutze ich diese wie eine einfache serielle Schnittstelle und definiere meine Telegramme selbst.
Ich habe mir eine am CAN-Bus für Kfz orientierte Kommunikationsstruktur aufgebaut.

Dabei sende ich Messwerte einfach zyklisch mit einstellbarem Abstand (0.1 s, 1 s, 10 s, je nach Anforderung durch die Datenquelle) ins Netz (egal von welchem Gerät). Statt dem CAN-Identifier verwende ich "lesbare" Namen zur Identifikation der Botschaften. Die Länge des Telegramms spielt bei der hohen Geschwindigkeit eine untergeordnete Rolle, allerdings sollten es weniger als 1500 (1460) Bytes sein, weil die Sockets sonst stückeln.

Um Telegrammverluste zu erkennen (bei WLAN je nach Last hin und wieder, bei Ethernet wegen der heute üblichen Netzwerkstruktur mit Switches nie) werden die Telegramme beim Absenden mit einer fortlaufenden Nummer ergänzt.

Die Absender (und die zugehörigen Klassen, die in C++ auf den Arduinos und dem PC nahezu gleich sind und auf den Smartphones und Tablets in Java sehr ähnlich) nenne ich Twitter, weil das Bild dem des bekannten sozialen Netzwerkes sehr ähnlich ist.

Ich kann auf beliebigen Geräten die Messwerte spezifisch verarbeiten, indem ich die eingehenden Rundrufe nach dem Botschaftsnamen filtere. Die dafür eingesetzten Klassen (C++ und Java) nenne ich Follower.

Um IP-Adressen muss ich mich nicht kümmern, Netzwerkeinstellungen sind nicht erforderlich (natürlich muss ich die Geräte bei WLAN am Access-Point anmelden, das geschieht bei mir im Programm beim Einschalten der Geräte).
Für gezielte Übertragungen (z.B. bei der Gerätekonfiguration im Betrieb) verwende ich individuelle Gerätenamen in spezifischen Telegrammen, teilweise auch mit Joker-Zeichen zur spontanen Gruppenbildung.

Was sich in den Jahren bei mir als besonders vorteilhaft herausgestellt hat:

  1. Ich kann Messwerte auf beliebigen Geräte verarbeiten, einfach so, durch Lauschen am Netzwerk. Alle Visualisierungen (Anzeigen) stellen dabei keine Netzwerklast dar.
  2. Ich muss keinen "Master" pflegen, habe mehrere voneinander unabhängige Anwendungen, die auf unterschiedlichen Geräten laufen (sog. Multi-Agenten-System). Wird eine Anwendung ausgeschaltet, arbeiten die anderen unabhängig davon weiter.
  3. Gruppen von Geräten können sehr leicht synchronisiert werden, indem sie demselben Twitter folgen (es entsteht so eine Art "Schwarmintelligenz").
  4. Die Programmierung des Gesamtsystems ist deutlich einfacher geworden, weil durch das Modell (Twitter/Follower) automatisch eine Modularisierung erfolgt. Trotz vergleichbar hoher Komplexität ist es sehr übersichtlich und einfach strukturiert.
  5. Ich muss nicht Alles alleine machen. Mit Offenlegung der Telegramme können beliebige Interessierte eigene Twitter (mit individuellen Namen) entwickeln, die ich ohne Aufwand einfach an mein Netz anschließe und dafür auf irgendeinem Gerät (Follower) eine Anwendung schreibe. Oder eine andere Anwendung für den neuen Twitter erweitere.

Morgen zusammen,

sorry ich steh so etwas von auf dem Schlauch...

@ StefanL38
Ich probier seit über einer Stunden deinen sketch zum laufen zu bringen.
Bin einfach zu doof :pensive:
Ich bekomm noch nicht mal die richtige(n) libraries eingebunden.
Die library welche ich heruntergeladen und eingebunden habe funktioniert nicht.
Bei der nächsten ist nicht "alles dabei" hab ich den Eindruck.
Kann mir bitte jemand einen Link einstellen wo ich die richtige und zuverlässige library bekomme? Sorry!

und noch eine blöde Frage zu:

Der Syntax wäre doch:
#define WIFI_SSID mein_WLAN
#define WIFI_PASS mein_passwort_123

da kommt kein < > ; " oder irgendetwas dran?

Dank euch!

Wenn der Compiler mit Fehlermeldung abgebrochen hat.
Klicke auf den Button "Fehlermeldungen kopieren"

Wechsle zum Forum
Dann Klicke den Code-Section-Button </>

dann drücke Strg-V um die kompletten Fehlermeldungen einzufügen
Damit kann man analysieren woran es klemmt.

vgs

Hi,
heir meine Schritte welche ich gemacht hab.
Download der Library
Link:
http://www.martyncurrey.com/download/esp8266wifi-library/

Library durch Arduino IDE einbinden lassen.

Dann hab ich festgestellt, das ich anscheinend das ESP8266WiFi.h für diese library klein schreiben muss.
Also ESP8266wifi.h eingegeben.

Jetzt kommts mir so vor (ich kann die Fehlermeldung aber nicht richtig interpretieren) also ob er die Befehle nicht kennt.
Fehlermeldung:

Arduino: 1.8.19 (Windows 10), Board: "Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"





















C:\Users\BN\Desktop\WLAN_Sender\WLAN_Sender.ino: In function 'void setup()':

WLAN_Sender:23:3: error: 'WiFi' was not declared in this scope

   WiFi.begin(WIFI_SSID, WIFI_PASS);

   ^~~~

C:\Users\BN\Desktop\WLAN_Sender\WLAN_Sender.ino:23:3: note: suggested alternative: 'WiFiDrv'

   WiFi.begin(WIFI_SSID, WIFI_PASS);

   ^~~~

   WiFiDrv

WLAN_Sender:5:19: error: 'Mein_WLAN' was not declared in this scope

 #define WIFI_SSID Mein_WLAN

                   ^

C:\Users\BN\Desktop\WLAN_Sender\WLAN_Sender.ino:23:14: note: in expansion of macro 'WIFI_SSID'

   WiFi.begin(WIFI_SSID, WIFI_PASS);

              ^~~~~~~~~

WLAN_Sender:6:19: error: 'Passwort123' was not declared in this scope

 #define WIFI_PASS Passwort123

                   ^

C:\Users\BN\Desktop\WLAN_Sender\WLAN_Sender.ino:23:25: note: in expansion of macro 'WIFI_PASS'

   WiFi.begin(WIFI_SSID, WIFI_PASS);

                         ^~~~~~~~~

WLAN_Sender:24:13: error: 'WIFI_STA' was not declared in this scope

   WiFi.mode(WIFI_STA);

             ^~~~~~~~

C:\Users\BN\Desktop\WLAN_Sender\WLAN_Sender.ino:24:13: note: suggested alternative: 'WIFI_SSID'

   WiFi.mode(WIFI_STA);

             ^~~~~~~~

             WIFI_SSID

WLAN_Sender:30:27: error: 'WL_CONNECTED' was not declared in this scope

   while (WiFi.status() != WL_CONNECTED)

                           ^~~~~~~~~~~~

exit status 1

'WiFi' was not declared in this scope



Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.

Hallo,
eigentlich sind die libs im standard core für den 8266 schon mit drin , da musst du nichts zusätzlich herunterladen. Hast Du denn das Paket für den 8266 installiert ?

#define WIFI_SSID "TheOtherESP"
#define WIFI_PASS "flashmeifyoucan

das ist so schon richtig hinter ein #define gehört kein ;
Schau dir doch einfach die Beispiele zum ESP in der IDE an da findest Du auch was zu UDP.
Heinz

Hi, danke für deine Antwort...

und wieder steh ich auf dem Schlauch...
Welches Paket?

Ich verwende das ESP-01S ESP8266 Wireless WIFI module welches ich an einen Arduino Mega angeschlossen hab.
Anschluss konnt ich aber natürlich noch nicht prüfen, da ich den ganz einfachen Sketch von StefanL38 ja nicht zum laufen bekomme.

ESP8266 Boards Unterstützung installieren:

In den Voreinstellungen die Board-URL eintragen
http://arduino.esp8266.com/stable/package_esp8266com_index.json

Dann sollte das flutschen.
vgs

Hi, danke auch mit dem ESP-01S ESP8266 Wireless WIFI module?
Oder hab ich da Grundlegend etwas falsch verstanden / gekauft?

Nachtrag:

ich glaub mir geht gerade ein Lichtlein auf...
Ich hätte ein ESP8266 board kaufen sollen nicht nur das Modul

OK jetzt kommen wir der Sache näher.

Mein Demo-Programm wird auf den

ESP8266 selbst

draufgeflasht
und funktioniert dann ganz ohne Zusammenschluss mit einem anderen Microcontroller.

standalone

Das ESP8266-01
grafik

ist das dafür denkbar ungünstigte Board das man sich aussuchen kann.

E hat nämlich nur zwei IO-pins und man braucht auch noch einen extra-Programmieradapter.

Vielleicht machst du mal einen gaaanz grundsätzlichen Strategiewechsel von

Möglichst billig und möglichst wenig lesen sondern sich alles zusammenreimen

auf

einen moderaten Geldbetrag ausgeben und
Schritt für Schritt nach einem ausführlichen Tutorial vorgehen.
Genau dieses ESP32-board kaufen.

nicht

irgendein anderes!
Aus folgenden Gründen:

Hat eine Onboard-LED die man als Heartbeat-LED benutzen kann.
Diese On-Board LED haben nicht alle ESP32-boards

Das flashen funktioniert ohne extra Tastendruck am Board
(da muss man bei anderen Boards erst einmal einen zusätzlichen Kondensator anlöten)

Und dann die Installation der ESP32-Board Unterstützung nach diesem

Schritt für Schritt Tutorial

vornehmen

vgs

Hallo
wenn Du das ESP8266-01 Modul im AT Modus betreiben willst geht das im Grunde auch, allerdings ist das ziemlich doof, kann man nicht empfehlen. Als Standard ist auf dem Modul eine Software drauf die sich mittels AT Befehlen über die Serielle Schnittstelle bedienen lässt. Dazu gibts ein Manual beim ESP . Ein bischen was dazu findet Du z.B hier

Du kannst da gerne was mit rumspielen und dann selbst entscheiden.
Heinz

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.