sending a long value using 4 ASCII symbols


I’m a beginner with Arduino and I have a little question for whom it may concern.

I am using 2 XBee modules and I would like to send a 32-bits value from one module to the other, using a 4 ASCII symbols package. Tell me if I’m wrong but I think that a ASCII symbol is just an integer between -128 to 127 isn’t it ? So, for example, if I send a ‘a’, I will get a ‘98’ with this code :

char c = ""; //je déclare ma variable c en type char et je l'initialise
for (int i =0; i<256; i++) //un octet complet
    c=char(i); //c prend la valeur du caractère ASCII n° i 
    Serial.println(c); //j'envoie mon caractère sur le port-série
    delay(250); // j'attend 250 ms

So I succeeded in sending an integer between -128 an 127 with just one char but I really don’t know how I can send “1000000000” for example.

The reason why I don’t want to send ‘1’,‘0’,‘0’,‘0’…‘0’ and to use a .toInt() function is because I’m limited in baud rate! I want to be as efficient as possible to gain in speed.

If anybody can help me, I would be grateful !

Tanks a lot!

10 0000 0000

can be thought of as 0x200

so you could send '2', '0', '0' and convert it back

Send it as binary. That way any 32 bit integer (or even single precision float) will only take 4 bytes.

When people refer to ascii characters they usually mean human readable characters - from codes 48 to to 126. Using human readable characters has the advantage that they make debugging easier.

This Python function converts a number into 3 ascii chars

def numToChar3(numVal):
        # convert a number into three ascii chars
    if abs(numVal) > 131072:
        numVal = 0
    numVal += 131072
    highChar = int(numVal / 4096)
    midVal = numVal - 4096 * highChar
    midChar = int(midVal / 64)
    lowChar = (midVal - 64 * midChar)
    reslt = chr(highChar + 48) + chr(midChar + 48) + chr(lowChar + 48)
    return reslt

and this Arduino function converts it back into a number

long numParseRcvdChars3(byte ndx) {
 long numVal = 0;
 numVal = (long)(rcvdChars[ndx] - 48) * 4096 + (long)(rcvdChars[ndx+1] - 48) * 64 + (long)(rcvdChars[ndx+2] - 48);
 numVal -= 131072L;
 return numVal;

Using 3 characters allows values up to +/- 131072 and, obviously you can extend the concept to use more characters. And, of course, you could implement the equivalent of the Python code on an Arduino. Interestingly the Arduino parse function is very significantly faster than the standard atoi() function.

Another major advantage of using only part of the range of byte values is that you can use some of the other values as start- and end-markers for the message. See the 3rd example in Serial Input Basics. Using start- and end-markers with binary data is more complex.