Проблема при отправке числа с плавающей запятой и нескольких чисел с плавающей запятой

Передача числовых значений между системами сопряжена с трудностями. Вы должны не только убедиться, что оба конца согласны с размером данных (16 бит против 32 битных целых чисел, float против double и т.д.), Но и что порядок байтов обрабатывается правильно. Вдобавок ко всему, нужно знать, где находится число в потоке данных. Поскольку нечем разграничивать каждое значение (а когда у вас есть 8 бит ширины связи и 8 бит данных, нет места для "внеполосных" управляющих сигналов), у вас нет способа узнать, какой байт в потоке данных соответствует какому байту в необработанных данных значения.

Гораздо лучше закодировать данные в какой-нибудь другой формат, который оставляет вам возможность добавлять разделительные управляющие сигналы и имеет заранее определенный машинно-независимый формат данных.

Самая простая кодировка: ASCII. Просто "выведите" числа в виде текста с требуемой точностью (количество знаков после запятой) как одно число в строке. Затем на Arduino вы можете считывать текстовые данные по строке за раз, а затем использовать внутренние процедуры преобразования с плавающей запятой, чтобы снова превратить эти данные в фактическое значение с плавающей запятой.

Некоторые ссылки:

• Чтение последовательного на Arduino - сообщение в моем блоге, также применимое к связи TCP / IP
• String::toFloat() - преобразование строкового объекта в значение с плавающей запятой
• strtof() - преобразует строку C в значение с плавающей запятой.

Ознакомьтесь с библиотекой I2C_Anything. Он используется для передачи любого типа данных по битам с использованием последовательного протокола I2C, но алгоритмы могут быть так же легко использованы по ЛЮБОМУ последовательному соединению. Вы действительно должны убедиться, что размер определенного типа данных одинаков на обоих концах, но это все.

Here's my subroutine running on a Teensy 3.5 that acquires VL53L0X LIDAR data from another Arduino processor (actually a Teensy 3.2).

    bool GetRequestedVL53l0xValues(VL53L0X_REQUEST which)
{
  //Назначение: Получение данных датчика VL53L0X ToF от обработчика датчиков Teensy
  //Входные данные: 
  // which = VL53L0X_REQUEST значение, обозначающее, какую комбинацию значений извлекать
  // VL53L0X_CENTERS_ONLY -> Только значения левого/ правого центрального датчика
  // VL53L0X_RIGHT -> Все три значения правого датчика, в порядке спереди / по центру / сзади
  // VL53L0X_LEFT -> Все три значения левого датчика, в порядке спереди /по центру/ сзади
  // VL53L0X_ALL -> Все семь значений датчика, в левом / правом переднем /центральном / заднем / заднем порядке
  // VL53L0X_REAR_ONLY -> добавлено 24.10.2010 Только показания заднего датчика

  // Результаты: 
  // Запрошенные значения датчика, полученные через I2C из обработчика датчиков VL53L0X
  // Возвращает TRUE, если извлечение данных прошло успешно, в противном случае FALSE
  // План:
  // Шаг 1: Отправить запрос обработчику VL53L0X
  // Шаг 2: получение запрошенных данных
  //Примечания:
  // Скопировано из функции IsIRBeamAvail() FourWD_WallE2_V4.ino и адаптировано
    // 05.08.2010 добавлен тип запроса VL53L0X_ALL
    // 24.01.2011 добавлено обнаружение ошибок / создание отчетов
    // 16.01.22 rev для использования функций I2C_Anything1 для Wire1

  //Шаг 1: Отправить запрос обработчику VL53L0X
  //ОТЛАЖИВАТЬ!!
    //myTeePrint.printf("Отправка %d на подчиненный \ n", который);
  //ОТЛАЖИВАТЬ!!

  //myTeePrint.printf("В GetRequestedVL53l0xValues(%d)\n", (int)который);

  //03/01/22 обороты до cvt все показания до cm
  uint16_t Lidar_RightFrontMM = 0;
  uint16_t Lidar_RightCenterMM = 0;
  uint16_t Lidar_RightRearMM = 0;
  uint16_t Lidar_RearMM = 0;

  uint16_t Lidar_LeftFrontMM = 0;
  uint16_t Lidar_LeftCenterMM = 0;
  uint16_t Lidar_LeftRearMM = 0;


  Wire1.beginTransmission(VL53L0X_I2C_SLAVE_ADDRESS);
  I2C_writeAnything((uint8_t)which, &Wire1);
  Wire1.endTransmission();


  //Шаг 2: получаем запрошенные данные
  int readResult = 0;
  int data_size = 0;
  switch (which)
  {
  case VL53L0X_READYCHECK: //11/10/20 добавлено для предотвращения неправильного чтения во время крошечной настройки ()
    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, (uint16_t)(sizeof(bVL53L0X_TeensyReady)));
    readResult = I2C_readAnything(bVL53L0X_TeensyReady, &Wire1);
    break;

  case VL53L0X_CENTERS_ONLY:
    // здесь нужны только два значения данных
    data_size = 2 * sizeof(uint16_t);
    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, (uint16_t)(2 * sizeof(Lidar_RightCenterMM)));
    readResult = I2C_readAnything(Lidar_RightCenterMM, &Wire1);
    glRightCenterCm = Lidar_RightCenterMM / 10; //усечение целых чисел в порядке

    if (readResult > 0)
    {
      I2C_readAnything(Lidar_LeftCenterMM, &Wire1);
      glLeftCenterCm = Lidar_LeftCenterMM / 10; //усечение целых чисел в порядке
    }

    //ОТЛАЖИВАТЬ!!
        //myTeePrint.printf("VL53L0X_CENTERS_ONLY случай: есть LC/RC = %d, %d \n", Lidar_LeftCenterMM, Lidar_RightCenterMM);
    //ОТЛАЖИВАТЬ!!

    break;
  case VL53L0X_RIGHT:
    // здесь необходимы четыре значения данных
    data_size = 3 * sizeof(uint16_t) + sizeof(float);

    //ОТЛАЖИВАТЬ!!
        //myTeePrint.printf("data_size = %d \n", data_size);
    //ОТЛАЖИВАТЬ!!

    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, data_size);
    readResult = I2C_readAnything(Lidar_RightFrontMM, &Wire1);
    glRightFrontCm = Lidar_RightFrontMM / 10; //усечение целых чисел в порядке

    if (readResult > 0)
    {
      readResult = I2C_readAnything(Lidar_RightCenterMM, &Wire1);
      glRightCenterCm = Lidar_RightCenterMM / 10; //усечение целых чисел в порядке
    }
    if (readResult > 0)
    {
      readResult = I2C_readAnything(Lidar_RightRearMM, &Wire1);
      glRightRearCm = Lidar_RightRearMM / 10; //усечение целых чисел в порядке
    }
    if (readResult > 0)
    {
      readResult = I2C_readAnything(glRightSteeringVal, &Wire1);
    }

    //ОТЛАЖИВАТЬ!!
        //myTeePrint.printf("VL53L0X_RIGHT case: есть L /C / R /S = %d, %d, %d, %3.2f \n",
        // glRightFrontCm, Lidar_RightCenterMM, lidar_rightrearmmm, ToFSteeringVal);
    //ОТЛАЖИВАТЬ!!

    break;
  case VL53L0X_LEFT:
    // здесь необходимы четыре значения данных
    //data_size = 3 * sizeof(int) + sizeof(float);
    data_size = 3 * sizeof(uint16_t) + sizeof(float);

    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, data_size);
    readResult = I2C_readAnything(Lidar_LeftFrontMM, &Wire1);
    glLeftFrontCm = Lidar_LeftFrontMM / 10; //усечение целых чисел в порядке

    if (readResult > 0)
    {
      readResult = I2C_readAnything(Lidar_LeftCenterMM, &Wire1);
      glLeftCenterCm = Lidar_LeftCenterMM / 10; //усечение целых чисел в порядке
    }
    if (readResult > 0)
    {
      readResult = I2C_readAnything(Lidar_LeftRearMM, &Wire1);
      glLeftRearCm = Lidar_LeftRearMM / 10; //усечение целых чисел в порядке
    }
    if (readResult > 0)
    {
      readResult = I2C_readAnything(glLeftSteeringVal, &Wire1);
    }

    //ОТЛАЖИВАТЬ!!
        //myTeePrint.printf("VL53L0X_RIGHT case: есть L /C /R /S = %d, %d, %d, %3.2f \n",
        // Lidar_LeftFrontMM, Lidar_LeftCenterMM, lidar_leftrearmmm, ToFSteeringVal);
    //ОТЛАЖИВАТЬ!!

    break;
  case VL53L0X_ALL: // добавлено 05.08.2010, chg к VL53L0X_ALL 31.10.2010
    // здесь требуется девять значений данных - 7 целых чисел и 2 числа с плавающей запятой
    data_size = 7 * sizeof(uint16_t) + 2 * sizeof(float); //10/31/20 добавлено заднее расстояние

    //myTeePrint.printf("В VL53L0X_ALL случае с data_size = %d\n", data_size);

    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, data_size);

    //Lidar_LeftFrontMM
    readResult = I2C_readAnything(Lidar_LeftFrontMM, &Wire1);
    glLeftFrontCm = Lidar_LeftFrontMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_LeftFrontMM))
    {
      myTeePrint.printf("Error reading Lidar_LeftFrontMM\n");
    }

    //lidar_leftcenter мм
    readResult = I2C_readAnything(Lidar_LeftCenterMM, &Wire1);
    glLeftCenterCm = Lidar_LeftCenterMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_LeftCenterMM))
    {
      myTeePrint.printf("Error reading Lidar_LeftCenterMM\n");
    }

    //Lidar_LeftRearMM
    readResult = I2C_readAnything(Lidar_LeftRearMM, &Wire1);
    glLeftRearCm = Lidar_LeftRearMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_LeftRearMM))
    {
      myTeePrint.printf("Error reading Lidar_LeftRearMM\n");
    }

    // Левый поворотный вал
    readResult = I2C_readAnything(glLeftSteeringVal, &Wire1);
    if (readResult != sizeof(glLeftSteeringVal))
    {
      myTeePrint.printf("Error reading glLeftSteeringVal\n");
    }

    //Lidar_RightFrontMM
    readResult = I2C_readAnything(Lidar_RightFrontMM, &Wire1);
    glRightFrontCm = Lidar_RightFrontMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_RightFrontMM))
    {
      myTeePrint.printf("Error reading Lidar_RightFrontMM\n");
    }

    //Lidar_RightCenterMM
    readResult = I2C_readAnything(Lidar_RightCenterMM, &Wire1);
    glRightCenterCm = Lidar_RightCenterMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_RightCenterMM))
    {
      myTeePrint.printf("Error reading Lidar_RightCenterMM\n");
    }

    //Lidar_RightRearMM
    readResult = I2C_readAnything(Lidar_RightRearMM, &Wire1);
    glRightRearCm = Lidar_RightRearMM / 10; //усечение целых чисел в порядке

    if (readResult != sizeof(Lidar_RightRearMM))
    {
      myTeePrint.printf("Error reading Lidar_RightRearMM\n");
    }

    //Лидар_РеарММ
    readResult = I2C_readAnything(Lidar_RearMM, &Wire1);
    glRearCm = Lidar_RearMM / 10; //усечение целых чисел в порядке
    if (readResult != sizeof(Lidar_RearMM))
    {
      myTeePrint.printf("Error reading Lidar_RearMM\n");
    }

    //glRightSteeringVal
    readResult = I2C_readAnything(glRightSteeringVal, &Wire1);
    if (readResult != sizeof(glRightSteeringVal))
    {
      myTeePrint.printf("Error reading glLeftSteeringVal\n");
    }

    //myTeePrint.printf("%lu: VL53l0x - %d, %d, %d, %d, %d, %d\n",
    // millis(),
    // Lidar_LeftFrontMM, Lidar_LeftCenterMM, Lidar_LeftRearMM,
    // glRightFrontCm, Lidar_RightCenterMM, Lidar_RightRearMM,
    // Lidar_RearMM);
    break; //10/31/20 исправлена ошибка

  case VL53L0X_REAR_ONLY:
    // здесь требуется только ОДНО значение данных
    data_size = sizeof(uint16_t);
    Wire1.requestFrom(VL53L0X_I2C_SLAVE_ADDRESS, (uint16_t)(sizeof(Lidar_RearMM)));
    readResult = I2C_readAnything(Lidar_RearMM, &Wire1);
    glRearCm = Lidar_RearMM / 10; //усечение целых чисел в порядке

    //ОТЛАЖИВАТЬ!!
        //myTeePrint.printf("VL53L0X_REAR_ONLY case: Есть задний = %d \n", Lidar_RearMM);
    //ОТЛАЖИВАТЬ!!

    break;

  default:
    break;
  }
  //myTeePrint.printf("GetRequestedVL53l0xValues(): LR/LC/LF/RR/RC/RF/R = %d\t%d\t%d\t%d\t%d\t%d\t%d\n",
  // Lidar_LeftRearMM, Lidar_LeftCenterMM, Lidar_LeftFrontMM,
  // lidar_rightrearmmm, Lidar_RightCenterMM, glRightFrontCm, lidar_rearmmm);

  return readResult > 0; //это верно только в том случае, если все чтения завершились успешно
}

а вот соответствующий код на другом конце ссылки I2C:

// функция, которая выполняется всякий раз, когда данные запрашиваются ведущим
// эта функция зарегистрирована как событие, см. раздел setup()
void requestEvent()
{
  // Назначение: Отправка запрошенных данных датчика на мега-контроллер по основной шине I2C
  //Входные данные: 
  // request_type = значение uint8_t, обозначающее тип запрашиваемых данных (из receiveEvent())
  // 0 = только межосевые расстояния слева и справа.
  // 1 = правая сторона переднего, центрального и заднего расстояний, плюс значение рулевого управления.
  // 2 = переднее, центральное и заднее расстояния с левой стороны, плюс значение рулевого управления.
  // 3 = оба боковых передних, центральных и задних расстояния плюс оба значения рулевого управления.
// Результаты:
  // Запрошенные данные, отправленные мастеру
  //Примечания:
  // 05.08.2010 добавлен тип запроса VL53L0X_ALL, чтобы получить обе стороны одновременно
  // 24.10.2010 добавлен тип запроса VL53L0X_REAR_ONLY
  // 11/09/20 добавлена запись в контакт для мониторинга O'scope

  int data_size = 0;

//ОТЛАЖИВАТЬ!!
    //Serial.printf("RequestEvent() с request_type = %d: VL53L0X Расстояния спереди / по центру / Сзади = %d, %d, %d \n", 
    // request_type, RF_Dist_mm, RC_Dist_mm, RR_Dist_mm);
//ОТЛАЖИВАТЬ!!

  //digitalWrite(LED_BUILTIN, HIGH);//добавлено 22.01.22
  digitalWrite(REQUEST_EVENT_DURATION_OUTPUT_PIN, HIGH);

  digitalToggle(LED_BUILTIN);//2/21/22 добавлен для визуальной индикации
  switch (request_type)
  {
  case  VL53L0X_READYCHECK: // добавлено 11/10/20 для предотвращения неправильного чтения во время крошечной настройки ()
    //Serial.printf("в случае VL53L0X_READYCHECK в %lu с bTeensyReady = %d \n", millis(), bTeensyReady);
    I2C_writeAnything(bTeensyReady);
    break;

  case VL53L0X_CENTERS_ONLY:

    //ОТЛАЖИВАТЬ!!
      //data_size = 2*sizeof(uint16_t);
      //Serial.printf("Отправка %d байтов LC_Dist_mm = %d, RC_Dist_mm = %d в master\n", data_size, LC_Dist_mm, RC_Dist_mm);
    //ОТЛАЖИВАТЬ!!

    I2C_writeAnything(RC_Dist_mm);
    I2C_writeAnything(LC_Dist_mm);
    break;

  case VL53L0X_RIGHT:

    //ОТЛАЖИВАТЬ!!
            //data_size = 3 * sizeof(uint16_t) + sizeof(с плавающей точкой);
            //Serial.printf("Отправка %d байтов RF/RC/RR/RS vals = %d, %d, %d, %3.2f в master\n",
            // data_size, RF_Dist_mm, RC_Dist_mm, RR_Dist_mm, RightSteeringVal);
    //ОТЛАЖИВАТЬ!!

    I2C_writeAnything(RF_Dist_mm);
    I2C_writeAnything(RC_Dist_mm);
    I2C_writeAnything(RR_Dist_mm);
    I2C_writeAnything(RightSteeringVal);
    break;

  case VL53L0X_LEFT:

    //ОТЛАЖИВАТЬ!!
            //data_size = 3 * sizeof(uint16_t) + sizeof(с плавающей точкой);
            //Serial.printf("Отправка %d байтов LF/LC/LR/LS vals = %d, %d, %d, %3.2f в master\n",
            // data_size, LF_Dist_mm, LC_Dist_mm, LR_Dist_mm, LeftSteeringVal);
    //ОТЛАЖИВАТЬ!!

    I2C_writeAnything(LF_Dist_mm);
    I2C_writeAnything(LC_Dist_mm);
    I2C_writeAnything(LR_Dist_mm);
    I2C_writeAnything(LeftSteeringVal);
    break;

  case VL53L0X_ALL:
    //Serial.printf("В VL53L0X_ALL случае \n");
    //добавлено 05.08.2010 для получения данных с обеих сторон одновременно
    //10/31/20 chg в VL53L0X_ALL и сообщить все 7 значений датчика

//ОТЛАЖИВАТЬ!!
    //data_size = 3 * sizeof(uint16_t) + sizeof(с плавающей точкой);
    //data_size = 7 * sizeof(uint16_t) + 2 * sizeof(с плавающей точкой);
    //Serial.printf("Отправка %d байт в master\n", data_size);
    //Serial.printf("%d байт: %d\t%d\t%d\t%3.2f\t%d\t%d\t%d\t%3.2f\n",
    // data_size, LF_Dist_mm, LC_Dist_mm, LR_Dist_mm, Значение левого поворота,
    // RF_Dist_mm, RC_Dist_mm, RR_Dist_mm, Rear_Dist_mm, значение правого поворота);
//ОТЛАЖИВАТЬ!!



    //ОТЛАЖИВАТЬ!!
      //data_size = 3 * sizeof(uint16_t) + sizeof(с плавающей точкой);
      //Serial.printf("Отправка %d байтов LF/LC/LR/LS vals = %d, %d, %d, %3.2f в master\n",
      // data_size, LF_Dist_mm, LC_Dist_mm, LR_Dist_mm, LeftSteeringVal);
    //ОТЛАЖИВАТЬ!!

    //левая сторона  
    I2C_writeAnything(LF_Dist_mm);
    I2C_writeAnything(LC_Dist_mm);
    I2C_writeAnything(LR_Dist_mm);
    I2C_writeAnything(LeftSteeringVal);


    //ОТЛАЖИВАТЬ!!
      //data_size = 3 * sizeof(uint16_t) + sizeof(с плавающей точкой);
      //data_size = 4 * sizeof(uint16_t) + sizeof(с плавающей точкой);
      //Serial.printf("Отправка %d байтов RF/RC/RR/R/RS vals = %d, %d, %d, %d, %3.2f в master\n",
      // data_size, RF_Dist_mm, RC_Dist_mm, RR_Dist_mm, Rear_Dist_mm, RightSteeringVal);
    //ОТЛАЖИВАТЬ!!

       //правая сторона
    I2C_writeAnything(RF_Dist_mm);
    I2C_writeAnything(RC_Dist_mm);
    I2C_writeAnything(RR_Dist_mm);
    I2C_writeAnything(Rear_Dist_mm);
    I2C_writeAnything(RightSteeringVal);

    break;

  case VL53L0X_REAR_ONLY:

    //ОТЛАЖИВАТЬ!!
      //data_size = sizeof(uint16_t);
      //Serial.printf("Отправка %d байтов Rear_Dist_mm = %d в master\n", data_size, Rear_Dist_mm);
    //ОТЛАЖИВАТЬ!!

    I2C_writeAnything(Rear_Dist_mm);
    break;

  default:
    break;
  }
  digitalToggle(LED_BUILTIN);//2/21/22 добавлено для визуальной индикации активности I2C

  digitalWrite(REQUEST_EVENT_DURATION_OUTPUT_PIN, LOW);
  //digitalWrite(LED_BUILTIN, НИЗКИЙ);//добавлено 22.01.22
}

В качестве альтернативы вы можете отправить цифры в виде текста, как было предложено Эдгаром Бонетом выше. Вот короткая программа, которую я только что создал, которая демонстрирует эту возможность, используя два крошечных процессора 3.x. Программа ожидает появления символа на своем последовательном порту, и если таковые обнаруживаются, они передаются на другой процессор через последовательное соединение между ними, а также передаются обратно на отправляющий последовательный порт. Это должно работать с любым процессором Arduino, который имеет два последовательных порта (Serial для связи с ПК, Serial1 для связи с другим процессором). Я использовал встроенный светодиод в качестве монитора активности.

/*
    Имя: Serial_Anything.ino
    Создано: 26.04.2022 6:23:01 PM
    Автор: FRANKNEWXPS15\Фрэнк

    Проект для демонстрации передачи произвольных типов данных по последовательному соединению
    Идея состоит в том, чтобы перенести I2C_Anything для использования через обычное соединение с последовательным портом
*/

#include "Serial_Anything.h"

//char buff[30];

void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial1.begin(115200);
  delay(1000);

  Serial.printf("Serial_Anything Demo\n");

  pinMode(LED_BUILTIN, OUTPUT);

  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);

}

void loop()
{
  if (Serial.available())
  {
    //buff[buffidx] = Serial.read();
    //buffidx++;
    char c = Serial.read();
    Serial1.write(c);
    digitalWrite(LED_BUILTIN, HIGH);
    delay(50);
    digitalWrite(LED_BUILTIN, LOW);
    Serial.write(c);
  }

  if (Serial1.available())
  {
    //buff[buffidx] = Serial.read();
    //buffidx++;
    char c = Serial1.read();
    Serial.write(c);
    digitalWrite(LED_BUILTIN, HIGH);
    delay(50);
    digitalWrite(LED_BUILTIN, LOW);
  }
}

Вот краткий раздел результатов типичного запуска:

Крошка1:

Port closed
Opening port
Port open
Serial_Anything Demo
y
y
y
y
X
X
X
X
the quick
314159
3.14159

Крошка2:

Opening port
Port open
y
y
y
y
y
y
y
y
y
y
y
y
y
X
X
X
X
the quick
314159
3.14159