RaspberryPi для Arduino - отправка и получение строки

По сути, эта задача состоит из двух частей: разбиения целого числа на его байты и повторной сборки целого числа из байтов. Эти части должны быть воспроизведены как на Pi, так и на Arduino. Сначала я обращусь к стороне Pi на Python:

Разделение целого числа:

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

Сборка целого числа из байтов:

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, в C

Разделить целое число:

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]);
    }
}

Повторная сборка полученного целого числа: Примечание. У меня возникли некоторые проблемы с пониманием того, что делает ваш другой код в этой подпрограмме, поэтому я собираюсь сократить его до простой сборки целого числа.

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();
}

У меня нет под рукой материалов, чтобы проверить это, поэтому, возможно, я перевернул порядок байтов в той или иной процедуре. Если вы обнаружите, что что-то входит или выходит в обратном направлении, проще всего исправить это в скрипте Python с помощью встроенной функции reversed() в строках или списках.

Ссылки (я использовал код из примеров Arduino):
строковые объекты Arduino
Строковые конструкторы Arduino
Встроенные модули Python chr() и ord()

Проверьте следующую ссылку:

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

Когда я отправлял данные туда и обратно с помощью I2C, я преобразовывал строковые символы в массивы байтов и наоборот. Итак, поскольку вы всегда отправляете байты. Это всегда будет работать, так как вы отправляете числа от 0 до 255.

Не уверен, что это помогает, но, по крайней мере, может дать вам представление.

Вы можете преобразовать число в строку цифр, как вы сказали. Но вы также можете отправить необработанные байты.

Строка цифр

Преимущества

• Число может иметь бесконечные цифры. Обратите внимание, что когда Arduino считывает число как строку, оно бесконечно, но вы не можете преобразовать его все в целое число, если оно выходит за пределы 16-битного диапазона (или 32-битного для Due).

Недостатки

• Переменный размер, что требует больше усилий при чтении.
• Пустая трата байтов, потому что каждая десятичная цифра будет байтом плюс нуль-терминатор в сумме (digits + 1).
• При необходимости использовать десятичную арифметику (которая на самом деле полезна только для человеческого счета), обратите внимание, что операция «число в строку» также использует десятичную арифметику.
• Вы не можете отправлять/получать отрицательные числа (если вы не отправляете отрицательный сигнал, тратя больше времени и байтов).

Необработанные байты

Преимущества

• Количество байтов, отправляемых для каждого целого числа, всегда равно 4.
• Вы можете отправлять/получать отрицательные числа.
• Побитовая арифметика в C++ для извлечения каждого байта из числа выполняется очень быстро.
• В Python уже есть библиотека struct, которая упаковывает/распаковывает каждый байт числа в строку для отправки/получения, поэтому вам не нужно выполнять арифметические действия, как в C++.

Недостатки

• Число имеет ограниченный диапазон (в нашем случае это 32-битное целое число со знаком, которое находится в диапазоне от -2147483648 до 2147483647). Но это не имеет значения, потому что ни один Arduino не может работать с более чем 32-битным процессором.

Поэтому я бы использовал метод необработанных байтов, для которого я могу предоставить некоторые непроверенные функции:

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]

И часть Arduino:

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);
    }
}

У меня нет опыта работы с I2C, но если его очередь FIFO, то код должен работать.