Академический Документы
Профессиональный Документы
Культура Документы
На этой странице представлен список всех (или почти всех) доступных “из коробки” команд для
Arduino с кратким описанием и примерами. Часть информации взята из Гугла, в основном
некоторые особенности языка, часть получена методом проб и ошибок. Полную информацию о том,
как этим пользоваться, можно получить из уроков или официального reference. Также изо всех сил
рекомендую вот этот онлайн справочник по C++, из него можно узнать гораздо больше о некоторых
особенностях использования операторов и типов данных.
А ещё у меня есть краткий сборник всех основных Ардуино-функций для печати! Смотри в этом
уроке.
Структура скетча
Синтаксис, структура кода
Условия (if, switch)
Циклы (for, while)
Операторы
Запятая ,
Арифметические
Сравнение и логика
Составные операторы
Битовые операции
Указатели и ссылки
Работа с данными
Типы данных, переменные
Структуры
Перечисления
Классы
Массивы
Строки (объект String)
Спецификаторы переменных
Преобразование типов данных
“Символьные” функции
Работа с цифрами
Целые и дробные числа
Математические функции и константы
Псевдослучайные числа
Биты и байты
Ввод-вывод
Цифровые пины
Аналоговые пины
Аппаратные прерывания
Генерация и обработка сигналов
Другое
Работа с Serial
Функции времени
Встроенные макро/константы
Утилиты
Работа с памятью
Другие операторы и слова
Разное
Квалификаторы и спецификаторы
Ковариантный возврат
Обработка исключений
Пространство имён
Полезные страницы
Структура скетча
Синтаксис, структура кода
/* */
Многострочный комментарий
/* этот код не
компилируется */
//
Однострочный комментарий
// этот код
// не компилируется
;
void setup() {}
Функция, содержимое которой выполняется один раз при запуске микроконтроллера. Подробнее
– в этом уроке.
void loop() {}
Функция, содержимое которой выполняется (или пытается выполняться) “по кругу” на протяжении
всего времени работы МК. Подробнее – в этом уроке.
#include
В чём отличие <> и “”? Когда указываем название “в кавычках”, компилятор сначала ищет файл
в папке со скетчем, а затем в папке с библиотеками. При использовании <галочек> компилятор
ищет файл только в папке с библиотеками
#define
При помощи условной компиляции очень удобно собирать и настраивать сложные проекты с
кучей настроек и библиотек, подключаемых “по условию”. Например:
#define DEBUG 1
void setup() {
#if (DEBUG == 1)
Serial.begin(9600);
Serial.println("Hello!");
#endif
}
Если параметру DEBUG установить 1, то будет подключена библиотека Serial, если 0 – то нет.
Таким образом получаем универсальный оптимизированный проект с отладкой. Подробнее – в
этом уроке.
#ifdef, #ifndef
goto
}
// еще код
}
}
bailout:
// перенеслись сюда
return
// сложные условия
if (myflag && myFlag2) c = 10; // если оба флага true
byte buttonState;
if (buttonState == 1) a = 10; // если buttonState 1
else if (buttonState == 2) a = 20; // если нет, но если buttonState 2
else a = 30; // если и это не верно, то вот
?
switch.. case
switch (val) {
case 1:
// выполнить, если val == 1
break;
case 2:
// выполнить, если val == 2
break;
default:
// выполнить, если val ни 1 ни 2
// default опционален
break;
}
Оператор break очень важен, позволяет выйти из switch. Но можно использовать так:
switch (val) {
case 1:
case 2:
case 3:
case 4:
// выполнить, если val == 1, 2, 3 или 4
break;
case 5:
// выполнить, если val == 5
break;
}
for
Цикл – “счётчик”. for (инициализация; условие; инкремент). Подробнее – в этом уроке.
Также используется для создания замкнутых циклов, т.к. настройки for необязательны. Выход
только через break или goto
while
while (a < b) {
// выполняется, пока a меньше b
}
Может быть использован для создания замкнутого цикла, выход только через break или goto
while (true) {
// крутимся в цикле вечно
}
do.. while
do {
// выполняется, пока a меньше b
} while (a < b);
continue
Выходит из цикла
Операторы
Запятая ,
Запятая тоже является оператором, используется в следующих случаях:
// присвоить 3 к b
// прибавить 1 к b
// приравнять к a
a = (b = 3, ++b); // a == 4
// объявить i и j
// прибавлять i+1 и j+2
for (byte i = 0, j = 0; i < 10; i++, j += 2) {
// тут i меняется от 0 до 9
// и j меняется от 0 до 18
}
Арифметические
Арифметические операторы – самые простые и понятные из всех
= присваивание
% остаток от деления
* умножение
/ деление
+ сложение
- вычитание
Большой урок по математическим действиям.
Сравнение и логика
== равенство (a == b)
!= неравенство (a != b)
>= больше или равно
<= меньше или равно
> больше
< меньше
! логическое НЕ, отрицание. Аналог – оператор not
&& логическое И. Аналог – оператор and
|| логическое ИЛИ. Аналог – оператор or
Подробный урок по сравнениям и условиям.
Составные операторы
++ (плюс плюс) инкремент: a++ равносильно a = a + 1
-- (минус минус) декремент: a — равносильно a = a – 1
+= составное сложение: a += 10 равносильно a = a + 10
-= составное вычитание: a -= 10 равносильно a = a – 10
*= составное умножение: a *= 10 равносильно a = a * 10
/= составное деление: a /= 10 равносильно a = a / 10
%= прибавить остаток от деления: a %= 10 равносильно a = a + a % 10
&= составное битовое И: a &= b равносильно a = a & b
^= составное исключающее ИЛИ: a ^= b равносильно a = a ^ b
|= составное ИЛИ: a |= b равносильно a = a | b
По битовым операциям читай отдельный урок. По математическим операциям у меня тоже есть
подробный урок.
Битовые операции
& битовое И
<< битовый сдвиг влево
>> битовый сдвиг вправо
^ битовое исключающее ИЛИ (аналогичный оператор – xor)
| битовое ИЛИ
~ битовое НЕ
По битовым операциям читай урок у меня на сайте.
Указатели и ссылки
& – возвращает адрес данных в памяти (адрес первого блока данных)
* – возвращает значение по указанному адресу
-> – оператор косвенного обращения к членам и методам (для указателей на структуры
и классы). Является короткой записью конструкции через указатель: a-
>b равносильно (*a).b
Подробнее об указателях и ссылках читайте в отдельном уроке.
Работа с данными
Типы данных, переменные
Переменная – элементарная ячейка для хранения данных (цифр). Переменные разных типов имеют
разный “размер ячейки” и имеют разный лимит на размер числа.
Альт.
Название Вес Диапазон Особенность
название
Логическая переменная.
boolean bool 1 байт 0 или 1, true или false bool на Arduino тоже
занимает 1 байт, а не бит!
int16_t,
int 2 байта -32 768… 32 767
short
unsigned uint16_t,
2 байта 0… 65 535
int word
unsigned
uint32_t 4 байта 0… 4 294 967 295 0… 4 миллиарда…
long
Хранит числа с
-3.4028235E+38… плавающей точкой
float - 4 байта
3.4028235E+38 (десятичные дроби).
Точность: 6-7 знаков
Существует еще несколько специальных типов данных для символов. Подробнее можно почитать
здесь.
wchar_t – 16 битный символ
char16_t – 2-х байтный char
char32_t – 4-х байтный char
Также есть такое понятие, как переопределение типов данных (не создавая новых типов), для этого
используется ключевое слово typedef. Typedef работает следующим образом: typedef <тип>
<имя>; – создать новый тип данных <имя> на основе типа <тип>. Пример:
Создаёт тип данных под названием color, который будет абсолютно идентичен типу byte (то есть
принимать 0-255). Теперь с этим типом можно создавать переменные:
color R, G, B;
Создали три переменные типа color, который тот же byte, только в профиль. Это всё!
Структуры
Структура (struct) – очень составной тип данных: совокупность разнотипных переменных,
объединённых одним именем.
struct <ярлык> {
<тип> <имя переменной 1>;
<тип> <имя переменной 2>;
<тип> <имя переменной 3>;
};
Ярлык будет являться новым типом данных, и, используя этот ярлык, можно объявлять уже
непосредственно саму структуру:
Также есть вариант объявления структуры без создания ярлыка, т.е. создаём структуру, не объявляя
её как тип данных со своим именем.
struct {
<тип> <имя переменной 1>;
<тип> <имя переменной 2>;
<тип> <имя переменной 3>;
} <имя структуры>;
Обращение к члену структуры производится вот по такой схеме: <имя структуры>.<имя
переменной> и позволяет менять или читать значение.
Если две структуры имеют одинаковую структуру (объявлены одним ярлыком) то можно
одну структуру просто приравнять к другой, все переменные запишутся соответственно на
свои места.
Ещё одним удобным вариантом является присваивание значения вот таким образом: <имя
структуры> = ( <ярлык> ) { <значение переменной 1>, <значение переменной 2>,
<значение переменной 3> };
Более подробно про структуры читай тут.
Перечисления
Перечисления (enum – enumeration) – тип данных, представляющий собой набор именованных
констант, нужен в первую очередь для удобства программиста.
Таким образом мы объявили ярлык. Теперь, используя этот ярлык, можно объявить само
перечисление:
Также как и у структур, можно объявить перечисление без создания ярлыка (зачем нам лишняя
строчка?):
Классы
Классы в С++ – это основной и очень мощный инструмент языка, большинство “библиотек”
являются классами. Иерархия такая:
Класс
Объект
Свойства и методы
Класс объявляется следующим образом:
class /*имя класса*/
{
private:
// список свойств и методов для использования внутри класса
public:
// список методов доступных другим функциям и объектам программы
protected:
// список средств, доступных при наследовании
};
Более подробно про работу с классами читай вот в этом уроке про классы.
Массивы
Для объявления массива достаточно указать квадратные скобки после имени переменной, тип
данных – любой. Более подробно про массивы читай в уроке.
// храним символы
char message[6] = "hello";
Строки можно сравнивать, складывать и вычитать, также для работы с ними есть куча функций:
charAt()
myString.charAt(index);
Возвращает элемент строки myString под номером index. Аналог – myString[index];
setCharAt()
myString.setCharAt(index, val);
Записывает в строку myString символ val на позицию index. Аналог – myString[index] = val;
compareTo()
myString.compareTo(myString2);
Возвращает отрицательное число, если myString идёт до myString2
Возвращает положительное число, если myString идёт после myString2
Возвращает 0, если строки одинаковы
concat()
myString.concat(value);
Присоединяет value к строке (value может иметь любой численный тип данных). Возвращает true
при успешном выполнении, false при ошибке. Аналог – сложение, myString + value;
endsWith()
myString.endsWith(myString2);
Проверяет, заканчивается ли myString символами из myString2. В случае совпадения
возвращает true
startsWith()
myString.startsWith(myString2);
Проверяет, начинается ли myString символами из myString2. В случае совпадения возвращает
true
equals()
myString.equals(myString2);
Возвращает true, если myString совпадает с myString2. Регистр букв важен
equalsIgnoreCase()
myString.equalsIgnoreCase(myString2);
Возвращает true, если myString совпадает с myString2. Регистр букв неважен
indexOf()
myString.indexOf(val);
myString.indexOf(val, from);
Ищет и возвращает номер (позицию) значения val в строке, ищет слева направо, возвращает
номер первого символа в совпадении. val может быть char или String, то есть ищем в строке
другую строку или символ. Можно искать, начиная с позиции from. В случае, когда не может
найти val в строке, возвращает -1.
lastIndexOf()
myString.lastIndexOf(val);
myString.lastIndexOf(val, from);
Ищет и возвращает номер (позицию) значения val в строке, ищет справа налево, возвращает
номер последнего символа в совпадении. val может быть char или String, то есть ищем в строке
другую строку или символ. Можно искать, начиная с позиции from. В случае, когда не может
найти val в строке, возвращает -1.
length()
myString.length();
Возвращает длину строки в количестве символов
remove()
myString.remove(index);
myString.remove(index, count);
Удаляет из строки символы, начиная с index и до конца, либо до указанного count
replace()
myString.replace(substring1, substring2);
В строке myString заменяет последовательность символов substring1 на substring2.
reserve()
myString.reserve(size);
Зарезервировать в памяти количество байт size для работы со строкой
c_str()
myString.c_str();
Преобразовывает строку в “СИ” формат (null-terminated string) и возвращает указатель на
полученную строку
trim()
myString.trim();
Удаляет пробелы из начала и конца строки. Действует со строкой, к которой применяется
substring()
myString.substring(from);
myString.substring(from, to);
Возвращает кусок строки, содержащейся в myString начиная с позиции from и до конца, либо до
позиции to
toCharArray()
myString.toCharArray(buf, len);
Раскидывает строку в массив – буфер buf (типа char []) с начала и до длины len
getBytes()
myString.getBytes(buf, len);
Копирует указанное количество символов len (вплоть до unsigned int) в буфер buf (byte [])
toFloat()
myString.toFloat();
Возвращает содержимое строки в тип данных float
toDouble()
myString.toDouble();
Возвращает содержимое строки в тип данных double
toInt()
myString.toInt();
Возвращает содержимое строки в тип данных int
toLowerCase()
myString.toLowerCase();
Переводит все символы в нижний регистр. Было ААААА – станет ааааа
toUpperCase()
myString.toUpperCase();
Переводит все символы в верхний регистр. Было ааааа – станет ААААА
Спецификаторы переменных
const – константа, такую переменную нельзя изменить (будет ошибка). const int val =
10;
static – позволяет объявить локальную переменную внутри функции, и эта переменная
не будет заново переобъявляться при повторном вызове функции. Эдакая локальная
глобальная переменная. Почитать
volatile – указывает компилятору, что переменную не нужно оптимизировать, что её
значение может меняться извне. Такой спецификатор должен быть применён к
переменным, которые меняют своё значение в прерывании. Почитать
extern – указывает компилятору, что эта переменная объявлена в другом файле
программы, но мы хотим пользоваться именно ей, а не создавать новую с таким же
именем в этом файле программы. Позволяет читать/записывать в переменные, созданные
в других файлах (библиотеках)!
Таким образом можно преобразовывать обычные переменные, указатели и другие типы данных.
toInt()
toFloat()
toCharArray()
Иногда можно встретить преобразование типов через оператор cast . Отличную статью можно
глянуть на Хабре, а я кратко опишу 4 основных каста:
“Символьные” функции
Все следующие функции принимают как аргумент символ (тип char), анализируют его и возвращают
true или false в зависимости от предназначения.
Работа с цифрами
Целые и дробные числа
Arduino поддерживает работу с целыми числами в разных системах исчисления:
8 (восьмеричная)
10 (десятичная)
0 (ноль)
нет
0175
100500
цифры 0 – 7
цифры 0 – 9
16 (шестнадцатеричная) 0x (ноль икс) 0xFF21A цифры 0-9, буквы A-F
long val;
val = 2000000000 + 6000000; // посчитает корректно (т.к. сложение)
val = 25 * 1000; // посчитает корректно (умножение, меньше 32'768)
val = 35 * 1000; // посчитает НЕКОРРЕКТНО! (умножение, больше 32'768)
val = (long)35 * 1000; // посчитает корректно (выделяем память (long) )
val = 35 * 1000L; // посчитает корректно (модификатор L)
val = 35 * 1000u; // посчитает корректно (модификатор u)
val = 70 * 1000u; // посчитает НЕКОРРЕКТНО (модификатор u, результат >
val = 1000 + 35 * 10 * 100; // посчитает НЕКОРРЕКТНО! (в умножении больше 32'768
val = 1000 + 35 * 10 * 100L; // посчитает корректно! (модификатор L)
val = (long)35 * 1000 + 35 * 1000; // посчитает НЕКОРРЕКТНО! Второе умножение всё порти
val = (long)35 * 1000 + (long)35 * 1000; // посчитает корректно (выделяем память (long)
val = 35 * 1000L + 35 * 1000L; // посчитает корректно (модификатор L)
Arduino поддерживает работу с числами с плавающей точкой (десятичные дроби). Этот тип данных
не является для неё “родным”, поэтому вычисления с ним производятся в несколько раз дольше,
чем с целочисленным типом (около 7 микросекунд на действие). Arduino поддерживает три типа
ввода чисел с плавающей точкой:
С вычислениями есть такая особенность: если в выражении нет float чисел, то вычисления будут
иметь целый результат (дробная часть отсекается). Для получения правильного результата нужно
писать (float) перед действием, или использовать float числа при записи. Смотрим:
float val;
val = 100 / 3; // посчитает НЕПРАВИЛЬНО (результат 3.0)
val = (float)100 / 3; // посчитает правильно (указываем (float))
val = 100.0 / 3; // посчитает правильно (есть число float)
val = 100 / 3.0; // посчитает правильно (есть число float)
Ну и напоследок, при присваивании float числа целочисленному типу данных дробная часть
отсекается. Если хотите математическое округление – его нужно использовать отдельно:
int val;
val = 3.25; // val принимает 3
val = 3.92; // val принимает 3
val = round(3.25); // val принимает 3
val = round(3.92); // val принимает 4
Ардуино - функции
Математические константы
Псевдослучайные числа
random(max) – возвращает случайное число в диапазоне от 0 до (max – 1)
random(min, max) – возвращает случайное число в диапазоне от min до (max – 1)
randomSeed(value) – дать генератору случайных чисел новую опорную точку для счёта.
value – любое число. Обычно при старте программы (в setup) подают значение с
неподключенного аналогового пина, получая таким образом 1024 набора случайных чисел
Подробный урок о случайных числах.
Биты и байты
Битовые операции – подробнее читай в отдельном уроке.
bit(val) – считает значение байта val по порядку (0 будет 1, 1 будет 2, 2 будет 4, 3
будет 8 и.т.д.)
bitClear(x, n) – устанавливает на 0 бит, находящийся в числе x под номером n
bitSet(x, n) – устанавливает на 1 бит, находящийся в числе x под номером n
bitWrite(x, n, b) – устанавливает на значение b (0 или 1) бит , находящийся в числе x
под номером n
bitRead(x, n) – возвращает значение бита (0 или 1), находящегося в числе x под
номером n
highByte(x) – извлекает и возвращает старший (крайний левый) байт переменной типа
word (либо второй младший байт переменной, если ее тип занимает больше двух байт).
lowByte(x) – извлекает и возвращает младший (крайний правый) байт переменной
(например, типа word).
bit_is_set(x, n) – проверка (возвращает 1 если включен) бита n в числе x
bit_is_clear(x, n) – проверка (возвращает 1 если выключен) бита n в числе x
loop_until_bit_is_set(x, n) – висеть в цикле (ждать), пока включен бит n в числе x
loop_until_bit_is_clear(x, n) – висеть в цикле (ждать), пока выключен бит n в числе
x
Ввод-вывод
Цифровые пины
pinMode(pin, mode)
Устанавливает режим работы пина pin (ATmega 328: D0-D13, A0-A5) на режим mode:
INPUT – вход (все пины сконфигурированы так по умолчанию)
OUTPUT – выход (при использовании analogWrite ставится автоматически)
INPUT_PULLUP – подтяжка к питанию (например для обработки кнопок)
Отдельный урок по цифровым пинам.
digitalRead(pin)
digitalWrite(pin, value)
Запускает генерацию ШИМ сигнала (отдельный урок про ШИМ) на пине pin со значением value.
Для стандартного 8-ми битного режима это значение 0-255, соответствует скважности 0-100%.
Подробнее о смене частоты и разрядности ШИМ смотрите в этом уроке. ШИМ пины:
ATmega 328/168 (Nano, UNO, Mini): D3, D5, D6, D9, D10, D11
ATmega 32U4 (Leonardo, Micro): D3, D5, D6, D9, D10, D11, D13
ATmega 2560 (Mega): D2 – D13, D44 – D46
Аналоговые пины
analogRead(pin)
Читает и возвращает оцифрованное напряжение с пина pin. АЦП на большинстве плат Arduino
имеет разрядность 10 бит, так что возвращаемое значение 0 – 1023 при напряжении 0 – опорное
на пине. Урок про аналоговые пины.
analogReference(mode)
Аппаратные прерывания
digitalPinToInterrupt(pin)
Согласно выбранной в ArduinoIDE плате возвращает номер прерывания согласно номеру пина
pin, таким образом можно объявить прерывания так: attachInterrupt(digitalPinToInterrupt(pin), ISR,
mode)
detachInterrupt(pin)
interrupts()
noInterrupts()
Генерировать звук частоты frequency (Герц) на пине pin. Опционально – делать это в течение
времени duration, миллисекунды. Может генерировать звук только на одном пине! Прежде, чем
начать делать это на другом, нужно отключить генерацию функцией noTone(pin). tone использует
системный Timer 2
noTone(pin)
Обрабатывает импульс на пине pin со значением value (HIGH или LOW) и возвращает его
продолжительность в микросекундах. Если value HIGH, функция ждёт, пока пин изменит
состояние с LOW на HIGH, и измеряет время до следующего включения на LOW. И наоборот.
Можно задать timeout таймаут ожидания импульса, по умолчанию 1 секунда.
Работает с импульсами от 10 мкс до 3 минут.
Осуществляет побитовый сдвиг и считывание байта данных, начиная с самого старшего (левого)
или младшего (правого) значащего бита. Процесс считывания каждого бита заключается в
следующем: тактовый вывод clockPin переводится в высокий уровень, считывается очередной
бит из линии данных dataPin, после чего тактовый вывод сбрасывается в низкий уровень.
bitOrder принимает MSBFIRST (начиная со старшего бита) или LSBFIRST (начиная с младшего
бита). Функция возвращает считанный байт.
Осуществляет побитовый сдвиг и вывод байта данных value, начиная с самого старшего (левого)
или младшего (правого) значащего бита. Функция поочередно отправляет каждый бит на
указанный пин dataPin вывода данных, после чего формирует импульс (высокий уровень, затем
низкий) на тактовом выводе clockPin, сообщая внешнему устройству о поступлении нового бита.
Примечание: Для взаимодействия с устройствами, тактируемыми по фронту импульсов,
перед вызовом shiftOut() необходимо убедиться, что тактовый вывод переключен в низкий
уровень, например с помощью функции digitalWrite(clockPin, LOW).
bitOrder принимает MSBFIRST (начиная со старшего бита) или LSBFIRST (начиная с младшего
бита)
Другое
Работа с Serial
Serial.begin(speed)
Запустить связь по Serial (читай отдельный урок про Serial) на скорости speed (baud rate, бит в
секунду). Список скоростей для монитора порта Arduino IDE:
300
1200
2400
4800
9600 чаще всего используется, можно назвать стандартной для большинства устройств
с связью через TTL
19200
38400
57600
115200 тоже часто встречается
230400
250000
500000
1000000
2000000
Serial.end()
Прекратить связь по Serial. Для УНО/НАНО (ATmega328) это позволяет освободить пины 0 и 1
для обычных целей (чтение/запись)
Serial.available()
Возвращает количество байт, хранящихся в буфере (объём буфера 64 байта) и доступных для
чтения
Serial.availableForWrite()
Отправляет в порт val численное значение или строку, или отправляет количество len байт из
буфера buf. Важно! Отправляет данные как байт (см. таблицу ASCII), то есть отправив 88 вы
получите букву X: Serial.write(88); выведет букву X
Отправляет в порт значение val – число или строку. В отличие от write выводит именно символы,
т.е. отправив 88 вы получите 88: Serial.print(88); выведет 88.
Serial.print(78); // выведет 78
Serial.print(1.23456); // 1.23 (умолч. 2 знака)
Serial.print('N'); // выведет N
Serial.print("Hello world."); // Hello world.
format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в
соответствующей системе исчисления, а цифра после вывода float позволяет настраивать
выводимое количество знаков после точки
Полный аналог print(), но автоматически переводит строку после вывода. Позволяет также
вызываться без аргументов (с пустыми скобками) просто для перевода строки
Serial.flush()
Serial.peek()
Возвращает текущий байт с края буфера, не убирая его из буфера. При вызове Serial.read() будет
считан тот же байт, но из буфера уже уберётся
Serial.read()
Читает и возвращает байт как код символа из таблицы ASCII. Если нужно вернуть цифру, делаем
Serial.read() – ‘0’;
Serial.setTimeout(time)
Устанавливает time (миллисекунды) таймаут ожидания приёма данных для следующих ниже
функций. По умолчанию равен 1000 мс (1 секунда)
Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать
длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
if (Serial.find(target))
Serial.println("found");
// вывести found, если было послано
}
}
Serial.findUntil(target, terminal)
Читает данные из буфера и ищет набор символов target (тип char) либо терминальную строку
terminal. Ожидает окончания передачи по таймауту, либо завершает приём после чтения
terminal
Serial.readBytes(buffer, length)
Читает данные из порта и закидывает их в буфер buffer (массив char [] или byte []), также
указывается количество байт, который нужно записать – length (чтобы не переполнить буфер)
Читает данные из порта и закидывает их в буфер buffer (массив char [] или byte []), также
указывается количество байт, который нужно записать – length (чтобы не переполнить буфер) и
терминальный символ character. Окончание приёма в buffer происходит при достижении
заданного количества length, при приёме терминального символа character (он в буфер не идёт)
или по таймауту
Serial.readString()
Читает буфер порта и формирует из данных строку String, которую возвращает. Заканчивает
работу по таймауту
Serial.readStringUntil(terminator)
Читает буфер порта и формирует из данных строку String, которую возвращает. Заканчивает
работу по таймауту или после приёма символа terminator (символ char)
Serial.parseInt(), Serial.parseInt(skipChar)
Читает целочисленное значение из буфера порта и возвращает его (тип long). Заканчивает
работу по таймауту. Останавливает чтение на всех знаках, кроме знака – (минус). Можно также
отдельно указать символ skipChar, который нужно пропустить, например кавычку-разделитель
тысяч (10’325’685), чтобы принять такое число
Serial.parseFloat()
Читает значение с плавающей точкой из буфера порта и возвращает его. Заканчивает работу по
таймауту
Функции времени
delay(time)
delayMicroseconds(time)
millis()
Возвращает количество миллисекунд, прошедших с запуска. Возвращает unsigned long (uint32_t),
от 1 до 4 294 967 295 миллисекунд (~50 суток), имеет разрешение 1 миллисекунда, после
переполнения сбрасывается в 0. Работает на системном таймере Timer 0. Читай урок по
функциям времени.
micros()
Встроенные макро/константы
INPUT , OUTPUT ,
0, 1 и 2 соответственно
INPUT_PULLUP
CHANGE , FALLING ,
1, 2 и 3 соответственно
RISING
Утилиты
sizeof(variable)
PROGMEM
Утилита позволяет на этапе загрузки скетча поместить данные (отдельные значения, массивы,
строки) во Flash память микроконтроллера и читать их во время работы, таким образом экономя
SRAM память. Пример использования:
void setup() {
Serial.begin(9600);
Serial.println(pgm_read_word(&(ints[2]))); // выведет 16843
Serial.println(pgm_read_float(&(floats[1]))); // выведет 120.25
// setup
Serial.println((int)pgm_read_word(&(ints[2]))); // выведет -16843
Также есть более удобный способ записывать и читать данные, реализован в библиотеках.
Смотреть тут
F() macro
Так называемая “F() macro” позволяет хранить строки во Flash памяти, не занимая место в SRAM.
Работает очень просто и эффективно, позволяя делать девайс с расширенным общением/
отладкой через Serial порт и не думать о забитой оперативке:
Работа с памятью
malloc() – выделение памяти
free() – освобождение памяти
new() – выделение памяти (полный аналог malloc)
delete() – освобождение памяти (полный аналог free)
memset() – заполняет блоки памяти по адресу
Читайте отдельный урок по работе с динамической памятью.
Ковариантный возврат
Почитать тут
override – модификатор
final – модификатор
Обработка исключений
Почитать можно тут и тут
try – попытка
throw – вызов исключения
catch – обработка исключения
Пространство имён
Почитать можно тут
Полезные страницы
Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у
проверенных продавцов
Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
Полная документация по языку Ардуино, все встроенные функции и макросы, все
доступные типы данных
Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры,
парсинг данных
Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из
самых подробных в рунете
Поддержать автора за работу над уроками
Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту
(alex@alexgyver.ru)