[I posted this to the Arduino developer's mailing list, but figured others might find it useful too]
When I first started with Arduino, I thought Serial.available() was a very loose wrapping of the RXC bit in the USCRA register, i.e. if I didn’t get data out of there fast, it’d be gone. That led to convoluted code like:
if( Serial.available() ) {
val1 = Serial.read();
while( !Serial.available() );
val2 = Serial.read();
// and so on
}
Yuck. So you end up designing protocols that are too terse. Or maybe you think you need to buffer so you don’t lose it:
while( Serial.available() ) {
commandbuffer[i++] = Serial.read();
}
Then parsing becomes a two step process: read serial, parse buffer. Confusing to newbies perhaps, but at least it allows for a better protocol down the line. (And descend into madness as you gaze into the maw of strtok())
Because Serial contains these big comfy buffers, we often don’t need a second buffer to let us easily implement good protocols. My current favorite is to do something like this:
// protocol is "CCaaaa", two bytes of command, four bytes of args
if( Serial.available() >= 6 ) { // command length is 6 bytes
cmd0 = Serial.read();
cmd1 = Serial.read();
arg0 = Serial.read();
arg1 = Serial.read();
// ...etc...
}
I don’t think I’ve seen any Serial examples that check for a specific number of bytes available. It’s really handy.
Implementing a human-friendly protocol like “command arg0 arg1 arg2″, where command and args are space-separated strings like “servo 12 0xff”, is currently hard with Serial. I do this right now with a 2nd buffer and lots of C hackery:
char* cmdbuf; char c; int i;
while( Serial.available() && c!= '\n' ) { // buffer up a line
c = Serial.read();
cmdbuf[i++] = c;
}
int i = 0;
while( cmdbuf[++i] != ' ' ) ; // find first space
cmdbuf[i] = 0; // null terminate command
char* cmd = cmdbuf; //
int cmdlen = i; // length of cmd
int args[5], a; // five args max, 'a' is arg counter
char* s; char* argbuf = cmdbuf+cmdlen+1;
while( (s = strtok(argbuf, " ")) != NULL && a < 5 ) {
argbuf = NULL;
args[a++] = (byte)strtol(s,NULL,0); // parse hex or decimal arg
}
int argcnt = a; // number of args read
This sort of functionality would be great in a library I think. Maybe not in Serial, but a core class.
Any other protocols people like to use and the Arduino code they use to do it?
Hi todbot & Rob -
*Loved* the code for serial communication- many many thanks…
In using it I noticed it was getting so far and it was freezing.. going through the code (Rob re-wrote) I noticed that the malloc was been run and using up all the memory.. so put
free(cmdbuf);
somewhere when you are clearing variables and you shouldn’t have the same problem :D
Yes, it’s easy to run into many traps when using malloc(). Since the memory space of the chip in Arduino is so small and the tasks being performed are usually fairly simple, I much prefer to use statically-allocated buffers. You never run the risk of memory leaks then and you can know at compile-time exactly how much RAM you have left. (Arduino doesn’t yet expose this however, but the “avr-size” command can give you static RAM usage)
but
while( Serial.available() && c!= ‘\n’ ) {
requires that Arduino while is waiting for the endline, cannot do anything other.
I think it is a big problem to solve.
r.
no, sorry… I mistaked!!! :)
Hi ryuujin,
There is the possibility for the lockup you fear when doing something like:
while( Serial.available() < 5 ) { // wait for 5 bytes // do nothing }If the host never sends 5 characters, it'll just hang. One wait to get around this is to have a timeout:
long start_time = millis(); while( Serial.available() < 5 ) { // wait for 5 bytes if( (millis() - start_time) < 3000 ) // wait at most 3 seconds break; }