SoftwareSerial gibt falsche Werte zurück

International Deutsch
1

Hallo zusammen,

Hab mir eine ESP "AT" Bliothek erstellt, nun wollte ich noch den Serialport im Konstruktor übergeben und sehe da ein Problem beim SoftwareSerial.

Kurz zusammengefasst: Serialport wird mit "Konstruktor(&verwendeterSerial)" übergeben und in der Klasse gibt's dann ein Objekt"Stream *WifiSerial;", welches den Serial übergeben bekommt. Danach sind zwei Funktionen relevant für den Datenaustausch:

Sendecode:

void AT_DataExchange()
{
          if(Buffer[0].length() > 0 and RxMsg.length() == 0) 
          {
            //WifiSerial->println(Buffer[0].c_str());
            WifiSerial->println(Buffer[0].c_str());
            Serial.println("WIFI SEND:");
            Serial.print("            >> ");
            Serial.println(Buffer[0].c_str());
            
          }
}

Empfangscode:

void RxRead()
{
      while(WifiSerial->available()) //Wenn Nachricht vorhanden, speichere erstmal in einen Pufferspeicher
      {
        char tmpChr = WifiSerial->read();
        Serial.println(tmpChr);
        RxMsgBuffer += tmpChr;        
      }
      if(RxMsgBuffer.lastIndexOf("\n") > -1) // Wenn ein Zeilenumbruch vorhanden, dann nehme den Teilstring
      {
        int cutPos = RxMsgBuffer.indexOf("\n")+1;
        
        String HelpStr;
        RxMsg = RxMsgBuffer;
        RxMsg.remove(cutPos);
        RxMsgBuffer = RxMsgBuffer.substring(cutPos);
      }
      else // Wenn kein Text, dann leer
      {
        RxMsg = "";
      }
}

Wenn ich einen Hardware-Serial übergebe, kommen die AT-Rückmeldungen des ESP problemlos und ich hab auch eine Wifi-Verbindung für den Datenaustausch.
Aber wenn ich Software-Serial verwende, kommen nur komische Zahlen zurück. Die ersten Zeichen passen noch, aber mit der Länge der Zeichen steigert sich der Unsinn.
Ein Beispiel: "AT+CWMODE=1" gibt als Antwort nicht "AT+CWMODE=1 OK" sondern "AT+CWMODQ⸮j OK"

Muss man bei SoftwareSerial was beachten mit der Übergabe von Zeigern oder harmoniert diese nicht gut mit der String Bibliothek? Auch wenn ich das tmpChr direkt auslese, kommt der gleiche Unsinn raus. (Deshalb die ganzen "Serial.print" Befehle im Code).

2

Was sollen wir mit den unvollständigen Fragmenten anfangen?

Gruß Tommy

3

Normal nimmt für sowas Referenzen statt Zeiger, aber im Prinzip ist das nicht das Problem

SoftwareSerial ist natürlich generell weniger zuverlässig als eine Hardware-Schnittstelle. Das kann unter gewissen Umständen solche Fehler verursachen

Das ganze Gewurschtel mit der String Klasse ist hier eigentlich überflüssig, aber das ist nicht die Ursache des Problems.
Deine Behandlung des LFs z.B. ist äußerst abstrus. Du speicherst das LF ab und fragst ab ob es vorhanden. Danach wird irgendwas mit Teil-Strings gemacht. Statt einfach abzufragen ob das eingelesene Zeichen ein LF ist

4

Möglich, dass du die Baudzahl zu hoch gewählt hast ?

5

@Tommy56: Ich dachte ich hol mir nur die beiden Funktionen raus, die ich für das Senden bzw. Empfangen der AT-Befehle verwende. Der Rest ist nur zum Senden und Auswerten der Daten.
Hier nochmal der ganze Code, aber der ist halt bereits sehr angewachsen und besteht im Allgemeinen nur im Aufruf und Auswerten der beiden oben genannten Funktionen.
Hier der Code, der ausgeführt wird:

#include "ESP8266s.h"
#include <SoftwareSerial.h>
#define  WifiSerial espSerial
SoftwareSerial espSerial =  SoftwareSerial(10,11);   

ESP8266 ESP(&espSerial);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  WifiSerial.begin(115200);

  ESP.ping();
  ESP.ConnectToAP("SSID", "Passwort");
  ESP.StartServer(8000);
  while(ESP.DataExchange())
    delay(10);
}

void loop() {
// Loopcode
}

Hier der Code, der ESP Klasse, welche ich als Objekt erzeuge, sofern ich in einem Projekt ein ESP verwende:

#ifndef ESP8266s_h
#define ESP8266s_h
#include "Timers.h"
#include <SoftwareSerial.h>
#define Buffersize 10

class ESP8266
{
  private:
    Timer WifiTimer{8000};
    Stream *WifiSerial;
    bool busy; 
    byte SendStep;
    byte resendCount;
    byte WaitingMessages;
    String Buffer[Buffersize];
 
    String RxMsg;
    String RxMsgBuffer;
    bool RxMsgComplete;
    
    void RxRead()
    {
      while(WifiSerial->available())
      {
        char tmpChr = WifiSerial->read();
        Serial.println(tmpChr);
        RxMsgBuffer += tmpChr;        
      }
      if(RxMsgBuffer.lastIndexOf("\n") > -1)
      {
        int cutPos = RxMsgBuffer.indexOf("\n")+1;
        
        String HelpStr;
        RxMsg = RxMsgBuffer;
        RxMsg.remove(cutPos);
        RxMsgBuffer = RxMsgBuffer.substring(cutPos);
      }
      else
      {
        RxMsg = "";
      }
    }
    
    void AT_DataExchange()
    {
      switch(SendStep) {
      
        case 0: //Send AT message, if available
          busy = false;
          if(Buffer[0].length() > 0 and RxMsg.length() == 0) 
          {
            //WifiSerial->println(Buffer[0].c_str());
            WifiSerial->println(Buffer[0].c_str());
            Serial.println("WIFI SEND:");
            Serial.print("            >> ");
            Serial.println(Buffer[0].c_str());
            WifiTimer.Start();
            busy = true;
            SendStep = 1;
          }
          break;
          
        case 1: //Wait for answer
          Serial.println("WIFI ANSWER:");
          SendStep = 2;
          
        case 2: // Check answer
          if(RxMsg.length() > 0)
          {
            Serial.print("            >> ");
            Serial.print(RxMsg);

            if(RxMsg.indexOf("OK") > -1)
            {
              SendStep = 0; 
              WaitingMessages--; 
              for(int i=0; i < Buffersize-1; i++)
              {
                Buffer[i] = Buffer[i+1];
              }
              Buffer[9] = "";
            }
            else if(RxMsg.indexOf("ERROR") > -1)
            {
              SendStep = 0;
            }
          }
          if(WifiTimer.Finished())
          {  
            SendStep = 0;
            Serial.println("            >> TIMEOUT");
          }
          RxMsg = "";
          break;
      }
    }
    
    bool AT_addBuffer(String newAT)
    {
      if(Buffer[Buffersize-1].length() > 0)
      {
        Serial.print("WIFI  >> Buffer overflow ... Message not sent");
      }
      else
      {
        for(int i=0; i < Buffersize; i++)
        {
          if(Buffer[i].length() == 0)
          {
            Buffer[i] = newAT;
            WaitingMessages = i+1;
            Serial.print("WIFI  >> Message \"");
            Serial.print(newAT.c_str());
            Serial.print("\" added  ...  ");
            Serial.print(WaitingMessages);
            Serial.println(" message(s) waiting for sending");
            break;
          }
        }
      }
    }
    
    bool AT()
    {
      return AT_addBuffer("AT");    
    }
    
    bool AT_GMR()
    {
      return AT_addBuffer("AT+GMR");
    }
    
    bool AT_GSLP(unsigned long Time)
    {
      String tmpStr = "AT+GSLP=";
      tmpStr += Time;
      return AT_addBuffer(tmpStr.c_str());    
    }
    
    bool ATE(bool IsActive)
    {
      String tmpStr = "ATE";
      tmpStr += IsActive;
      return AT_addBuffer(tmpStr.c_str());   
    }
    
    bool AT_CWMODE(byte Mode)
    {
      String tmpStr = "AT+CWMODE=";
      tmpStr += Mode;
      return AT_addBuffer(tmpStr.c_str());    
    }
    
    bool AT_RST()
    {
      return AT_addBuffer("AT+RST");    
    }
    
    bool AT_CWJAP(String WifiSSID, String Password)
    {
      String tmpStr = "AT+CWJAP=\"";
      tmpStr += WifiSSID;
      tmpStr += "\",\"";
      tmpStr += Password;
      tmpStr += "\"";
      return AT_addBuffer(tmpStr.c_str());    
    }   
    bool AT_CWLAP()
    {
      return AT_addBuffer("AT+CWLAP");
    }
    
    bool AT_CWQAP()
    {
      return AT_addBuffer("AT+CWQAP");
    }

    bool AT_CWSAP(String WifiSSID, String Password, byte Channel, byte SecurityMode)
    {
      String tmpStr = "AT+CWSAP=\"";
      tmpStr += WifiSSID;
      tmpStr += "\",\"";
      tmpStr += Password;
      tmpStr += ",";
      tmpStr += Channel;
      tmpStr += ",";
      tmpStr += SecurityMode;
      return AT_addBuffer(tmpStr.c_str());   
    }
    
    bool AT_CIPSTART(String Communication, String toServer, int Port)
    {
      String tmpStr = "AT+CIPSTART=\"";
      tmpStr += Communication;
      tmpStr += "\",\"";
      tmpStr += toServer;
      tmpStr += ",";
      tmpStr += Port;
      return AT_addBuffer(tmpStr.c_str());  
    }
    
    bool AT_CIPMUX(bool Mode)
    {
      String tmpStr = "AT+CIPMUX=";
      tmpStr += Mode;
      return AT_addBuffer(tmpStr.c_str());    
    }      
    
    bool AT_CIPSERVER(int Port) 
    {    
      String tmpStr = "AT+CIPSERVER=1,";
      tmpStr += Port;
      return AT_addBuffer(tmpStr.c_str());    
    }  
    
    bool AT_CIPSTATUS()
    {
      AT_addBuffer("AT+CIPSTATUS");
    }
    
    bool AT_CIPSEND(int ConnectionID, String Message)
    {
      bool rtrn = true;
      String tmpStr = "AT+CIPSEND=";
      tmpStr += ConnectionID;
      tmpStr += ",";
      tmpStr += Message.length();
      AT_addBuffer(tmpStr.c_str());
      
      tmpStr = Message;
      rtrn &= AT_addBuffer(tmpStr.c_str()); 
      
      return rtrn; 
    }
    
    bool AT_CIPSTA()
    {
      bool rtrn = true;
      rtrn = AT_addBuffer("AT+CIPSTA?");  
      return rtrn;
    }
    bool AT_CIFSR()
    {
      bool rtrn = true;
      rtrn = AT_addBuffer("AT+CIFSR");  
      return rtrn;
    }

  public:
    ESP8266(Stream *getSerial)
    {
      WifiSerial = getSerial;
    }
    
    byte DataExchange()
    {
      RxRead();
      AT_DataExchange();
      return WaitingMessages;
    }
    String ReadMsg()
    {
      return RxMsg;
    }

    bool GotMsg()
    {
      if(RxMsg.length() > 0)
        return true;
      else
        return false;
    }
    
    void ping()
    {
      AT();
      AT_GMR();
    }
    
    void ConnectToAP(String WifiSSID, String Password)
    {
      AT_CWMODE(1);
      AT_RST();
      AT_CWJAP(WifiSSID, Password);
      AT_CIPSTA();
      //AT_CIFSR();
    }

    void DisconnnectFromAP()
    {
      AT_CWQAP();
    }

    void StartServer(int Port)
    {
      AT_CIPMUX(1);
      AT_CIPSERVER(Port);
    }
    
    void CloseServer()
    {
      AT_CIPMUX(0);
      AT_RST();
    }
    
    void Send(int ConnectionID, String Message)
    {
      AT_CIPSEND(ConnectionID, Message);
    }
    
};
#endif
6

Ich muss es leider in zwei Posts aufteilen, da der ganze Code die 9000 Zeichen sprengt.

In einem Array kann ich maximal 10 AT-Befehle eintragen, für jeden AT-Befehl hab ich eine eigene Funktion erstellt. Durch die DataExchange() Funktion kann ich den Puffer entweder in einer while-Schleife abarbeiten (was aber in der Loop alles ausbremst, aber im Setup durchaus akzeptabel ist), oder ich rufe sie in der Loop jedesmal zyklisch auf um den nächsten Befehl zu senden, sofern ich nicht auf eine Antwort warte. Über eine Switch-Case wird der Status der Übertragung geprüft. Das ist bereits ziemlich viel Code, weshalb ich nicht alles posten wollte (der Übersichtlichkeit halber).

@Serenifly: Ich habs zu Begin als Referenz versucht, allerdings hat die "Read()" keine Werte zurück gegeben und ich bin mit Zeigern etwas vertrauter. Da es ein paar wenige Bibliotheken gibt, wo es so übergeben wird, hab ich mich dafür entschieden. Aber das Anpassen ist später das kleinere Problem.
Dieses Gewurschtel ist tatsächlich fast historisch gewachsen, da ich zu Beginn Probleme hatte, den String richtig auszulesen und auszuwerten. Das wird noch vereinfacht, wenns einmal komplett funktioniert.

@HotSystems: Der Standard bei den ESP8266 ist 115200, da hab ich erstmal nichts angepasst. Kann gerne eine geringere Baudrate versuchen.

7

115200 dürfte für SoftwareSerial zu hoch sein

Und auch hier gehören Referenzen hin:

bool AT_CWSAP(String WifiSSID, String Password, byte Channel, byte SecurityMode)

Korrekt mindestens so:

bool AT_CWSAP(String& WifiSSID, String& Password, byte Channel, byte SecurityMode)

Analog bei allen anderen Methoden. Objekte übergibt man immer als Referenz um die Kopie zu vermeiden. Sauberer noch eine const-Referenz wenn man den String nicht verändert

Dein ständiges c_str() ist auch überflüssig. Siehe z.B. das:

return AT_addBuffer(tmpStr.c_str());

 bool AT_addBuffer(String newAT)

Du übergibst einen C-String (also ein char Array). Aber die Methode macht gleich wieder ein String Objekt daraus

8

Ich habs heute doch noch gleich getestet (nur Schnelltest) und tatsächlich minimiert sich der Fehler mit niedrigerer Baudrate. Getestet mit 9600 und 19200.

Am Arduino Mega klappts dadurch gut am Testaufbau, beim Nano für die finale Anwendung hakt es irgendwie noch etwas mehr, aber auch hier kommt häufiger was sinnvolles zurück.

Danke erstmal, damit bin ich ein großes Stück weiter.

9

Du hast am Anfang den ESP erwähnt. Jetzt sagst du aber dass es auf dem Nano laufen soll. Einen AVR Prozessor zum Testen zu verwenden ist ok, aber wenn das am Ende nur auf AVRs laufen soll bist du mit AltSoftSerial besser dran. Das verwendet einen Hardware Timer und ist damit zuverlässiger. Geht allerdings nicht auf ESPs