Глава 9. Основы программирования Arduino
Для всех, кого пугают сложные конструкции языков программирования, здесь приведено небольшое вступление в основы программирования на языке Arduino С. Вы скоро увидите, как можно просто и быстро написать собственные программы с небольшим числом команд. Все последующие проекты с платформой Arduino основаны на сведениях, приведенных в этой главе.
9.1. Биты и байты
На данный момент самая маленькая единица измерения информации в вычислительной системе — это бит. На английском языке двоичные числа обозначаются как binary digit (двоичная цифра). Так возникло искусственно образованное слово "бит" (Bit). Один бит может принимать только два значения: 0 или 1 (наличие или отсутствие электрического тока). Информация может представляться как последовательность из определенного числа битов.
В нашем случае 1 байт— это последовательность из 8 битов. Следовательно, один байт может представляться и интерпретироваться как 256 различных комбинаций. Половину байта, т. е. 4 бита, называют тетрадой или полубайтом:
4 бита = 1 полубайт = 1 тетрада 8 битов = 2 полубайта = 1 байт
Коэффициент пересчета между двоичными единицами измерения количества информации равен 1 024 (табл. 9.1). Исключение — преобразование бита в байт, т. к. при этом коэффициент пересчета равен 8. Эти некруглые числа возникают из-за того, что в информатике вычисления проводятся по основанию "2".
9.2. Базовая структура программы
Структура большинства программ очень сходна, поскольку широко используется процедурное программирование. Процедурное программирование состоит в разбиении компьютерных программ на небольшие частные задачи, которые обозначаются как процедуры (подпрограммы). Самый маленький и неделимый шаг при этом методе — это команда (оператор, инструкция). Программа выполняется последовательно от команды к команде. Сам термин "процедура" означает "продвигаться" и происходит от латинского слова "procedo". Программист приказывает микроконтроллеру при помощи программы, в какой последовательности нужно действовать. Цель этого принципа программирования — простота разработки и возможность повторного использования фрагментов (модулей) исходного кода.
9.2.1. Последовательное выполнение программы
При последовательном программировании код, состоящий из отдельных процедур, выполняется в цикле. На рис. 9.1 показано выполнение последовательности команд "ввод данных — обработка — вывод данных".
9.2.2. Прерывание выполнения программы
Иногда возникает необходимость прервать последовательное выполнение программы. Это выполняется с помощью прерываний (Interrupt). Основная часть программы выполняется, как и при последовательном программировании — бесконечный цикл, в котором повторяются отдельные процедуры. Как только произойдет внешнее или внутреннее прерывание, например, нажатие кнопки, основной цикл (Main-Loop) прервется и произойдет переход в программу обработки прерываний (Interrupt-Routine). В ней отрабатываются специальные задачи, например, аварийное отключение и т. п. Далее работа продолжается снова в основном цикле, где могут выполняться вспомогательные операции. Выполнение прерываний иллюстрирует рис. 9.2.
9.3. Структура программы Arduino
Программа Arduino состоит из следующих основных частей:
□ Комментарии и описание программы.
□ Заголовки файлов и подключенные библиотеки.
□ Объявление глобальных переменных.
□ Стандартная настройка void setup () (порты и конфигурация).
□ Основной ЦИКЛ void loop ().
□ Собственные процедуры.
Как мы увидим далее, соблюдать немногие основные правила программирования совсем не трудно. Следующий шаг — применение уже изученного материала для написания небольшой программы.
9.4. Первая программа с Arduino
Теперь создадим первую настоящую программу Arduino. В качестве упражнения можно просто перепечатать исходный текст листинга 9.1. Если и это делать не хочется, найдите исходный код на прилагаемом к книге компакт-диске в папке Beispiele\Erstes_Programm. Для выполнения программы потребуется Arduino-терминал.
Запустите терминальную программу после компилирования исходного кода и передачи в контроллер. Наша программа рассчитывает сумму двух чисел и выводит результат через терминал. После вывода результата начинает мигать светодиод L. С нажатием кнопки сброса программа запускается снова.
ЛИСТИНГ 9.1
// Franzis Arduino
// Первая программа Arduino, которую я сам составил :-)
int ledPin = 13; // Светодиод присоединяется к цифровому выводу 13
void setup() {
Serial.begin(9600); pinMode(ledPin, OUTPUT);
Serial.println("Unser erstes Arduino Programm"); Serial.println();
}
void loop {
Serial.print("Die Summe aus 5 + 188 lautet "); Serial.print(5+188);
while(true) {
digitaiwrite(ledPin, HIGH); delay(500);
digitaiwrite(ledPin, HIGH);
delay(500);
continue;
}
Программа иллюстрирует самые важные принципы последовательного алгоритма. Сначала контроллеру Arduino сообщается, что переменная ledpin должна содержать число 13. Затем выполняется установка начальных значений. Здесь указывается, к какому выводу присоединяется светодиод и задается скорость последовательного интерфейса, равная 9 600 бод. Установку завершает вывод информации через последовательный интерфейс.
Далее идет переход к основному циклу с именем loop (). В нем первая функция serial.print выводит текст, а вторая — сумму 5+188. Помните, что функция serial .printin после вывода осуществляет переход к левому краю с передачей управления на начало следующей строки (CR+LF), a serial.print — нет.
После вывода информации запускается бесконечный цикл while, обеспечивающий непрерывное мигание светодиода.
Совет
При написании текста программы обращайте внимание на правильный стиль оформления: выбор верхнего и нижнего регистра, добавление отступов, расстановку скобок и точек с запятой.
9.5. Команды Arduino и их применение
Тем, кто только начинает программирование с помощью Arduino, следует тщательно изучить этот раздел и опробовать приведенные примеры на практике до тех пор, пока все нюансы не будут поняты. По сути, это маленький учебный курс программирования с помощью Arduino на языке С, на котором базируются все последующие эксперименты.
9.5.1. Комментарии в исходном тексте
Чтобы правильно читать программу по прошествии определенного времени и понимать ее, необходимо тщательно и аккуратно документировать свой исходный код. Можно внедрять документацию прямо в исходный код. Для этого имеются разные символы комментариев, которые предназначены для включения обычных текстов (листинг 9.2). В среде разработки Arduino текст, снабженный комментарием, выделен серым цветом.
ЛИСТИНГ 9.2
/*
Я пишу
многострочный комментарий,
который становится все длиннее и длиннее ...
*/
А так комментарий выглядит еще лучше!
Примечание
Комментарии в коде программы значительно облегчают ее чтение через некоторое время. Подумайте, сможете ли вы вспомнить через год, что делали сегодня в программе?!
9.5.2. Фигурные скобки {}
Фигурные скобки выделяют фрагмент кода для компилятора. Блок кода всегда открывается символом { и завершается }. Между скобками располагаются команды.
ПРИМЕР
type Meine_Funktion() {
// В пределах скобок находятся команды }
9.5.3. Точка с запятой ;
Точка с запятой завершает команду. Если пропустить этот символ, компилятор Arduino выдаст сообщение об ошибке.
ПРИМЕР
Int х=42; // Здесь переменная х объявляется как Integer-переменная и ей задается число 42, точка с запятой завершает определение.
9.5.4. Типы данных и переменные
Каждая программа состоит из различных переменных, которые либо зависят от внешнего окружения (например, аналоговый или цифровой вход), либо требуются для расчета в программе и вывода результатов. В распоряжении программиста есть различные типы переменных: Byte (байт), integer (целое число), Long (длинное целое число) и Float (число с плавающей запятой). Тип переменной всегда нужно задавать перед ее применением.
9.5.5. Имя переменной
В среде разработки Arduino С имеется различие между верхним и нижним регистром символов имени переменной. В Arduino допускается подчеркивание _. Оно часто используется, чтобы сделать длинные имена переменной разборчивее. Ключевые слова (if, while, do и т.д.) не могут быть именами переменной. Имена глобальных переменных и функций не могут совпадать. Кроме того, не допускается одновременное задание функций и локальных переменных с одним и тем же именем.
9.5.6. Локальные и глобальные переменные
Если переменная объявляется в пределах функции, процедуры или как аргумент функции, она является локальной. Это значит, что переменная существует только внутри своей функции. Переменная, объявленная вне функции, является глобальной. Она определена для всех функций в пределах нашей программы.
ПРИМЕР
byte Variable; // Переменная типа Byte, она может принимать значения от 0 до 255
float PI = 3.1415; // Константа PI объявлена как Float
int myArray[9] // Массив Byte, объявлен состоящим
// из 10 элементов типа Int.
// К соответствующему элементу обращаются через // указатель: Var(x)
// Нумерация элементов массивов начинается с 0!
9.5.7. Различные типы данных
В следующих разделах показано, какие типы данных существуют и сколько при этом занимается памяти.
Boolean
Переменная типа Boolean может принимать два состояния: true (истина) или false (ложь). Такая переменная занимает 1 байт в памяти. Значение true соответствует логической единице, a false — это не логический нуль, как часто предполагают, а состояние, отличное от логической единицы.
boolean MeineWahrheit = true; // Переменная истинна
Byte
1 байт — это 8 бит, поэтому такая переменная может принимать значения от 0 до 255.
byte MeineVariable = 0; // Переменная здесь инициализируется нулевым значением
Char
Символ имеет размер 1 байт. Переменная char — это символ в одиночных кавычках, т. е. с апострофом. Если требуется строка из нескольких символов, то их заключают в двойные кавычки (например, "ПРИВЕТ"). Символ получает номер из набора символов ASCII. Например, буква "А" — это число 65. Символьные переменные могут принимать значения от -127 до +127.
char MeinCharakter = "А"; // Число 65
Unsigned Char
Символы без знака (unsigned char) ведут себя как символы со знаком, но они могут принимать только положительные значения в диапазоне от 0 до 255.
unsigned char = "В"; // Число 66
Int(lnteger)
Целое число (integer) состоит из двух байтов и может принимать значения от-32 768 до +32 768.
int MeineVariable = -32760; // Целая переменная со значением -32 760
Unsigned int
Тип unsigned integer охватывает переменные в диапазоне от 0 до 65 535 (216 - 1). В отличие от int тип unsigned int не имеет знака. Такая переменная занимает в памяти два байта.
int MeineVariable = 50000; /Г Целая переменная без знака со значением 50 000
Long
Переменная Long состоит из четырех байтов и может принимать значения от -2 147 483 648 до 2 147 483 647 (32 бита Long).
long MeineVariable = 10000000; // переменная Long со значением 10 000 000
Unsigned Long
Переменная unsigned Long состоит из четырех байтов и может принимать значения от 0 до 4 294 967 295 (32 бита Long). Переменная не имеет знака и может хранить только положительные значения.
unsigned long MeineVariable = 54544454544;//Очень, очень большая переменная
Float
Переменные Float могут хранить 32 бита значения со знаком. Диапазон принимаемых значений лежит в пределах от -3.4028235Е+38 до +3.4028235Е+38. Для этой переменной требуется четыре байта в памяти.
float MeineVariable = 100.42; // переменная Float со значением 100,42
String
Строковая переменная (string) — ЭТО массив (Array) переменных Char и нулевого символа.
Для каждого символа требуется, таким образом, один байт и в конце цепочки дополнительно еще один байт для нулевого символа. Таким образом, например, для слова "Hallo" требуется шесть байтов.
char MeineZeichenkette[] = "Hallo Welt"; // Требуется 11 байтов
Arrays
Массив (Arrays) — это упорядоченный набор переменных (рис. 9.3). В информатике массив обозначает структуру данных. С помощью массива данные, как правило, одинакового типа (Byte, int и т. д.) заносятся в память компьютера таким образом, что доступ к данным становится возможен через указатель. В языке Arduino массивы должны объявляться как данные типа integer. Нумерация элементов массива в Arduino начинается с нуля, в некоторых других компиляторах нумерация начинается с единицы. Кроме того, важно знать, что Arduino поддерживает в настоящее время только одномерные массивы. Пример работы с массивами приведен в листинге 9.3.
ЛИСТИНГ 9.3
// Franzis Arduino
// Arrays
int Array_1[3];
int Array_2[] = {1,2,3};
void setup()
{
Serial.begin(9600);
Serial.println("Arduino Arrays");
Serial.println();
}
void loop()
{
byte x;
Array_1[0] = 1;
Array_1[1] = 2;
Array_1[2] = 3;
Array_1[3] = 4;
Serial.println("Ausgabe Array 1 ");
Serial.println("----------------");
// Die Daten des ersten Arrays werden ausgeben
for(x=0;x<3;x++)
{
Serial.print(Array_1[x]);
Serial.println();
}
Serial.println("Ausgabe Array 2 ");
Serial.println("----------------");
// Die Daten des ersten Arrays werden ausgeben
Serial.print(Array_2[0]);
Serial.println();
Serial.print(Array_2[1]);
Serial.println();
Serial.print(Array_2[2]);
while(1);
}В первом массиве мы задаем размер "3". Таким образом, в этом массиве можно сохранять четыре переменные типа integer (16 бит). Размерность второго массива не указана и три его элемента заданы в фигурных скобках. Речь идет о динамическом массиве. В основном цикле мы назначаем элементам первого массива различные значения, в нашем случае 1, 2, 3, 4. Можете указать другие значения, чтобы лучше понять работу с массивами.
Переменная счетчика х цикла For содержит значение указателя массива для вывода значений в терминале. Значения элементов второго массива и указателя тоже выводятся в терминале.
Цикл while (1) представляет собой бесконечный цикл основной программы, поэтому достаточно ее однократного запуска.
9.5.8. Операторы
Каждому типу данных соответствуют свои операторы, которые указывают, какие операции могут применяться. Рассмотрим возможные операторы Arduino и их действие.
Арифметические операторы
= (присваивание).
+ (сложение).
- (вычитание).
* (умножение).
/ (деление).
% (деление по модулю — вычисление остатка от деления).
Операторы сравнения
== (равно, например а == в).
! = (не равно, например а ! = в).
< (меньше, например а < в).
> (больше, например а > в).
<= (меньше равно, например а <= в).
>= (больше равно, например а >= в).
Побитовая арифметика
& (битовое И).
| (битовое ИЛИ).
~ (битовое НЕ).
Булева арифметика
&& (логическое И, например, если выражение && Antwort_B истинно, тогда делать то-то).
|| (логическое ИЛИ, например, если выражение | | Antwort_B истинно, тогда делать то-то).
! (логическое отрицание, например, если выражение ! Antwort_B истинно, тогда делать то-то).
Увеличение и уменьшение значения
++ (инкремент, например i++, переменная i будет увеличена на единицу).
-- (декремент, например i—, переменная i будет на единицу меньше).
+= (присваивание с инкрементом, например i +=5, переменная i будет увеличена на 5 и результат присвоен переменной i).
-= (присваивание с декрементом, например i -=5, переменная i будет уменьшена на 5 и результат присвоен переменной i).
*= (присваивание с умножением, например i *= 2, переменная i будет умножена на 2 и результат присвоен переменной i).
/= (присваивание с делением, например i /= 2, переменная i будет разделена на 2 и результат присвоен переменной i)
Константы
Вот примеры констант:
HIGH / LOW (HIGH = 1, LOW = О).
INPUT/OUTPUT (INPUT = 0, OUTPUT = l).
true/false (true = 1, false != l).
9.5.9. Директива #define
Define — это директива препроцессора, которая запускается перед компилированием. Можно сказать, что речь идет о собственном маленьком компиляторе, который заранее преобразует команды #define в константы. Директива позволяет задавать постоянное значение переменной:
#define Variablel 1 // Без точки с запятой!
Здесь переменная variablel получает значение 1. Всякий раз, когда в программе встречается имя variablel, значение переменной заменяется на 1. Для нас эта замена неочевидна, но компилятор действует так, как описано. Тот, кто интересуется подробнее препроцессором и директивой #def ine, может найти более подробную информацию в Интернете
9.5.10. Управляющие конструкци
Для возможности реагировать на события (условия) каждой программе требуются, так называемые, управляющие конструкции. Они указываются в языке С с помощью управляющих операторов if. . . else-if. . . else ИЛИ switch case. В приведенных далее листингах вывод осуществляется через встроенную в Arduino терминальную программу. Загрузите примеры в плату микроконтроллера и запустите после этого терминальную программу, чтобы разобраться, что происходит
Оператор if
Листинг 9.4 иллюстрирует синтаксис, а листинг 9.5 — пример использования оператора if
ЛИСТИНГ 9.4
if (Variable А = Variable В) {
// Здесь находится код, который выполняется,
// когда А равно В }
ЛИСТИНГ 9.5
// Franzis Arduino // if..'.
int x;
void setup () {
Serial.begin(9600);
Serial.println("If Anweisungen");
Serial.println();
}
void loop() {
if(x==10) {
Serial.println("Die Variable X hat nun den Zaehlerstand 10!"); while(1);
}
x++;
Основной цикл void loop о выполняется до тех пор, пока переменная х типа integer не будет равна ю. Тело цикла составляют операторы между if и скобками {}. С помощью if можно реализовать простой способ передачи управления (разветвления в программе). Вы можете сами экспериментировать с другими операторами. Здесь допустимы логические операции ! =, <> и т. п.
if... else
Листинг 9.6 поясняет синтаксис, а листинг 9.7 — пример использования оператора if...else.
ЛИСТИНГ 9.6
if (Variable A > Variable B) {
// Код, который должен выполняться }
else // или когда А не больше В {
// Код, который должен выполняться }
ЛИСТИНГ 9.7
// Franzis Arduino // if... else...
int x;
void setup() {
Serial.begin(9600);
Serial.println("If und Else Anweisungen"); Serial.println();
}
void loop() {
if(x==10) {
Serial.println("Die Variable X hat nun den Zaehlerstand 10!"); while(1);
}
else {
Serial.print("X = "); Serial.print(x); Serial.println();
}
x++ ;
}
С конструкцией else можно реализовать различные альтернативные варианты. Программа выводит значение переменной х, пока оно не достигнет ю. Как только переменная х будет равна ю, запускается фрагмент программы между скобками else {}.
Возможность многократного чередования команд дает оператор else if. Здесь могут запрашиваться разные состояния переменных. В зависимости от логического значения (true или false) в условном операторе eise-if выполняется соответствующая ветвь программы. Синтаксис поясняет листинг 9.8.
ЛИСТИНГ 9.8
if(Variable A != Variable B)
{
// Код, который должен запускаться }
else if (Variable A == Variable B) {
// Код, который должен запускаться }
else (Variable A > Variable B) {
// Код, который должен запускаться }
ЛИСТИНГ 9.9
// Franzis Arduino
// Else If
int x;
void setup() {
Serial.begin(9600);
Serial.println("Else If Anweisungen"); Serial.println();
}
void loop()
{
if(x==42)
{
Serial.println("Die Variable X hat nun den Zaehlerstand 100 erreicht!");
while(1);
}
else if (x==10)
{
Serial .println ("Wir haben 10 erreicht");
}
else {
Serial .print("X = "); Serial.print(x); Serial.println();
}
X++; }
В листинге 9.9 в зависимости от значения переменной х выводится разный текст.
switch case
Конструкция switch case ведет себя подобно оператору else if. Здесь также в зависимости от логического значения соответствующего выражения будет выполнен соответствующий раздел кода. По умолчанию можно задать альтернативный вариант, при отсутствии соответствия условий внутри оператора case. Выход из оператора case осуществляется при помощи оператора break (листинг 9.10). Пример приведен в листинге 9.11.
ЛИСТИНГ 9.10
Switch( Variable )
{
case 1:
// Код, который должен запускаться переменной = 1
break;
case 2:
// Код, который должен запускаться переменной = 2
break;
default:
// Альтернативный код, если все другие условия не
// выполняются
}
ЛИСТИНГ 9.11
// Franzis Arduino
// Switch Case
int x;
void setup()
{
Serial.begin(9600);
Serial.println("Switch Case Anweisungen"); Serial.println();
}
void loop()
{
switch (x)
{
case 10:
Serial.println("Wir haben 10 erreicht"); break;
case 20:
Serial.println("Wir haben 20 erreicht"); break;
case 30:
Serial.println("Wir haben 30 erreicht"); while(1); break;
default: Serial.print("X = "); Serial.print(x); Serial.println();
}
x++;
}
В основном цикле значение переменной х увеличивается на единицу. При соответствии определенному условию в команде switch, в терминал будет выведено сообщение.
9.5.11. Циклы
При программировании часто требуются циклы, например, чтобы реализовать десятичный, двоичный счетчики или заставить программу бесконечное число раз повторять выполнение некоторого фрагмента. Цикл подходит также для организации чтения данных из последовательного интерфейса. Существуют несколько типов циклов. У каждого из них есть свои особенности, с которыми мы сейчас познакомимся.
for
Цикл for считает переменную вверх или вниз в пределах одного указанного диапазона значений. При этом может задаваться определенная величина приращения (инкремент). Листинг 9.12 иллюстрирует синтаксис цикла for, а листинг 9.13 — пример его использования.
ЛИСТИНГ 9.12
// Структура цикла for
for( Startbedingung ; Stoppbedingung ; Zahler erhohen )
{
// Блок программы
}
// Этот цикл считает от 0 до 10 с шагом 1
for( х = 0 ; х < 11 ; х++)
{
// Код, который должен выполняться 10 раз }
// Теперь значение переменной х увеличивается на 2
for( х = 0 ; х < 11 ; х=х+2)
{
// Код, который должен выполняться 10 раз
}
// Переменная х уменьшается с 10 до 1 (шаг 1) for( х = 10 ; х != 0 ; х--)
{
// Код, который должен выполняться 10 раз
}
ЛИСТИНГ 9.13
// Franzis Arduino
// For
int x;
void setup()
{
Serial.begin(9600);
Serial.println("For Anweisungen");
Serial.println();
}
void loop()
{
Serial.println("Schrittweite 1");
for(x=0;x<ll;x++)
{
Serial.print("X = ");
Serial.print(x);
Serial.println();
}
Serial.println (11 Schrittweite 2");
for(x= 0;x<11;x=x+2)
{
Serial.print("X = ");
Serial.print(x);
Serial.println();
}
Serial, print In ("Jetzt zaehlen wir von 10 mit Schrittweite 1 auf 1 herunter" );
for(x=10;x!=0;x-)
Serial.print("X = ");
Serial.print(x);
Serial.println();
}
// Конец программы!
while(1);
}
Программа содержит три цикла for и поясняет принцип работы посредством вывода показаний счетчика. Чтобы считать вплоть до 10, нужно указывать максимальное значение счетчика цикла, равным 11. Таким образом, цикл работает, пока значение счетчика меньше 11. Если задать максимальное значение равным 10, то цикл не отработает последний шаг.
while и do while
Еще два варианта цикла— это while и do while. Операторы в теле цикла do while выполняются один раз, затем проверяется условие окончания цикла. Следовательно, этот цикл выполнится, по меньшей мере, один раз. Оператор while часто применяется для организации бесконечных циклов. Тем не менее, цикл можно прервать при помощи оператора break. Если требуется проверить условие перед выполнением операторов цикла, то нужно использовать оператор while. Сначала производится проверка, а затем выполняются операторы тела цикла. Листинг 9.14 иллюстрирует синтаксис цикла while, а листинг 9.15 — пример его использования.
ЛИСТИНГ 9.14
// Бесконечные циклы
while(1) {
// При любых обстоятельствах здесь мы хотим действовать
}
// Бесконечные циклы при обусловленной отмене
while(1)
{
Variable++;
if( Variable > 10 ) break;
}
// While
While( Variable < 10 )
{
Variable++; }
//Do While
do
{
Variable++;
} while( Variable < 10 );
ЛИСТИНГ 9.15
// Franzis Arduino
//Do While
int X=0;
void setup()
{
Serial.begin(9600);
Serial.println("Do und Do While Prograram");
Serial.println();
}
void loop()
while(1)
{
x++;
Serial.print(X);
Serial.println();
if(X>9) break;
}
x=0 ;
Serial.println();
while(X<10)
{
x++;
Serial.print(x);
Serial.println();
}
x=0;
Serial.println();
//Do While
do
{
x++;
Serial.print(x);
Serial.println();
} while( X < 10 );
while(1);
9.5.12. Функции и подпрограммы
Вам очень часто потребуются функции. Они делают программу нагляднее, а также позволяют реализовать собственные команды. Вы можете создать свои функции и процедуры (подпрограммы без возвращаемого значения), которые потребуются снова и снова, и использовать их в будущих проектах (принцип модульного построения). Различие между функцией и процедурой (универсальное название sub Routine (подпрограмма)) состоит в том, что функция в противоположность процедуре возвращает значение. В функции может, например, выполняться математическое выражение, которое возвращает результат передаваемой переменной.
Подпрограмма
Листинг 9.16 иллюстрирует пример подпрограммы.
ЛИСТИНГ 9.16
// Franzis Arduino
// Arduino Sub-Routinen
void setup()
{
Serial.begin(9600);
Serial.println("Arduino Sub-Routinen");
Serial.println();
}
void loop()
{
Ausgabe1();
Ausgabe2();
while(1);
}
void Ausgabe1()
{
Serial.println("Ausgabe 1");
}
void Ausgabe2()
{
Serial.println("Ausgabe 2");
}
Функции
Функция — это блок кодов программы, у которых есть имя и ряд команд, которые запускаются при вызове функции. Примеры функций void setup () и void loop () уже встречались ранее. Существуют также встроенные функции, которые мы рассмотрим далее.
Писать собственные фу
