How do I receive an entire string as opposed to 1 character at a time on the arduino?

Question

I followed the instructions on this website successfully:

http://www.doctormonk.com/2012/04/raspberry-pi-and-arduino.html

and I was able to get communication between the pi and my arudino mega exactly as the website specifies.

However, instead of sending an integer representing the number of times the LED blinks, I want to sent ASCII text like:

"MOVE 5 METERS FORWARD", "TURN LEFT", "MOVE 10 METERS BACKWARD" to the arduino from the pi.

I wrote the following code:

char inData[64];
char inChar=-1;

void setup(){
   Serial.begin(9600);
   Serial.begin("Waiting for Raspberry Pi to send a signal...\n");
}


void loop(){
    byte numBytesAvailable= Serial.available();

    // if there is something to read
    if (numBytesAvailable > 0){
        // store everything into "inData"
        int i;
        for (i=0;i<numBytesAvailable;i++){
            inChar= Serial.read();
            inData[i] = inChar;
        }

        inData[i] = '\0';


        Serial.print("Arduino Received: ");
        Serial.println(inData);
    }
}

I flashed above code succesfully to my Arduino Mega 2560.

I switched to my python terminal on the Raspberry Pi and in the console I typed:

import serial
ser = serial.Serial('/dev/ttyACM1',9600)
ser.write("MOVE")

What gets displayed on my Arduino's Serial Monitor is as follows:

Arduino Received: M
Arduino Received: O
Arduino Received: V
Arduino Received: E

But what I want is:

Arduino Received: MOVE

How do I change the code above to get all characters into the inData buffer?

Answer 1

The problem is that the Arduino is looping around so fast, it will execute the if (numBytesAvailable > 0) line several times between each character arriving through the serial port. So as soon as a character does arrive, it grabs it, loops from zero to one, and prints a single character out.

What you should do is send an end of line character ('\n') after each command from your Python program. Then have your Arduino code buffer each character it receives and only act on the message once it receives the end-of-line character.

So if you change your Python code do send an end of line character, like so:

import serial
ser = serial.Serial('/dev/ttyACM1',9600)
ser.write("MOVE\n")

Then your Arduino code can be something like this:

// Buffer to store incoming commands from serial port
String inData;

void setup() {
    Serial.begin(9600);
    Serial.println("Waiting for Raspberry Pi to send a signal...\n");
}

void loop() {
    while (Serial.available() > 0)
    {
        char recieved = Serial.read();
        inData += recieved; 

        // Process message when new line character is recieved
        if (recieved == '\n')
        {
            Serial.print("Arduino Received: ");
            Serial.print(inData);

            inData = ""; // Clear recieved buffer
        }
    }
}

Answer 2

Your Python script is sending four bytes, M, O, V, and E. How is the Arduino supposed to know that that's a single string? Consider that the Python code:

ser.write("MOVE")

is completely identical to

ser.write("MO")
ser.write("VE")

from the Arduino's point of view. Serial ports transfer characters, not strings.

In your code, the Arduino is fast (compared to the 9600 baud rate), so every time it calls Serial.available(), it only sees one of those four characters. That's why you got the output you did.

What you'll need to do is come up with some way of delimiting strings, i.e. marking them in some way from Python so that the Arduino can append the individual characters that it receives into your high-level concept of a string.

Using lines is straightforward: send every string terminated with a newline character ('\n'). On the Arduino, read characters and append them to your string. When you see a '\n', the string is over and you can print it.

Answer 3

  if(Serial.available() > 0) {
     str = Serial.readStringUntil('\n');
     Serial.println(str);

The above code works perfect on my connection between Pi and Arduino

Answer 4

Use .readline instead of .read

I had the same issue and this fixed it right away. Hope this helped!

Answer 5

This is how I did it from the first example:

String readString;

void setup()
{
    Serial.begin(9600); // initialization
}

void loop()
{
    char incomingByte;
    while (Serial.available() > 0)
    {
        delay(10); // if the data came
        incomingByte = Serial.read(); // read byte
        //Serial.println(incomingByte);
        readString += incomingByte;
    }

    if(readString != "")
    {
        Serial.print("arduino recived this : ");
        Serial.println(readString);
    }
    readString = "";
}

Answer 6

With both Putty and Tera Term hyperterminal programs the only way I could detect a new line was to use cartridge return detection '\r' instead of '\n' linefeed. Then use the trim command to remove unwanted handshaking characters. For this project I needed to use a TTL serial input and not USB. Using the Arduino terminal select "Carriage return" instead of "Newline" Sample code below that forms a string to process instead of a byte.

if (Serial1.available() > 0) {
    char inChar = (char)Serial1.read();
    // add it to the inputString:
    inputString += inChar;
    //Serial1.println(inChar, BIN); Used while testing to see hidden characters
    if (inChar == '\r') {  // use '\n' for new line and '\r' for Carriage return 
      inputString.trim(); //trim string to remove handshaking characters CR and LF
    }
}