Datenaustausch zwischen 4 Controllino MEGA's via SPI

Hallo allerseits,
ich muss ein größeres Modell steuern, woran 4 Controllino MEGAS's beteiligt sind, jeweils für verschiedene Maschinen. Damit sie miteinander kommunizieren können, müssen sie untereinander Werte Austauschen (vom Typ "char" und "bool"), wofür ich sie über einen Ethernet Switch verbinden wollte.
Ich habe dazu bereits ein Thema gefunden, jedoch ist das auf mein Setup nicht direkt anwendbar bzw. habe ich es nicht erfolgreich anwenden können. Wahrscheinlich, da die Controllinos dabei direkt verbunden waren(?)
Hat hier vielleicht schon jemand Erfahrungen damit sammeln können?
Freundliche Grüße
Joe

Schaue dir die Ethernet Beispiele in der IDE an.

SPI ist etwas anderes, als Ethernet. Bei Ethernet verwendet man z.B. UDP oder TCP (als Suchanstoß) als Übertragungsprotokoll.

Gruß Tommy

... zumindest im gleichen Forum hätte man sich die Arbeit machen können, das andere Thema zu Erwähnen ...

Wer weiß, an wie vielen Stellen noch diese Anfrage gestellt wurde, wie viel man-power dafür sinnlos verheizt wird und am Schluß kommt nicht Mal ein 'Danke' bzw 'Funktioniert' - von der 'Solution' ganz zu schweigen.

Nun denn, wieder Einer, Der auf die schwarze Liste käme, wenn ich denn Eine hätte.

Danke erst mal für die Korrekturen bzgl. Ethernet und SPI.
Ich hatte mir halt die Pinout.pdf vom Controllino Mega angesehen und dort war die Abbildung des Ethernet Ports (Anhang) mit den für SPI notwendigen Anschlüssen, so zumiondest habe ich das hier verstanden. Tut mir ja Leid, dass ich die Elite in diesem Forum so nerve. Ich verlange ja auch nicht eine Musterlösung für mein Problem, sondern versuche noch vieles zu verstehen und da helfen mir die Hinweise auf Beispiel libraries oder ähnliches ja auch schon sehr.
Und wenn ich eine Lösung habe, werde ich die natürlich auch vorstellen und das Thema beenden, nur habe ich noch keine.
Gruß Joe

Was fehlt dir noch zur Lösung?
Warum reichen dir die Ethernet Beispiele nicht?

Also bislang habe ich es geschafft, dass mein Controllino, den ich als Server beschrieben habe Daten an einen Controllino als Client sendet.
Coder des Servers:

#include <SPI.h>
#include <Ethernet.h>

// network configuration.  gateway and subnet are optional.

 // the media access control (ethernet hardware) address for the shield:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEF };  
//the IP address for the shield:
byte ip[] = { 192, 168, 0, 111 };    
// the router's gateway address:
byte gateway[] = { 10, 0, 0, 1 };
// the subnet:
byte subnet[] = { 255, 255, 0, 0 };

// telnet defaults to port 23
EthernetServer server = EthernetServer(80);

void setup()
{
  // initialize the ethernet device
  Ethernet.begin(mac, ip, gateway, subnet);
  Serial.begin(9600);

  // start listening for clients
  server.begin();
  
}

char x = 0;

void loop()
{

// if an incoming client connects, there will be bytes available to read:
  EthernetClient client = server.available();
  if (client == true) {
    // read bytes from the incoming client and write them back
    // to any clients connected to the server:
    Serial.print("----");
    Serial.print(client.read());
    server.write(client.read());
  }
//  x = '5';
//  server.write(x);
}

Wenn ich die letzten beiden Zeilen auskommentiere, sende ich "5" an alle Clients, den ich auch mit dem Code für den Client empfange und ausgebe:

#include <Ethernet.h>
#include <SPI.h>


byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 0, 177 };
byte server[] = { 192, 168, 0, 111 }; // Controllino 4

EthernetClient client;

void setup()
{
  Ethernet.begin(mac, ip);
  Serial.begin(9600);

  delay(1000);

  Serial.println("connecting...");

  if (client.connect(server, 80)) {
    Serial.println("connected");
    client.println("GET /search?q=arduino HTTP/1.0");
    client.println();
  } else {
    Serial.println("connection failed");
  }
}

char c;

void loop()
{
  if (client.available()) {
    c = client.read();
    Serial.println(c);
  }

  if (!client.connected()) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }
  //c = '4';             hier habe ich versucht eine 4 zu senden
  //client.write(c);
}

Ich komme jedoch, wenn ich mit dem Befehl client.write etwas versuche an den Server zu senden nicht in die If-Schleife: "if (client == true) {... ".
Also die Beispiele haben mir schon sehr geholfen, aber bislang funktioniert das Senden nur in eine Richtung. So ist also mein Stand gerade.
Gruß Joe

client.println("GET /search?q=arduino HTTP/1.0");

Die Nutzung des HTTP ist wichtig, wenn Browser mit dem Server quatschen sollen.
Auch eine übliche Anwendung.

Aber hier:
Für die nackte Datenübertragung zwischen 2 Arduinos ist es eher unnützer Ballast.

TCP halte ich allerdings schon für sinnvoll, da es eine gesicherte Transportschicht bietet.
Schlanker, würde es mit UDP werden.

Am Rande: (vielleicht ist das ja was für dich)
Ein übliches Protokoll für den Datenverkehr zwischen Speicherprogrammierbaren Steuerungen wäre "Modbus". Damit wärst du dann kompatibel mit einer großen Gruppe SPS, von zahlreichen Herstellern.
Suche mal nach "Arduino Ethernet Modbus"

combie:
Ein übliches Protokoll für den Datenverkehr zwischen Speicherprogrammierbaren Steuerungen wäre "Modbus". Damit wärst du dann kompatibel mit einer großen Gruppe SPS, von zahlreichen Herstellern.
Suche mal nach "Arduino Ethernet Modbus"

Okay, danke, da schaue ich mal rein.

Ich habe endlich eine funktionierende Lösung!
Als ich mir die Udp Reference angesehen habe, sah es dort etwas einfacher aus (Danke nochmal für den Hinweis) und mit ein wenig Probieren können jetzt beide Controllinos über das Netzwerkkabel Daten senden und empfangen.

Der Code für Controlliono1:

#include <SPI.h>         // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include <EthernetUdp.h>         // UDP library from: bjoern@cs.stanford.edu 12/30/2008


// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {  
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEF };
IPAddress ip(192, 168, 1, 178);

unsigned int localPort = 8888;      // local port to listen on

// An EthernetUDP instance to let us send and receive packets over UDP
EthernetUDP Udp;

void setup() {
  // start the Ethernet and UDP:
  Ethernet.begin(mac,ip);
  Udp.begin(localPort);

  Serial.begin(9600);
}

void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
    Serial.print("Received packet of size ");
    Serial.println(packetSize);
    Serial.print("From ");
    Serial.println(Udp.remoteIP());
    Serial.print("Data:  ");
    Serial.println(Udp.read());
    Serial.println("#############################################");
  }
  delay(10);
  
  Udp.beginPacket("192.168.1.177", 8888);
  Serial.print(Udp.beginPacket("192.168.1.177", 8888));
  char x = 5;
  Udp.write(x);
  Udp.endPacket();
  
}

Und für den Zweiten:

#include <SPI.h>         // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include <EthernetUdp.h>         // UDP library from: bjoern@cs.stanford.edu 12/30/2008


// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {  
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 177);

unsigned int localPort = 8888;      // local port to listen on

// An EthernetUDP instance to let us send and receive packets over UDP
EthernetUDP Udp;

void setup() {
  // start the Ethernet and UDP:
  Ethernet.begin(mac,ip);
  Udp.begin(localPort);

  Serial.begin(9600);
}

void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
    Serial.print("Received packet of size ");
    Serial.println(packetSize);
    Serial.print("From ");
    Serial.println(Udp.remoteIP());
    Serial.print("Data:  ");
    char z = Udp.read();
    if (z == 5) {
      Serial.println(z, DEC);
    }    
    Serial.println(z);
    Serial.println("#############################################");
    
    Udp.beginPacket("192.168.1.178", 8888);
    Udp.write(1); // Send response after receiving data
    Udp.endPacket();
    
  }
  delay(10);
  
}

Ich werde ein weiteres Update posten, wenn ich noch weitere verbunden und am laufen habe.
Danke bis hierhin für die Hilfe und wichtigen Hinweise!
Grüße Joe

Hi

2x die gleiche MAC-Adresse funktioniert?
Dachte, nur da drüber werden die einzelnen Geräte identifiziert ... ?

MfG

Edit
War mir nicht aufgefallen, daß die letzte Zahl unterschiedlich ist - so sollten auch die Probleme, Die combie bei identischer MAC erwähnt hat, direkt 'hinterm Pflug' sein.
Danke sowohl für die Erklärung, daß Das Probleme mit sich bringen kann und für's Augen öffnen - vll. beim nächsten Mal einfach genauer nach schauen ... :wink:

postmaster-ino:
2x die gleiche MAC-Adresse funktioniert?

Ich hatte jetzt bei dem einen aus dem letzten F ein D gemacht. Sind die dann noch gleich?
Aber ja, es funktioniert.
Freundliche Grüße

postmaster-ino:
2x die gleiche MAC-Adresse funktioniert?
Dachte, nur da drüber werden die einzelnen Geräte identifiziert ... ?

Liegt dran, was dazwischen hängt.
Mit Hub oder Switch, keine Chance, würde ich mal sagen.
LowLevel billig Router versagen auch daran.

Befindet sich ein Gateway, oder TCP/IP Router, dazwischen, dann geht das, zumindest besteht eine Chance, dass er auf einer höheren Protokollebene arbeitet und für jedes seiner Interfaces eine eigene ARP Tabelle hält.

Basis Info: Address Resolution Protocol