das Design kann man allgemein verbessern
Elementweiser zugriff auf statisches array z.b.
Interrup vs. PollingCode:#DEFINE MAXLEN = 1024 ... char inputString[MAXLEN]; ... inputString[n] = serialGetchar(Serial); if (inputString[n]=="\n") { stringComplete = true; ... } ... n++;
"If abfragen" mit Klammern machen es übersichtlicher und vermeidet Fehler
zum überprüfen ob der Buffer evtl. überläuft kann man das Resultat von serialDataAvail(Serial) ausgebenCode:if(foo == 42) // Leerzeichen zwischen == und dem Rest { doBar; } else { doFoo }
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
wenn du dir meinen Code genau ansiehst, mache ich das ja schon genau so.Zitat von Ceos
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)
du musst dann nur den stringBuffer in dein inputString kopieren bevor du ihn weiter verwendest (oder den inputString gleich ganz verwerfen bzw. umdeklarieren)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++; } }
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.
klar, genau so mache ich es ja:basierend auf deinem Code fetzen (mir war entgangen dass weiter vorne noch mehr code steht
du musst dann nur den stringBuffer in dein inputString kopieren bevor du ihn weiter verwendest (oder den inputString gleich ganz verwerfen bzw. umdeklarieren)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++; } }
für MAXLEN wäre natürlich sinnvoll MSGLEN zu wählen
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 13:04 Uhr)
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:
Raspi 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++; }
output e.g.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); }
hat jemand vielleicht doch die rettende Idee?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 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Geändert von HaWe (10.06.2019 um 09:47 Uhr)
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 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, ¶m); pthread_create(&thread2, NULL, UART_thr, NULL); // medium priority: UART param.sched_priority = 40; pthread_setschedparam(thread2, SCHED_RR, ¶m); 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 16:50 Uhr)
Berechtigungen
Zitieren
Lesezeichen