Какая команда позволяет воспользоваться математическими справочниками

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

#define MOTOR_PIN 10 // пин мотора 10 #define LED_PIN 3 // пин светодиода 3

После компиляции все встречающиеся в тексте программы слова MOTOR_PIN будут заменены на цифру 10, а LED_PIN – на цифру 3. Такой способ хранения констант не использует оперативную память микроконтроллера. Также define позволяет делать т.н. макро функции. Например Ардуиновская функция sq (квадрат) является макро, который при компиляции превращается в умножение:

#define sq(x) ((x)*(x))

#if, #elif, #else, #endif

Директивы препроцессору, позволяющие включать или исключать участки кода по условию

#define TEST 1 // определяем TEST как 1 #if (TEST == 1) // если TEST 1 #define VALUE 10 // определить VALUE как 10 #elif (TEST == 0) // TEST 0 #define VALUE 20 // определить VALUE как 20 #else // если нет #define VALUE 30 // определить VALUE как 30 #endif // конец условия

При помощи условной компиляции очень удобно собирать и настраивать сложные проекты с кучей настроек и библиотек, подключаемых “по условию”. Например:

#define DEBUG 1 void setup()

Если параметру DEBUG установить 1, то будет подключена библиотека Serial, если 0 – то нет. Таким образом получаем универсальный оптимизированный проект с отладкой. Подробнее – в этом уроке.

#ifdef, #ifndef

Условные директивы препроцессору, позволяют включать или исключать участки кода по условию: ifdef – определено ли? ifndef – не определено ли? Подробнее – в этом уроке.

#define TEST // определяем TEST #ifdef TEST // если TEST определено #define VALUE 10 // определить VALUE как 10 #else // если закоммент. #define TEST #define VALUE 20 // определить VALUE как 20 #endif // конец условия

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

for (byte r = 0; r < 255; r++) < for (byte g = 255; g >-1; g--) < for (byte b = 0; b < 255; b++) < if (analogRead(0) >250) < // уйти из сравнений goto bailout; >// еще код > > > bailout: // перенеслись сюда

Оператор прерывания функции, он же оператор возврата значения из функции. Подробнее – в этом уроке

Условия (if, switch)

if, else if, else

Оператор сравнения и его друзья. Подробнее – в этом уроке.

// при выполнения одного действия <> необязательны if (a > b) c = 10; // если a больше b, то c = 10 else c = 20; // если нет, то с = 20 // вместо сравнения можно использовать лог. переменную boolean myFlag, myFlag2; if (myFlag) c = 10; // сложные условия if (myflag && myFlag2) c = 10; // если оба флага true // при выполнении двух и более <> обязательны if (myFlag) < с = 10; b = c; >else < с = 20; b = a; >byte buttonState; if (buttonState == 1) a = 10; // если buttonState 1 else if (buttonState == 2) a = 20; // если нет, но если buttonState 2 else a = 30; // если и это не верно, то вот

Укороченная запись условия: (логика) ? правда : ложь. Подробнее – в этом уроке.

int с = (a > b) ? 10 : -20; // если a > b, то с = 10. Если нет, то с = -20 boolean flag = true; Serial.println( (flag) ? ("флаг поднят") : ("флаг опущен") );

switch.. case

Оператор выбора, заменяет конструкцию с else if. Подробнее – в этом уроке.

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, while)

Цикл – “счётчик”. for (инициализация; условие; инкремент). Подробнее – в этом уроке.

for (int i = 0; i < 10; i++) < a = i; // а примет значения от 0 до 9 на каждой итерации Serial.println(a); // вывод в порт >// для одного действия <> не нужны for (int i = 0; i < 10; i++) Serial.println(i); // вывод в порт

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

for (;;); // крутимся в цикле вечно

Цикл с предусловием. Подробнее – в этом уроке.

while (a < b) < // выполняется, пока a меньше b >

Может быть использован для создания замкнутого цикла, выход только через break или goto

while (true) < // крутимся в цикле вечно >

Цикл с постусловием. Подробнее – в этом уроке.

do < // выполняется, пока a меньше b >while (a < b);

Отличается от while тем, что гарантированно выполнится хотя бы один раз

Пропускает все оставшиеся в теле цикла действия и переходит к следующей итерации

Выходит из цикла

Операторы

Запятая ,

Запятая тоже является оператором, используется в следующих случаях:

• Перечисление элементов в массивах (урок про массивы)
• Перечисление аргументов в функциях (урок про функции)
• Выполнение последовательности действий (сделать это И это)

Рассмотрим третий случай здесь:

// объявить a и b и дать им значения int a = 5, b = 10; // присвоить 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

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

Работа с данными

Типы данных, переменные

Переменная – элементарная ячейка для хранения данных (цифр). Переменные разных типов имеют разный “размер ячейки” и имеют разный лимит на размер числа.

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

• wchar_t – 16 битный символ
• char16_t – 2-х байтный char
• char32_t – 4-х байтный char

Также есть такое понятие, как переопределение типов данных (не создавая новых типов), для этого используется ключевое слово typedef. Typedef работает следующим образом: typedef ; – создать новый тип данных на основе типа . Пример:

typedef byte color;

Создаёт тип данных под названием color, который будет абсолютно идентичен типу byte (то есть принимать 0-255). Теперь с этим типом можно создавать переменные:

color R, G, B;

Создали три переменные типа color, который тот же byte, только в профиль. Это всё!

Более подробно о переменных и данных можно почитать вот здесь.

Структуры

Структура (struct) – очень составной тип данных: совокупность разнотипных переменных, объединённых одним именем.

struct  < ; ; ; >;

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

 ; // объявить одну структуру , ; // объявить две структуры типа  [5]; // объявить массив структур

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

struct < ; ; ; > ;

• Обращение к члену структуры производится вот по такой схеме: . и позволяет менять или читать значение.
• Если две структуры имеют одинаковую структуру (объявлены одним ярлыком) то можно одну структуру просто приравнять к другой, все переменные запишутся соответственно на свои места.
• Ещё одним удобным вариантом является присваивание значения вот таким образом: = ( ) < , , >;

Более подробно про структуры читай тут.

Перечисления

Перечисления (enum – enumeration) – тип данных, представляющий собой набор именованных констант, нужен в первую очередь для удобства программиста.

Объявление перечисления чем-то похоже на объявление структуры:

enum , , , , >;

Таким образом мы объявили ярлык. Теперь, используя этот ярлык, можно объявить само перечисление:

Также как и у структур, можно объявить перечисление без создания ярлыка (зачем нам лишняя строчка?):

enum , , , , > ;

Созданное таким образом перечисление является переменной, которая может принимать указанные для неё , также с этими именами её можно сравнивать. Теперь самое главное: имена для программы являются числами, начиная с 0 и далее по порядку увеличиваясь на 1. В абстрактном примере выше равно 0, равно 1, равно 2, и так далее. Помимо указанных имён, перечислению можно приравнять и число напрямую, но как бы зачем.

Более подробно про перечисления читай тут.

Классы

Классы в С++ – это основной и очень мощный инструмент языка, большинство “библиотек” являются классами. Иерархия такая:

• Класс
• Объект
• Свойства и методы

Класс объявляется следующим образом:

class /*имя класса*/ < private: // список свойств и методов для использования внутри класса public: // список методов доступных другим функциям и объектам программы protected: // список средств, доступных при наследовании >;

Более подробно про работу с классами читай вот в этом уроке про классы.

Массивы

Для объявления массива достаточно указать квадратные скобки после имени переменной, тип данных – любой. Более подробно про массивы читай в уроке.

// указываем количество ячеек и всё, дальше можно с ними работать int myInts[6]; // указываем содержимое ячеек, компилятор сам посчитает их количество int myPins[] = ; // указываем и то и то, количество ячеек в [ ] должно совпадать с < >или быть больше! float Sens[3] = ; // храним символы char message[6] = "hello"; // помним, что порядок ячеек начинается с нуля! myInts[0] = 10; // записать 10 в ячейку 0 массива myInts

Строки (объект String)

String – очень мощный инструмент для работы со строками, т.е. текстовыми данными. Объявить строку можно несколькими способами:

String string0 = "Hello String"; // заполняем словами в кавычках String string1 = String("lol ") + String("kek"); // сумма двух строк String string2 = String('a'); // строка из символа в одинарных кавычках String string3 = String("This is string"); // конвертируем строку в String String string4 = String(string3 + " more"); // складываем строку string3 с текстом в кавычках String string5 = String(13); // конвертируем из числа в String String string6 = String(20, DEC); // конвертируем из числа с указанием базиса (десятичный) String string7 = String(45, HEX); // конвертируем из числа с указанием базиса (16-ричный) String string8 = String(255, BIN); // конвертируем из числа с указанием базиса (двоичный) String string9 = String(5.698, 3); // из float с указанием количества знаков после запятой (тут 3) // можно формировать название из кусочков, например для работы с файлами #define NAME "speed" #define TYPE "-log" #define EXT ".txt" // при сложении достаточно указать String 1 раз для первой строки String filename = String(NAME) + TYPE + EXT; // filename будет равна speed-log.txt // доступ к элементу строки работает по такому же механизму, как массив string1[0] = "a"; // теперь вместо Hello String у нас aello String

Подробнее про строки String и массивы символов читай в этом уроке.

Строки можно сравнивать, складывать и вычитать, также для работы с ними есть куча функций:

myString.charAt(index);

Возвращает элемент строки myString под номером index. Аналог – myString[index];

myString.setCharAt(index, val);

Записывает в строку myString символ val на позицию index. Аналог – myString[index] = val;

myString.compareTo(myString2);

• Возвращает отрицательное число, если myString идёт до myString2
• Возвращает положительное число, если myString идёт после myString2
• Возвращает 0, если строки одинаковы

myString.concat(value);

Присоединяет value к строке (value может иметь любой численный тип данных). Возвращает true при успешном выполнении, false при ошибке. Аналог – сложение, myString + value;

myString.endsWith(myString2);

Проверяет, заканчивается ли myString символами из myString2. В случае совпадения возвращает true

startsWith()

myString.startsWith(myString2);

Проверяет, начинается ли myString символами из myString2. В случае совпадения возвращает true

myString.equals(myString2);

Возвращает true, если myString совпадает с myString2. Регистр букв важен

equalsIgnoreCase()

myString.equalsIgnoreCase (myString2);

Возвращает true, если myString совпадает с myString2. Регистр букв неважен

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.

myString.length();

Возвращает длину строки в количестве символов

myString.remove(index);
myString.remove(index, count);

Удаляет из строки символы, начиная с index и до конца, либо до указанного count

myString.replace(substring1, substring2);

В строке myString заменяет последовательность символов substring1 на substring2.

String myString = "lol kek 4eburek"; // заменить чебурек на пельмень myString.replace("4eburek", "pelmen");

myString.reserve(size);

Зарезервировать в памяти количество байт size для работы со строкой

myString.c_str();

Преобразовывает строку в “СИ” формат (null-terminated string) и возвращает указатель на полученную строку

myString.trim();

Удаляет пробелы из начала и конца строки. Действует со строкой, к которой применяется

myString.substring(from);
myString.substring(from, to);

Возвращает кусок строки, содержащейся в myString начиная с позиции from и до конца, либо до позиции to

String myString = "lol kek 4eburek"; String chebur = myString.substring(8); // строка chebur содержит в себе "4eburek"

toCharArray()

myString.toCharArray(buf, len);

Раскидывает строку в массив – буфер buf (типа char []) с начала и до длины len

myString.getBytes(buf, len);

Копирует указанное количество символов len (вплоть до unsigned int) в буфер buf (byte [])

myString.toFloat();

Возвращает содержимое строки в тип данных float

myString.toDouble();

Возвращает содержимое строки в тип данных double

myString.toInt();

Возвращает содержимое строки в тип данных int

String myString = "10500"; int val = myString.toInt(); // val теперь 10500

toLowerCase()

myString.toLowerCase();

Переводит все символы в нижний регистр. Было ААААА – станет ааааа

toUpperCase()

myString.toUpperCase();

Переводит все символы в верхний регистр. Было ааааа – станет ААААА

Спецификаторы переменных

• const – константа, такую переменную нельзя изменить (будет ошибка). const int val = 10;
• static – позволяет объявить локальную переменную внутри функции, и эта переменная не будет заново переобъявляться при повторном вызове функции. Эдакая локальная глобальная переменная. Почитать
• volatile – указывает компилятору, что переменную не нужно оптимизировать, что её значение может меняться извне. Такой спецификатор должен быть применён к переменным, которые меняют своё значение в прерывании. Почитать
• extern – указывает компилятору, что эта переменная объявлена в другом файле программы, но мы хотим пользоваться именно ей, а не создавать новую с таким же именем в этом файле программы. Позволяет читать/записывать в переменные, созданные в других файлах (библиотеках)!

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

Переменные разных типов данных могут быть преобразованы в друг друга, для этого достаточно указать нужный тип данных в скобках перед преобразуемой переменной (тип_данных)переменная . Результат вернёт переменную с новым типом данных, сам же тип данной у переменной не изменится (работает в рамках одного действия):

// переменная типа byte byte val = 10; // передаём какой-то функции, которая ожидает int sendVal( (int)val );

Таким образом можно преобразовывать обычные переменные, указатели и другие типы данных.

И для строк мы уже рассматривали выше

• toInt()
• toFloat()
• toCharArray()

Иногда можно встретить преобразование типов через оператор cast . Отличную статью можно глянуть на Хабре, а я кратко опишу 4 основных каста:

• reinterpret_cast – приведение типов без проверки, непосредственное указание компилятору. Применяется только в случае полной уверенности программиста в собственных действиях. Не снимает const и volatile , применяется для приведения указателя к указателю, указателя к целому и наоборот;
• static_cast – преобразует выражения одного статического типа в объекты и значения другого статического типа. Поддерживается преобразование численных типов, указателей и ссылок по иерархии наследования как вверх, так и вниз. Преобразование проверяется на уровне компиляции и в случае ошибки приведения типов будет выдано сообщение;
• dynamic_cast – используется для динамического приведения типов во время выполнения. В случае неправильного приведения типов для ссылок вызывается исключительная ситуация std::bad_cast, а для указателей будет возвращен 0;
• const_cast – самое простое приведение типов. Снимает const и volatile , то есть константность и отказ от оптимизации компилятором переменной. Это преобразование проверяется на уровне компиляции и в случае ошибки приведения типов будет выдано сообщение.

Как пользоваться: на примере предыдущего примера

// переменная типа byte byte val = 10; // передаём какой-то функции, которая ожидает int sendVal( static_cast(val) );

Подробный урок по типам данных смотри тут.

“Символьные” функции

Все следующие функции принимают как аргумент символ (тип char), анализируют его и возвращают true или false в зависимости от предназначения.

• isAlpha(thisChar) – возвращает true, если thisChar – буква
• isAlphaNumeric(thisChar) – возвращает true, если thisChar – буква или цифра
• isAscii(thisChar) – возвращает true, если thisChar входит в таблицу ASCII
• isControl(thisChar) – возвращает true, если thisChar – контрольный символ
• isDigit(thisChar) – возвращает true, если thisChar – цифра
• isGraph(thisChar) – возвращает true, если thisChar – печатаемый знак (кроме пробела)
• isPrintable(thisChar) – возвращает true, если thisChar – печатаемый знак (включая пробел)
• isHexadecimalDigit(thisChar) – возвращает true, если thisChar цифра 0-9 или буква A-F
• isPunct(thisChar) – возвращает true, если thisChar – знак пунктуации
• isLowerCase(thisChar) – возвращает true, если thisChar – буква в нижнем регистре (маленькая)
• isUpperCase(thisChar) – возвращает true, если thisChar – буква в верхнем регистре (большая)
• isSpace(thisChar) – возвращает true, если thisChar – пробел
• isWhitespace(thisChar) – возвращает true, если thisChar – форматированный пробел (formfeed (‘\f’), newline (‘\n’), carriage return (‘\r’), horizontal tab (‘\t’), and vertical tab (‘\v’))

Работа с цифрами

Целые и дробные числа

Arduino поддерживает работу с целыми числами в разных системах исчисления:

ВАЖНО! Для арифметических вычислений по умолчанию используется ячейка long (4 байта), но при умножении и делении используется int (2 байта), что может привести к непредсказуемым результатам! Если при умножении чисел результат превышает 32’768, он будет посчитан некорректно. Для исправления ситуации нужно писать (тип данных) перед умножением, что заставит МК выделить дополнительную память для вычисления (например (long)35 * 1000). Также существую модификаторы, делающие примерно то же самое.

• u или U – перевод в формат unsigned int (от 0 до 65’535). Пример: 36000u
• l или L – перевод в формат long (-2 147 483 648… 2 147 483 647). Пример: 325646L
• ul или UL – перевод в формат unsigned long (от 0 до 4 294 967 295). Пример: 361341ul

Посмотрим, как это работает на практике:

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, результат > 65535) 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 val2 = 100; val = val2 / 3; // посчитает правильно (есть число 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

Математические функции и константы

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

Математические функции из math.h

Размеры типов данных

Ардуино - функции

Математические константы

Псевдослучайные числа

• 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)

Читает состояние пина pin и возвращает :

• 0 или LOW – на пине 0 Вольт (точнее 0-2.5В)
• 1 или HIGH – на пине 5 Вольт (точнее 2.5-опорное В)

digitalWrite(pin, value)

Подаёт на пин pin сигнал value:

• 0 или LOW – 0 Вольт (GND)
• 1 или HIGH – 5 Вольт (точнее, напряжение питания)

analogWrite(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)

Устанавливает режим работы АЦП согласно mode:

• DEFAULT: опорное напряжение равно напряжению питания МК
• INTERNAL: встроенный источник опорного на 1.1V для ATmega168 или ATmega328P и 2.56V на ATmega8
• INTERNAL1V1: встроенный источник опорного на 1.1V (только для Arduino Mega)
• INTERNAL2V56: встроенный источник опорного на 2.56V (только для Arduino Mega)
• EXTERNAL: опорным будет считаться напряжение, поданное на пин AREF

Как это влияет на работу? Значение 1023 функции analogRead() будет соответствовать опорному напряжению или выше его, соответственно поставив INTERNAL можно измерять напряжение от 0 до 1.1V с точностью (1.1 / 1023 ~ 1.2 мВ), напряжение выше 1.1V будет всегда 1023. После изменения источника опорного напряжения (вызова analogReference) первые несколько измерений могут быть нестабильными.

Нельзя использовать напряжение меньше 0V или выше 5V в качестве внешнего опорного в пин AREF. Также при использовании режима EXTERNAL нужно вызвать analogReference(EXTERNAL) до вызова функции analogRead(), иначе можно повредить микроконтроллер. Также можно подключить опорное в пин AREF через резистор на ~5 кОм, но так как вход AREF имеет собственное сопротивление в 32 кОм, реальное опорное будет например 2.5 * 32 / (32 + 5) = ~2.2V

Аппаратные прерывания

attachInterrupt(pin, ISR, mode)

Подключить прерывание (читай урок про прерывания) на номер прерывания pin, назначить функцию ISR как обработчик и установить режим прерывания mode:

• LOW – срабатывает при сигнале LOW на пине
• RISING – срабатывает при изменении сигнала на пине с LOW на HIGH
• FALLING – срабатывает при изменении сигнала на пине с HIGH на LOW
• CHANGE – срабатывает при изменении сигнала (с LOW на HIGH и наоборот)

Не все пины могут в прерывания:

digitalPinToInterrupt(pin)

Согласно выбранной в ArduinoIDE плате возвращает номер прерывания согласно номеру пина pin, таким образом можно объявить прерывания так: attachInterrupt(digitalPinToInterrupt(pin), ISR, mode)

detachInterrupt(pin)
Отключить прерывание на пине pin
interrupts()
Разрешить все прерывания (макрос на функцию sei() )
noInterrupts()
Запретить все прерывания (макрос на функцию cli() )

Генерация и обработка сигналов

tone(pin, frequency), tone(pin, frequency, duration)

Генерировать звук частоты frequency (Герц) на пине pin. Опционально – делать это в течение времени duration, миллисекунды. Может генерировать звук только на одном пине! Прежде, чем начать делать это на другом, нужно отключить генерацию функцией noTone(pin). tone использует системный Timer 2

noTone(pin)
Принудительно выключить генерацию звука на пине pin
pulseIn(pin, value), pulseIn(pin, value, timeout)

Обрабатывает импульс на пине pin со значением value (HIGH или LOW) и возвращает его продолжительность в микросекундах. Если value HIGH, функция ждёт, пока пин изменит состояние с LOW на HIGH, и измеряет время до следующего включения на LOW. И наоборот. Можно задать timeout таймаут ожидания импульса, по умолчанию 1 секунда.

Работает с импульсами от 10 мкс до 3 минут.

pulseInLong(pin, value), pulseInLong(pin, value, timeout)

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

Работает с импульсами от 10 мкс до 3 минут.

shiftIn(dataPin, clockPin, bitOrder)

Осуществляет побитовый сдвиг и считывание байта данных, начиная с самого старшего (левого) или младшего (правого) значащего бита. Процесс считывания каждого бита заключается в следующем: тактовый вывод clockPin переводится в высокий уровень, считывается очередной бит из линии данных dataPin, после чего тактовый вывод сбрасывается в низкий уровень. bitOrder принимает MSBFIRST (начиная со старшего бита) или LSBFIRST (начиная с младшего бита). Функция возвращает считанный байт.

shiftOut(dataPin, clockPin, bitOrder, value)

Осуществляет побитовый сдвиг и вывод байта данных 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. Для УНО/НАНО (ATmega328) это позволяет освободить пины 0 и 1 для обычных целей (чтение/запись)

Serial.available()
Возвращает количество байт, хранящихся в буфере (объём буфера 64 байта) и доступных для чтения
Serial.availableForWrite()

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

Serial.write(val), Serial.write(buf, len)

Отправляет в порт val численное значение или строку, или отправляет количество len байт из буфера buf. Важно! Отправляет данные как байт (см. таблицу ASCII), то есть отправив 88 вы получите букву X: Serial.write(88); выведет букву X

Serial.print(val), Serial.print(val, format)

Отправляет в порт значение 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. // можно сделать форматированный вывод в стиле Serial.print("i have " + String(50) + " apples"); // выведет строку i have 50 apples // вместо чисел можно пихать переменные byte appls = 50; Serial.print("i have " + String(appls) + " apples"); // выведет то же самое

format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в соответствующей системе исчисления, а цифра после вывода float позволяет настраивать выводимое количество знаков после точки

Serial.print(78, BIN); // вывод "1001110" Serial.print(78, OCT); // вывод "116" Serial.print(78, DEC); // вывод "78" Serial.print(78, HEX); // вывод "4E" Serial.print(1.23456, 0); // вывод "1" Serial.print(1.23456, 2); // вывод "1.23" Serial.print(1.23456, 4); // вывод "1.2345"

Serial.println(), Serial.println(val), Serial.println(val, format)

Полный аналог print(), но автоматически переводит строку после вывода. Позволяет также вызываться без аргументов (с пустыми скобками) просто для перевода строки

Serial.flush()
Ожидает окончания передачи данных
Serial.peek()

Возвращает текущий байт с края буфера, не убирая его из буфера. При вызове Serial.read() будет считан тот же байт, но из буфера уже уберётся

Serial.read()

Читает и возвращает байт как код символа из таблицы ASCII. Если нужно вернуть цифру, делаем Serial.read() – ‘0’;

Serial.setTimeout(time)

Устанавливает time (миллисекунды) таймаут ожидания приёма данных для следующих ниже функций. По умолчанию равен 1000 мс (1 секунда)

Serial.find(target), Serial.find(target, length)

Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту

// будем искать слово hello char target[] = "hello"; 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 (чтобы не переполнить буфер)

Serial.readBytesUntil(character, buffer, 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)

“Приостанавливает” выполнение кода на time миллисекунд. Дальше функции delay выполнение кода не идёт, за исключением прерываний. Использовать рекомендуется только в самых крайних или тех случаях, когда delay не влияет на скорость работы устройства. time принимает тип данных unsigned long и может приостановить выполнение на срок от 1 мс до ~50 суток (4 294 967 295 миллисекунд) с разрешением в 1 миллисекунду. Работает на системном таймере Timer 0. Читай урок по функциям времени.

delayMicroseconds(time)

Аналог delay(), приостанавливает выполнение кода на time микросекунд. Может приостановить выполнение на срок от 4 до 16’383 микросекунд с разрешением 4 микросекунды. Для бОльших периодов используйте delay(). Читай урок по функциям времени.

Возвращает количество миллисекунд, прошедших с запуска. Возвращает unsigned long (uint32_t), от 1 до 4 294 967 295 миллисекунд (~50 суток), имеет разрешение 1 миллисекунда, после переполнения сбрасывается в 0. Работает на системном таймере Timer 0. Читай урок по функциям времени.

Возвращает количество микросекунд, прошедших с запуска. Возвращает unsigned long (uint32_t), от 4 до 4 294 967 295 микросекунд (~70 минут), имеет разрешение в 4 микросекунды, после переполнения сбрасывается в 0. Работает на системном таймере Timer 0. Читай урок по функциям времени.

Встроенные макро/константы

Утилиты

sizeof(variable)

Возвращает вес переменной variable в байтах, работает с численными переменными всех типов, массивами, строками

// массивы разных типов byte arrayB[5]; int arrayI[5]; long arrayL[5]; float arrayF[5]; String myString = "lol kek"; // выводим суммарный вес массива Serial.println(sizeof(arrayB)); // вывод: 5 Serial.println(sizeof(arrayI)); // вывод: 10 Serial.println(sizeof(arrayL)); // вывод: 20 Serial.println(sizeof(arrayF)); // вывод: 20 Serial.println(sizeof(myString)); // вывод: 6 // выводим количество ячеек массива, разделив на вес одной Serial.println(sizeof(arrayB) / sizeof(arrayB[0])); // вывод: 5 Serial.println(sizeof(arrayI) / sizeof(arrayI[0])); // вывод: 5 Serial.println(sizeof(arrayL) / sizeof(arrayL[0])); // вывод: 5 Serial.println(sizeof(arrayF) / sizeof(arrayF[0])); // вывод: 5

Утилита позволяет на этапе загрузки скетча поместить данные (отдельные значения, массивы, строки) во Flash память микроконтроллера и читать их во время работы, таким образом экономя SRAM память. Пример использования:

// сохраняем несколько целых чисел const uint16_t ints[] PROGMEM = ; // сохраняем несколько десятичных дробей const float floats[] PROGMEM = ; // сохраняем несколько символов const char message[] PROGMEM = ; void setup() < Serial.begin(9600); Serial.println(pgm_read_word(&(ints[2]))); // выведет 16843 Serial.println(pgm_read_float(&(floats[1]))); // выведет 120.25 for (byte i = 0; i < 13; i++) Serial.print((char)pgm_read_byte(&(message[i]))); // выведет Hello! Lolkek >

Основная функция чтения из progmem – pgm_read_. Мы можем использовать вот эти 4:

• pgm_read_byte(data); – для 1-го байта (char, byte, int8_t, uint8_t)
• pgm_read_word(data); – для 2-х байт (int, word, unsigned int, int16_t, int16_t)
• pgm_read_dword(data); – для 4-х байт (long, unsigned long, int32_t, int32_t)
• pgm_read_float(data); – для чисел с плавающей точкой

Внимание! При чтении отрицательных (signed) чисел, нужно привести тип данных. Пример:

// сохраняем несколько целых с разными знаками const int16_t ints[] PROGMEM = ; // setup Serial.println((int)pgm_read_word(&(ints[2]))); // выведет -16843

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

Так называемая “F() macro” позволяет хранить строки во Flash памяти, не занимая место в SRAM. Работает очень просто и эффективно, позволяя делать девайс с расширенным общением/отладкой через Serial порт и не думать о забитой оперативке:

// данный вывод (строка, текст) занимает в оперативной памяти 18 байт Serial.println("Hello !"); // данный вывод ничего не занимает в оперативной памяти, благодаря F() Serial.println(F("Type /help to help"));

Работа с памятью

• malloc() – выделение памяти
• free() – освобождение памяти
• new() – выделение памяти (полный аналог malloc)
• delete() – освобождение памяти (полный аналог free)
• memset() – заполняет блоки памяти по адресу

Другие операторы и слова

Разное

• export – слово не используется (зарезервировано), читать тут
• virtual – спецификатор виртуальной функции, читать тут

• yield() – часть библиотеки Schelduer для создания “многопоточности”. Читать тут
• complex – комплексный класс. Читать тут
• explict – позволяет создать неконвертирующий конструктор
• union – объект “объединение”, читать тут
• friend – дружественные функции, читать тут
• NULL и null – пустые указатели

Квалификаторы и спецификаторы

• register – данный спецификатор указывает компилятору хранить значение переменной не в памяти, а в регистре процессора
• auto – не имеет смысла
• mutable – позволяет создать “неприкосновенный” объект

Ковариантный возврат

• override – модификатор
• final – модификатор

Обработка исключений

Почитать можно тут и тут

• try – попытка
• throw – вызов исключения
• catch – обработка исключения

Пространство имён

• namespace – создание пространства имён
• using – позволяет использовать имя из пространства имён без оператора ::

Полезные страницы

• Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
• Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
• Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
• Полная документация по языку Ардуино, все встроенные функции и макросы, все доступные типы данных
• Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
• Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
• Поддержать автора за работу над уроками
• Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту ([email protected])