Arduino read big amount of serial data without losses - arduino

Question

In Arduino Serial I need to read those kind of lines <1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16> As fast
as possible, without blocking.
The goal is to set values of array compensation[] without delay.
In this example <1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16> Would display 1000 (as 100% have been read) But I don't get 100% but periodique losses at 96% and then 95% … So I need my code to display 1000 (for 100%) every time.
This is what I have already :
static int compensastion[64];
int passage=1;
const byte numChars = 1000;
char receivedChars[numChars];
boolean newData = false;
int score = 0;
int mal_score = 0;
void setup() {
Serial.begin(115200);
Serial.println();
}
void loop() {
read_inputs();
// get the percentage of success for this simple message from 1 to 16
Serial.print(double(double(score) / double(mal_score+score))*10000);
Serial.println();
}
void read_inputs(){
recvWithStartEndMarkers();
check();
}
// Get the full line <1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16>
void recvWithStartEndMarkers() {
static boolean recvInProgress = false;
static byte ndx = 0;
char startMarker = '<';
char endMarker = '>';
char rc;
if (Serial.available() > 0 && newData == false) {
rc = Serial.read();
if (recvInProgress == true) {
if (rc != endMarker) {
receivedChars[ndx] = rc;
ndx++;
if (ndx >= numChars) {
ndx = numChars - 1;
}
}
else {
receivedChars[ndx] = '\0';
recvInProgress = false;
ndx = 0;
newData = true;
}
}
else if (rc == startMarker) {
recvInProgress = true;
}
}
}
// Parse the line in digits
void check(){
if (newData == true) {
newData = false;
int marge = 0;
passage=1;
for(int j = 0; j < numChars; j=j+1){
int my_int = -1;
char buf[4];
if(isDigit(receivedChars[j]) &&marge == 0 ){
if(!isDigit(receivedChars[j+1])){
my_int = receivedChars[j] - '0';
marge=marge+1;
}
if(isDigit(receivedChars[j+1]) && !isDigit(receivedChars[j+2]) ){
my_int = receivedChars[j] - '0';
my_int = my_int*10 + (receivedChars[j+1] - '0');
marge=marge+2;
}
if(isDigit(receivedChars[j+1]) && isDigit(receivedChars[j+2]) && !isDigit(receivedChars[j+3]) ){
my_int = receivedChars[j] - '0';
my_int = my_int*10 + (receivedChars[j+1] - '0');
my_int = my_int*10 + (receivedChars[j+2] - '0');
marge=marge+3;
}
}
if (isDigit(receivedChars[j]) && my_int != -1){
if(passage == my_int){
score=score+1;
}else{
mal_score= mal_score+1;
}
compensastion[(passage-1)*2] = my_int;
passage=passage+1;
if(passage+1 >= 16+2){
passage=1;
}
}
if(marge > 0){
marge=marge-1;
}
}
}
}

Answer 1

In my experience, one of the most effective ways to handle huge amounts of serial data is using Interrupts and Finite State Machines (FSM).
Please carefully read this guide by the amazing Nick Gammon. FSMs are the most versatile approach when dealing with intensive processing tasks. (Not to be confused with RTOS, though)
Regarding the serial communication, I would implement the serial reading through the serialEvent() interrupt along the lines of the following example:
char serialString[] = " "; // Empty serial string variable
bool stringFinished = false; // Flag to indicate reception of a string after terminator is reached
void setup(){
previousEncoderTime = 0;
}
void loop(){
unsigned long now = millis();
if (stringFinished){ // When the serial Port has received a command
stringFinished = false;
// Implement your logic here
}
}
void serialEvent()
{
int idx = 0;
while (Serial.available())
{
char inChar = (char)Serial.read();
if (inChar == '\n') // The reading event stops at a new line character
{
serialTail = true;
serialString[idx] = inChar;
}
if (!serialTail)
{
serialString[idx] = inChar;
idx++;
}
if (serialTail)
{
stringFinished = true;
Serial.flush();
serialTail = false;
}
}
}
Finally, try to compartmentalize all the necessary data processing in single-purpose functions. This way your code will have a proper flow and you will reduce the risk of blocking the system with heavy tasks.
EDIT: I forgot to mention that the Serial.available() is regarded as a polling method which is highly unreliable and time-consuming. Stick to interrupts and you won't have massive issues