Справочник функций arduino. Arduino — управляющие операторы

Этот симулятор лучше всего работает в браузере Chrome
Давайте рассмотрим Arduino по внимательней.

Arduino это не большой компьютер, к которому могут подключаться внешние цепи. В Arduino Uno используется Atmega 328P
Это самый большой чип на плате. Этот чип выполняет программы, которые хранятся в его памяти. Вы можете загрузить программу через usb с помощью Arduino IDE. Usb порт также обеспечивает питание arduino.

Есть отдельный разъём питания. На плате есть два вывода обозначенные 5v и 3.3v, которые нужны для того, чтобы запитывать различные устройства. Так же вы найдете контакты, помеченные как GND, это выводы земли (земля это 0В). Платформа Arduino, так же, имеет 14 цифровых выводов (пинов), помеченных цифрами от 0 до 13, которые подключаются к внешним узлам и имеют два состояния высокое или низкое (включено или выключено). Эти контакты могут работать как выходы или как входы, т.е. они могут либо передавать какие-то данные и управлять внешними устройствами, либо получать данные с устройств. Следующие выводы на плате обозначены А0-А5. Это аналоговые входы, которые могут принимать данные с различных датчиков. Это особенно удобно, когда вам надо измерить некий диапазон, например температуру. У аналоговых входов есть дополнительные функции, которые можно задействовать отдельно.

Как использовать макетную плату.

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

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

Два верхних и нижних ряда соединены по - рядно вдоль всей платы. Эти ряды используются, чтобы подавать питание на схему. Это может быть 5в или 3.3в, но в любом случае, первое, что вам надо сделать - это подключить 5в и GND на макетную плату, как показано на рисунке. Иногда эти соединения рядов могут прерываться посередине платы, тогда, если вам понадобится, вы можете их соединить, как показано на рисунке.

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

Первое, что мы подключим к нашему микроконтроллеру, это светодиод. Схема электрических соединений показана на картинке.

Для чего нужен резистор в схеме? В данном случае он ограничивает ток, который проходит через светодиод. Каждый светодиод рассчитан на определённый ток, и если этот ток будет больше, то светодиод выйдет из строя. Узнать, какого номинала должен быть резистор можно с помощью закона ома. Для тех кто не знает или забыл, закон ома говорит, что существует линейная зависимость тока от напряжения. Т.е, чем больше мы приложим напряжение к резистору, тем больше потечет через него ток.
V=I*R
Где V -напряжение на резистор
I - ток через резистор
R - сопротивление, которое надо найти.
Во-первых, мы должны узнать напряжение на резистор. Большинство светодиодов 3мм или 5мм, которые вы будете использовать, имеют рабочее напряжение 3в. Значит, на резисторе нам надо погасить 5-3=2в.

Затем мы вычислим ток, проходящий через резистор.
Большинство 3 и 5мм светодиодов светятся полной яркостью при токе 20мА. Ток больше этого может вывести их из строя, а ток меньшей силы снизит их яркость, не причинив никакого вреда.

Итак, мы хотим включить светодиод в цепь 5в,чтобы на нем был ток 20мА. Так как все детали включены в одну цепь на резистор тоже будет ток 20мА.
Мы получаем
2В = 20 мА * R
2В = 0.02A * R
R = 100 Ом
100 Ом это минимальное сопротивление, лучше использовать немного больше, потому, что светодиоды имеют некоторый разброс характеристик.
В данном примере используется резистор 220 Ом. Только потому, что у автора их очень много:wink: .

Вставьте светодиод в отверстия посередине платы таким образом, чтобы его длинный вывод был соединён с одним из выводов резистора. Второй конец резистора соедините с 5V, а второй вывод светодиода соедините с GND. Светодиод должен загореться.

Обратите внимание, что есть разница, как соединять светодиод. Ток течёт от более длинного вывода к более короткому. На схеме это можно представить, что ток течёт в ту сторону, куда направлен треугольник. Попробуйте перевернуть светодиод и вы увидите, что он не будет светиться.

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

Анатомия Arduino Sketch.

Программы для Arduino называют sketch. Они состоят из двух основных функций. Функция setup и функция loop
внутри этой функции вы будете задавать все основные настройки. Какие выводы будут работать на вход или выход, какие библиотеки подключать, инициализировать переменные. Функция Setup() запускается только один раз в течение скетча, когда стартует выполнение программы.
это основная функция, которая выполняется после setup() . Фактически это сама программа. Это функция будет выполняться бесконечно, пока вы не выключите питание.

Arduino мигает светодиодом

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

Эта функция используется в setup () части программы и служит для инициализации выводов, которые вы будете использовать, как вход (INPUT) или выход (OUTPUT) . Вы не сможете считать или записать данные с пина, пока не установите его соответственно в pinMode . Эта функция имеет два аргумента: pinNumber - это номер пина, который вы будете использовать.

Mode -задает, как пин будет работать. На вход (INPUT) или выход (OUTPUT) . Чтобы зажечь светодиод мы должны подать сигнал ИЗ Arduino. Для этого мы настраиваем пин на выход.
- эта функция служит для того, чтобы задать состояние (state) пина (pinNumber) . Есть два основных состояния (вообще их 3), одно это HIGH , на пине будет 5в, другое это Low и на пине будет 0в. Значит, чтобы зажечь светодиод нам надо на пине, соединенном со светодиодом выставить высокий уровень HIGH .

Задержка. Служит для задержки работы программы на заданный в мсек период.
Ниже приведен код, который заставляет мигать светодиод.
//LED Blink int ledPin = 7;//пин Arduino к которому подключен светодиод void setup() { pinMode(ledPin, OUTPUT);// установка пина как ВЫХОД } void loop() { digitalWrite(ledPin, HIGH);//зажечь светодиод delay(1000);// задержка 1000 мсек (1 сек) digitalWrite(ledPin, LOW);//Выключить светодиод delay(1000);//ждать 1 сек }

Небольшие пояснения по коду.
Строки, которые начинаются с "//" это комментарии Arduino их игнорирует.
Все команды заканчиваются точкой с запятой, если вы их забудете, то получите сообщение об ошибке.

ledPin - это переменная. Переменные используются в программах для хранения значений. В данном примере переменной ledPin присваивается значение 7, это номер пина Arduino. Когда Arduino в программе встретит строку с переменной ledPin , он будет использовать то значение, которое мы указали ранее.
Так запись pinMode(ledPin, OUTPUT) аналогична записи pinMode(7, OUTPUT) .
Но в первом случае вам достаточно поменять переменную и она поменяется в каждой строке, где используется, а во втором случае вам, чтобы поменять переменную, придётся ручками в каждой команде вносить изменения.

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

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

Управление несколькими светодиодами.

В этом примере вы узнаете, как управлять несколькими светодиодами. Для этого установите ещё 3 светодиода на плату и соедините их с резисторами и выводами Arduino, как показано ниже.

Для того, чтобы включать и выключать светодиоды по очереди надо написать программу подобную этой:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() { //установка пинов как ВЫХОД pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); } void loop() { digitalWrite(led1Pin, HIGH);//зажечь светодиод delay(1000);//задержка 1 сек digitalWrite(led1Pin, LOW);//потушить светодиод delay(1000);//задержка 1 сек //do the same for the other 3 LEDs digitalWrite(led2Pin, HIGH);//зажечь светодиод delay(1000);// задержка 1 сек digitalWrite(led2Pin, LOW);//потушить светодиод delay(1000);//задержка 1 сек digitalWrite(led3Pin, HIGH);//зажечь светодиод delay(1000);// задержка 1 сек digitalWrite(led3Pin, LOW);//потушить светодиод delay(1000);//задержка 1 сек digitalWrite(led4Pin, HIGH);//зажечь светодиод delay(1000);// задержка 1 сек digitalWrite(led4Pin, LOW);//потушить светодиод delay(1000);//задержка 1 сек }

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

DigitalWrite (led4Pin, HIGH); delay (1000); digitalWrite (led4Pin, LOW); delay (1000);
полный код скетча во вложении (скачиваний: 1384)

Регулировка яркости светодиодов

Иногда вам надо будет менять яркость светодиодов в программе. Это можно сделать с помощью команды analogWrite() . Эта команда так быстро включает и выключает светодиод, что глаз не видит это мерцание. Если светодиод половину времени будет включён, а половину выключен, то визуально будет казаться, что он светится в половину своей яркости. Это называется широтно-импульсная модуляция (ШИМ или PWM по-английски). Шим применяется довольно часто, так как с ее помощью можно управлять "аналоговым" компонентом с помощью цифрового кода. Не все выводы Arduino подходят для этих целей. Только те выводы, около которых нарисовано такое обозначение "~ ". Вы увидите его рядом с выводами 3,5,6,9,10,11.
Соедините один из ваших светодиодов с одним из выводов ШИМ(у автора это вывод 9). Теперь запуститьскетч мигания светодиода, но прежде измените команду digitalWrite() на analogWrite() . analogWrite() имеет два аргумента: первый это номер вывода, а второй- значение ШИМ (0-255), применительно к светодиодам это будет их яркость свечения, а для электродвигателей скорость вращения. Ниже представлен код примера для разной яркости светодиода.
//Меняем яркость светодиода int ledPin = 9;//к этому выводу подсоединен светодиод void setup() { pinMode(ledPin, OUTPUT);// инициализация пина на вывод } void loop() { analogWrite(ledPin, 255);//полная яркость (255/255 = 1) delay(1000);// пауза 1 сек digitalWrite(ledPin, LOW);//выключить светодиод delay(1000);//пауза 1 сек analogWrite(ledPin, 191);//яркость на 3/4 (191/255 ~= 0.75) delay(1000);//пауза 1 сек digitalWrite(ledPin, LOW);//выключить светодиод delay(1000);//пауза 1 сек analogWrite(ledPin, 127);//половина яркости (127/255 ~= 0.5) delay(1000);// пауза 1 сек digitalWrite(ledPin, LOW);//выключить светодиод delay(1000);//пауза 1 сек analogWrite(ledPin, 63);//четверть яркости (63/255 ~= 0.25) delay(1000);// пауза 1 сек digitalWrite(ledPin, LOW);//выключить светодиод delay(1000);//пауза 1 сек }

Попробуйте поменять значение ШИМ в команде analogWrite () ,чтобы увидеть, как это влияет на яркость.
Далее вы узнаете, как регулировать яркость плавно от полной до нулевой. Можно,конечно, скопировать кусок кода 255 раз
analogWrite(ledPin, brightness); delay(5);//short delay brightness = brightness + 1;
Но, сами понимаете - это будет не практично. Для этого лучше всего использовать цикл FOR, который использовали ранее.
В следующем примере используются два цикла, один для уменьшения яркости от 255 до 0
for (int brightness=0;brightness=0;brightness--){ analogWrite(ledPin,brightness); delay(5); }
delay(5) используется, чтобы замедлить скорость нарастания и уменьшения яркости 5*256=1280 мсек= 1.28 сек.)
В первой строке используется "brightness- " ,для того чтобы значение яркости уменьшалось на 1, каждый раз, когда цикл повторяется. Обратите внимание, что цикл будет работать до тех пор, пока brightness >=0 .Заменив знак > на знак >= мы включили 0 в диапазон яркости. Ниже смоделирован этот скетч. //плавно меняем яркость int ledPin = 9;//к этому пину подключен светодиод void setup() { pinMode(ledPin, OUTPUT);// инициализация пина на выход } void loop() { //плавно увеличиваем яркость (0 to 255) for (int brightness=0;brightness=0;brightness--){ analogWrite(ledPin,brightness); delay(5); } delay(1000);//ждем 1 сек //плавно уменьшаем яркость (255 to 0) for (int brightness=255;brightness>=0;brightness--){ analogWrite(ledPin,brightness); delay(5); } delay(1000);//ждем 1 сек } }
Это видно не очень хорошо, но идея понятна.

RGB-светодиод и Arduino

RGB-светодиод на самом деле это три светодиода разного цвета в одном корпусе.

Включая разные светодиоды с различной яркостью можно комбинировать и получать разные цвета. Для Arduino, где количество градаций яркости равно 256 вы получите 256^3=16581375 возможных цветов. Реально их, конечно, будет меньше.
Светодиод, который мы будем использоваться общим катодом. Т.е. все три светодиода конструктивно соединены катодами к одному выводу. Этот вывод мы подсоединим к выводу GND. Остальные выводы, через ограничительные резисторы, надо подсоединить к выводам ШИМ. Автор использовал выводы 9-11.Таким образом можно будет управлять каждым светодиодом отдельно. В первом скетче показано, как включить каждый светодиод отдельно.

//RGB LED - test //pin connections int red = 9; int green = 10; int blue = 11; void setup(){ pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); } void loop(){ //включение/выключение красного светодиод digitalWrite(red, HIGH); delay(500); digitalWrite(red, LOW); delay(500); //включение/выключение зеленого светодиода digitalWrite(green, HIGH); delay(500); digitalWrite(green, LOW); delay(500); //включение/выключение синего светодиода digitalWrite(blue, HIGH); delay(500); digitalWrite(blue, LOW); delay(500); }

В следующем примере используются команды analogWrite() и , чтобы получать различные случайные значения яркости для светодиодов. Вы увидите разные цвета, меняющиеся случайным образом.
//RGB LED - random colors //pin connections int red = 9; int green = 10; int blue = 11; void setup(){ pinMode(red, OUTPUT); pinMode(blue, OUTPUT); pinMode(green, OUTPUT); } void loop(){ //pick a random color analogWrite(red, random(256)); analogWrite(blue, random(256)); analogWrite(green, random(256)); delay(1000);//wait one second }

Random(256) -возвращает случайное число в диапазоне от 0 до 255.
В прикрепленном файле скетч, который продемонстрирует плавные переходы цветов от красного к зеленому, затем к синему, красному, зеленому и т.д. (скачиваний: 381)
Пример скетча работает, но есть много повторяющегося кода. Можно упростить код, написав собственную вспомогательную функцию, которая будет плавно менять один цвет на другой.
Вот как она будет выглядеть: (скачиваний: 414)
Давайте рассмотрим определение функции по частям. Функция называется fader и имеет два аргумента. Каждый аргумент отделяется запятой и имеет тип объявленный в первой строке определения функции: void fader (int color1, int color2) . Вы видите, что оба аргумента объявлены как int , и им присвоены имена color1 и color2 в качестве условных переменных для определения функции. Void означает, что функция не возвращает никаких значений, она просто выполняет команды. Если надо было бы написать функцию, которая возвращала результат умножения это выглядело бы так:
int multiplier(int number1, int number2){ int product = number1*number2; return product; }
Обратите внимание, как мы объявили Тип int в качестве типа возвращаемого значения вместо
void .
Внутри функции идут команды, которые вы уже использовали в предыдущем скетче, только номера выводов заменили на color1 и color2 . Вызывается функция fader , ее аргументы вычисляются как color1 = red и color2 = green . В архиве полный скетч с использованием функций (скачиваний: 313)

Кнопка

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

Это значит, что пока кнопка не нажата, ток через неё не идёт, а после отпускания, кнопка возвращается в исходное положение.
В схеме, помимо кнопки используется резистор. В данном случае он не ограничивает ток, а "подтягивает" кнопку к 0в (GND). Т.е. пока кнопка не нажата на выводе Arduino, к которому она подключена, будет низкий уровень. Резистор, используемый в схеме 10 кОм.

//определяем нажатие кнопки int buttonPin = 7; void setup(){ pinMode(buttonPin, INPUT);//инициализируем пин на вход Serial.begin(9600);//инициализируем последовательный порт } void loop(){ if (digitalRead(buttonPin)==HIGH){//если кнопка нажата Serial.println("pressed"); // выводим надпись "pressed" } else { Serial.println("unpressed");// иначе "unpressed" } }
В этом скетче несколько новых команд.
-эта команда принимает значение High (высокий уровень) и low (низкий уровень), того вывода, который мы проверяем. Предварительно в setup() этот вывод надо настроить на вход.
; //где buttonPin это номер вывода, куда подсоединяется кнопка.
Последовательный порт позволяет отправлять Arduino сообщения на компьютер, в то время, как сам контроллер выполняет программу. Это полезно для отладки программы, отправки сообщений на другие устройства или приложения. Чтобы включить передачу данных через последовательный порт (другое название UART или USART), надо инициализировать его в setup()

Serial.begin() имеет всего один аргумент-это скорость передачи данных между Arduino и компьютером.
скетче используется команда для вывода сообщения на экран в Arduino IDE (Tools >> Serial Monitor).
- конструкция позволяют контролировать ход выполнения программы, объеденив несколько проверок в одном месте.
If(если) digitalRead возвращает значение HIGH, то на мониторе выводится слово "нажата". Else(иначе) на мониторе выводится слово " отжата" . Теперь можно попробовать включать и выключать светодиод по нажатию кнопки.
//button press detection with LED output int buttonPin = 7; int ledPin = 8; void setup(){ pinMode(buttonPin, INPUT);//this time we will set button pin as INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); } void loop(){ if (digitalRead(buttonPin)==HIGH){ digitalWrite(ledPin,HIGH); Serial.println("pressed"); } else { digitalWrite(ledPin,LOW); Serial.println("unpressed"); } }

Аналоговый вход.

analogRead позволяет считать данные с одного из аналоговых выводов Arduino и выводит значение в диапазоне от 0 (0В) до 1023 (5В). Если напряжение на аналоговом входе будет равно 2.5В, то будет напечатано 2.5 / 5 * 1023 = 512
analogRead имеет только один аргумент- Это номер аналогового входа (А0-А5). В следующем скетче приводится код считывания напряжения с потенциометра. Для этого подключите переменный резистор, крайними выводами на пины 5V и GND, а средний вывод на вход А0.

Запустите следующий код и посмотрите в serial monitor, как меняются значения в зависимости от поворота ручки резистора.
//analog input int potPin = A0;//к этому пину подсоединяется центральный вывод потенциометра void setup(){ //аналоговый пин по умолчанию включен на вход, поэтому инициализация не нужна Serial.begin(9600); } void loop(){ int potVal = analogRead(potPin);//potVal is a number between 0 and 1023 Serial.println(potVal); }
Следующий скетч объединяет скетч нажатия кнопки и скетч управления яркостью светодиода. Светодиод будет включаться от кнопки, и управлять яркостью свечения будет потенциометр.
//button press detection with LED output and variable intensity int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup(){ pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); } void loop(){ if (digitalRead(buttonPin)==HIGH){//if button pressed int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//turn on led with intensity set by pot Serial.println("pressed"); } else { digitalWrite(ledPin, LOW);//turn off if button is not pressed Serial.println("unpressed"); } }

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

Arduino IDE позаимствовал с C/C++ большинство необходимых элементов управления. Их синтаксис идентичен с C. Ниже мы в двух словах опишем их синтаксис.

Оператор if

Оператор if позволяет выполнить определенный фрагмент программы в зависимости от результата проверки определенного условия. Если условие выполняется, то код программы будет выполнен, если же условие не выполняется, то код программы будет пропущен. Синтаксис команды if выглядит следующим образом:

If(условие) { инструкция1; инструкция2; }

Условием может быть любое сравнение переменной или значения, возвращаемое функцией. Основным критерием условия if является то, что ответ всегда должен быть или истина (true) или ложь (false). Примеры условий для оператора if:

if(a!=2) { } if(x<10) { } if(znak==’B’) { }

Внутри скобок, которые прописаны внутри условия, можно выполнить код.

Люди, которые приступают к изучению программирования, часто делают ошибку, приравнивая значение указанной переменной с помощью одного знака «=». Такая запись однозначно указывает на присвоение значения переменно, и, следовательно, условие всегда будет «true», то есть выполняться. Проверка того, что переменная равна определенному значению, всегда обозначается двойным знаком равно (==).

В качестве условия можно использовать состояние функции, например:

If(init()) { Serial.print(«ок»); }

Приведенный выше пример будет выполнен следующим образом: на первом этапе вызывается функция init(). Эта функция возвращает значение, которое будет интерпретировано как «true» или «false». В зависимости от результата сравнения будет отправлен текст «ок» или ничего не будет отправлено.

Оператор if…else

Расширенным оператором if является оператор if….else. Он обеспечивает выполнение одного фрагмента кода, когда условие выполняется (true), и выполнение второй фрагмент кода, если условие не выполняется (false). Синтаксис операторf if….else выглядит следующим образом:

If (условие) { // команда A } else { // команда B }

Команды «A» будут выполняться только в том случае, если условие выполнено, команда «B» будет выполняться, когда условие не выполнено. Одновременное выполнение команды «A» и «B» невозможно. Следующий пример показывает, как использовать синтаксис if…else:

If (init()) { Serial.print(«ок»); } else { Serial.print(«ошибка»); }

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

Обычной практикой является отрицание условия. Это связано с тем, что функция, которая выполнена правильно возвращает значение 0, а функция, которая отработала неверно по какой-то причине, возвращает ненулевое значение.

Объяснение такого «усложнения жизни» — просто. Если функция выполнена правильно, то это единственная информация, которая нам нужна. В случае же ошибки, стоит иногда понять, что пошло не так, почему функция не выполнена правильно. И здесь на помощь приходят числа, отличающиеся от нуля, т. е. с помощью цифровых кодов мы можем определить тип ошибки. Например, 1 — проблема с чтением какого-то значения, 2 — нет места в памяти или на диске и т. д.

В последнем измененном примере показано, как вызвать функцию, которая возвращает ноль при правильном выполнении:

If (!init()) { Serial.print(«ок»); } else { Serial.print(«ошибка»); }

Оператор switch case

Оператор if позволяет проверить только одно условие. Иногда необходимо выполнить одно из действий в зависимости от возвращаемого или прочитанного значения. Для этого идеально подходит оператор множественного выбора switch. Ниже показан синтаксис команды switch:

Switch (var) { case 1: //инструкция для var=1 break; case 2: // инструкция для var=2 break; default: // инструкция по умолчанию (если var отличается от 1 и 2) }

В зависимости от значения переменной var выполняются инструкции в определенных блоках. Метка case означает начало блока для указанного значения. Например, case 1: означает, что данный блок будет выполнен для значения переменной var, равной один.

Каждый блок должен быть завершен с помощью команды break. Он прерывает дальнейшее выполнение оператора switch. Если команду break пропустить, то инструкции будут выполняться и в последующих блоках до команды break. Метка default не является обязательной, как и else в команде if. Инструкции, расположенные в блоке default выполняются только тогда, когда значение переменной var не подходит ни к одному шаблону.

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

Switch (x) { case 1: //инструкция для x=1 break; case 2: case 3: case 5: // инструкция для x=2 или 3 или 4 break; case 4: // инструкция для x=4 break; case 6: // инструкция для x=6 break; default: // инструкция по умолчанию (если х отличается от 1,2,3,4,5,6) }

В зависимости от значения переменной x будет выполнен соответствующий блок инструкций. Повторение case 2: case 3: case 5: информирует компилятор о том, что если переменная x имеет значение 2 или 3 или 5, то будет выполнен один и тот же фрагмент кода.

Оператор for

Оператор for используется для многократного выполнения одного и того же кода. Часто необходимо выполнить одни и те же инструкции, изменив только значение какой-то переменной. Для этого идеально подходит цикл for. Синтаксис команды выглядит следующим образом:

Int i; for(i=0;i<10;i++) { // инструкции для выполнения в цикле }

Первый параметр, приводимый в инструкции for — начальное значение переменной. Еще один элемент — это проверка условия о продолжении выполнения цикла. Цикл выполняется до тех пор, пока выполняется условие. Последний элемент — это изменение значения переменной. Чаще всего мы увеличиваем или уменьшаем ее значение (по необходимости). В этом примере, инструкции, содержащиеся в цикле будут выполняться при i=0…9.

Часто переменная, используемая в цикле объявляется там же:

For(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

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

For(int i=10;i>0;i—) { Serial.print(i); // отправятся номера 10,9,8,7,6,5,4,3,2,1 }

Оператор while

Цикл for идеально подходит там, где мы хотим выполнить подсчет. В ситуации, когда необходимо выполнить определенные действия в результате какого-то события, которое не обязательно является предсказуемым (например, мы ждем нажатия кнопки), то мы можем использовать оператор while, который выполняет блок оператора до тех пор, пока выполняется условие. Синтаксис оператора while выглядит следующим образом:

While(условие) { // блок инструкций для выполнения }

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

Int x=2; while(x>5) { Serial.print(x); } —————————————- int y=5; while(y>0) { Serial.print(y); }

Первый блок операторов, расположенный внутри while не выполнится никогда. Переменная x имеет значение два и она не станет больше 5. Во втором примере мы имеем дело с бесконечным циклом. Переменная «y» имеет занчение 5, т. е. больше нуля. Внутри цикла не происходит никакого изменения переменной «y», поэтому цикл никогда не будет завершен.

Это распространенная ошибка, когда мы забываем об изменении параметра, вызывающего прекращение цикла. Ниже приведено два правильных примера применения цикла while:

Int x=0; while(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

В первом примере мы позаботились об изменении значения переменной, которая проверяется в условии. В результате цикл когда-нибудь завершится. Во втором примере был преднамеренно создан бесконечный цикл. Этот цикл эквивалентен функции loop () в Arduino IDE. Кроме того, внутри цикла введена проверка условия, после выполнения которого цикл завершается командой break.

Оператор do…while

Разновидностью цикла while является цикл do…while. Кроме синтаксиса он отличается местом проверки условия. В случае do…while проверка условия производится после выполнения блока инструкций. Это означает, что блок инструкций в теле цикла выполнится хотя бы один раз. Ниже приведен синтаксис команды do…while:

Do { // блок инструкций } while(условие)

Все, что написано об операторе while относится также и к do…while. Ниже приведен пример использования цикла do…while:

Int x=10; do { // блок инструкций x—; } while(x>0); —————————————- do { // блок инструкций if(условие) break; } while(true);

Оператор break

Оператор break позволяет выйти из цикла (do…while, for, while) и выйти из опции switch. В следующем примере рассмотрим выполнение команды break:

For(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

Цикл должен быть исполнен для чисел от 0 до 9, но для числа 5 выполняется условие, которое запускает оператор break. Это приведет к выходу из цикла. В результате в последовательный порт (Serial.print) будет отправлены только числа 0,1,2,3,4.

Оператор continue

Оператор continue вызывает прекращение выполнения инструкций цикла (do…while, for, while) для текущего значения и переход к выполнению следующего шага цикла. В следующем примере показано, как работает оператор continue:

For(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

Как не трудно заметить, цикл будет выполнен для значения от 0 до 9. Для значения 5 исполнится команда continue, в результате чего инструкции, находящиеся после этой команды выполнены не будут. В результате в последовательный порт (Serial.print) будут отправлены числа 0,1,2,3,4,6,7,8,9.

Оператор return

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

Int checkSensor(){ if (analogRead(0) > 400) { // чтение аналогового входа return 1; // Для значений больше 400 возвращается 1 else{ return 0; // для других возвращается 0 } }

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

Void имя_функции() { инструкция1; if(x==0) return; инструкция2; инструкция3; }

В приведенном выше примере инструкция1 будет выполнять всегда, когда вызывается функция. Выполнение же инструкция2 и инструкция3 зависит от результата команды if. Если условие будет выполнено (true), то будет выполнена команда return и функция завершит работу.

В случае, когда условие не выполнено команда return так же не выполняется, а выполняются инструкции инструкция2 и инструкция3, и после этого функция завершает свою работу.

Оператор goto

Из идеологических соображений необходимо пропустить это описание… Оператор goto является командой, которую не следует использовать в обычном программировании. Он вызывает усложнения кода и является плохой привычкой в программировании. Настоятельно рекомендуем не использовать эту команду в своих программах. Из-за того, что goto есть в официальной документации на сайте arduino.cc приведем его краткое описание. Синтаксис команды goto:

…. goto metka; // перейдите на строку с надписью ‘metka’ ….. …. …. metka: // метка, с которой программа продолжит работу …

Команда позволяет переход к обозначенной метке, т. е. к месту в программе.

Этот урок дает минимальные знания, необходимые для программирования систем Ардуино на языке C. Можно только просмотреть его и в дальнейшем использовать как справочную информацию. Тем, кто программировал на C в других системах можно пропустить статью.

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

Структура программы Ардуино.

Структура программы Ардуино достаточно проста и в минимальном варианте состоит из двух частей setup() и loop().

void setup() {

void loop() {

Функция setup() выполняется один раз, при включении питания или сбросе контроллера. Обычно в ней происходят начальные установки переменных, регистров. Функция должна присутствовать в программе, даже если в ней ничего нет.

После завершения setup() управление переходит к функции loop(). Она в бесконечном цикле выполняет команды, записанные в ее теле (между фигурными скобками). Собственно эти команды и совершают все алгоритмические действия контроллера.

Первоначальные правила синтаксиса языка C.

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

z = x + y;
z= x
+ y ;

{ } фигурные скобки определяют блок функции или выражений. Например, в функциях setup() и loop().

/* … */ блок комментария , обязательно закрыть.

/* это блок комментария */

// однострочный комментарий , закрывать не надо, действует до конца строки.

// это одна строка комментария

Переменные и типы данных.

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

Тип данных	Разрядность, бит	Диапазон чисел
boolean	8	true, false
char	8	-128 … 127
unsigned char	8	0 … 255
byte	8	0 … 255
int	16	-32768 … 32767
unsigned int	16	0 … 65535
word	16	0 … 65535
long	32	-2147483648 … 2147483647
unsigned long	32	0 … 4294967295
short	16	-32768 … 32767
float	32	-3.4028235+38 … 3.4028235+38
double	32	-3.4028235+38 … 3.4028235+38

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

Объявление переменных.

Указывается тип данных, а затем имя переменной.

int x; // объявление переменной с именем x типа int
float widthBox; // объявление переменной с именем widthBox типа float

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

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

Переменные, объявленные в начале программы, до функции void setup(), считаются глобальными и доступны в любом месте программы.
Локальные переменные объявляются внутри функций или таких блоков, как цикл for, и могут использоваться только в объявленных блоках. Возможны несколько переменных с одним именем, но разными областями видимости.

int mode; // переменная доступна всем функциям

void setup() {
// пустой блок, начальные установки не требуются
}

void loop() {

long count; // переменная count доступна только в функции loop()

for (int i=0; i < 10;) // переменная i доступна только внутри цикла
{
i++;
}
}

При объявлении переменной можно задать ее начальное значение (проинициализировать).

int x = 0; // объявляется переменная x с начальным значением 0
char d = ‘a’; // объявляется переменная d с начальным значением равным коду символа ”a”

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

int x; // переменная int
char y; // переменная char
int z; // переменная int

z = x + (int) y; // переменная y явно преобразована в int

Арифметические операции.

Операции отношения.

Логические операции.

Операции над указателями.

Битовые операции.

&	И
\|	ИЛИ
^	ИСКЛЮЧАЮЩЕЕ ИЛИ
~	ИНВЕРСИЯ
<<	СДВИГ ВЛЕВО
>>	СДВИГ ВПРАВО

Операции смешанного присваивания.

Выбор вариантов, управление программой.

Оператор IF проверяет условие в скобках и выполняет последующее выражение или блок в фигурных скобках, если условие истинно.

if (x == 5) // если x=5, то выполняется z=0
z=0;

if (x > 5) // если x >
{ z=0; y=8; }

IF … ELSE позволяет сделать выбор между двух вариантов.

if (x > 5) // если x > 5, то выполняется блок z=0, y=8;
{
z=0;
y=8;
}

{
z=0;
y=0;
}

ELSE IF – позволяет сделать множественный выбор

if (x > 5) // если x > 5, то выполняется блок z=0, y=8;
{
z=0;
y=8;
}

else if (x > 20) // если x > 20, выполняется этот блок
{
}

else // в противном случае выполняется этот блок
{
z=0;
y=0;
}

SWITCH CASE - множественный выбор. Позволяет сравнить переменную (в примере это x) с несколькими константами (в примере 5 и 10) и выполнить блок, в котором переменная равна константе.

switch (x) {

case 5:
// код выполняется если x = 5
break;

case 10:
// код выполняется если x = 10
break;

default:
// код выполняется если не совпало ни одно предыдущее значение
break;
}

Цикл FOR . Конструкция позволяет организовывать циклы с заданным количеством итераций. Синтаксис выглядит так:

for (действие до начала цикла;
условие продолжения цикла;
действие в конце каждой итерации) {

// код тела цикла

Пример цикла из 100 итераций.

for (i=0; i < 100; i++) // начальное значение 0, конечное 99, шаг 1

{
sum = sum + I;
}

Цикл WHILE . Оператор позволяет организовывать циклы с конструкцией:

while (выражение)
{
// код тела цикла
}

Цикл выполняется до тех пор, пока выражение в скобках истинно. Пример цикла на 10 итераций.

x = 0;
while (x < 10)
{
// код тела цикла
x++;
}

DO WHILE – цикл с условием на выходе.

do
{
// код тела цикла
} while (выражение);

Цикл выполняется пока выражение истинно.
BREAK – оператор выхода из цикла. Используется для того, чтобы прервать выполнение циклов for, while, do while.

x = 0;
while (x < 10)
{
if (z > 20) break; // если z > 20, то выйти из цикла
// код тела цикла
x++;
}

GOTO – оператор безусловного перехода.

goto metka1; // переход на metka1
………………
metka1:

CONTINUE - пропуск операторов до конца тела цикла.

x = 0;
while (x < 10)
{
// код тела цикла
if (z > 20) continue; // если z > 20, то вернуться на начало тела цикла
// код тела цикла
x++;
}

Массивы.

Массив это область памяти, где последовательно хранятся несколько переменных.

Объявляется массив так.

int ages; // массив из 10 переменных типа int

float weight; // массив из 100 переменных типа float

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

int ages = { 23, 54, 34, 24, 45, 56, 23, 23, 27, 28};

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

x = ages; // x присваивается значение из 5 элемента массива.
ages = 32; // 9 элементу массива задается значение 32

Нумерация элементов массивов всегда с нуля.

Функции.

Функции позволяют выполнять одни и те же действия с разными данными. У функции есть:

имя, по которому ее вызывают;
аргументы – данные, которые функция использует для вычисления;
тип данных, возвращаемый функцией.

Описывается пользовательская функция вне функций setup() и loop().

void setup() {
// код выполняется один раз при запуске программы
}

void loop() {
// основной код, выполняется в цикле
}

// объявление пользовательской функции с именем functionName
type functionName(type argument1, type argument1, … , type argument)
{
// тело функции
return();
}

Пример функции, вычисляющей сумму квадратов двух аргументов.

int sumQwadr (int x, int y)
{
return(x* x + y*y);
}

Вызов функции происходит так:

d= 2; b= 3;
z= sumQwadr(d, b); // в z будет сумма квадратов переменных d и b

Функции бывают встроенные, пользовательские, подключаемые.

Очень коротко, но этих данных должно хватить для того, чтобы начать писать программы на C для систем Ардуино.

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

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

Имена в языке C.

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

Signal, TimeCount

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

Рубрика: . Вы можете добавить в закладки.

После ознакомления с основными элементами Arduino, а также написания программы «Hello World!» пришло время для знакомства с языком программирования.

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

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

Основы основ

Несколько формальных вещей, то есть таких, о которых все знают, но иногда забывают…

В Arduino IDE, как в C/C++, необходимо помнить о регистрах символов. Ключевые слова, такие как if, for всегда записываются в нижнем регистре. Каждая инструкция заканчивается на «;». Точка с запятой сообщает компилятору, какую часть интерпретировать как инструкцию.

Скобки {..} используются для обозначения программных блоков. Мы используем их для ограничения тела функции (см. ниже), циклов и условных операторов.

Хорошей практикой является добавление комментариев к содержимому программы, это помогает легко понять код. Однострочные комментарии начинаются с // (двойная косая черта). Многострочные комментарии начинаются с /* и заканчиваются на */

Если мы хотим подключить в нашу программу какую-либо библиотеку, мы используем команду include. Вот примеры подключения библиотек:

#include // стандартная библиотека #include «svoya_biblioteka.h» // библиотека в каталоге проекта

Функции в Arduino

Функция (подпрограмма) является отдельной частью программы, выполняющая некоторые операции. Функции используются для упрощения основной программы и улучшения читаемости кода. Полезно использовать функции, поскольку мы можем легко использовать их во многих своих проектах.

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

Объявление функции

Схема объявления функции выглядит следующим образом:

Тип имя_функции(параметр) { // инструкции для выполнения (тело функции) return (/* возвращение значения*/); }

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

После исполнения, функция вернет значение объявленного типа. В случае, если функция не принимает никакого возвращаемого значения, то тип данных будет «void».

имя_функции позволяет ее однозначно идентифицировать. Для того чтобы вызвать (запустить) функцию, мы даем ей имя.

параметр — параметр вызова функции. Параметры не обязательны, но зачастую они бывают полезны. Если мы напишем функцию, у которой нет аргументов, мы оставляем круглые скобки пустыми.

Внутри скобок «{…}» содержится собственно тело функции или инструкция, которые мы хотим выполнить. Описание конкретных инструкций укажем в отдельной статье.

Все функции, возвращающие значение, заканчиваются оператором return, за которым следует возвращаемое значение. Только функции, объявленные нулевым указателем («void»), не содержат оператор return. Необходимо знать, что оператор return завершает выполнение функции независимо от местоположения.

Ниже приведены некоторые примеры деклараций функций.

Void f1() { //тело функции } —————————————— int minus() { //тело функции return (0); } —————————————— int plus(int a, int b) { return (a+b); }

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

Настоятельно рекомендуем вам изучить и применять функции при написании собственных программ. Со временем, у каждого программиста набирается собственная библиотека функций «на все случаи жизни», которая позволяет облегчить и ускорить процесс написания новых программ.

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

Вызов функции

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

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

F1(); plus(2,2); y=plus(1,5);

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

Если функция f1() объявлена без параметров, то при ее вызове нельзя указывать никакие параметры, т.е. вызов функции f1(0) будет неверным.

Функция plus(int a, int b) требует ровно двух параметров, поэтому вызов с одним или тремя параметрами невозможно.

Вызов y=plus(1,5) приведет к выполнению функции «plus» с параметрами «1» и «5» и сохранить возвращаемое значение в переменную «y».

Функции setup() и loop().

Обладая знаниями об объявлении и вызове функций, мы можем перейти к системным функциям Arduino: setup() и loop() . Arduino IDE в обязательном порядке необходимо объявлять эти две функции.

setup () — это функция, которая вызывается автоматически при включении питания или нажатии кнопки RESET.

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

Void setup () { // тело функции — инициализация системы }

loop () — это функция, которая вызывается в бесконечном цикле. Данная функция также не возвращает значения и не вызывается с параметрами. Ниже показано правильное объявление функции loop():

Void loop () { // тело функции — программный код }

Как вы видите, объявление функции loop () идентично объявлению функции setup (). Различие состоит в выполнении этих функций микроконтроллером.

Теперь мы проанализируем следующий псевдокод:

Void setup () { on_led1 (); //включаем светодиод led1 off_led1 (); //выключаем светодиод led1 } void loop () { on_led2 (); //включаем светодиод led2 off_led2 (); //выключаем светодиод led2 }

В функции setup () есть две инструкции: первая включает светодиод led1, подключенный к плате (например, контакт 13), а вторая выключает светодиод led1.

Функция loop () имеет идентичные инструкции для включения и выключения светодиода led2, подключенного к плате (например, контакт 12).

В результате запуска программы светодиод led1 мигнет один раз, в то время как led2 будет загораться и гаснуть до тех пор, пока включено питание Arduino.

Нажатие кнопки RESET приведет к тому, что led1 снова мигнет один раз, а led2 снова начнет постоянно мигать.

Подведем итог:

Функции setup () и loop () — это системные функции, которые должны быть определены в каждом проекте. Даже в ситуации, когда в одном из них мы не пропишем какой-либо код, мы все равно должны объявить эти две функции;
Функция setup () выполняется один раз, loop() выполняется непрерывно;
Мы создаем собственные функции в одном файле;
Мы можем вызвать свои функции как из setup () и loop (), так и из других функций;
Наши собственные функции можно вызывать с параметрами и возвращать значение;
Вызов функции должен быть совершен в соответствии с ее декларацией.

Основа языка программирования модуля Arduino - это язык Си (скорее Си++). Ещё точнее, этот диалект языка называется Processing/Wiring. Хорошее обозрение языка вы найдёте в приложении. А мне хочется больше рассказать не о языке, а о программировании.

Программа - это некий набор команд, которые понимает процессор, процессор вашего компьютера или процессор микроконтроллера модуля Arduino, не суть важно. Процессор читает команды и выполняет их. Любые команды, которые понимает процессор - это двоичные числа. Это только двоичные числа и ничто иное. Выполняя арифметические операции, для которых процессор некогда и предназначался, процессор оперирует с числами. Двоичными числами. И получается, что и команды, и то, к чему они относятся, это только двоичные числа. Вот так. Но как же процессор разбирается в этой «куче» двоичных чисел?

Во-первых, все эти двоичные числа записываются в последовательные ячейки оперативной памяти, имеющие адреса. Когда вы загружаете программу, и она начинает работать, процессор получает первый адрес программы, где обязательно должна быть записана команда. Те команды, которые требуют от процессора операций с числами, имеют «опознавательные знаки», например, что в следующих двух ячейках памяти два числа, которые нужно сложить. А счётчик, назовём его счётчиком команд, где записан адрес следующей команды, в данном случае увеличивает адрес так, что в программе по этому адресу будет следующая команда. При неправильной работе программы или сбоях процессор может ошибиться, и тогда, прочитав вместо команды число, процессор делает совсем не то, что должен делать, а программа «зависает».

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

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

Я не готов спорить, но считаю, что программу удобнее начинать с описания на обычном языке. И в этом смысле я считаю, что программирование не следует путать с написанием кода программы. Когда программа описана обычными словами, вам легче определить, например, какой язык программирования выбрать для создания кода программы.

Ближе всего к записи программы с помощью двоичных чисел, язык ассемблер. Для него характерно соответствие команд языка двоичным командам, понятным процессору. Но кодирование программ на ассемблере требует больших усилий и ближе к искусству, чем к формальным операциям. Более универсальны и легче в применении языки высокого уровня, как Бэйсик или Си. И давно для записи программ в общем виде используют графический язык, а в последнее время появились и «переводчики» с этого языка на язык процессоров.

Кроме языков программирования общего применения, всегда существовала некоторая специализация языков программирования, и существовали специализированные языки. К последним я бы отнёс и язык программирования модуля Arduino.

Всё, что нужно сказать модулю, чтобы он сделал что-то нужное нам, организовано в удобный набор команд. Но вначале о том, что нам нужно от Arduino?

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

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

Давайте посмотрим, о чём нам может рассказать самая простая программа «Помигать светодиодом».

int ledPin = 13;

pinMode (ledPin, OUTPUT);

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

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

Но этот же вывод порта может работать и как вход. В этом случае его можно представить, например, как вход цифровой микросхемы – на вход подаётся логический уровень, высокий или низкий (см. Приложение А, цифровой ввод).

Как мы мигаем светодиодом:

Включить выходной вывод порта. Выключить вывод порта.

Но процессор работает очень быстро. Мы не успеем заметить мигания. Чтобы заметить это мигание, нам нужно добавить паузы. То есть:

Включить выходной вывод порта. Пауза 1 секунда.

Выключить вывод порта.

Пауза 1 секунда.

Это наша программа. Процессор прочитает первую команду и включит вывод, светодиод загорится. Затем процессор сделает паузу в работе и выключить вывод, светодиод погаснет. Но он только один раз мигнул.

Повторение какого-либо процесса или набора команд называется в программировании циклом. Используются разные виды циклов. Есть цикл, который выполняется заданное число раз. Это цикл for. Есть циклы, которые выполняются до тех пор, пока не будет выполнено некоторое условие, которое является частью языковой конструкции цикла. А если условие не будет выполнено никогда, то цикл выполняется бесконечное число раз. Это бесконечный цикл.

Я не думаю, что микроконтроллеры используются с программами того вида, который приведён выше. То есть, один раз выполнено несколько команд и больше контроллер не работает. Как правило, он работает постоянно, как только на него подаётся питающее напряжение. А, значит, микроконтроллер должен работать в бесконечном цикле.

Именно об этом говорит функция void loop(), loop - это петля, замкнутый цикл. Условия прекращения работы цикла нет, а, следовательно, нет условия его завершения.

Кроме того, мы должны сообщить модулю Arduino, какой вывод порта и как мы хотим использовать, для выхода (OUTPUT) или для входа (INPUT). Этой цели служит функция void setup(), которая для языка Arduino является обязательной, даже если она не используется, и команда pinMode(), для задания режима работы вывода.

pinMode (ledPin, OUTPUT);

И ещё, языковая конструкция использует переменные для определения номера вывода:

int ledPin = 13;

Использование переменных удобно. Решив, что вы будете использовать не вывод 13, а 12, вы внесёте изменение только в одной строке. Особенно сильно это сказывается в больших программах. Имя переменной можно выбирать по своему усмотрению, но, как правило, оно должно быть только символьным, и часто количество символов ограничивается. Если вы неверно зададите имя переменной, думаю, компилятор вас поправит.

Функция digitalWrite (ledPin, HIGH) устанавливает заданный вывод в состояние с высоким уровнем, то есть включает вывод.

А delay (1000), как вы уже поняли, означает паузу в 1000 миллисекунд или 1 секунду.

Осталось понять, что означают такие приставки, как int, void. Любые значения, любые переменные размещаются в памяти, как и команды программы. В ячейки памяти записываются числа зачастую из 8 битов. Это байт. Но байт - это числа от 0 до 255. Для записи больших чисел нужно два байта или больше, то есть, две или больше ячеек памяти. Чтобы процессору было ясно, как отыскать число, разные типы чисел имеют разные названия. Так число по имени byte, займёт одну ячейку, int (integer, целое) больше. Кроме того, функции, используемые в языках программирования, тоже возвращают числа. Чтобы определить, какой тип числа должна вернуть функция, перед функцией записывают этот тип возвращаемого числа. Но некоторые функции могут не возвращать числа, такие функции предваряют записью void (см. Приложение А, переменные).

Вот, сколько интересного может рассказать даже самая простая программа.

Обо всём этом вы, надеюсь, прочитаете в приложении. А сейчас проделаем простые эксперименты, используя только то, что мы уже знаем из возможностей языка. Первое, заменим переменную типа int, которая занимает много места в памяти, на byte - одно место, одна ячейка памяти. Посмотрим, что у нас получится.

byte ledPin = 13;

pinMode (ledPin, OUTPUT);

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

После компиляции и загрузки программы в модуль мы не заметим изменений в работе программы. Хорошо. Тогда изменим программу так, чтобы заметить изменения в её работе.

Для этого мы заменим число в функции delay (1000) переменной, назвав её my_del. Эта переменная должна быть целым числом, то есть, int.

int my_del = 5000;

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

byte my_del = 5000;

Разница, уверен, получится ощутимая.

Проделаем ещё один эксперимент с изменением длительности пауз. Уменьшение длительности пауз выполним, скажем, пять раз. Сделаем паузу в 2 секунды, а затем будем увеличивать тоже пять раз. И вновь сделаем паузу в 2 секунды. Цикл, выполняемый заданное количество раз, называется циклом for и записывается он так:

for (int i = 0; i<5; i++)

что-то, что выполняется в цикле for

Для выполнения цикла ему нужна переменная, у нас это i, переменной нужно задать начальное значение, которое мы ей и присвоили. Затем следует условие завершения работы цикла, у нас i меньше 5. А запись i++ - это характерная для языка Си запись увеличения переменной на единицу. Фигурные скобки ограничивают набор команд, подлежащих выполнению в цикле for. В других языках программирования могут быть другие ограничители для выделения блока кода функции.

Внутри цикла мы выполняем то же, что и раньше, с небольшими изменениями:

for (int i = 0; i<5; i++)

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

my_del = my_del - 100;

Об изменении записи паузы мы говорили выше, а изменение самой паузы достигается уменьшением переменной на 100.

Для второго цикла мы запишем этот же блок кода, но переменную длительности паузы будем увеличивать на 100.

for (int i = 0; i<5; i++)

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

Вы заметили, что запись уменьшения паузы и её увеличения выглядят по-разному. Это тоже особенность языка Си. Хотя для ясности следовало повторить эту запись, изменив только знак минус на плюс. Итак, мы получаем такую программу:

int ledPin = 13;

int my_del = 1000;

pinMode (ledPin, OUTPUT);

for (int i = 0; i<5; i++)

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

for (int i = 0; i<5; i++)

digitalWrite (ledPin, HIGH);

digitalWrite (ledPin, LOW);

Скопируем код нашей программы в программу Arduin, скомпилируем её и загрузим в модуль. Изменение длительности пауз заметно. И будет ещё заметнее, попробуйте, если цикл for выполнить, скажем, раз 8.

То, что мы сейчас сделали, делают и профессиональные программисты - имея готовую программу, её легко можно модифицировать под свои нужды или желания. Поэтому все свои программы они хранят. Что я советую делать и вам.

Что мы упустили в своём эксперименте? Мы не прокомментировали нашу работу. Для добавления комментария используется либо двойная «прямая» косая черта, либо одиночная, но со звёздочками (см. Приложение А). Я советую вам это сделать самостоятельно, поскольку вернувшись к программе через некоторое время, вы легче в ней разберётесь, если будут пояснения, что вы делаете в том или ином месте программы. И ещё советую в папке с каждой программой хранить её описание на обычном языке, выполненное в любом текстовом редакторе.

Самая простая программа «помигать светодиодом» может послужить ещё для десятка экспериментов (даже с одним светодиодом). Мне кажется эта часть работы, придумывать, что ещё можно сделать интересного, самая интересная. Если вы обратитесь к приложению, где описан язык программирования, к разделу «управление программой», то можно заменить цикл for на другой вид цикла. И попробовать, как работают другие виды цикла.

Хотя процессор микроконтроллера, как любой другой, может производить вычисления (для того его и придумывали), и это используется, например, в приборах, всё-таки наиболее характерной операцией для микроконтроллера будет установка выхода порта в высокое или низкое состояние, то есть, «помигать светодиодом», как реакция на внешние события.

О внешних событиях микроконтроллер узнаёт, в основном, по состоянию входов. Настроив выводы порта на цифровой вход, мы можем следить за ним. Если исходное состояние входа - высокий уровень, а событие вызывает переход входа в низкое состояние, то мы можем что-то сделать, реагируя на это событие.

Самый простой пример - на входе кнопка. Когда кнопка не нажата, вход в высоком состоянии. Если нажать кнопку, то вход переходит в низкое состояние, а мы можем «зажечь» светодиод на выходе. При следующем нажатии на кнопку светодиод можно погасить.

Это опять пример простой программы. Даже начинающему она может показаться неинтересной. Однако и эта простая программа может найти вполне полезное применение. Приведу только один пример: мы будем после нажатия на кнопку не зажигать светодиод, а помигаем (определённым образом). И светодиод возьмём с инфракрасным излучением. В результате мы получим пульт управления. Вот такая простая программа.

В разных версиях программы есть различия в списке примеров. Но можно обратиться к руководству по языку в приложении, где есть пример и схема программы (в разделе примеров, названном «приложение») для работы с вводом. Я скопирую программу:

int ledPin = 13;

pinMode (ledPin, OUTPUT);

pinMode (inPin, INPUT);

if (digitalRead(inPin) == HIGH)

digitalWrite(ledPin, HIGH);

digitalWrite (ledPin, LOW);

И, как вы видите, совершенно новую программу мы получаем, модифицируя старую. Теперь светодиод будет мигать только тогда, когда нажата кнопка, которая присоединена к выводу 2. Вывод 2 через резистор 10 кОм присоединён к общему проводу (земле, GND). Кнопка одним концом присоединена к питающему напряжению +5В, а другим концом к выводу 2.

В программе мы встречаем новую языковую конструкцию if из раздела управления программой. Читается она так: если выполняется условие (заключённое в скобках), то выполняется блок программы, заключённый в фигурные скобки. Обратите внимание, что в условии (digitalRead(inPin) == HIGH) равенство входа высокому состоянию выполнено с помощью двух знаков равенства! Очень часто в спешке об этом забывается, и условие получается неверным.

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

Второй вопрос - как найти у модуля те выводы, которые используются в программе?

С этим вопросом поможет разобраться картинка, которую я взял с сайта: http://robocraft.ru/.

Рис. 4.1. Расположение и назначение выводов контроллера и модуля Arduino

Все выводы моего модуля CraftDuino промаркированы, так что найти нужный вывод не составит труда. Можно подключать кнопку и резистор и проверять работу программы. Кстати, на вышеупомянутом сайте RoboCraft весь процесс отображён на картинках (но программа использует не совсем такие выводы!). Советую посмотреть.

Многие микроконтроллеры в своём составе имеют дополнительные аппаратные устройства. Так Atmega168, на основе которого собран модуль Arduino имеет UART, встроенный блок для связи с другими устройствами с помощью последовательного обмена данными. Например, с компьютером через COM-порт. Или с другим микроконтроллером с помощью его встроенного блока UART. Есть ещё и аналого-цифровой преобразователь. И формирователь широтно- импульсной модуляции.

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

// Fading LED by BARRAGAN

int value = 0; // переменная для хранения нужного значения

int ledpin = 9; // светодиод подключен к digital pin 9

// Нет необходимости вызвать функцию pinMode

for(value = 0 ; value <= 255; value+=5) // постепенно зажигаем светодиод

analogWrite(ledpin, value); // значение вывода (от 0 до 255)

delay(30); // ждѐм 🙂

for(value = 255; value >=0; value-=5) // постепенно гасим светодиод

analogWrite(ledpin, value);

Если в предыдущей программе новой для нас была функция digitalRead(inPin), чтение цифрового ввода, то в этой программе новая для нас функция analogWrite(ledpin, value), хотя параметры этой функции - уже знакомые нам переменные. Об использовании аналогового входа, использовании АЦП (аналого-цифрового преобразователя), мы поговорим позже. А сейчас вернёмся к общим вопросам программирования.

Программирование это то, что доступно всем, но потребуется время, чтобы освоить и программирование, и какой-либо язык программирования. Сегодня есть ряд программ, помогающих освоить именно программирование. И одна из них имеет непосредственное отношение к модулю Arduino. Называется она Scratch for Arduino или сокращённо S4A. Найти и скачать эту программу можно по адресу: http://seaside.citilab.eu/scratch/arduino. Я не знаю, как точно переводится название программы, но «to begin from scratch» переводится, как «начать с нуля».

На сайте проекта S4A есть версии для Windows и Linux, но для последней операционной системы готовая к установке программа в версии дистрибутива Debian. Не хочу сказать, что её нельзя использовать с другими дистрибутивами Linux, но вначале посмотрим, как работать в программе с модулем Arduino в Windows.

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

Рис. 4.2. Переключатель языков интерфейса программы

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

Рис. 4.3. Список языков для использования в интерфейсе программы

… отмеченном, как «больше…».

Если ничего не предпринимать, то надпись в правом окне «Searching board…» остаётся, но модуль не находится. Чтобы модуль Arduino подключить к программе S4A, следует загрузить с сайта проекта ещё кое-что.

Рис. 4.4. Файл для загрузки в модуль Arduino для S4A

Этот файл не что иное, как программа для Arduino (Sketch). То есть, текстовый файл, который можно скопировать в редактор Arduino, откомпилировать и загрузить в модуль. После выхода из программы Arduino можно запустить программу S4A и теперь модуль находится.

Рис. 4.5. Подключение модуля к программе

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