How to get parts of char* string - c++

Question

I have a device that sends serial data to my esp8266.
I need to parse that data to my application.
The format of each line I receive from the serial port is like this:
"\x02""Q,328,013.83,N,00,\x03""1D"
where the 1st character is char 2 (start of transmission) and the 3rd from the end is char 3 (end of transmission). The last number ("1C") is the checksum.
The numbers between, are the values I want to parse.
I 've written the following code which works, but I wonder if this the correct way of doing it.
#include <iostream>
#include <stdio.h>
#include <string.h>
uint16_t calcCRC(char* str)
{
uint16_t crc=0; // starting value as you like, must be the same before each calculation
for (uint16_t i=0; i<strlen(str); i++) // for each character in the string
{
crc ^= str[i]; // update the crc value
}
printf("CRC: %X\n", crc);
return crc;
}
int main()
{
char * data= "\x02""Q,328,013.83,N,00,\x03""1D";
const char start = 2; //stx start transmission
const char end = 3; //etx end transmission
char* pos1 = strchr(data, start);
char* pos2 = strchr(data, end);
int p1,p2;
if (pos1 && pos2) {
p1 = pos1-data+1;
p2 = pos2-data+1;
printf ("found at %d, %d\n", p1, p2);
} else
return 0;
char* checksumStr;
checksumStr = strrchr(data, end);
int checksum = 0;
if (checksumStr) {
checksum = strtol(checksumStr+1, NULL, 16);
}
printf("checksum char: |%s| check number %X\n", checksumStr+1, checksum);
char cleanData[25];
strncpy(cleanData, data+p1, p2-p1-1);
cleanData[p2-p1-1] = '\0';
uint16_t crc = calcCRC(cleanData);
printf("Clean data to checksum: |%s|\n", cleanData);
char* addr = strtok(cleanData, ","); // Q
int WindDir = atoi(strtok(NULL, ",")); // 328
float WindSpeed = atof(strtok(NULL, ",")); // 13.83
char* unit = strtok(NULL, ","); // N
char* deviceStatus = strtok(NULL,","); // 00
printf("CRC: %X, Speed %3.2f, dir %d, ", crc, WindSpeed, WindDir);
return(0);
}
Run it here
Thank you !!

Answer 1

Break your code into two parts:
Message extraction – extracts the actual message from buffer and checks the checksum.
Message processing – converts the message to tokens which then can be easily take care of and extracts the information.
Your calling code should look like this:
// extract the message
char msg[ 1024 ];
if ( !extract_message( msg, data ) )
return false;
// process the message
int dir;
double speed;
process_message( msg, dir, speed );
A message extraction function idea:
#define STX '\x02'
#define ETX '\x03'
bool extract_message( char* d, const char* s )
{
// start of text
if ( *s != STX )
return false;
++s;
// actual message
char cs = 0; // checksum
while ( *s && ETX != *s )
{
cs ^= *s;
*d++ = *s++;
}
*(d-1) = '\0';
// end of text
if ( *s != ETX )
return false;
++s;
// sent checksum
char scs = (char)strtol( s, 0, 16 );
//
return scs == cs;
}
A processing function idea:
#define MAX_TOKENS 5
bool process_message(char* buf, int& dir, double& speed) // assumes the message is correct
{
// breaks the input into tokens (see strtok)
const char* delim = ",";
const char* tokens[ MAX_TOKENS ];
int token_count = 0;
for ( char* cursor = strtok( buf, delim ); cursor; cursor = strtok( 0, delim ) )
{
tokens[ token_count ] = cursor;
++token_count;
}
// ...
dir = atoi( tokens[ 1 ] ); // assumes the token is valid
speed = atof( tokens[ 2 ] ); // assumes the token is valid
//
return true;
}
I do not have a handy Arduino compiler, so the code might need some tweaking.

Answer 2

If your code works well, it's fine, but I recommend to you to write C++ style codes. I wrote part of your code in C++. I believe you can understand how to read the rest of your data using istream.
I also hope you perfer using std::string than const char*, use std::iostream to get or put data from and to. There's more flexible way to split strings using std::regex but I think it's too hard to understand currently.
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(void)
{
string data = "Q,328,013.83,N,00,1D";
istringstream iss(data);
string tmp;
int wind_dir;
float wind_speed;
getline(iss, tmp, ','); // read until ','
iss >> wind_dir;
getline(iss, tmp, ','); // read until ','
iss >> wind_speed;
return 0;
}

Answer 3

It is a little unclear what you are asking. When you say:
I've written the following code which works, ...
There is no way the code as written above can work. You do not have the control characters 2 (ASCII stx - start transmission) or 3 (ASCII etx - end transmission) embedded in data, so your conditional if (pos1 && pos2) tests false and you exit with return 0; (normally return 1; is used to indicate error, that is the value of EXIT_FAILURE)
To make your code work and include stx at the beginning of data and etx at the end, you can do:
char data[32] = "";
char stx[2] = { 2 };
char etx[2] = { 3 };
char *serial= "Q,328,013.83,N,00,1D";
strcat (data, stx);
strcat (data, serial);
strcat (data, etx);
That now provides data in a form where strchr(data, start); and strchr(data, end); will properly locate the start and end of the serial data in the example.
The remainder of your code DOES work, though note all your variables addr, WinDir, WindSpeed, unit and deviceStatus are pointers to address within cleanData and are only valid while cleanData remains in scope. That is fine here as your code ends thereafter, but if you intend to do this within a function and want to return the values, then you will need to provide storage for each and copy each to storage that will remain valid after cleanData has gone out of scope.
Currently addr, unit and deviceStatus are unused in your code. You can write a short printf to output their values to have your code compile cleanly, without warning (you can also cast to (void*), but I'm not positive that is supported on Arduino). Adding a short printf solves the warning issue and gives you a look at all the data parse from cleanData, e.g.
printf ("\naddr : %s\n"
"WinDir : %d\n"
"WindSpeed : %.2f\n"
"unit : %s\n"
"deviceStatus : %s\n\n",
addr, WindDir, WindSpeed, unit, deviceStatus);
With that, your code compiles cleanly and does work (though you need a final '\n' at the end of printf("CRC: %X, Speed %3.2f, dir %d, ", crc, WindSpeed, WindDir); (or a simple putchar ('\n'); for your code to be POSIX compliant.
I'm not sure if the embedded stx and etx were your stumbling blocks or not, that's not 100% clear from the question, but without them the code does not work. Let me know if you have further questions.
After Question Update
If you are looking for an alternative to parsing the data, you could declare addr, unit and devicestatus a short character arrays, e.g. char [16] (or whatever the longest is), and then simply use sscanf to parse data directly, e.g.
if (sscanf (data, "\x02 %15[^,],%d,%f, %15[^,], %15[^,], \x03",
addr, &winddir, &windspeed, unit, devicestatus) != 5) {
fputs ("error parsing data.\n", stderr);
return 1;
}
sscanf can adequately handle the embedded stx and etx. A minimal example using sscanf on data directly could be:
#include <stdio.h>
#define MINSTR 16
int main (void) {
char *data = "\x02""Q,328,013.83,N,00,\x03""1D",
addr[MINSTR],
unit[MINSTR],
devicestatus[MINSTR];
int winddir;
float windspeed;
if (sscanf (data, "\x02 %15[^,],%d,%f, %15[^,], %15[^,], \x03",
addr, &winddir, &windspeed, unit, devicestatus) != 5) {
fputs ("error parsing data.\n", stderr);
return 1;
}
printf ("addr : %s\n"
"windir : %d\n"
"windspeed : %.2f\n"
"unit : %s\n"
"devicestatus : %s\n", addr, winddir, windspeed, unit, devicestatus);
}
Example Use/Output
$ ./bin/windspeed+dir
addr : Q
windir : 328
windspeed : 13.83
unit : N
devicestatus : 00