Daten in den Seriellen Monitor schreiben

International Deutsch
1

Hallo miteinander, ich hätte eine kurze Frage. Und zwar kommuniziere ich mit einem anderen Arduino und dies funktioniert einband frei.

Wenn ich jetzt jedoch etwas zusätzlichen in den Seriellen Monitor schreiben will, dann funktioniert dies nicht.

Ich vermute es liegt am folgenden:

String response = Serial.readString();
response.trim();

wenn ich diese Zeile weglasse, kann ich zwar was in den Seriellen Monitor etwas schreiben. Kann aber die Daten vom anderen Arduino nicht auslesen.

Hier noch der vollständige Code:


unsigned long lastExecutedMillis = 0; // vairable to save the last executed time
#define EXE_INTERVAL 800


void setup() {
  Serial.begin(9600);// Öffne die serielle Verbindung zum seriellen Monitor
}

void loop() 
{

  if(Serial.available())
  {
    String change = Serial.readString();
    change.trim();
    Serial.println(change);
    
  }
  else
  {
     // Abfrage an den Slave senden
    Serial.println("Are you there");
    delay(500);

  // Auf die Antwort des Slaves warten
  
    String response = Serial.readString();
    response.trim();
    if (response == "I am here") {
      // Daten abrufen
      Serial.println("I am here");
      Serial.println("get Data");
      delay(500); // Eine Sekunde warten
      
      // Daten vom Slave empfangen und ausgeben
        String data = Serial.readString();
        data.trim();
        Serial.println(data);
        delay(500); 
    }
  }
}
void DELAY()
{
  unsigned long currentMillis = millis();
    
  if (currentMillis - lastExecutedMillis >= EXE_INTERVAL) {
      lastExecutedMillis = currentMillis; // save the last executed time
      
  }
  else
  {
    DELAY();
  }
}
2

Ich sehe 3 Möglichkeiten.

  1. Du verwendest 2 verschiedene Serielle SST (z.B. Softwareserial für die Kommunikation und Serial für den Monitor)
  2. Du kapselst die Kommunikation innerhalb einer Anfangs- und Endesequenz
  3. Du verwendest für die Kommunikation eine andere SST, z.B. I2C

Gruß Tommy

3

Danke für die schnelle Antwort, setzte mich gleich dran.

4

Und zusätzlich ist das schon der "wievielte" Thread zu diesem Thema?
Kannst du nicht in dem zuvor erstellten Thread bleiben ?
Oder passen die die da gestellten Antworten nicht.

Da wurde dir schon sehr viel zu deinem Problem geschrieben, einfach nur lesen und richtig machen.

5

Welche Variante ist die Lösung?
Du könntest Deine Lösung auch der Nachwelt präsentieren.

Gruß Tommy

6

Nummer 1 hat funktioniert. Danke nochmals

7

Das ist aber nicht deine Lösung, sondern der Vorschlag von Tommy.
Deine Lösung wäre deinen Sketch hier in Code-Tags zu zeigen.

8

Master Code:

#include <SoftwareSerial.h>
  
SoftwareSerial softSerial(10, 11); // RX, TX für SoftwareSerial
  
void setup() {
  Serial.begin(9600); // Öffne die serielle Verbindung zum seriellen Monitor
  softSerial.begin(9600); // Öffne die Verbindung zur Softwareserial-Schnittstelle für den Slave
} 
  
void loop() {
  if (Serial.available()) 
  {
    String change = Serial.readString();
    change.trim();
    Serial.println(change);

    // Sende die eingegebene Zeichenkette an den Slave
    delay(2500); // Kurze Verzögerung für die serielle Übertragung  
  } 
  else 
  {
    // Abfrage an den Slave senden
  
    Serial.println("Are you there");
    softSerial.println("Are you there");
    delay(300);
  
    // Auf die Antwort des Slaves warten
    String response = "";
    unsigned long startTime = millis();
    while (millis() - startTime < 1000) 
    { // Maximal 1 Sekunde auf Antwort warten
      if (softSerial.available()) 
      {
        char c = softSerial.read();
        response += c;       
      }
    }
    response.trim();
    
    if (response == "I am here") 
    {
      // Daten abrufen
      softSerial.println("I am here");
      softSerial.println("get Data");
      
      Serial.println("I am here");
      Serial.println("get Data");
      delay(200); // Eine Sekunde warten
  
      // Daten vom Slave empfangen und ausgeben
      String data = "";
      startTime = millis();
      while (millis() - startTime < 2000) 
      { // Maximal 1 Sekunde auf Daten warten
        if (softSerial.available()) 
        {
          char c = softSerial.read();
          data += c;
          startTime = millis(); // Zurücksetzen der Zeit, da Daten empfangen wurden
        }
      }
      data.trim();
      Serial.println(data);
      delay(500);
      startTime = millis(); // Zurücksetzen der Zeit, da Daten empfangen wurden
    }
  }
}

Slave Code:

#include <SoftwareSerial.h>
  
SoftwareSerial softSerial(10, 11); // RX, TX für SoftwareSerial
  
String name = "Arduino Nano";
String articleNumber = "12345";
String serialNumber = "98765";
String serviceDate = "2023-07-14";
String hardwareVersion = "1.0";
  
void setup() 
{ 
  softSerial.begin(9600); // Verbindung zur Softwareserial-Schnittstelle für den Master
}  
  
void loop() {
  // Auf Befehl des Masters warten
  
  if (softSerial.available()) 
  {
      String command = "";
      unsigned long startTime = millis();
      startTime = millis();
      while (millis() - startTime < 1000) 
      { // Maximal 1 Sekunde auf Daten warten
        if (softSerial.available()) 
        {
          char c = softSerial.read();
          command += c;
          startTime = millis(); // Zurücksetzen der Zeit, da Daten empfangen wurden 
        }
      }
      command.trim();
      
    if (command == "Are you there") 
    {
      // Antwort an den Master senden
      softSerial.println("I am here");
      delay(500);
  
      // Daten an den Master senden
      softSerial.print("Name: ");
      softSerial.println(name);
      softSerial.print("Article Number: ");
      softSerial.println(articleNumber);
      softSerial.print("Serial Number: ");
      softSerial.println(serialNumber);
      softSerial.print("Service Date: ");
      softSerial.println(serviceDate);
      softSerial.print("Hardware Version: ");
      softSerial.println(hardwareVersion);
    }
  }
}
9

Hallo, prima und danke.

10

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