Переменные arduino. Типы данных и переменные в Arduino: полное руководство

Какие типы данных используются в Arduino. Как правильно объявлять и использовать переменные различных типов. Чем отличаются целочисленные, вещественные и символьные типы данных в Arduino.

Основные типы данных в Arduino

В Arduino используется несколько основных типов данных для хранения различной информации:

• Целочисленные типы (int, long, byte и др.) — для хранения целых чисел
• Вещественные типы (float, double) — для чисел с дробной частью
• Символьные типы (char) — для отдельных символов
• Логический тип (boolean) — для значений true/false

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

Целочисленные типы данных

Целочисленные типы используются для хранения целых чисел без дробной части. Основные целочисленные типы в Arduino:

• byte — 8 бит, диапазон 0-255
• int — 16 бит, диапазон -32768 до 32767
• long — 32 бита, диапазон -2147483648 до 2147483647

Пример объявления и использования переменных целочисленных типов:

byte sensorValue = 127; 
int counter = 1000;
long bigNumber = 100000;

counter = counter + 1; // Увеличение на 1

Вещественные типы данных

Вещественные типы позволяют хранить числа с дробной частью. В Arduino используются два основных вещественных типа:

• float — 32 бита, точность 6-7 десятичных знаков
• double — 32 бита на большинстве плат Arduino (64 бита на Due)

Пример использования вещественных типов:

float temperature = 25.5;
double pi = 3.14159265359;

temperature = temperature + 0.5; // Увеличение на 0.5 градуса

Символьный тип char

Тип char используется для хранения одиночных символов. Он занимает 1 байт памяти.

Пример использования типа char:

char grade = 'A';
char newline = '\n';

Логический тип boolean

Тип boolean используется для хранения логических значений true или false. Он удобен для работы с цифровыми пинами и условиями.

Пример использования boolean:

boolean ledOn = true;
boolean buttonPressed = false;

if (buttonPressed) {
  digitalWrite(LED_PIN, ledOn);
}

Модификаторы типов данных

Модификаторы позволяют изменять свойства базовых типов данных:

• unsigned — только положительные значения
• signed — положительные и отрицательные значения (по умолчанию)
• short — уменьшает размер типа
• long — увеличивает размер типа

Например:

unsigned long bigPositiveNumber = 4294967295;
short int smallNumber = 100;
 

Как выбрать правильный тип данных?

При выборе типа данных для переменной следует учитывать:

• Диапазон возможных значений переменной
• Требуемую точность для чисел с плавающей точкой
• Объем доступной памяти
• Скорость работы с различными типами данных

Правильный выбор типа позволит оптимизировать использование ресурсов микроконтроллера и избежать ошибок переполнения.

Объявление и инициализация переменных

Переменные в Arduino объявляются следующим образом:

тип имя_переменной;
тип имя_переменной = начальное_значение;

Например:

int count; 
float temperature = 25.5;
char grade = 'A';
boolean ledOn = false;

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

Область видимости переменных

В Arduino переменные могут иметь различную область видимости:

• Глобальные переменные — объявленные вне функций, доступны во всем скетче
• Локальные переменные — объявленные внутри функции, доступны только в ней

Пример:

int globalVar = 10; // Глобальная переменная

void setup() {
  int localVar = 5; // Локальная переменная
}

void loop() {
  globalVar++; // Доступна
  localVar++; // Ошибка! Не доступна
}

Константы в Arduino

Для объявления констант в Arduino используется ключевое слово const:

const float PI = 3.14159;
const int LED_PIN = 13;

Константы нельзя изменять в процессе выполнения программы. Их использование помогает сделать код более понятным и избежать случайных изменений важных значений.

Преобразование типов данных

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

int intValue = 65;
char charValue = (char)intValue; // Явное преобразование в char

float floatValue = 10.5;
int roundedValue = (int)floatValue; // Округление до целого числа

При преобразовании следует учитывать возможную потерю точности или переполнение, особенно при преобразовании из типов с большим диапазоном в типы с меньшим диапазоном.

Работа с массивами

Массивы позволяют хранить несколько значений одного типа. В Arduino массивы объявляются следующим образом:

тип имя_массива[размер];

Например:

int sensorValues[5]; // Массив из 5 целых чисел
float temperatures[] = {25.5, 26.7, 24.3}; // Инициализация массива

Доступ к элементам массива осуществляется по индексу, начиная с 0:

sensorValues[0] = 100;
float currentTemp = temperatures[1];

Типичные ошибки при работе с переменными

При работе с переменными в Arduino следует избегать следующих ошибок:

• Использование неинициализированных переменных
• Выход за границы массива
• Переполнение при работе с целочисленными типами
• Потеря точности при преобразовании типов
• Использование глобальных переменных там, где достаточно локальных

Внимательное отношение к типам данных и области видимости переменных поможет избежать многих ошибок при программировании Arduino.

Заключение

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

Типы переменных в Arduino IDE – RxTx.su

В этой статье мы рассмотрим

Тип данных переменной определяется при объявлении переменной. Чтобы объявить тип данных переменной, напишите тип данных перед именем переменной:

int variable;

Это объявляет переменную как int — целое число.

Используемый тип данных будет зависеть от размера и типа значения, которое будет храниться в переменной. А также определяет, какой объем памяти будет зарезервирован для переменной.

Тип данных int

Наиболее распространенным типом данных является целое число. Переменные, объявленные как int, могут содержать целые числа, такие как 5, 22 или

int variable = 9;

В этом примере мы объявляем переменную целочисленного типа int с именем variable и устанавливаем ее равной числу девять.

Целочисленные переменные используют два байта памяти, поэтому они могут содержать 2¹⁶ различных чисел (до 65 536). Но тип данных int может содержать положительные и отрицательные значения, поэтому диапазон фактически разделен между -32 768 и 32 767.

Существует также целочисленный тип данных без знака — unsigned int. Без знака означает, что число может содержать только положительные числа и ноль. Целочисленные переменные без знака занимают два байта памяти.

Чтобы объявить переменную unsigned int, используйте этот код:

unsigned int variable = 8;

Тип данных long

Тип данных long используется для хранения больших целых чисел. Переменные, объявленные как long, используют четыре байта памяти, поэтому они могут содержать до 2³² или 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

При объявлении переменной с 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 для каждого символа в следующей таблице:

Первый видимый символ в Ардуино начинается со значения 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.

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

Надеемся, эта статья помогла вам познакомиться с типами данных и тем, как они используются в программировании Arduino. Оставляйте комментарии ниже, если у вас есть какие-либо вопросы!

Урок 3. Переменные — Что и как строить на земельном участке или обо всем понемногу

Наконец добрались до одного из главных вопросов- переменные. Часть из них уже была описана в первом и втором уроках, настало время описать их все. Начнем по возрастанию.

Первый тип переменных, занимает 1 байт памяти и может принимать целые значения от 0 до 255. Им хорошо описывать  номера пинов и вообще любые переменные, значения которых находятся в данных пределах. Преимущества- занимает мало места, недостатки- слишком малый диапазон значений.

Записывается как byte n1=100;— переменной n1 типа byte присваивается значение 100.

Второй тип, занимает 1 байт памяти и может принимать только два значения- TRUE или FALSE. Очень удобен для переключения цифровых входов/ выходов в логические состояния.

Записывается как boolean run = false;— переменной run типа boolean присваивается значение false.

Третий тип, занимает 1 байт на знак, предназначен для написания текста в нормальном виде или посредством ASCII- кодов. Принимает значения от -128 до 127. 

Таблица ASCII- кодов.

Значение  Буква

0  null
1
2
3
4
5
6
7
8
9   tab	
10  line feed	
11
12
13 carriage return
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Значение Буква

32	space
33	!
34	"
35	#
36	$
37	%
38	&
39	'
40	(
41	)
42	*
43	+
44	,
45	-
46	.
47	/
48	0
49	1
50	2
51	3
52	4
53	5
54	6
55	7
56	8
57	9
58	:
59	;
60	<
61	=
62	>
63	?

Значение Буква

64	@
65	A
66	B
67	C
68	D
69	E
70	F
71	G
72	H
73	I
74	J
75	K
76	L
77	M
78	N
79	O
80	P
81	Q
82	R
83	S
84	T
85	U
86	V
87	W
88	X
89	Y
90	Z
91	[
92	\
93	]
94	^
95	_

Значение Буква

96	`
97	a
98	b
99	c
100	d
101	e
102	f
103	g
104	h
105	i
106	j
107	k
108	l
109	m
110	n
111	o
112	p
113	q
114	r
115	s
116	t
117	u
118	v
119	w
120	x
121	y
122	z
123	{
124	|
125	}
126	~
127

char myChar = ‘A’;

char myChar = 65; // обе записи эквивалентны — переменной myChar типа char присваивается значение A.

char errorMessage = «choose another option»;-  переменной errorMessage  присваивается значение choose another option.

Четвертый тип, это копия типа byte и в программировании предпочитают использовать именно тип byte. unsigned char используется крайне редко.

Записывается как unsigned char myChar = 240;— переменной myChar  типа unsigned char присваивается значение 240.

Пятый тип, записывается как int,  может принимать целые значения от -32768 до 32768.  Размер  integer-2 байта (кроме ARDUINO DUE, в нем INT занимает уже 4 байта но значения принимает от -2147483648 до 2147483647 ). Занимает мало места но диапазон гораздо выше чем у переменных типа byte.

Записывается как int n1=100;— переменной типа integer присваивается значение 100.

В нормальном виде тип integer отображается в десятичном виде, но можно отображать и в бинарном, восьмеричном, шестнадцатиричном коде. 1) + 1). Перед значением ставится 0x.

Кроме того константы типа integer можно преобразовывать в другие типы, если переменная не входит в диапазон integer:

•  ‘u’ или ‘U’ преобразовывает в формат unsigned data. Например: 33u
•  ‘l’  или ‘L’ преобразовывает в формат long. Например: 100000L
•  ‘ul’ или ‘UL’ преобразовывает в формат unsigned long. Например: 32767ul

Шестой тип, записывается как unsigned int, имеет размер 2 байта и принимает целые значения от 0 до 65535. В контроллере ARDUINO DUE занимает 4 байта и может принимать целые значения от 0 до 4294967295.

Записывается как unsigned int n1=100;— переменной n1 типа unsigned integer присваивается значение 100.

Седьмой тип, записывается так же, занимает 2 байта и принимает значения от 0 до 65535. Применяется редко, вместо него обычно используют unsigned integer.

Записывается как word w = 10000;— переменной w типа word присваивается значение 10000.

Восьмой тип, записывается так же, занимает 4 байта, принимает целые значения от -2147483648 до 2147483647.

Записывается как long var = 120000; переменной var типа long присваивается значение 120000.

Может использоваться в константах для преобразования типа integer в тип long, для этого в конце числа нужно дописать L и например

int n1=100000L; — преобразует  константу n1 типа integer в тип long и присваивает ей значение 100000.

unsigned long

Девятый тип, занимает как и long 4 байта но, в отличии от него, не может принимать отрицательные значения, хотя верхний предел выше в 2 раза. Принимает значения от 0 до 4294967295.

Записывается как unsigned long var = 120000;  переменной var типа unsigned long присваивается значение 120000.

short

Десятый тип, занимает 2 байта, принимает целые значения от -32768 до 32767.

Записывается как short var = 12000; переменной var типа short присваивается значение 12000.

 float

Одиннадцатый тип, занимает 4 байта, принимает значения с плавающей точкой в пределах от  -3.4028235E+38 до 3.4028235E+38.  Предпочтительно использовать тип double, вместо  float, тем более что занимает он такой же размер- 4 байта, т.к. этот тип выкидывает странные штуки, и если разделить 8.0/4.0, то это вовсе не означает что результат будет равен 2.0. Максимальная точность ограничивается 6-7 разрядами цифр вне зависимости от положения запятой.

Записывается как float var = 3.14157; переменной var типа float присваивается значение 3.14157.

double

Двенадцатый тип, занимает 4 байта (на ARDUINO DUE занимает 8 байт), не имеет ограничений по точности в сравнении с float, принимает значения с плавающей точкой в пределах от  -3.4028235E+38 до 3.4028235E+38.

Записывается как long var = 3.14157; переменной var типа long присваивается значение 3. 14157.

 string

Тринадцатый тип. Вообще то встречается 2 типа string- string array (текстовый массив) и String (текстовая переменная).

char Str3[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’, ‘\0’}; — объявляет массив из 8 разрядов с 0 до 7, недостающий 7 разряд- присваивается null.

String stringOne = «Hello String»; — переменной stringOne типа String присваивается значение Hello String.

array

Четырнадцатый тип. Массив.  Можно указывать размер массива в квадратных скобках. Счет начинается с 0, недостающим значениям присваивается null.

int mySensVals[6] = {2, 4, -8, 3, 2}; — массив значений integer.

Можно не указывать разрядность массива, компилятор ARDUINO сам посчитает элементы и выставит правильный размер начиная с 0.

int myPins[] = {2, 4, 8, 3, 6}; — аналогично записи int myPins[4] = {2, 4, 8, 3, 6};

Область применения:

Где же можно применять переменные и где можно обойтись без них.

Прежде всего стоит определиться- сколько раз будет использована переменная. Если она будет использоваться один раз то не стоит ее вводить, гораздо проще просто вставить формулу в то место где должна быть эта переменная. МК просто просчитает формулу и двинется дальше. Если же переменная будет использоваться несколько раз- лучше ввести ее в программу один раз и зарезервировать под нее память нежели МК будет несколько раз высчитывать одни и те же значения- этим вы повысите скорость работы. Еще один совет: при определении переменных желательно указывать в названии ее тип- так вы будете сразу определять какой тип переменной вы используете. Например:

Объявили переменную:

int n1=10000;

Когда вы будете писать программу вы каждый раз будете думать- а какой тип имеет переменная n1? Каждый раз придется искать в коде  где она объявлена, это занимает время и поднимает нервы, в конце концов где нибудь закрадется ошибка, опять отлаживать и т.д. Поэтому гораздо проще было бы написать:

int intn1=10000;

Три первых буквы уже указали ее тип- integer, можете сами определить для себя- указывать только первые буквы типов, например in1— что значит integer n1. Так будет гораздо проще и считается хорошим тоном в программировании.

Основные ошибки при работе с переменными:

• неправильное присваивание переменным одного типа значений другого типа. Например:

int x=12;

void loop{

x=«Hello String»; — Присваиваем переменной типа integer переменную типа String.

}

• Выход за пределы значений переменной. Например:

int x= 12568+50000; — максимальное значение integer 32768.

• Неправильное написание типа переменной. Например:

imt x= 12568; — imt вместо int.

Следующий урок>>

Arduino IDE: переменные — STEMpedia

Переменная используется для хранения значения или информации, чтобы мы могли обращаться к ней и/или манипулировать ею на более позднем этапе жизненного цикла эскиза Arduino. Память выделяется для хранения переменной, и переменной дается имя, которое позволяет нам получить к ней доступ в скетче.

Ниже приведены некоторые типы переменных, которые часто используются в скетчах Arduino:

Тип данных	Размер в байтах	Описание
char	1 байт	Он хранит 8-битное числовое значение ASCII символов, таких как алфавиты, символы и т. д. Он также может хранить число со знаком в диапазоне от -128 до 127. Символьные литералы записываются одинарными символами. кавычки, такие как «a», «#» и т. д., и их числовое значение ASCII хранится в соответствующем месте переменной.
беззнаковый символ	1 байт	Он может хранить 8-битные числовые значения ASCII символов, символов и т. д., а также может хранить любое число без знака в диапазоне от 0 до 255. Символьные литералы записываются в одинарных кавычках, таких как «a», «#» и т. д. их числовое значение ASCII хранится в соответствующем месте переменной.
int	2 байта	Хранит 2-байтовое (16-битное) целое число со знаком в диапазоне от -32 768 до 32 767.
целое число без знака
float	4 байта	Сохраняет 4-байтовое (32-разрядное) значение со знаком, которое является целым числом или значением с десятичной точкой (скажем, 12,15), которое находится в диапазоне от -3,4028235E+38 до 3,4028235E+38.
double	4 байта	То же, что и float для evive.

В Arduino есть и другие типы переменных. Нажмите здесь, чтобы узнать больше.

Стандартная форма определения переменной:

Variable_Datatype Variable_Name;

Variable_Datatype может быть int или float в зависимости от типа переменной, которую вы хотите. Variable_Name — это имя переменной. Переменная упоминается или используется по имени позже в программе.

При присвоении переменной типа и имени в памяти освобождается место для этой переменной.

если вы хотите подсчитать, сколько раз выполняется основной цикл, вы должны сначала определить переменную count как показано ниже:

int count;

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

1. Переменные могут состоять как из прописных (A-Z), так и из строчных (a-z) букв.
2. Переменные могут содержать числа от 0 до 9, но не могут начинаться с цифры.
3. Имена переменных могут не совпадать с ключевыми словами языка Arduino, например. у вас не может быть переменной с именем float.
4. Переменные должны иметь уникальные имена, т. е. у вас не может быть двух переменных с одинаковыми именами.
5. Имена переменных чувствительны к регистру, поэтому Count и count являются двумя разными переменными .
6. Переменные не могут содержать никаких специальных символов, кроме символа подчеркивания (_).

Вы можете присвоить значение переменной с помощью следующего оператора:

Имя_переменной = Выражение;

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

Давайте создадим новый скетч, где мы добавим две переменные float к новой переменной. Ниже приведен код:

Когда значение переменной отправляется в окно последовательного монитора,   println() автоматически округляет число до двух знаков после запятой, т. е. до количества знаков после запятой.

Во второй раз, когда println() используется для отправки значения переменной в окно последовательного монитора, количество десятичных разрядов указывается как 5 . Это делается путем передачи второго значения параметра 5 функции println() .

Какие типы переменных есть в Arduino?

Спиш Трешки:

• 1 Variables in Arduino
• 2 Computer programming with variables
• 3 Arduino – variables types
• 4 Void
• 5 Int
• 6 Char
• 7 Float
• 8 Double
• 9 Unsigned int
• 10 Short
• 11 Длинный без знака
• 12 Байт
• 13 Слово

Время чтения: 4 мин.

Переменные в Arduino

В программировании очень важен тип объявляемых переменных. От него зависит корректность кода, а также возможности переменной и, например, точность вычислений в программе, которую мы пишем. В этой статье представлены типы переменных, используемых при программировании в среде Arduino IDE.

Компьютерное программирование с переменными

Компьютеры, включая миниатюрные платформы для прототипирования, такие как Arduino, выполняют вычисления и логические операции с использованием процессора. В основе процессора и микроконтроллера лежит арифметико-логическое устройство (ALU), которое выполняет простые операции с ячейками в памяти , такие как сложение, вычитание и логическое произведение. Арифметико-логическое устройство не распознает, что представляют собой эти данные, даже несмотря на знания проектировщика или целевого пользователя. Данные, подлежащие арифметико-логическим операциям, нужны при выполнении расчетов на целых чисел, а также чисел с плавающей запятой .

Весь контекст для этих операций поступает от компилятора , а подсказки о контексте поступают компилятору от пользователя. Задача программиста, с другой стороны, состоит в том, чтобы сообщить компилятору, какое из значений, взятых для вычислений, является целым числом, а какое — числом с плавающей запятой. Таким образом, компилятор должен понимать, что мы имеем в виду, когда, например, хотим сложить два числа — одно целое, а другое — с плавающей запятой. В одних случаях это простая операция, а в других нет. Этот, казалось бы, простой процесс сложнее, чем может показаться , особенно если смотреть с точки зрения выполнения этих вычислений непосредственно человеком на листе бумаги или в памяти. По этой причине при вводе числовых данных в программу необходимо указывать тип переменной , присвоенной этому аргументу.

Arduino — типы переменных

Типы переменных используются для указания типов данных и связанных функций для обработки данных. Их указание используется для объявления функций и переменных, которые определяют битовый шаблон и объем памяти.

В среде разработки Arduino IDE используются следующие типы переменных, которые мы рассмотрим на примерах:

• void
• внутр.
• символ
• поплавок
• двойной
• целое число без знака
• короткий
• длинный
• длинное беззнаковое
• байт
• слово

Void

Тип данных void определяет пустой набор значений и используется только для объявления функций. Он используется в качестве возвращаемого типа для функций, которые не возвращают никакого значения. Рассмотрим следующий код:

 Плата Arduino UNO R3, тип данных int хранит значения размером до двух байт. Однако в случае плат Arduino Zero и Arduino MKR1000 на базе микроконтроллера SAMD21 и Arduino Due тип данных int хранит значения от 4 до 32 бит.  Следовательно, минимальный диапазон составляет от -(231) до ((231)-1) или от -2 147 483 648 до 2 147 483 647. Отрицательные числа хранятся в виде степеней двойки с натуральным показателем степени. Значение старшего бита (MSB) определяет знак числа. Рассмотрим следующий код:
 

 Любая переменная или идентификатор переменной становится целочисленной переменной и может хранить только целые числа. Рассмотрим следующий код:

 где:
 вар = переменная
 val = значение, присвоенное переменной
 Рассмотрим код:

 где:
 вар = переменная
 val = значение, присвоенное переменной var
 Рассмотрим код:

 Двойной 
 Тип данных double также используется для обработки десятичных чисел или чисел с плавающей запятой.  Занимает в два раза больше памяти , чем тип float. Он хранит числа с плавающей запятой  с более высокой точностью и диапазоном  . Тип double представляет числа с плавающей запятой двойной точности и занимает четыре байта на платах ATmega и UNO и 8 байтов на Arduino Due.