(Hit CTRL+T in the IDE before posting, badly indented code is very hard to read!)
This piece of code:
while (Serial.peek() != 241 )
{
Serial.println(Serial.available(),DEC);
incoming_Char[a]=Serial.read();
a++;
}
will happily overwrite poor Arduino's RAM with -1, unless the byte 241 comes in in time. This is definitely not a robust piece of code. When you access an array element, you have to make sure the element index is less than the total number of array elements, otherwise you might read garbage, or worse you can overwrite portions of RAM which might belong to other part of the program, causing data corruption or (most likely) a program crash.
Here's a sketch that will scale to whatever message length you want to use (provided you don't use the entire RAM for a simple buffer).
const int BUFSIZE = 230; // max message size is BUFSIZE - 1 to leave room for the end-of-string NULL character (i.e. 0x00)
const char EOM = '*'; // marks the end of the message
char buffer[BUFSIZE]; // here we store the message as we receive it char by char
int bufPos = 0; // where to store the next received char in buffer
// this function will have to analyze the message's contents and
// take appropriate action
void processMessage(const char *msg) {
// this is only a test, so we just
// print out the message
Serial.print("Received: ");
Serial.println(msg);
}
void setup()
{
Serial.begin(115200);
}
void loop ()
{
char ch;
while (Serial.available() > 0) {
ch = Serial.read();
if (ch == EOM) { // end-of-message
buffer[bufPos] = 0; // string terminator
processMessage(buffer); // do something with the received message
bufPos = 0; // restart for next messages
}
else {
if (bufPos < (BUFSIZE - 1)) { // if there's still room in the buffer
buffer[bufPos] = ch; // store the received char
bufPos++; // forward 1 position in buffer
}
else {
Serial.println("Lost byte!"); // no more room, have to throw away the received char
}
}
}
}
Instruction: throw as many character as you want at the Arduino. It will store them inside buffer until it receives *. If * doesn't come before the buffer is full, it will print out an error message. When * is received, it will print the buffer contents and start over, waiting for the next message.
This code works with messages of any length, up to BUFSIZE-1.
My goal is actually a 960 byte command...
Beware, you're using half the RAM of Arduino just to store a message... You'll quickly run into out-of-ram bugs. Rethink you design.