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

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

Zitat:

---

Zitat von Ceos

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.

basierend auf deinem Code fetzen (mir war entgangen dass weiter vorne noch mehr code steht :D)

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

Zitat:

---

Zitat von Ceos

basierend auf deinem Code fetzen (mir war entgangen dass weiter vorne noch mehr code steht :D)

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 );

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?

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)...

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 ¹/₂ Stunden stabil ohne Unterbrechungen! 8)

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


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);
}

---