Неожиданное поведение с расчетом Arduino Uno

Question

Неожиданное поведение с расчетом Arduino Uno

arduino-uno calculation

У меня есть очень простой фрагмент кода, в котором одно и то же вычисление выводит разные значения в зависимости от того, как я выполняю вычисление. Платформой, на которой я запускаю этот код, является Arduino Uno с микроконтроллером Atmel MEGA328P. Вот код:

void setup() {
  
  Serial.begin(9600);
  unsigned long num = 100927;
  Serial.println(1000*60);
  Serial.println(num/(1000*60));
  Serial.println(num/(60000));
}

void loop() {}

Этот код выводит на консоль следующее:

-> -5536
-> 0
-> 1

Я не понимаю, почему num/(1000*60) и num/(60000) дают разные значения? Кроме того, 1000*60 оценивается как мусорное значение, которое выглядит так, как будто оно каким-то образом установило тип данных в int и привело к переполнению "int" диапазон.

У меня большой опыт программирования на Python. Я полагаю, что привык к тому, что python динамически интерпретирует переменные типы данных для меня, поэтому язык arduino меня немного смущает. Любая помощь приветствуется!

@Archit K, 👍2

1 ответ

Лучший ответ:

@*Nick Gammon* · Accepted Answer · 2023-04-27 05:35-00:00

Это чисто программирование на C++, о котором я рассказываю на своем веб-сайте. р>

Однако, поскольку здесь не допускаются ответы только по ссылкам, я воспроизвожу этот пост ниже:

Как вы думаете, что здесь будет напечатано на платформе Arduino (Uno)?

void setup ()
  {
  Serial.begin (115200);
  Serial.println ();
  
  Serial.println (30000 + 30000); // дважды 30000
  Serial.println (60 * 60 * 24);  // секунд в сутках
  Serial.println (50 / 100 * 1000); // половина от 1000
  }  // конец настройки

void loop () { }

Вы догадались:

60000
86400
500

Нет!

Он печатает:

-5536
20864
0

Это связано с целочисленной арифметикой. Если компилятор может, он обрабатывает числовой литерал (например, 60) как тип int, что означает, что он имеет диапазон от -32768 до +32767. Это может быть неожиданным для пользователей современных компиляторов, поскольку в настоящее время int обычно имеет длину 32 бита. Однако на 8-битных процессорах Arduino, таких как Atmega328P, компилятор обрабатывает целое число как 16-битное. Стандарт C++ допускает размер минимум 16 бит, но не гарантируется, что он будет больше.

И арифметика выполняется с использованием типа наибольшего аргумента, что означает, что арифметика в каждом случае выполняется как 16-битная арифметика, и, таким образом, она переполняется, когда достигает 32767.

Например, 30000 + 30000 = 60000, что равно 0xEA60 в шестнадцатеричном формате. К сожалению, 0xEA60 — это именно то, как -5536 хранится в типе int, поэтому он печатает -5536.

При этом 60 * 60 * 24 = 86400, что равно 0x15180 в шестнадцатеричном формате. Поскольку это не помещается в 16 бит, оно усекается до 0x5180, что равно 20864 в десятичном виде (как напечатано).

Наконец, в целочисленной арифметике 50/100 равно нулю, умножьте ноль на 1000, и вы все равно получите ноль, поэтому окончательный результат равен нулю.

Можем ли мы "помочь" компилятору, сообщая ему, какой результат нам нужен, например, вот так?

-5536
20864
0

Это печатает:

-5536
20864
0,00

Так что нет, это не помогло.

Решение

Во-первых, вы можете добавить суффикс к числовым литералам (например, L для long или UL для unsigned long) и добавить десятичный разряд к числам с плавающей запятой, например:

void setup ()
  {
  Serial.begin (115200);
  Serial.println ();

  long a = 30000 + 30000;
  long b = 60 * 60 * 24;
  float c = 50 / 100 * 1000;
  
  Serial.println (a);
  Serial.println (b);
  Serial.println (c);
  }  // end of setup

void loop () { }

Теперь мы получаем:

-5536
20864
0.00

Вам нужно помочь только с первым литералом, как только компилятор узнает, что мы используем длинные числа (или числа с плавающей запятой), он будет использовать их для выражения. *

Или мы можем "транслировать" их:

void setup ()
  {
  Serial.begin (115200);
  Serial.println ();
  
  Serial.println (30000L + 30000); // twice 30000
  Serial.println (60L * 60 * 24);  // seconds in a day
  Serial.println (50.0 / 100 * 1000); // half of 1000
  }  // end of setup

void loop () { }

Результаты:

60000
86400
500.00

Приведение типов полезно для переменных, потому что вы не можете просто добавить "L" в конец имени переменной.

Альтернативный синтаксис — использовать такой конструктор:

void setup ()
  {
  Serial.begin (115200);
  Serial.println ();
  
  long a =  (long) 30000 + 30000;
  long b =  (long) 60 * 60 * 24;
  float c = (float) 50 / 100 * 1000;
  
  Serial.println (a);
  Serial.println (b);
  Serial.println (c);
  }  // конец настройки

void loop () { }

(Те же результаты).

* На самом деле это несколько сложнее, как объясняет эта ссылка: Понятие о правилах преобразования целых чисел

Компилятор "продвигает" значение в выражении, соответствующее другому "более высокому рангу" тип, при определенных обстоятельствах. Например, добавление int и long приведет к преобразованию int в long (независимо от независимо от того, появляется ли оно первым в выражении или нет). Однако если int добавляется к другому int, он не превращает их в long, даже если результат может не уместиться в int.

Дополнительные пояснения

Меня спросили в комментариях, почему 1000 * 60 не совпадает с 60000 с точки зрения компилятора.

Ответ заключается в том, что компилятор будет обрабатывать целочисленный литерал как int (если это возможно), а int на этой платформе составляет 16 бит.

Таким образом, 1000 (int) * 60 (еще одно int) умножаются с использованием 16-битной арифметики, что дает результат, который переполняется.

Однако литерал 60000 не может быть сохранен как int, поэтому компилятор продвигает его до long (он же "long целое"). Поскольку он был повышен до long, он правильно сохраняется, и дальнейшие операции с 60000 будут выполняться с long арифметикой.

Я видел людей, кодирующих 60000 как 60000L, но это необязательно. Компилятор не настолько глуп, чтобы хранить 60000 как -5536, так как это явно не намерение программиста.