interpreting a string

I'm using snippets of code to try to read accelerometer data from an android phone through bluetooth. I have attached my code and a screenshot of the string values sent to the serial monitor. I would like to be able to use the values in the string separately. For instance, I would like to capture the left and right data separately and continuously. Is that what is called parsing?   int motorLeft = L41:;

#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11); // RX, TX

int led = 9;
char myChar = 'a';
String string;

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(57600);
  pinMode(led, OUTPUT);
  Serial.println("Goodnight moon!");
  // set the data rate for the SoftwareSerial port
  mySerial.begin(57600);
}


void loop() // run over and over
{
  string = "";
  while (true) {
    myChar = mySerial.read();

    if (32 <= myChar && myChar <= 127) {
      string += myChar;
    }
    if (myChar == ':') {
      break;
    }
    delay(10);
  }// While End


  Serial.println(string);

}

Is that what is called parsing?

Yes.

You really need to stop using Strings. They have no place on an Arduino. You know how much data you are using. Create a char array and an index. Store the incoming characters in the array, at the index location. Add a NULL after every character is added.

Then, use strtok() to parse the string and atoi() to convert the tokens to ints.

http://forum.arduino.cc/index.php?topic=396450.0

I tried to adapt from this blog

First, I don't understand why all this is in the setup function. Secondly, when I check the serial monitor, it's blank. Thirdly, I don't understand where these values come from: char instring[] = "R39:L147:"; I just took them randomly from the values that came from the android using previous sketch.

My goal is to get int leftVal and int rightVal from R39:L147:

#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11); // RX, TX

int led = 9;
int androidValue;
char myChar = 'a';


void setup() {
  char instring[] = "R39:L147:"; //
  char delimiters[] = "!:,";
  char* valAccel;
  //This initializes strtok with our string to tokenize
  valAccel = strtok(instring, delimiters);

  while (valAccel != NULL) {
    Serial.println(androidValue);
    androidValue = atoi (valAccel);
    valAccel = strtok (NULL, delimiters);

  }

  // Open serial communications and wait for port to open:
  Serial.begin(57600);
  pinMode(led, OUTPUT);
 
  // set the data rate for the SoftwareSerial port
  mySerial.begin(57600);

}


void loop() // run over and over
{
myChar=mySerial.read();


  }

First, I don't understand why all this is in the setup function.

Because it is demonstration code

Secondly, when I check the serial monitor, it's blank.

Possibly because your Serial.begin() should be before the very first Serial.print() / Serial.println()

Thirdly, I don't understand where these values come from: char instring[] = "R39:L147:"; I just took them randomly from the values that came from the android using previous sketch.

You have to populate instring with data from the serial port (in your case the software serial port). Read the link that PaulS provided, it shows you how to read serial data into a nul terminated character array and how to parse it. Although the code uses the serial port, the principles equally apply to reading from the software serial port (or from a SD card or from a network connection or ...).

My code now looks like this:

// Example 5 - Receive with start- and end-markers combined with parsing
#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11); // RX, TX
const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

      // variables to hold the parsed data
char messageFromPC[numChars] = {0};
int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;
float floatFromPC = 0.0;

boolean newData = false;

//============

void setup() {
    Serial.begin(57600);
    Serial.println("This demo expects 2 pieces of data"); 
    Serial.println("the first is the motorLeft pwm value"); 
    Serial.println("next is motorRight pwm value");
    Serial.println();
}

//============

void loop() {
    recvWithStartEndMarkers();
    if (newData == true) {
        strcpy(tempChars, receivedChars);
            // this temporary copy is necessary to protect the original data
            //   because strtok() used in parseData() replaces the commas with \0
        parseData();
        showParsedData();
        newData = false;
    }
}

//============

void recvWithStartEndMarkers() {
    static boolean recvInProgress = false;
    static byte ndx = 0;
    char startMarker = '<';
    char endMarker = '>';
    char rc;

    while (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'; // terminate the string
                recvInProgress = false;
                ndx = 0;
                newData = true;
            }
        }

        else if (rc == startMarker) {
            recvInProgress = true;
        }
    }
}

//============

void parseData() {      // split the data into its parts

    char * strtokIndx; // this is used by strtok() as an index

    strtokIndx = strtok(tempChars,",");      
    pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer 
 
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer


}

//============

void showParsedData() {

    Serial.print("Left Motor ");
    Serial.println(pwmLeftFromAndroid);
    Serial.print("Right Motor ");
    Serial.println(pwmRightFromAndroid);
}

I tried to modify the example 5 of the tutorial that Paul S. suggested. The only thing that appears in my serial monitor is the message from void setup(); It's not printing any data sent from my android. The data the arduino receives from the android should look something like this: <12,255> Both of these numbers will be a value of 0 to 255 depending on how the phone is tilted. I want to use the number on the left as the pwmLeftFromAndroid number and the number on the right as the pwmRightFromAndroid.

Anybody see what I'm doing wrong? I'm pretty sure I'm not doing something right in the void parseData(); function.

I also added the SoftwareSerial library to the sketch so I can have my bluetooth plugged in to my arduino while it is also using the 0, 1 tx/rx pins for the serial monitor.

// Example 5 - Receive with start- and end-markers combined with parsing

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data

int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;

boolean newData = false;
int motorPinL = 5;
int motorPinR = 6;

//============

void setup() {
  pinMode(motorPinL, OUTPUT);
  pinMode(motorPinR, OUTPUT);
  Serial.begin(57600);
}

//============

void loop() {
  recvWithStartEndMarkers();
  if (newData == true) {
    strcpy(tempChars, receivedChars);
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
    parseData();

    newData = false;
  }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (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'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void parseData() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");
  pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer
  analogWrite(motorPinL, pwmLeftFromAndroid);
  analogWrite(motorPinR, pwmRightFromAndroid);


}

//============

I removed the serial.print functions and added two led's for debugging and for simulating a left motor and a right motor. When I tilt the phone the two led's light up according to the pwm from the tilt.

This seems to work as expected.

Your code in reply #4 works as expected when using the serial port.

This demo expects 2 pieces of data
the first is the motorLeft pwm value
next is motorRight pwm value

L12,R3
Left Motor 0
Right Motor 0
12,3
Left Motor 12
Right Motor 3

I added one additional Serial.println in the code so I could see what was actually received.

void loop()
{
  recvWithStartEndMarkers();
  if (newData == true)
  {
    strcpy(tempChars, receivedChars);
    Serial.println(receivedChars);

...
...
}

Initially I did send a L and a R in front of the numbers and that resulted in 0 for the printed values as letters are not valid for numbers :wink: Once I understood that I did not have to send that, the code happily showed what was entered.

So can't say what went wrong in your code. I did not use a bluetooth module connected to the hardware serial.

If you want to use bluetooth as well on software serial, configure the sofware serial with the correct baudrate (in setup()) and read from software serial instead of from hardware serial in recvWithStartEndMarkers().

By the way, as you don't seem to have a need to keep the original string, there is no need to have a second array to keep a copy the original message.

It's also reasonably easy to write your own non-destructive version of parseData() using strchr instead. That way you have control.

void parseData()
{
  // find comma
  char *ptr = strchr(receivedChars, ',');

  // if no comma found
  if (ptr == NULL)
  {
    return;
  }
  // replace comma by nul chracter
  *ptr = '\0';
  // convert
  pwmLeftFromAndroid = atoi(receivedChars);

  // restore comma
  *ptr = ',';

  // point to position after comma
  ptr++;
  // convert
  pwmRightFromAndroid = atoi(ptr);
}

excellent! works just like I hoped. Now for the Android side.....Thanks for your help!

I would like to add to my sketch in my reply #5 above some incoming data from the android. The data would be either of two characters . 'a' or 'b' to turn an led on or off on the arduino. Right now, the android constantly sends two sets of numbers over the bluetooth connection to the arduino. I'm just at a loss on where to start. I think I would start here to have the arduino look for a single char coming from the android as opposed to the stream of two sets of numbers.

Can you tell me if I am on the right track? I won't be able to test this for a few days until I get some parts in the mail.

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;
  char ledData;  //new char to receive 'a' or 'b' from android. 

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();
    ledData = Serial.read();  //read bluetooth android data. I don't know how to proceed without mixing up the data

    if (recvInProgress == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

Does this look like I'm on the right track? As I said, I would test it, but I'm waiting on parts in the mail.

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;
  char ledData;  //new char to receive 'a' or 'b' from android.

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();
    ledData = Serial.read();  //read bluetooth android data. I don't know how to proceed without mixing up the data
    if (ledData == 'a')  {
       digitalWrite (led, HIGH);
} 
     if (ledData == 'b')  {
       digitalWrite (led, LOW);
} 
    if (recvInProgress == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

Does this look like I'm on the right track?

It looks like it was copied from Robin2's thread and butchered. We have no idea where you call the function, what serial data you are sending, or what you do with the data that the function collects.

If you are not sending < or >, then the code isn't going to work.

I added this to the loop of my code to try to simply allow the arduino to receive a 1 or 0 to turn on/off the led:

        if (Serial.available()>0){
    ledData = Serial.read();
    
    if (ledData = 0){
      digitalWrite(led, LOW);
    }
    if (ledData = 1){
      digitalWrite(led, HIGH);
    }
    }

The led does not light up when I press the button on the android. Here is the full sketch:

// Example 5 - Receive with start- and end-markers combined with parsing

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing
char ledData;

// variables to hold the parsed data

int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;

boolean newData = false;
int motorPinL = 5;
int motorPinR = 6;
int led = 4;

//============

void setup() {
  pinMode(motorPinL, OUTPUT);
  pinMode(motorPinR, OUTPUT);
  Serial.begin(57600);
}

//============

void loop() {
  recvWithStartEndMarkers();
  if (newData == true) {
    strcpy(tempChars, receivedChars);
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
        if (Serial.available()>0){
    ledData = Serial.read();
    
    if (ledData = 0){
      digitalWrite(led, LOW);
    }
    if (ledData = 1){
      digitalWrite(led, HIGH);
    }
    }
    parseData();
    
    newData = false;
  }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (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'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void parseData() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");
  pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer
  analogWrite(motorPinL, pwmLeftFromAndroid);
  analogWrite(motorPinR, pwmRightFromAndroid);


}

If someone could point me in the right direction, I would greatly appreciate it.

Be consistent. If you send data from the android (it does not matter what), adhere to the format. So <41,33> or or . This allows you to use a single function (recvWithStartEndMarkers()) to read the data and there is no need for additional serial reads.

Now you can easily check if the received data is a letter or two numbers separated by a comma.

I suggest that you first change the name of the parseData() function so it reflects what it does, e.g. motorControl().

Next write a second function to control the led, e.g. ledControl()

void ledControl()
{
  if(receivedChars[0] == 'a')
  {
    digitalWrite(led, LOW);
  }
  if(receivedChars[0] == 'b')
  {
    digitalWrite(led, HIGH);
  }
}

The above checks the first character in receivedChars and controls the led based on that. You can also opt for a switch statement instead of the two if statements.

Write a new parseData (in the below I call it processData as I think it' a better name) that determines if the data indicates the control of the motors or the control of the led and call the appropriate function.

void processData()
{
    // if the first character is 'a' or 'b', control the led
    if(receivedChars[0] == 'a' || receivedChars[0] == 'b')
    {
      ledControl();
    }
    // else control the motors
    else
    {
      motorControl();
    }
}

And in loop() you can now call processData if new data is received.

void loop()
{
  recvWithStartEndMarkers();
  if (newData == true)
  {
    processData();
    newData = false;
  }
}

Note that I have removed the not-so-useful copy of receivedChars, so you need to change motorControl to use the receivedChars.

It might also be time to consider all functionalities that you want to control from the android and come up with a flexible protocol.

e.g.
function:data
For the motorControl, it can be
<M:speedL,speedR>; example <M:41,33>
For the led(s), it can be
<L:whichLed,onoffStatus>; example <L:3,0> to switch the 3rd led (or the led on pin 3 depending on implementation) off.

The parsing of the incoming message will now involve splitting on the colon first to determine which function needs to be called.

Thanks for your reply. I know you have spent a lot of time and I appreciate it. Here is the sketch so far for reference:

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data

int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;

boolean newData = false;
int motorPinL = 5;
int motorPinR = 6;

//============

void setup() {
  pinMode(motorPinL, OUTPUT);
  pinMode(motorPinR, OUTPUT);
  Serial.begin(57600);
}

//============

void loop()
{
  recvWithStartEndMarkers();
  if (newData == true)
  {
    processData();
    newData = false;
  }
}

void processData()
{
    // if the first character is 'a' or 'b', control the led
    if(receivedChars[0] == 'a' || receivedChars[0] == 'b')    {
      ledControl();
    }
    // else control the motors
    else
    {
      motorControl();
    }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (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'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void motorControl() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");
  pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer
  analogWrite(motorPinL, pwmLeftFromAndroid);
  analogWrite(motorPinR, pwmRightFromAndroid);


}

what is the ndx in void recvWithStartEndMarkers() function? I don't understand its meaning or purpose. Especially this statement: receivedChars[ndx] = rc;

and is the motorControl function is looking for receivedChars?

what is the ndx in void recvWithStartEndMarkers() function?

It is a variable that defines where to store the next character in the array (an index, in other words).

and is the motorControl function is looking for receivedChars?

No. It assumes that you have copied the data from receivedChars to tempChars.

This works! Thanks for your help.

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data

int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;

boolean newData = false;
int motorPinL = 5;
int motorPinR = 6;
int led = 9;
//============

void setup() {
  pinMode(led, OUTPUT);
  pinMode(motorPinL, OUTPUT);
  pinMode(motorPinR, OUTPUT);
  Serial.begin(57600);
}

//============

void loop()
{
  recvWithStartEndMarkers();
  if (newData == true)
  {
    processData();
    newData = false;
  }
}

void processData()
{
  // if the first character is 'a' or 'b', control the led
  if (receivedChars[0] == 'a' || receivedChars[0] == 'b')    {
    ledControl();
  }
  // else control the motors
  else
  {
    motorControl();
  }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (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'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void motorControl() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");
  pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer
  analogWrite(motorPinL, pwmLeftFromAndroid);
  analogWrite(motorPinR, pwmRightFromAndroid);


}
void ledControl()
{
  if (receivedChars[0] == 'a')
  {
    digitalWrite(led, LOW);
    Serial.println(receivedChars);
  }
  if (receivedChars[0] == 'b')
  {
    digitalWrite(led, HIGH);
    Serial.println(receivedChars);
  }
}

I think I spoke too soon about the code working. Here is the code I'm using. I have attached a screenshot of the serial monitor that shows the result of the parsing is 0 for both the pwmLeftFromAndroid and the pwmRightFromAndroid. I should see numbers from 0 to 9 (with or without a negative sign). When I send the 'a' or 'b' from Android, I do see that on the serial monitor. Can anybody spot any errors?

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data

int pwmLeftFromAndroid = 0;
int pwmRightFromAndroid = 0;

boolean newData = false;
int motorPinL = 5;
int motorPinR = 6;
int led = 8;
//============

void setup() {
  pinMode(led, OUTPUT);
  pinMode(motorPinL, OUTPUT);
  pinMode(motorPinR, OUTPUT);
  Serial.begin(57600);
}

//============

void loop()
{
  recvWithStartEndMarkers();
  if (newData == true)
  {
    processData();
    newData = false;
  }
}

void processData()
{
  // if the first character is 'a' or 'b', control the led
  if (receivedChars[0] == 'a' || receivedChars[0] == 'b')    {
    ledControl();
  }
  // else control the motors
  else
  {
    motorControl();
  }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (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'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void motorControl() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");
  pwmLeftFromAndroid = atoi(strtokIndx);     // convert this part to an integer

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  pwmRightFromAndroid = atoi(strtokIndx);     // convert this part to an integer
  analogWrite(motorPinL, pwmLeftFromAndroid);
  Serial.print("Left: ");
  Serial.println(pwmLeftFromAndroid);
  Serial.println();
  analogWrite(motorPinR, pwmRightFromAndroid);
    Serial.print("Right: ");
  Serial.println(pwmRightFromAndroid);
  Serial.println();


}
void ledControl()
{
  if (receivedChars[0] == 'a')
  {
    digitalWrite(led, LOW);
    Serial.println(receivedChars);
    Serial.println();
  }
  if (receivedChars[0] == 'b')
  {
    digitalWrite(led, HIGH);
    Serial.println(receivedChars);
    Serial.println();
  }
}

How is the data from the Android getting to the Arduino?

In other words, are you using Serial to talk to the Android AND the PC? If you are, knock that crap off.

bluetooth from android to arduino
If I insert this:

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();
    Serial.println(rc);

I get a result from the Android that I would expect in the serial monitor as shown in the attachment