Какие типы данных доступны в Arduino. Как правильно объявлять и использовать переменные разных типов. Чем отличаются знаковые и беззнаковые целые числа. Как работать с числами с плавающей точкой.
Основные типы данных в Arduino
Arduino предоставляет разработчикам набор базовых типов данных для хранения и обработки различной информации. Понимание этих типов критически важно для эффективного программирования микроконтроллеров. Рассмотрим основные типы данных, доступные в Arduino:
- boolean — логический тип (true/false)
- char — символьный тип
- byte — 8-битное беззнаковое целое
- int — 16-битное целое со знаком
- unsigned int — 16-битное беззнаковое целое
- long — 32-битное целое со знаком
- unsigned long — 32-битное беззнаковое целое
- float — число с плавающей точкой
Каждый из этих типов предназначен для хранения определенного вида данных и имеет свои особенности использования. Разберем их подробнее.
Целочисленные типы данных
Целочисленные типы используются для хранения целых чисел без дробной части. В Arduino доступны следующие целочисленные типы:
int
Тип int занимает 2 байта (16 бит) и может хранить значения от -32768 до 32767. Это наиболее часто используемый целочисленный тип в Arduino. Пример объявления переменной типа int:
int temperature = 25;
int sensorValue = analogRead(A0);unsigned int
Беззнаковый целочисленный тип, также занимает 2 байта, но может хранить только положительные значения от 0 до 65535. Используется, когда не требуются отрицательные числа:
unsigned int counter = 0;
counter++;long
32-битное целое со знаком, позволяет хранить значения от -2147483648 до 2147483647. Используется для больших чисел:
long bigNumber = 1000000;
long milliseconds = millis();unsigned long
Беззнаковый 32-битный тип для очень больших положительных чисел от 0 до 4294967295:unsigned long veryBigNumber = 3000000000;
unsigned long runtime = millis();Символьные и логические типы данных
Кроме числовых, в Arduino есть типы для хранения символов и логических значений:
char
Тип char занимает 1 байт и используется для хранения одиночных символов:
char grade = 'A';
char newline = '\n';boolean
Логический тип для хранения значений true или false:
boolean isOn = true;
boolean buttonPressed = digitalRead(2);Числа с плавающей точкой
Для работы с дробными числами в Arduino используется тип float:
float
Тип float занимает 4 байта и позволяет хранить числа с дробной частью:
float pi = 3.14159; float voltage = 3.3;
Важно помнить, что операции с float выполняются медленнее, чем с целыми числами, поэтому их следует использовать только при необходимости.
Выбор подходящего типа данных
При выборе типа данных для переменной следует учитывать несколько факторов:
- Диапазон возможных значений
- Требуемая точность (для дробных чисел)
- Объем доступной памяти
- Скорость выполнения операций
Правильный выбор типа данных позволяет оптимизировать использование памяти и повысить производительность программы.
Объявление и инициализация переменных
Переменные в Arduino объявляются указанием типа данных и имени переменной. Инициализация (присвоение начального значения) может происходить как при объявлении, так и позже:
int count; // объявление
count = 0; // инициализация
float temperature = 22.5; // объявление и инициализацияХорошей практикой считается инициализация переменных при объявлении, чтобы избежать использования неопределенных значений.
Константы и модификатор const
Для значений, которые не должны изменяться в ходе выполнения программы, используются константы. В Arduino их можно объявить двумя способами:
#define PI 3.14159 // макрос-константа
const float pi = 3.14159; // константная переменнаяИспользование const предпочтительнее, так как оно обеспечивает типобезопасность и позволяет отлаживать код.
Преобразование типов данных
Иногда возникает необходимость преобразовать данные из одного типа в другой. В Arduino это можно сделать явным или неявным образом:
int intValue = 10;
float floatValue = intValue; // неявное преобразование
float pi = 3.14159;
int intPi = (int)pi; // явное преобразование, результат: 3При преобразовании следует помнить о возможной потере точности или переполнении.
Особенности работы с беззнаковыми типами
Беззнаковые типы (unsigned) могут хранить только неотрицательные значения, но имеют больший положительный диапазон. При работе с ними следует учитывать возможность переполнения:
unsigned int counter = 0;
counter--; // результат: 65535, а не -1Это поведение может быть полезным в некоторых алгоритмах, но также может привести к трудноуловимым ошибкам.
Оптимизация использования памяти
Микроконтроллеры Arduino имеют ограниченный объем памяти, поэтому важно оптимизировать ее использование. Вот несколько советов:
- Используйте наименьший подходящий тип данных
- Применяйте const для неизменяемых значений
- Используйте PROGMEM для хранения констант в программной памяти
- Освобождайте динамически выделенную память, когда она больше не нужна
Следуя этим рекомендациям, вы сможете эффективно использовать доступную память Arduino.
Работа с массивами
Массивы позволяют хранить несколько значений одного типа. В Arduino массивы объявляются следующим образом:
int temperatures[5]; // массив из 5 целых чисел
float voltages[] = {3.3, 5.0, 9.0}; // инициализация при объявленииПри работе с массивами важно помнить, что индексация начинается с 0, а выход за границы массива может привести к непредсказуемому поведению программы.
Типы данных | Arduino технологии
| Тип | Занимаемый размер (байт) | Минимальное значение | Максимальное значение |
|---|---|---|---|
| boolean | 1 | false | true |
| char | 1 | -128 | 127 |
| byte | 1 | 0 | |
| int, short | 2 | -32768 | 32767 |
| unsigned int | 2 | 0 | 65535 |
| long | 4 | -2147483648 | 2147483647 |
| unsigned long | 4 | 0 | 4294967295 |
| float, double | 4 | -3. 4028235E+38 | 3.4028235E+38 |
boolean
Логический тип, может принимать только 2 значения — true (правда) и false (ложь). В памяти занимает 1 байт.
bool a = true; a = false;
числа
char
Тип позволяет хранить 1 алфавитно-цифровой символ и занимае 1 байт. Для записи символа используются одинарные кавычки.
В памяти хранится число, соответствующее записанному символу в таблице ASCII, поэтому над переменной можно производить арифметические действия.
char a = 'A'; // число 65 по таблице ASCII a++; // число 66, соответствующее символу 'B' char b = 65; // тоже самое, что присвоить символ 'A'
Переменная это типа — знаковая, диапазон допустимых значений — от -128 до 127.
byte
Тип для хранения однобайтового целого беззнакового числа. Соответственно диапазон значений от 0 до 255.
byte x = 155;
int
Пожалуй самый частоиспользуемый тип для хранения целых чисел со знаком — integer (целое число).
Занимает 2 байта и может хранить цисла от -32768 до 32767.
На платформе Arduino также присутствует тип , который ничем не отличается от типа int.
int y = 10;
unsigned int
Беззнаковое целое число, занимает так же, как и int, 2 байта. Диапазон значений — от 0 до 65535.
long
Тип long служит для хранение больших целых знаковых чисел. Диапазон его значений от -2147483648 до 2147483647, а занимает в памяти он 4 байта.
unsigned long
Беззнаковое целое число расширенного диапазона может хранить значения от 0 до 4294967295 и занимает 4 байта.
float
Тип данных чисел с плавающей точкой (или с плавающей запятой). Используется для нецелочисленных расчетов. В Arduino используется например для считывания значений с аналоговых пинов. Диапазон значений от -3.4028235E+38 до 3.4028235E+38,а занимает такая переменная 4 байта.
Точность — 6-7 знаков после запятой.
double
Тип ничем не отличается от типа float и введен для обратной совместимости.
На многих других платформах он имеет большую чем у float точность.
string
Тип для хранение текстовых строк. Является массивом символов типа char и символа конца строки ‘\0’ в последнем его элементе. Не путать с классами string и String.
Строка может быть создана и инициализирована несколькими способами:
char str[7]; // объявление пустой строки с резервированием 7 символов - 6 под строку и последний - под символ завершения строки
char str[7] = "qwerty"; // объявление строки с инициализацией начальным значением
char str[7] = {'q', 'w', 'e', 'r', 't', 'y', '\0'}; // посимвольная инициализация
char str[] = "qwerty"; // более удобная инициализация без указания размера - он посчитается автоматические с учетом символа конца строки
Если забыть указать символ конца строки при посимвольной инициализации или не отвести под него место, то функции работы со строками будут работать некорректно.
массив
Массив — это набор элементов одного типа с доступом к каждому элементу по индексу.
int arr[6]; // объявление массива с выделением памяти под 6 элементов типа int
int arr[] = {1, 2, 3, 4, 5, 6}; // объявление массива с инициализацией его начальными значениями, при этом не обязательно указывать его размер, однако превышать его нельзя
char str[] = "qwerty"; // инициализация массива символов - строки
Нумерация индексов массива начинается с 0.
int arr[10]; arr[0] = 123; // пример присвоение значения первому элементу массива int b = arr[1]; // пример считывание значения из второго по счету элемента массива
void
Ключевое слово void используется при объявлении функции, которая не возвращает значения.
Преобразование типов
Преобразование типов — это приведение значение переменной к другому типа, отличному от типа данной переменной.
Приведение типов делится на явное и неявное.
Пример явного приведения типа:
float a = 7.5; int b = (int)a; // в переменную b будет записано значение переменной a, приведенной к целочисленному типу, то есть число 7
Пример неявного приведения типа:
int a = 1;
if (a) {
// код будет выполнен в случае ненулевого значения переменной a
}
Условная конструкция if принимает на вход значение типа boolean, поэтому целочисленное значение переменной a будет приведено к типа boolean.
Еще один пример явного приведения типа:
float res = (float)17 / 2; // в переменную res будет сохранение значение 8.5, тогда как без приведения к типу float в ней бы оказалось бы 8.0
Типы переменных в Arduino IDE – RxTx.su
В этой статье мы рассмотрим типы данных в Ардуино и как они используются в программировании. Типы данных важны для понимания, поскольку они определяют типы, которые могут хранить переменные.
Тип данных переменной определяется при объявлении переменной. Чтобы объявить тип данных переменной, напишите тип данных перед именем переменной:
int variable;
Это объявляет переменную как int — целое число.
Используемый тип данных будет зависеть от размера и типа значения, которое будет храниться в переменной.
А также определяет, какой объем памяти будет зарезервирован для переменной.
Тип данных int
Наиболее распространенным типом данных является целое число. Переменные, объявленные как int, могут содержать целые числа, такие как 5, 22 или 1023. Чтобы объявить переменную с типом int, объявите ее следующим образом:
int variable = 9;
В этом примере мы объявляем переменную целочисленного типа int с именем variable и устанавливаем ее равной числу девять.
Целочисленные переменные используют два байта памяти, поэтому они могут содержать 216 различных чисел (до 65 536). Но тип данных int может содержать положительные и отрицательные значения, поэтому диапазон фактически разделен между -32 768 и 32 767.
Существует также целочисленный тип данных без знака — unsigned int. Без знака означает, что число может содержать только положительные числа и ноль. Целочисленные переменные без знака занимают два байта памяти. Но поскольку они содержат только положительные значения, они могут содержать целые числа от 0 до 65 535.
Чтобы объявить переменную unsigned int, используйте этот код:
unsigned int variable = 8;
Тип данных long
Тип данных long используется для хранения больших целых чисел. Переменные, объявленные как long, используют четыре байта памяти, поэтому они могут содержать до 232 или 4 294 967 296 различных чисел. Но это число делится между положительными и отрицательными значениями (от -2 147 483 648 до 2 147 483 647).
Чтобы объявить переменную с типом данных long, используйте этот код:
unsigned long variable = 4;
Тип данных float
Типы данных long и int могут хранить только целые числа. Но что делать, если вам нужно сохранить значение с десятичной точкой или дробью?
Используйте типы данных float или double. Переменные float и double могут хранить положительные и отрицательные дробные числа. Они оба делают одно и то же, поэтому ключевые слова взаимозаменяемы. Они также оба используют 4 байта памяти. Значения, которые они могут хранить варьируются от 3,4028235E+38 до -3,4028235E+38.
При объявлении переменной с float или double число должно быть записано с десятичной точкой, иначе оно будет рассматриваться как целое число.
Следует иметь в виду, что математические операции выполняются намного медленнее с числами с плавающей точкой и двойными числами по сравнению с целыми числами. Следовательно, ваша программа будет работать быстрее, если вы сможете использовать целые числа вместо чисел с плавающей точкой.
Чтобы объявить переменную как число с плавающей запятой float, используйте этот код:
float variable = 8.123;
Логический тип данных boolean (true и false)
Иногда вам нужна переменная только для хранения двух значений. Например, когда вы считываете цифровой вывод или записываете состояние для светодиода, вам нужно сохранить только одно из двух значений: HIGH (оно же логическая 1, оно же — истина true) и LOW (оно же логический 0, оно же — ложь false).
boolean variable = HIGH; bool flag = 0;
Для этих типов переменных вы можете использовать логический тип данных. Логические переменные могут хранить только два возможных значения: true или false, HIGH или LOW и 1 или 0. Они используют только один байт памяти.
Тип данных char в Arduino
Используйте символьный тип данных char, если ваша переменная должна содержать только одну букву, цифру или символ. Тип данных char хранит символы ASCII, такие как a, b, c, 1, 2, 3, а также знаки *, % и $.
Символ ASCII может быть сохранен в переменной char и занимает только один байт данных.
Каждому символу ASCII присвоен уникальный номер. Вы можете найти значение ASCII для каждого символа в следующей таблице:
Таблица значений символов ASCII (нажмите на изображение для ее увеличения)Первый видимый символ в Ардуино начинается со значения 33, с символа ! и заканчивается значением 126, символом ~, поэтому символы после 126 в последовательном порту будут отображаться как ⸮
Таблица разбита на две колонки для каждого символа ASCII.
Столбец «Значение» соответствует числовому значению каждого символа, а столбец «символ» показывает фактический символ.
char variable = 'f';
Чтобы сохранить символ ASCII в переменной char, используйте одинарные кавычки вокруг символа при объявлении переменной. Например, чтобы сохранить символ доллара в переменной char, вы можете использовать этот код:
char variable = '$';
Чтобы сохранить значение символа ASCII в переменной, используйте номер ASCII без кавычек. Например, это сохранит символ собаки @ в переменной variable:
char variable = 64;
Использование числовых значений ASCII в переменных char позволяет выполнять арифметические действия с буквами.
Это иногда используется для перемещения значения по алфавиту.
Тип данных byte
Тип данных byte аналогичен типу данных unsigned char. Он может хранить положительные целые числа от 0 до 255. Он использует только один байт памяти, поэтому это хороший способ сэкономить место в программе, если вам нужно хранить небольшие значения, такие как номера контактов платы Ардуино, например.
byte variable = 255;
Модификатор переменной const
Модификатор переменной const не является типом данных, но он влияет на поведение переменной в программе Arduino. Ключевое слово const делает переменную постоянной. Как только постоянная переменная объявлена и установлена равной значению, она не может быть изменена позже в программе.
Модификатор const обычно используется для переменных, как номера выводов и математические константы. Значения, которые не будут изменяться в программе.
Объявление переменной как const делает ее доступной только для чтения, поэтому она не использует SRAM, что уменьшает размер вашей программы.
const int variable = 255;
В большинстве случаев вам может сойти с рук объявление переменных в виде целых чисел. Но использование идеального типа данных сэкономит память и позволит вашим программам работать быстрее и эффективнее.
Например, если вы знаете, что переменная никогда не будет хранить значение больше 255, было бы разумно объявить ее как byte вместо int.
Возможно вам будет полезна статья про типы переменных, их объявление и использование математических операций над переменными..jpg?1526326268034)
Надеемся, эта статья помогла вам познакомиться с типами данных и тем, как они используются в программировании Arduino. Оставляйте комментарии ниже, если у вас есть какие-либо вопросы!
Документация
- Даташит на Arduino NANO
- Даташит на Arduino UNO
- Даташит на Arduino MEGA
Компоненты
- Arduino NANO
- Arduino UNO
- Arduino MEGA
Урок 05: Понимание и использование переменных кода Arduino
Давайте обсудим мощную и довольно запутанную тему программирования — переменные. Переменные кода Arduino похожи на ведра. Вы выбираете, какие типы вещей вы хотите в ведре, и можете менять содержимое так часто, как вам нравится. Когда вы объявляете переменную, вы сообщаете программе две вещи: во-первых, какие типы вещей вы планируете поместить в ведро, и, во-вторых, какое имя у ведра, чтобы вы могли обратиться к нему позже.
Если вы скажете программе, что будете наливать жидкости в ведро, то вы можете весь день наполнять его пивом, водой и чаем со льдом, но как только вы попытаетесь наполнить его камнями, компилятор вызовет вы на вашем несоответствии.
В заявленном для жидкостей ведре идут только жидкости. Чтобы объявить переменную, вы пишете тип содержимого, которое она будет содержать, а затем имя:
флюидное ведроПеременная;
Обратите внимание, что в приведенном выше заявлении объявления слово «флюид» имеет другой цвет — это потому, что Arduino знает типы переменных данных — и они получают специальный цвет, чтобы уменьшить путаницу и, конечно же, потому что они крутые.
Существует несколько типов переменных типов данных, которые вы можете объявить. В этом уроке мы обсудим целочисленный тип данных.
Вы, наверное, знаете, что целое число — это целое число (без десятичных знаков). Для Arduino целое число — это число от -32 768 до 32 767. Если вы попытаетесь поместить большее число в целочисленную переменную, значение перевернется на противоположную сторону, как в игре Pac-Man. Если к 32 767 прибавить 5, получится – 32 764. Если из -32 768 вычесть 5, получится 32 763.
Целое число сокращается как целое.
Поскольку целое число является типом данных Arduino, оно изменит цвет на оранжевый.
int led;// целочисленная переменная с именем led.
Имя переменной может быть любым с некоторыми ограничениями. Есть также несколько хороших соглашений, которым нужно следовать…
- Имя переменной должно описывать ее функцию, например, переменная ledPin может быть номером вывода, к которому вы подключаете свой светодиод на плате Arduino.
- По соглашению большинство переменных начинаются с нижнего регистра.
- Имена переменных не могут совпадать с именами ключевых слов.
А что если мы захотим положить что-нибудь в ведро? Итак, мы присваиваем значение переменной. Когда мы впервые присваиваем значение, это называется инициализацией, и для этого мы используем знак равенства. Похоже на это.
вн.; //сначала объявляем переменную светодиод = 13; // теперь мы инициализируем переменную
Или мы можем инициализировать и объявить переменную одновременно…
инт светодиод = 13; //объявить и инициализировать переменную с помощью одного оператора
Теперь, если вы собираетесь инициализировать переменную (то есть присвоить ей значение для хранения) перед функцией setup() , то вы должны сделать все это в одной строке вот так:
int led = 13;
недействительная установка () {
} Или можно сделать так:
int led;
недействительная установка () {
светодиод = 13;
} Ну вот и все, что мы пока будем говорить о переменных.
Надеюсь, у вас есть общее представление о том, как они объявляются и инициализируются. 932 — 1).
Разница между целыми числами без знака и целыми числами со знаком заключается в способе интерпретации старшего бита, иногда называемого «знаковым» битом. В типе Arduino int (со знаком), если старший бит равен «1», число интерпретируется как отрицательное число, а остальные 15 бит интерпретируются с помощью (математика с дополнением до 2).
целое число без знака var = val;
целое число без знака ledPin = 13;
※ ПРИМЕЧАНИЯ И ПРЕДУПРЕЖДЕНИЯ:
Когда беззнаковые переменные превышают свою максимальную емкость, они «сбрасываются» обратно на 0, а также наоборот:
unsigned int x; х = 0; х = х — 1; // x теперь содержит 65535 — переворачивается в отрицательном направлении х = х + 1; // x теперь содержит 0 — перебрасывает
Математика с беззнаковыми переменными может привести к неожиданным результатам, даже если ваша беззнаковая переменная никогда не перекатывается.
MCU применяет следующие правила:
Вычисление выполняется в пределах целевой переменной. Например. если переменная назначения подписана, она будет выполнять математические операции со знаком, даже если обе входные переменные не имеют знака.
Однако при расчете, требующем промежуточного результата, объем промежуточного результата не определяется кодом. В этом случае MCU будет выполнять беззнаковые вычисления для промежуточного результата, потому что оба входа беззнаковые!
беззнаковое целое х = 5; беззнаковое целое у = 10; результат; результат = х — у; // 5 — 10 = -5, как и ожидалось результат = (х — у) / 2; // 5 — 10 в математике без знака равно 65530! 65530/2 = 32765 // решение: использовать переменные со знаком или выполнять расчет пошагово. результат = х — у; // 5 — 10 = -5, как и ожидалось результат = результат / 2; // -5/2 = -2 (только целочисленная математика, десятичные разряды опускаются)
Зачем вообще использовать беззнаковые переменные?
Желательно поведение при переворачивании, т.
