RaspberryPi to Arduino -send and receive string

This problem essentially has two parts: splitting an integer into its bytes and reassembling an integer from bytes. These parts must be replicated on both the Pi and Arduino. I'll address the Pi side first, in Python:

Splitting an integer:

def writeNumber(value):

    # assuming we have an arbitrary size integer passed in value
    for character in str(val): # convert into a string and iterate over it
        bus.write_byte(address, ord(character)) # send each char's ASCII encoding

    return -1

Reassembling an integer from bytes:

def readNumber():

    # I'm not familiar with the SMbus library, so you'll have to figure out how to
    # tell if any more bytes are available and when a transmission of integer bytes
    # is complete. For now, I'll use the boolean variable "bytes_available" to mean
    # "we are still transmitting a single value, one byte at a time"

    byte_list = []
    while bytes_available:
        # build list of bytes in an integer - assuming bytes are sent in the same
        # order they would be written. Ex: integer '123' is sent as '1', '2', '3'
        byte_list.append(bus.read_byte(address))

    # now recombine the list of bytes into a single string, then convert back into int
    number = int("".join([chr(byte) for byte in byte_list]))
    return number

Arduino Side, in C

Split an Integer:

void sendData(){
    int i = 0;
    String outString = String(number); /* convert integer to string */
    int len = outString.length()+1     /* obtain length of string w/ terminator */
    char ascii_num[len];               /* create character array */

    outString.toCharArray(ascii_num, len); /* copy string to character array */

    for (i=0; i<len); ++i){
        Wire.write(ascii_num[i]);
    }
}

Reassembling a received Integer: Note: I'm having some trouble understanding what your other code in this routine is doing, so I'm going to reduce it to just assembling the integer.

void receiveData(int byteCount){
    int inChar;
    String inString = "";

    /* As with the Python receive routine, it will be up to you to identify the
       terminating condition for this loop - "bytes_available" means the same thing
       as before */

    while(bytes_available){ 
        inChar = Wire.read();
        inString += char(inChar);
    }

    number = inString.toInt();
}

I don't have the materials on hand to test this, so it's possible I've gotten the byte order flipped in one routine or another. If you find stuff coming in or out backwards, the easiest place to fix it is in the Python script by using the built-in function reversed() on the strings or lists.

References (I used some code from the Arduino Examples):
Arduino String objects
Arduino String Constructors
Python Built-ins chr() and ord()

Check the following Link:

[http://www.i2c-bus.org/][1]

When I was sending data back and forward using I2C I was converting the string characters to bytearrays and viceversa. So since you are always sending bytes. It will always work since you are sending numbers between 0-255.

Not sure this helps but at least may give you an idea.

You could convert the number to a string of digits like you said. But you could also send the raw bytes.

String of digits

Advantages

• Number can have infinite digits. Note that when Arduino reads the number as a string, it is infinite, but you can't convert it all to integer if it overflows the 16-bit range (or 32-bit for Due).

Disadvantages

• Variable size, thus requiring more effort in reading.
• Waste of bytes, because each decimal digit would be a byte, plus the null-terminator totalizing (digits + 1) size.
• Having to use decimal arithmetic (which really is only useful for human counting), note that a "number to string" operation also uses decimal arithmetic.
• You can't send/receive negative numbers (unless you send the minus signal, wasting more time and bytes).

Raw bytes

Advantages

• Number of bytes sent for each integer is always 4.
• You can send/receive negative numbers.
• The bitwise arithmetic in C++ for extracting each byte from the number is really fast.
• Python already has the struct library which packs/unpacks each byte in a number to a string to send/receive, so you don't need to do the arithmetic like in C++.

Disadvantages

• Number has a limited range (signed 32-bit integer in our case, which ranges from -2147483648 to 2147483647). But it doesn't matter because no Arduino can handle more than 32-bit anyways.

So I would use the raw bytes method, which I can provide some untested functions here:

import struct

# '<i' stands for litle-endian signed integer

def writeNumber(value):
  strout = struct.pack('<i', value)
  for i in range(4):
    bus.write_byte(address, strout[i])
  return -1

def readNumber():
  strin = ""
  for _ in range(4):
    strin += bus.read_byte(address)
  return struct.unpack('<i', strin)[0]

And the Arduino part:

void receiveData(int byteCount)
{
    // Check if we have a 32-bit number (4 bytes) in queue
    while(Wire.available() >= 4)
    {
        number = 0;
        for(int i = 0; i < 32; i += 8)
        {
            // This is merging the bytes into a single integer
            number |= ((int)Wire.read() << i);
        }

        Serial.print("data received: ");
        Serial.println(number);

        // ...
    }
}

void sendData()
{
    for(int i = 0; i < 32; i += 8)
    {
        // This is extracting each byte from the number
        Wire.write((number >> i) & 0xFF);
    }
}

I don't have any experience with I2C, but if its queue is a FIFO, then the code should work.