Bitte um Hilfe bei Serieller Verbindung zwischen Arduino Mega und Nano

Hallo
Ich habe versucht zwischen einem Mega und einem Nano Daten auszutauschen. Zweck des Ganzen soll sein, das der Mega über die an ihm angeschlossenen Sensoren Daten erfasst und anhand dieser Daten dann Relais ein oder aus schaltet oder auch 433mhz Funksignale sendet . Der nano soll Auch Relais steuern aber zwischen den Schaltungen Längere Pausen einlegen von bis zu 30 min. ich hab es zuerst mit Infrarot versucht allerdings ist mir das (in meinen Tests ) zu ungenau gewesen also möchte ich es per UART lösen.
Als Hardware habe ich an den Mega TX1 , RX1 und GND an eine Telefon unterputzdose angeschlossen die ich so Bearbeitet habe das ich 4 Leitungen habe und als kabel ein 6m (4 Adern, TX und RX sind auf einer Seite gekreuzt so das TX1 vom Mega auf Softserial RX vom Nano liegt)Telefonkabel am Nano ist die selbe Telefonanschluss Dose und genauso bearbeitet , laut Multimeter ist auch alles ok mit der Verkabelung . Nur kommen keine Daten an. Und ist es Normal das die Lampe vom Nano schwach leuchtet wenn das ganze verbunden ist ,und auf dem Mega strom ist, aber der Nano eigentlich aus sein müsste, weil weder Netzteil noch Usb eingesteckt sind?
Sind meine ersten versuchen mit dieser art von Verbindung also Verzeiht mir bitte wenn die ein oder andere "dumme" frage dabei ist .
Hier ist der Sketch vom Mega (nur das mit der Uart Verbindung der komplette Sketch passt hier nicht rein , allerdings Funktioniert der Rest auch)

int Heizung = 22;
int Abpumpen = 39  ;
int Umwaelzpumpe = 26  ;
int Wasser = 28 ;
int R400W2 = 22 ;
int R400W5 = 31 ;
int R400W6 = 30 ;
int R5750W = 32 ;

//////////////////////////////////////////////////////////////////////////////
//Serial Monitor
int incomingByte = 0;
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//Schwimmerschalter


int halb = 4;// Halb voll
int dreiviertel = 3;// Dreiviertel voll
int voll = 2;
/////////////////////////////////////////////////////////////
void Schwimmer() {
  if ((digitalRead(halb)  == HIGH ) && (digitalRead(dreiviertel) == HIGH ))
  {
    digitalWrite(Heizung  , HIGH);
    digitalWrite(Umwaelzpumpe , HIGH);
    digitalWrite(Abpumpen , HIGH); //Aus
    digitalWrite(Wasser , LOW ); //Ein
    //Umwälzpumpe aus
    Serial1.write(01010001);
    Serial.print ("Wasser ein ");
    delay(60UL * 1000UL);


  }
}

void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);
/////////////////////////////////////
//Relais
  digitalWrite(Heizung , HIGH);
  digitalWrite( Abpumpen , HIGH)  ;
  digitalWrite (Umwaelzpumpe , HIGH)  ;
  digitalWrite (Wasser, HIGH) ;
  digitalWrite (R400W2 , HIGH) ;
  digitalWrite (R400W5, HIGH) ;
  digitalWrite (R400W6 , HIGH) ;
  digitalWrite( R5750W, LOW) ;

  pinMode (Heizung , OUTPUT);
  pinMode (Abpumpen , OUTPUT);
  pinMode (Umwaelzpumpe , OUTPUT);
  pinMode (Wasser , OUTPUT);
  pinMode (R400W2 , OUTPUT) ;
  pinMode (R400W5 , OUTPUT) ;
  pinMode (R400W6 , OUTPUT) ;
  pinMode (R5750W , OUTPUT) ;

 // Schwimmer

  pinMode(halb, INPUT);
  pinMode(dreiviertel, INPUT);
  pinMode(voll, INPUT);

}

void loop() {
   Schwimmer();

   /////////////////////////////////////////////////////////////////
  ///Serial Monitor Steuerung


  {

    // send data only when you receive data:
    if (Serial.available() > 0) {
      // read the incoming byte:
      incomingByte = Serial.read(); }

      if ( incomingByte == 49 ) { ///1
        for (int i = 0; i < 3; i++)
           Serial1.write(000101  );
       
      }

      if ( incomingByte == 50 ) { //2
       
           Serial1.write(0101001);
      
      }
      if ( incomingByte == 51 ) { ///3
        
           Serial1.write(0xFF30CF);
        
      }
      if ( incomingByte == 52 ) { //4
         Serial1.write(0xFF18E7);
       
      }
    }
  }

  //////////////////////////////////////////////////////////////////
  /////

Und hier der vom Nano

#include <SoftwareSerial.h>        // Durch diesen Include können wir die Funktionen 
                                   // der SoftwareSerial Bibliothek nutzen.

SoftwareSerial softSerial(10, 11); // Pin D10 ist RX, Pin D11 ist TX.
                                   // Die Funktion softSerial() kann nun wie Serial() genutzt werden.

char c_inChar;   // Jedes empfangene Zeichen kommt kurzzeitig in diese Variable.
String s_input;  // In diesem String speichern wir dann unseren kompletten Text.
int relay1 = 2;
int relay2 = 3;
int relay3 = 4;
int relay4 = 5;
int relay5 = 6;


float eLS = 10 ;    
float zLS = 0;       
float dLS = 10 ;       
//pause zwischen den laufzeiten
unsigned long  Pause = 1; //min
unsigned long PauseLS = 1 ;
//Relais laufzeit bei in Sekunden

float eL = 3.5 ;      
float zL = 1.7;     
float dL = 12 ;       
float vL = 5 ;      
float fL = 1 ;   

byte val;


void setup()  
{
  Serial.begin(9600);
  // Dann initialisieren wir die serielle Schnittstelle der SoftwareSerial Bibliothek.
  softSerial.begin(9600);
  softSerial.print("Nachrichten vom Arduino landen hier.");
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);
  pinMode(relay4, OUTPUT);
  pinMode(relay5, OUTPUT);
 
}/*--(end setup )---*/


void loop()  
{
  // In dieser Schleife warten wir auf einen Text von PuTTY.
 if(softSerial.available() > 0){        // So lange etwas empfangen wird, durchlaufe die Schleife.
   c_inChar = softSerial.read();           // Speichere das empfangene Zeichen in der Variablen c_inChar.
    s_input.concat(c_inChar);               // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten.
   if (c_inChar == '\r') {                 // War das letzte Zeichen ein CR (Carriage Return)?
     
      Serial.print(s_input);                // Füge in dieselbe Zeile den empfangenen Text ein
      Serial.print('\n');                   // und schicke noch ein NL (NewLine) für einen Zeilenumbruch hinterher.
      s_input="";                           // Lösche den String für die nächste Nachricht.
      Serial.print(softSerial.read());
    }
  }
}

Ich wäre schon glücklich wenn mir einer sagen könnte wie ich die Daten lesen kann die ich verschicken möchte und über Kritik in form von Verbesserungsvorschlägen währe ich natürlich auch dankbar :slight_smile:

noiasca:
wennst magst:

deine PIN-Definitionen sind vermutlich konstant, und meist reicht byte.
statt
int Heizung = 22;

const byte Heizung = 22;

Was ist der vorteil, bzw der unterschied?

noiasca:
im setup() setzt du bereits ports mit digitalwrite, später setzt erst den pinMode. Warum?

das ist wohl eher zufällig so gekommen , hatte bisher für mich keinen merkbaren Einfluss auf die Schaltung

noiasca:
deine
if ( incomingByte ==

schreien eigentlich nach

switch-case

Ahh ok ja, das werde ich mal testen
Danke
Allerdings Funktioniert diese Eingabe für den Seriellen Monitor komischerweise, es ist allerdings noch nicht ganz ausgereift und die Funktion mit dem Serial1.write klappt nicht da keine Daten an den nano gesendet werden

Hallo, ein paar Gedanken meinerseits.

aus meiner Erfahrung bedeutet schwaches Glimmen immer Spannungs Verlust.
Funktioniert die Verbindung wenn du sie auf dem Tisch nachbaust? Für mich hört sich das nach Vertauschten Verbindungen an. Ein GND auf der TX Leitung oder sowas in der Richtung.
Oder das Kabel ist um eine scharfe Ecke gezogen und erzeugt dadurch eine unzulässige Verbindung.

Als ersten Schritt, denke ich ist wichtig das du folgende Dinge Prüfst.

Funktioniert die Verbindung generell ? Wenn ja, dann gets weiter.

Der ohmsche Widerstand der Leitungen (Einzelne Adern) untereinander. Dieser muss im Mega Ohm Bereich sein wenn kein Arduino angeschlossen ist.
Dann eine Messung gegen Erde, auch mit allen Leitern.
Dann Verbindest du alle Leiter auf einer Seite und misst ob alle Leiter auf der anderen Seite mit 0 Ohm verbunden sind.
Ist das alles OK. Kannst du davon ausgehen das das Kabel nicht das Problem darstellt. Zumindesten was die Verbindung anbelangt.
Dann Prüfst du mit einem Osziloskope ob du Fremdspannung oder Einstreusignale auf den Leitungen hast.
Kabel in der Wand oder Decke neigen dazu an 220 Volt Kabeln entlang zu kommen. Das könnte zu Problemen im EMV Bereich führen.
Ich verwende immer abgeschirmte, verdrillte Telefon Leitung, 2*2 mit 0,75 Qudrat.
Was du nicht verwenden solltest sind freie Leitungen die schon immer da waren :slight_smile:

Gruss Temucin alias TFT

  1. es ist verboten Spannung an irgendwelche Pins zu geben ohne daß die Versorgungsspannung vorhanden ist. Das macht fast jeden elektrischen Schaltkreis kaputt. Sie Spannung fließt über die Schautzdiode nach GND bzw +5V und versorgt so den NANO. Dadurch kann der Arduino-MEGA Ausgang und/oder die Schutzdioden am NANO kaputtgehen weil zuviel Strom fließt. Falls Du nicht verhindrn kannst daß der MEGA eingeschaltet ist der NANO aber nicht schalte 1kOhm-Widerstände auf RX und TX zwischen MEGA und NAMO
  2. wieso schickst Du "Nachrichten vom Arduino landen hier." vom NANO an den MEGA?
  3. Ich sehe in den Sketchen keinen Versand von Daten zwischen den Arduios. Der MEGA wartet auf eine Zahl 0,1,2 oder 3 vom PC. Der Nano auf ein CR.
  4. Du kannst auf dem NANO nicht alle Bytes einlesen und nur das letzte auf CR kontrollieren. Du mußt jedes ankommende Byte auf CR kontrollieren.
  5. benutze keine Strings.

Mach mal minimal-Sketche wo der MEGA alle paar Sekunden ein Byte sendet und der NANO dieses an den PC weitersendet.

Grüße Uwe

Pausen von 60 Sekunden helfen bei der seiellen Verbindung auch nicht. Verwende millis() !!

  • int zwei byte belegt, byte aber nur 1 byte

Beides belegt, wenn man es als const deklariert, kein Byte.

Denn der Kompiler kann das (meistens) komplett weg optimieren.

Der Optik wegen im Source würde ich es dennoch machen.

Nicht nur der Optik wegen...

const byte Heizung = 22;

Das beschreibt ganz genau, welche Daten man da verwendet.

Da digitalWrite() (und seine Brüder) da ein Byte erwarten, ist das genau richtig.
Und das const ebenso.
Man sollte sowieso nicht irgendwelche "const" (z.B. aus Faulheit) einsparen.

Dadurch, dass man Dinge zu Konstanten erklärt, kann der Kompiler bei versehentlichen Änderungen warnen/schreien.
Sonst sucht man sich u.U. einen Wolf, bei solchen Fehlern.
Das ist ein echter Mehrwert.

Dass dieses dem Kompiler viele Optimierungen ermöglicht, ist eine weitere Schaufel Zucker oben drauf.

temucin:
aus meiner Erfahrung bedeutet schwaches Glimmen immer Spannungs Verlust.
Funktioniert die Verbindung wenn du sie auf dem Tisch nachbaust? Für mich hört sich das nach Vertauschten Verbindungen an. Ein GND auf der TX Leitung oder sowas in der Richtung.
Oder das Kabel ist um eine scharfe Ecke gezogen und erzeugt dadurch eine unzulässige Verbindung.

Funktioniert die Verbindung generell ? Wenn ja, dann gets weiter.

Ja, das hatte ich oben auch schon geschrieben zumindest war es so gemeint das ich das so getestet habe.
die schaltung ist auf dem Tisch gebaut , allerdings ohne Steckbrett ,da ich sie sozusagen schon fertig in Kästen eingebaut habe die ich mir mit dem 3D Drucker dafür ausgedruckt habe.

temucin:
Dann Prüfst du mit einem Osziloskope ...........

Sowas habe ich leider nicht

temucin:
Kabel in der Wand oder Decke neigen dazu an 220 Volt Kabeln entlang zu kommen. Das könnte zu Problemen im EMV Bereich führen.
Ich verwende immer abgeschirmte, verdrillte Telefon Leitung, 2*2 mit 0,75 Qudrat.
Was du nicht verwenden solltest sind freie Leitungen die schon immer da waren :slight_smile:

Nein , wie gesagt es ist eine Schaltung die quasi auf dem Tisch aufgebaut ist :wink: nix in der wand , die Unterputzdosen hab ich nur genommen weil ich sie besser in die kästen einbauen kann und weil ich einen Stecker haben wollte bei der Verbindung um nachher beim aufbau flexibler zu sein.

uwefed:

  1. es ist verboten Spannung an irgendwelche Pins zu geben ohne daß die Versorgungsspannung vorhanden ist. Das macht fast jeden elektrischen Schaltkreis kaputt. Sie Spannung fließt über die Schautzdiode nach GND bzw +5V und versorgt so den NANO. Dadurch kann der Arduino-MEGA Ausgang und/oder die Schutzdioden am NANO kaputtgehen weil zuviel Strom fließt. Falls Du nicht verhindrn kannst daß der MEGA eingeschaltet ist der NANO aber nicht schalte 1kOhm-Widerstände auf RX und TX zwischen MEGA und NAMO

OK , das erklärt das , wusste ich nicht.

uwefed:
2) wieso schickst Du "Nachrichten vom Arduino landen hier." vom NANO an den MEGA?

Das steht da so weil das in dem Beispiel aus dem ich das übernommen habe HIER schon so stand , wie geht es denn richtig ? Ich habe das so verstanden das der "softSerial" port genauso wie der normale Serial.port aus TX und RX besteht also aus Empfangen und senden eben. Wo ist mein fehler und wie geht es richtig?

uwefed:
3) Ich sehe in den Sketchen keinen Versand von Daten zwischen den Arduios.

Wozu ist dann das Serial1.write ? Und wie wird das sonst gemacht?

uwefed:
Der MEGA wartet auf eine Zahl 0,1,2 oder 3 vom PC. Der Nano auf ein CR.

Fast :slight_smile: er wartet auf 1,2,3 oder 4 vom PC und soll dann darauf ein signal an den Nano schicken die eine Funtktion auslöst, das habe ich deshalb so gemacht weil der Mega Später an einem Rasspberry PI hängt und dann über vnc Desktop ferngesteuert und überwacht werden kann

uwefed:
4) Du kannst auf dem NANO nicht alle Bytes einlesen und nur das letzte auf CR kontrollieren. Du mußt jedes ankommende Byte auf CR kontrollieren.

Und wie geht das?

uwefed:
5) benutze keine Strings.

Mach mal minimal-Sketche wo der MEGA alle paar Sekunden ein Byte sendet und der NANO dieses an den PC weitersendet.
Grüße Uwe

Also einzelnen Zahlen meinst du ?

Danke für die erklärungen und die hinweise