Return to Answer

Yes. The receive ring buffer is 64 bytes and will discard anything past that until the program reads them out of the buffer.

But be careful: In serial monitor, any number of bytes more than 64 and ending with Enter will give you Serial.available==63 at the Arduino - and no \n at the end. This is important especially if you are using readline() in Python.

However, when NOT in the serial monitor, you can actually get the result Serial.available==64 and use Serial.read() to get them in sequence. No \n is required.

So be careful debugging in the serial monitor when it comes to buffer size and newlines. It is subtly different when programs are talking vs the serial monitor.

Most important difference is that a program can send a single byte and continue. Serial monitor will send a single character, but is blocked until you press newline to get it to transmit. Yet serial monitor does not send the newline character.

Simple scenario: You want the Arduino to respond to a single-byte command code send via the serial cable from a Raspbian system running a Python data logging program based on something the Arduino reads or by time of day.

You need to trigger the Arduino to take some action as a result.

So on the Arduino you want to first clear the receive buffer by simply reading it out like so:

Arduino code to read a single-character command:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()=='X') {
 .....respond to the X command....
 }
 else 
 ....etc...
 delay(60000);
}
 

Note that when a Rpi Python program is sitting there waiting for linein=ser.readline() the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the \n then returns the string to linein. The line can be very long. I have tested it to 100 bytes.

Software.Serial acts exactly the same way.

Yes. The receive ring buffer is 64 bytes and will discard anything past that until the program reads them out of the buffer.

But be careful: In serial monitor, any number of bytes more than 64 and ending with Enter will give you Serial.available==63 at the Arduino - and no \n at the end. This is important especially if you are using readline() in Python.

However, when NOT in the serial monitor, you can actually get the result Serial.available==64 and use Serial.read() to get them in sequence. No \n is required.

So be careful debugging in the serial monitor when it comes to buffer size and newlines. It is subtly different when programs are talking vs the serial monitor.

Most important difference is that a program can send a single byte and continue. Serial monitor will send a single character, but is blocked until you press newline to get it to transmit. Yet serial monitor does not send the newline character.

Simple scenario: You want the Arduino to respond to a single-byte command code send via the serial cable from a Raspbian system running a Python data logging program based on something the Arduino reads or by time of day.

You need to trigger the Arduino to take some action as a result.

So on the Arduino you want to first clear the receive buffer by simply reading it out like so:

Arduino code to read a single-character command:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()=='X') {
 .....respond to the X command....
 }
 else 
 ....etc...
 delay(60000);
}
 

Note that when a Rpi Python program is sitting there waiting for linein=ser.readline() the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the \n then returns the string to linein. The line can be very long. I have tested it to 100 bytes.

Software.Serial acts exactly the same way.

Yes. The receive ring buffer is 64 bytes and will discard anything past that until the program reads them out of the buffer.

But be careful: In serial monitor, any number of bytes more than 64 and ending with Enter will give you Serial.available==63 at the Arduino - and no \n at the end. This is important especially if you are using readline() in Python.

However, when NOT in the serial monitor, you can actually get the result Serial.available==64 and use Serial.read() to get them in sequence. No \n is required.

So be careful debugging in the serial monitor when it comes to buffer size and newlines. It is subtly different when programs are talking vs the serial monitor.

Most important difference is that a program can send a single byte and continue. Serial monitor will send a single character, but is blocked until you press newline to get it to transmit. Yet serial monitor does not send the newline character.

Simple scenario: You want the Arduino to respond to a single-byte command code send via the serial cable from a Raspbian system running a Python data logging program based on something the Arduino reads or by time of day.

You need to trigger the Arduino to take some action as a result.

So on the Arduino you want to first clear the receive buffer by simply reading it out like so:

Arduino code to read a single-character command:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()==88) {
 .....respond to the X (decimal 88) command....
 }
 else 
 ....etc...
delay(60000);
}
 

Note that when a Rpi Python program is sitting there waiting for linein=ser.readline() the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the \n then returns the string to linein. The line can be very long. I have tested it to 100 bytes.

Software.Serial acts exactly the same way.

Yes. The receive ring buffer is 64 bytes and will discard anything past that until the program reads them out of the buffer.

But be careful: In serial monitor, any number of bytes more than 64 and ending with Enter will give you Serial.available==63 at the Arduino - and no \n at the end. This is important especially if you are using readline() in Python.

However, when NOT in the serial monitor, you can actually get the result Serial.available==64 and use Serial.read() to get them in sequence. No \n is required.

So be careful debugging in the serial monitor when it comes to buffer size and newlines. It is subtly different when programs are talking vs the serial monitor.

Most important difference is that a program can send a single byte and continue. Serial monitor will send a single character, but is blocked until you press newline to get it to transmit. Yet serial monitor does not send the newline character.

Simple scenario: You want the Arduino to respond to a single-byte command code send via the serial cable from a Raspbian system running a Python data logging program based on something the Arduino reads or by time of day.

You need to trigger the Arduino to take some action as a result.

So on the Arduino you want to first clear the receive buffer by simply reading it out like so:

Arduino code to read a single-character command:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()=='X') {
 .....respond to the X command....
 }
 else 
 ....etc...
delay(60000);
}
 

Note that when a Rpi Python program is sitting there waiting for linein=ser.readline() the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the \n then returns the string to linein. The line can be very long. I have tested it to 100 bytes.

Software.Serial acts exactly the same way.

Arduino code:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()==88) {
 .....respond to the X command....
 }
 else {
 //  .. Do the data collection and send it over to Pi
 // .. 
 Serial.print(val1); serial.print("\t");
 Serial.print(val2); serial.print("\t");
 Serial.print("\n");
 }
delay(60000);
} // end loop
 

On the Raspbian system you will want to be always know you are starting with a fresh receive buffer at the Arduino, so simply send it a \n as the first character. The Arduino will basically ignore it in terms of Serial.available, but it readies it for the next line of input.

Python code:

import serial
import datetime
tab = "\t"
eol = "\n"
ser = serial.Serial("/dev/USB0",9600)
while True:
 print
 print "================================================================"
 print "========== WAITING FOR INPUT FROM /dev/ttyUSB0 ================="
 linein = ser.readline()
 if len(linein)<10 :
 print " --> Input less than 10 characters. Skipping"
 print
 continue
 if len(linein)>50 :
 print " --> Input more than 50 characters. Skipping."
 print
 continue
 tt = datetime.datetime.now()
 if getattr(tt,'hour')<10 : 
 ts = ts + '0' 
 ts = str(getattr(tt,'hour')) + ":"
 if getattr(tt,'minute')<10 : 
 ts = ts + '0'
 ts = ts + str(getattr(tt,'minute')) + ":"
 if getattr(tt,'second')<10: 
 ts = ts + '0'
 ts = ts + str(getattr(tt,'second'))
 td = datetime.datetime.today()
 ds = str(td.year)
 if td.month<10 :
 ds = ds +"0"
 ds = ds + str(td.month)
 if td.day<10 :
 ds = ds + "0"
 ds = ds + str(td.day)
 date = str(datetime.datetime.now().date())
 date = date[:10] 
 time = str(datetime.datetime.now().time())
 time = time[:8]
 outline = date + tab + time + tab + linein
 
 f = open(filename,"a")
 f.write(outline)
 f.close()
 ---> some condition causes the program to send out the X command 
 if outline[a:b] = xyz : <---some condition
 ser.print eol + "X" + eol <---send trigger code

Note that when the Python program is sitting there waiting for readline the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the eol then returns the string to linein. The line can be very long. I have tested it to 100 bytes.

Arduino code to read a single-character command:

byte ch;
void setup() {
 Serial.begin(9600));
 while (Serial.available>1) ch = ser.read();
}
void loop {
 if (Serial.Available==1 && Serial.read()==88) {
 .....respond to the X (decimal 88) command....
 }
 else 
 ....etc...
delay(60000);
}
 

Note that when a Rpi Python program is sitting there waiting for linein=ser.readline() the Arduino transmit buffer size is not relevant. Python collects each byte as it comes in until the \n then returns the string to linein. The line can be very long. I have tested it to 100 bytes.