-         
Seite 3 von 3 ErsteErste 123
Ergebnis 21 bis 27 von 27

Thema: UART Kommunikation zwischen Raspi und Arduino hängt sich ständig auf

  1. #21
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    30.12.2008
    Beiträge
    1.427
    Anzeige

    das Design kann man allgemein verbessern
    Elementweiser zugriff auf statisches array z.b.
    Code:
    #DEFINE MAXLEN = 1024
    ...
    char inputString[MAXLEN];
    ...
    inputString[n] = serialGetchar(Serial);
    if (inputString[n]=="\n")
    {
        stringComplete = true; 
        ...
    }
    ...
    n++;
    Interrup vs. Polling
    "If abfragen" mit Klammern machen es übersichtlicher und vermeidet Fehler
    Code:
    if(foo == 42)   // Leerzeichen zwischen == und dem Rest
    {
        doBar;
    }
    else
    {
        doFoo
    }
    zum überprüfen ob der Buffer evtl. überläuft kann man das Resultat von serialDataAvail(Serial) ausgeben
    Auf dem Raspi kann man sich auch mal dmesg "sudo dmesg" ausgeben lassen, damit sollte man Fehler von USB-Serial adapter+treiber finden können. bzw auch Speicherzugriffsfehler von deinem Programm

  2. #22
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.232
    Zitat Zitat von Ceos Beitrag anzeigen
    Jein @Holomino

    der "+"-Operator für Strings ist überschrieben mit der concat() Funktion

    man bräuchte mehr Details/Code um die Auswirkung bestimmen zu können. Wenn die Variable außerhalb der Methode deklariert ist sollte es kein Problem damit geben.

    Aber du hast recht was das Design angeht ... wenn ich nur eine maximale definierte Zahl an Bytes empfange, sollte man IMMER einen statischen Speicher verwenden um solch "volatilen" Daten zu verarbeiten, das ist nicht nur performanter, sondern vermeidet auch Nebeneffekte wie du sie beschreibst
    wenn du dir meinen Code genau ansiehst, mache ich das ja schon genau so.
    Wirklich weiterhelfen täte aber jetzt nur ein verbesserter, vollständiger, kompilierbarer Code sowohl für Raspi als auch (falls unbedingt nötig) für den Arduino, womit ich die neue Variante dann auch sofort testen könnte.
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  3. #23
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    34
    Beiträge
    3.114
    basierend auf deinem Code fetzen (mir war entgangen dass weiter vorne noch mehr code steht )

    Code:
    uint8_t stringBuffer[MAXLEN] ;
    
    
     if (serialDataAvail(Serial)) { 
            while(!stringComplete && n<MSGLEN-1) {    
              if(n==MSGLEN-2) inChar='\n'; // emergency brake
              else  
                inChar = serialGetchar(Serial); 
           
              if(inChar=='\n' || inChar>=' ') stringBuffer[n] = inChar;       
              if (inChar == '\n')  {
                stringComplete = true;
              }
              n++;
            } 
         }
    du musst dann nur den stringBuffer in dein inputString kopieren bevor du ihn weiter verwendest (oder den inputString gleich ganz verwerfen bzw. umdeklarieren)

    für MAXLEN wäre natürlich sinnvoll MSGLEN zu wählen
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  4. #24
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.232
    Zitat Zitat von Ceos Beitrag anzeigen
    basierend auf deinem Code fetzen (mir war entgangen dass weiter vorne noch mehr code steht )

    Code:
    uint8_t stringBuffer[MAXLEN] ;
    
    
     if (serialDataAvail(Serial)) { 
            while(!stringComplete && n<MSGLEN-1) {    
              if(n==MSGLEN-2) inChar='\n'; // emergency brake
              else  
                inChar = serialGetchar(Serial); 
           
              if(inChar=='\n' || inChar>=' ') stringBuffer[n] = inChar;       
              if (inChar == '\n')  {
                stringComplete = true;
              }
              n++;
            } 
         }
    du musst dann nur den stringBuffer in dein inputString kopieren bevor du ihn weiter verwendest (oder den inputString gleich ganz verwerfen bzw. umdeklarieren)

    für MAXLEN wäre natürlich sinnvoll MSGLEN zu wählen
    klar, genau so mache ich es ja:

    strcpy (mbuf, inputString.c_str() );

    auch eine Variante mit strncpy habe ich getestet, macht aber keinen Unterschied zur Laufzeit.

    int len=min( (int)inputString.length(), (int)MSGLEN-1) );
    strncpy (mbuf, inputString.c_str(), len );
    Geändert von HaWe (04.06.2019 um 12:04 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  5. #25
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.232
    update,
    soweit ich es beurteilen kann ist der Arduino code jetzt fail-safe, weil Serial.readStringUntil() intern alle Puffer und Timeouts selber verwaltet.
    (Arduino = Mega2560)

    Der Code wurde inzwischen geupdated zum Debuggen:
    i0 wird jetzt incrementiert in jeder Arduino loop und dann zurückgesendet,
    und i2 wird jetzt incrementiert in jeder Raspi loop und dann zurückgesendet.

    Es geht einige Sekunden oder gar Minuten gut, dann hängt sich das System plötzlich aber wieder auf:

    Arduino code:
    Code:
    // Arduino Serial to Raspi USB
    
    // history:
    // 0705  debug value (i2) from Raspi
    // 0704  Serial.readStringUntil(), debug value (i0) from Arduino
    // 0703  simple msg str 
    // 0702  fixes
    // 0701  Serial.read delimiters
    // 0700   
    // 0101  ported for RPi USB
    //
    // 0009  
    // 0008  analog aX=analogRead(AX) (X=0...11), syntax "&AX=%ld",aX
    // 0007  pin-loop, 6x out-pins OUTn(I/O/pwm), &_ALLPINS_=0 when BCB-close
    // 0006  output pins DPINn
    // 0003  send/receive strings
    // 0002  receiving strings, pattern: &varname1=value1;
    // 0001  receiving simple Serial char 
    
    // ver 0705
    
    const uint32_t UARTclock = 115200;
    
    int32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;          // int (general)
    
    
    
    String  inputString="";
    
    #define TOKLEN 30
    #define MSGLEN 1024
    char    mbuf[MSGLEN];  // cstring msg buffer
    char    cval[TOKLEN];  // number as cstring
    
    
    //==================================================================
    // string tools
    //==================================================================
    
    int16_t  strstrpos(const char * haystack, const char * needle)   // find 1st occurance of substr in str
    {
       const char *p = strstr(haystack, needle);
       if (p) return static_cast<int16_t>(p-haystack);
       return -1;   // Not found = -1.
    }
    
    
    char * cstringarg( const char* haystack, const char* vname, char* sarg ) {
       int i=0, pos=-1;
       unsigned char  ch=0xff;
       const char*  kini = "&";       // start of varname: '&'
       const char*  kin2 = "?";       // start of varname: '?'
       const char*  kequ = "=";       // end of varname, start of argument: '='
       
       const int    NLEN=30;
       char  needle[NLEN] = "";       // complete pattern:  &varname=abc1234
    
    
       strcpy(sarg,"");
       strcpy(needle, kini);
       strcat(needle, vname);
       strcat(needle, kequ);
       pos = strstrpos(haystack, needle); 
       if(pos==-1) {
          needle[0]=kin2[0];
          pos = strstrpos(haystack, needle);
          if(pos==-1) return sarg;
       }
       pos=pos+strlen(vname)+2; // start of value = kini+vname+kequ   
       while( (ch!='&')&&(ch!='\0') ) {
          ch=haystack[pos+i];    
          if( (ch=='&')||(ch==';')||(ch=='\0') ||(ch=='\n')
            ||(i+pos>=(int)strlen(haystack))||(i>NLEN-2) ) {
               sarg[i]='\0';
               return sarg;
          }       
          if( (ch!='&') ) {
              sarg[i]=ch;          
              i++;       
          }      
       } 
       return sarg;
    }
    
    
    //==================================================================
    // setup
    //==================================================================
    void setup() {
      Serial.begin(UARTclock);
      
      pinMode(LED_BUILTIN, OUTPUT);
      digitalWrite(LED_BUILTIN, LOW);
      
      i0=0;
      i1=1;
      i2=-22;
      i3=33;
      i4=-444;
      i5=5555;
      i6= (uint16_t)B10101010*256;
      i6+=(uint16_t)B10101010;
    
    }
    
    
    //==================================================================
    // loop
    //==================================================================
    
    void loop() {
    
      //-------------------------------------------------------------
      // receive
      
      int  n=0;
      char inChar;     
    
      if(Serial.available()) {  
           inputString=Serial.readStringUntil('\n');    
           inputString.toCharArray(mbuf, min( (int)inputString.length(), MSGLEN-1) );     
      }
        
      //----------------------
      // process mbuf!
    
      // debug: check for changed i2 by Raspi
      cstringarg(mbuf, "i2", cval); //    
      if(strlen(cval)>0) {          
         i2=(int32_t)atol(cval);
      }
        
    
      //----------------------    
      inputString="";
    
      //delay 
      delay(1);
      
    
      
      //-------------------------------------------------------------
      // send  
      
      //Serial.flush();  // debug: not needed
      
      char formatstr[MSGLEN];
      strcpy(formatstr, "§");
      strcat(formatstr, "&i0=%ld;&i1=%ld;&i2=%ld;&i3=%ld;&i4=%ld;&i5=%ld;&i6=%ld;\n");  
      sprintf(mbuf, formatstr, i0,i1,i2,i3,i4,i5,i6 );      
                 
      //for (int i=0; i<strlen(mbuf); i++ ) Serial.print(mbuf[i]); 
      Serial.print(mbuf); 
       
       //delay?
      delay(1);
        
      i0++;
    
      
    }
    Raspi code:
    Code:
    /*
       UART communication
       send/receive string of tokens
       *     
       Raspberry Pi  master
       ver 0702
     */
     
     /*
      * change log
      * 0702: debug value (i2) from Raspi
      * 0701: Serial Read delimiter, debug value (i0) from Arduino
      * 0700: first adjustments
      * 0669: UART 115200 baud  * 
      * 0667: Arduino via USB = ACM0
      * 
      */
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string>
    #include <math.h>
    #include <fcntl.h>
    #include <string.h>
    #include <sys/ioctl.h>
    #include <stdint.h>
    #include <time.h>
    #include <sys/time.h>
    #include <errno.h>
    #include <pthread.h>
    
    
    #include <wiringPi.h>
    #include <wiringSerial.h>
    
    #define  byte  uint8_t
    
    char   uart[128]  =  "/dev/ttyACM0";
    int    Serial;
    const  uint32_t UARTclock = 115200;
    
    int32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;          // int (general)
    //int32_t i0,i1,i2,i3,i4,i5,i6,i7,i8,i9;     
    
    
    #define TOKLEN 30
    #define MSGLEN 1024
    #define iINVALID -29999
    
    
    std::string  inputString="";
    char   cval[TOKLEN];  // number as cstring
    char   mbuf[MSGLEN];  // cstring msg buffer
    
    
    
    
    
    
    //==================================================================
    // string tools
    //==================================================================
    
    
    int16_t  strstrpos(const char * haystack, const char * needle)   // find 1st occurance of substr in str
    {
       const char *p = strstr(haystack, needle);
       if (p) return static_cast<int16_t>(p-haystack);
       return -1;   // Not found = -1.
    }
    
    
    char * cstringarg( const char* haystack, const char* vname, char* sarg ) {
       int i=0, pos=-1;
       unsigned char  ch=0xff;
       const char*  kini = "&";       // start of varname: '&'
       const char*  kin2 = "?";       // start of varname: '?'
       const char*  kequ = "=";       // end of varname, start of argument: '='
       
       const int    NLEN=30;
       char  needle[NLEN] = "";       // complete pattern:  &varname=abc1234
    
    
       strcpy(sarg,"");
       strcpy(needle, kini);
       strcat(needle, vname);
       strcat(needle, kequ);
       pos = strstrpos(haystack, needle); 
       if(pos==-1) {
          needle[0]=kin2[0];
          pos = strstrpos(haystack, needle);
          if(pos==-1) return sarg;
       }
       pos=pos+strlen(vname)+2; // start of value = kini+vname+kequ   
       while( (ch!='&')&&(ch!='\0') ) {
          ch=haystack[pos+i];    
          if( (ch=='&')||(ch==';')||(ch=='\0') ||(ch=='\n')
            ||(i+pos>=(int)strlen(haystack))||(i>NLEN-2) ) {
               sarg[i]='\0';
               return sarg;
          }       
          if( (ch!='&') ) {
              sarg[i]=ch;          
              i++;       
          }      
       } 
       return sarg;
    }
    
    
    
    //==================================================================
    // serial TCP
    //==================================================================
    
    
    void loop() {
        
      while(1) {  
          
         static bool stringComplete = false;
         
         
         //-------------------------------------------------------------
         // send    
         
         // debug
         i2++;  // change value to send back to Arduino
         
         char formatstr[MSGLEN];     
    
         // debug, cut-down:
         strcpy(formatstr, "§");
         strcat(formatstr, "&i0=%d;&i1=%d;&i2=%d;&i3=%d;\n");
         sprintf(mbuf, formatstr, i0,i1,i2,i3);
                        
         for(uint8_t i=0; i<strlen(mbuf); i++) {           //
            serialPutchar( Serial, mbuf[i]);               // Send values to the slave       
         }   
          
         
         //delay?
         delay(1); 
       
         
         
         
         //-------------------------------------------------------------
         // receive     
           
         int  n=0;
         char inChar;   
         char cstr[TOKLEN];
     
         inputString="";     
         stringComplete = false;
         
         if (serialDataAvail(Serial)) { 
           while(!stringComplete && n<MSGLEN-1) {    
              if(n==MSGLEN-2) inChar='\n'; // emergency brake
              else  
                inChar = serialGetchar(Serial); 
           
              if(inChar=='\n' || inChar>=' ') inputString += inChar;       
              if (inChar == '\n')  {
                stringComplete = true;
              }
              n++;
           } 
         }
       
         
         if (stringComplete)  {
             
           //inputString.to_str(mbuf, len-1);
           strcpy (mbuf, inputString.c_str() );
       
           fprintf(stderr,"\n"); fprintf(stderr,mbuf); //fprintf(stderr,"\n"); 
       
           
           // cstringarg( char* haystack, char* vname, char* carg )
           // haystack pattern: &varname=1234abc;  delimiters &, \n, \0, EOF 
       
           
           cstringarg(mbuf, "i0", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i0=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }   
           cstringarg(mbuf, "i1", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i1=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }
           cstringarg(mbuf, "i2", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i2=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }
           cstringarg(mbuf, "i3", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i3=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }  
           cstringarg(mbuf, "i4", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i4=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }   
           
           inputString="";
           stringComplete = false;
       
           //delay?
           delay(1);
         }
       
       }     
    }
    
    
    
    
    //==================================================================
    
     
    int main() {
         
        printf("initializing..."); printf("\n");
       
        // UART Serial com port
        Serial = serialOpen (uart, UARTclock);   
        printf("starting UART loop..."); printf("\n");   
        
        loop(); 
       
        serialClose( Serial);
        exit(0);
    }
    output e.g.
    Code:
    §&i0=17628;&i1=1;&i2=17434;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17628 
    i1=1 
    i2=17434 
    i3=33 
    i4=-444 
    
    §&i0=17629;&i1=1;&i2=17435;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17629 
    i1=1 
    i2=17435 
    i3=33 
    i4=-444 
    
    §&i0=17630;&i1=1;&i2=17436;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17630 
    i1=1 
    i2=17436 
    i3=33 
    i4=-444 
    
    §&i0=17631;&i1=1;&i2=17437;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17631 
    i1=1 
    i2=17437 
    i3=33 
    i4=-444 
    
    §&i0=17632;&i1=1;&i2=17438;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17632 
    i1=1 
    i2=17438 
    i3=33 
    i4=-444 
    
    §&i0=17633;&i1=1;&i2=17439;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17633 
    i1=1 
    i2=17439 
    i3=33 
    i4=-444 
    
    §&i0=17634;&i1=1;&i2=17440;&i3=33;&i4=-444;&i5=5555;&i6=43690;
    i0=17634 
    i1=1 
    i2=17440 
    i3=33 
    i4=-444 
    
    
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! hangs up !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    hat jemand vielleicht doch die rettende Idee?
    Geändert von HaWe (10.06.2019 um 08:47 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  6. #26
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.232
    PS, @Ceos, Holomino:
    wegen eurer Anmerkungen von oben:
    Grundsätzlich sind "klassische" C cstring Funktionen eher fehleranfällig als C++ std::string bzw. String-Methoden (0-Terminierung, Längenüberschreitung etc.), und noch nicht einmal originale <string.h> u/o <stdio.h> Funktionen verhalten sich hier immer identisch, logisch und/oder vorhersagbar.

    Arduino String entspricht aber einem abgespeckten std::string samt vieler seiner Methoden, und für beide sind

    String msg, s;
    char cstr[30];
    msg+= s;
    msg+= (String)cstr;

    völlig normale und legitime C++ Operationen, und Arduino arbeitet ja mit C++ und nicht mit C.

    Da die endgültige Länge von msg bei mir zur Laufzeit aber ständig wechselt und daher nicht bekannt ist, sondern nur: wie das terminierende byte aussieht ('\n'), wird gelesen bis '\n' erreicht ist.
    Genau wie std::string verwaltet Arduino String den notwendigen Speicher bei String-Methoden selbstständig, gerade auch bei der "Addition" (Concatenierung).
    Zur weiteren Verabeitung von enthaltenen "tokens" über ANSI C - <string.h> Funktionen wird dann der Inhalt von msg in einen Array definierter Maximallänge kopiert und dort weiterverarbeitet.
    (Außerdem ist das später in threads auch einfacher über mutexe zu schützen.)

    Übrigens kompiliere ich auch den Raspi code mit gpp/C++, nicht mit gcc/C.

    Betr. UART:
    Im Gegensatz zur Arduino Serial() class (vererbt von der Stream class) inkl. vieler eingebauter Puffer- und Timeout-Methoden arbeitet wiringPi per wiringSerial aber mit "klassischem" C, ohne eingebaute Korrekturmethoden, und daher vermute ich momentan die "Aufhänger" eher ursächlich Raspi-seitig (CMIIW)...
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  7. #27
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.232
    ich vermute, ich habe das Problem gelöst!
    Ich habe die UART-Kommunikation in einen extra pthread mit prio 60 ausgelagert, jetzt läuft es seit knapp 1 1/2 Stunden stabil ohne Unterbrechungen!

    update: schon über 3 Stunden fehlerfrei - ich denke ja, jetzt hab ich's!


    hier der aktuell getestete Code:

    Code:
    /*
       UART communication
       send/receive string of tokens
       *     
       Raspberry Pi  master
       ver 0704
     */
     
     /*
      * change log
      * 0704: extra console thread
      * 0703: pthread MT
      * 0702: debug value (i2) from Raspi
      * 0701: Serial Read delimiter, debug value (i0) from Arduino
      * 0700: first adjustments
      * 0669: UART 115200 baud  * 
      * 0667: Arduino via USB = ACM0
      * 
      */
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <stdint.h>
    
    #include <math.h>
    #include <fcntl.h>
    #include <string.h>
    #include <string>
    #include <sys/ioctl.h>
    #include <sys/time.h>
    #include <errno.h>
    #include <pthread.h>
    
    #include <linux/input.h>
    #include <termios.h>
    #include <signal.h>
    #include <sys/types.h>
    #include <dirent.h>
    #include <sys/stat.h>
    #include <sys/select.h>
    
    #include <wiringPi.h>
    #include <wiringSerial.h>
    
    #define  byte  uint8_t
    
    char   uart[128]  =  "/dev/ttyACM0";
    int    Serial;
    const  uint32_t UARTclock = 115200;
    
    int32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;          // int (general)
    //int32_t i0,i1,i2,i3,i4,i5,i6,i7,i8,i9;     
    
    
    #define TOKLEN 30
    #define MSGLEN 1024
    #define iINVALID -29999
    
    
    std::string  inputString="";
    char   cval[TOKLEN];  // number as cstring
    char   mbuf[MSGLEN];  // cstring msg buffer
    
    volatile uint8_t   _TASKS_ACTIVE_= 1;
    
    
    
    
    
    
    //==================================================================
    // tools
    //==================================================================
    
    // ============================================================ 
    // conio.h  
    
    bool kbhit(void)
    {
        struct termios original;
        tcgetattr(STDIN_FILENO, &original);
    
        struct termios term;
        memcpy(&term, &original, sizeof(term));
    
        term.c_lflag &= ~ICANON;
        tcsetattr(STDIN_FILENO, TCSANOW, &term);
    
        int characters_buffered = 0;
        ioctl(STDIN_FILENO, FIONREAD, &characters_buffered);
    
        tcsetattr(STDIN_FILENO, TCSANOW, &original);
    
        bool pressed = (characters_buffered != 0);
    
        return pressed;
    }
    
    void echoOff(void)
    {
        struct termios term;
        tcgetattr(STDIN_FILENO, &term);
    
        term.c_lflag &= ~ECHO;
        tcsetattr(STDIN_FILENO, TCSANOW, &term);
    }
    
    void echoOn(void)
    {
        struct termios term;
        tcgetattr(STDIN_FILENO, &term);
    
        term.c_lflag |= ECHO;
        tcsetattr(STDIN_FILENO, TCSANOW, &term);
    }
    
    
    
    
    // ============================================================ 
    // string tokens
    
    int16_t  strstrpos(const char * haystack, const char * needle)   // find 1st occurance of substr in str
    {
       const char *p = strstr(haystack, needle);
       if (p) return static_cast<int16_t>(p-haystack);
       return -1;   // Not found = -1.
    }
    
    
    char * cstringarg( const char* haystack, const char* vname, char* sarg ) {
       int i=0, pos=-1;
       unsigned char  ch=0xff;
       const char*  kini = "&";       // start of varname: '&'
       const char*  kin2 = "?";       // start of varname: '?'
       const char*  kequ = "=";       // end of varname, start of argument: '='
       
       const int    NLEN=30;
       char  needle[NLEN] = "";       // complete pattern:  &varname=abc1234
    
    
       strcpy(sarg,"");
       strcpy(needle, kini);
       strcat(needle, vname);
       strcat(needle, kequ);
       pos = strstrpos(haystack, needle); 
       if(pos==-1) {
          needle[0]=kin2[0];
          pos = strstrpos(haystack, needle);
          if(pos==-1) return sarg;
       }
       pos=pos+strlen(vname)+2; // start of value = kini+vname+kequ   
       while( (ch!='&')&&(ch!='\0') ) {
          ch=haystack[pos+i];    
          if( (ch=='&')||(ch==';')||(ch=='\0') ||(ch=='\n')
            ||(i+pos>=(int)strlen(haystack))||(i>NLEN-2) ) {
               sarg[i]='\0';
               return sarg;
          }       
          if( (ch!='&') ) {
              sarg[i]=ch;          
              i++;       
          }      
       } 
       return sarg;
    }
    
    
    
    
    
    
    //==================================================================
    // threads
    //==================================================================
    
    
    void* UART_thr( void* ) {
        
      while(_TASKS_ACTIVE_) {  
          
         static bool stringComplete = false;
         
         //serialFlush(Serial);
         
         //-------------------------------------------------------------
         // send    
         
         // debug
         i2++;  // change value to send back to Arduino
         
         char formatstr[MSGLEN];     
    
         // debug, cut-down:
         strcpy(formatstr, "§");
         strcat(formatstr, "&i0=%d;&i1=%d;&i2=%d;&i3=%d;\n");
         sprintf(mbuf, formatstr, i0,i1,i2,i3);
                        
         for(uint8_t i=0; i<strlen(mbuf); i++) {           //
            serialPutchar( Serial, mbuf[i]);               // Send values to the slave       
         }   
               
         //delay?
         delay(1);  
         
         
         //-------------------------------------------------------------
         // receive
         
         inputString="";
         char cstr[TOKLEN];
       
         int  n=0;
         char inChar;
         
         stringComplete=false;
         
         if (serialDataAvail(Serial)) 
         { 
           while(n<MSGLEN-1) {    
              if(n==MSGLEN-2) inChar='\n'; // emergency brake
              else  
                inChar = serialGetchar(Serial); 
           
              if(inChar=='\n' || inChar>=' ') inputString += inChar;       
              if (inChar == '\n')  {
                stringComplete = true;
                break;
              }          
              n++;
           } 
         }   
         
         if (stringComplete)  {
             
           //inputString.to_str(mbuf, len-1);
           strcpy (mbuf, inputString.c_str() );
       
           fprintf(stderr,"\n"); fprintf(stderr,mbuf); //fprintf(stderr,"\n"); 
       
           
           // cstringarg( char* haystack, char* vname, char* carg )
           // haystack pattern: &varname=1234abc;  delimiters &, \n, \0, EOF 
       
           
           cstringarg(mbuf, "i0", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i0=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }   
           cstringarg(mbuf, "i1", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i1=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }
           cstringarg(mbuf, "i2", cval); //    
           if(strlen(cval)>0) {          
              sprintf (cstr,  "i2=%d \n", (int32_t)atol(cval));
              fprintf(stderr, cstr);
           }       
           
           
           inputString="";
           stringComplete = false;
       
           //delay?
           delay(1);
         }             
       }     
       return NULL;
    }
    
    
    //=================================================
    
    
    void* KBD_thr(void*)           // low priority:  keyboard monitoring          // low priority:  keyboard monitoring
    {
       int   ch;  // keyboard scancode, letter char
       
       while(_TASKS_ACTIVE_) {               
        
          ch=0;      
          echoOff();      
          
          if (kbhit())    {          
              ch=getchar();      
              if(ch>=32 && ch<127) {
                  printf("%c", ch);
                  fflush(stdout);
              }   
              else if (ch<32) {
                  if (kbhit()) ch=getchar();     
              }
              if(ch==27) _TASKS_ACTIVE_ = false;
         }     
         delay(50);
       }         
       return NULL;
    }
    
    
    
    //==================================================================
    //==================================================================
     
    int main() {
        
        // threads    
        pthread_t  thread1, thread2;
        struct     sched_param  param;
        
        printf("starting ..."); printf("\n");   
        
        // open UART Serial com port    
        Serial = serialOpen (uart, UARTclock);       
            
    
        // start multithreading  
        
        pthread_create(&thread1, NULL, KBD_thr, NULL);     // low priority: keyboard monitor 
        param.sched_priority = 40;
        pthread_setschedparam(thread1, SCHED_RR, &param);
       
        pthread_create(&thread2, NULL, UART_thr, NULL);    // medium  priority: UART
        param.sched_priority = 40;
        pthread_setschedparam(thread2, SCHED_RR, &param);    
         
        
        while(_TASKS_ACTIVE_) { delay(10); }
         
        // wait for threads to join before exiting
        pthread_join(thread1, NULL);
        pthread_join(thread2, NULL);
       
        serialClose( Serial);
        exit(0);
    }
    Geändert von HaWe (14.06.2019 um 15:50 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

Seite 3 von 3 ErsteErste 123

Ähnliche Themen

  1. Antworten: 32
    Letzter Beitrag: 04.07.2018, 08:34
  2. Kommunikation zwischen Android und Sensor(UART)
    Von Alasa im Forum Elektronik
    Antworten: 3
    Letzter Beitrag: 18.10.2017, 10:48
  3. [ERLEDIGT] Problem bei UART Kommunikation zwischen ATmega und VB.net
    Von masasibe im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 15
    Letzter Beitrag: 10.09.2011, 17:41
  4. LCD-Kontrast und UART-Kommunikation zwischen 2 µcs
    Von MelMan im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 1
    Letzter Beitrag: 04.12.2008, 15:25
  5. Uart-Kommunikation zwischen µCs
    Von ProgDom im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 20.04.2006, 00:37

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •