Python & Arduino. Просто, быстро и красиво
Оборудование
Недавно я заполучил очень интересную плату: Arduino SS Micro. Эта плата, внешне напоминающая Digispark Attiny 85, тем не менее является китайской версией Arduino Micro, с выведенным выходом USB.
Подробно рассказывать о ней я не буду, ведь это уже сделал пользователь YouTube с ником iomoio, и его обзор можно посмотреть здесь.
Как мне кажется — это довольно крутое и удобное устройство для небольших домашних проектов, ведь у проводов есть супер-свойство: теряться в самый неподходящий момент.
В качестве управляющего компьютера был использован MacBook Pro с операционной системой macOS Mojave, но не надо закрывать статью, если вы используете Windows или Linux — всё описанное в статье будет работать без изменений на любой операционной системе.
Скетч для Arduino
В качестве примера будет использоваться скетч, включающий и выключающий светодиод, по команде из Serial-порта.
Светодиод в Arduino SS Micro висит на порте SS, и поэтому он автоматически выключается. Не смотря на это, стандартный пример Blink — мигающий светодиод работает.
Если вы будете использовать другую Arduino — не забудьте сменить пин светодиода.
Код для компьютера
Одним из достоинств Python, кроме его кроссплатформенности — наличие гигантского числа библиотек. Нам понадобятся:
- PySerial — библиотека для работы с Serial-портом
- PyQT5 — библиотека для создания графического интерфейса
Установка
Для установки, воспользуемся встроенным менеджером пакетов — pip.
Для удобства создания GUI можно установить программу QTDesigner.
Интерфейс
Поскольку данная программа предназначена скорее, для демонстрации возможностей, пользователь может выбрать порт из предложенных, а так же скорость, с которой будет происходить общение.
Исходный код
Вся работа с устройством происходит благодаря библиотеке PySerial. Но есть несколько нюансов. Например, как узнать, в какой из портов подключено устройство?
На всем прекрасно известном сайте stackoverflow, пользователь с ником Thomas предложил уже готовое решение, которое я и использовал.
Кроме этого необходимо хранить список доступных скоростей:
А теперь соберём вместе дизайн(созданный в QtDesigner и сконвертированный с помощью утилиты pyuic5 в .py файл), функции для сканирования портов и основной код программы.
Основной класс, содержащий в себе всю логику программы
Переменные self.Port и self.Speed — это выпадающие списки, содержащие в себе значения доступных портов и скоростей.
При нажатии на кнопку self.ConnectButton вызывается функция connect, в которой производится попытка подключения к заданному порту с заданной скоростью. Если подключение успешно, то кнопка окрашивается в зелёный цвет, и меняется надпись.
Функция send отправляет в наш порт байтовую строку — заставляющую включить режим мигания.
Таким образом можно управлять различными устройствами, подключёнными к USB.
Данная статья является вводной и обзорной, более полную информацию можно найти например тут:
Использование языка программирования Python вместе с Arduino
В настоящее время Arduino является одной из самых мощных и простых в использовании платформ с открытым исходным кодом. Однако тенденции современного мира таковы, что часто электронными платформами необходимо управлять с помощью высокоуровневого общецелевого языка программирования чтобы сделать их более эффективными и дружественными. Одним из таких языков является Python, который представляет собой интерпретируемый, объектно-ориентированный, высокоуровневый язык программирования с динамической семантикой и высокоуровневыми встроенными структурами данных, что делает его весьма привлекательным для быстрой разработки приложений.
Объединение возможностей Arduino и Python открывает двери для множества новых возможностей, поскольку Python имеет повышенную производительность и умеет взаимодействовать с другими платформами, такими как openCV, Matlab и т. д.
В этой статье мы изучим как установить Python на компьютер и как его использовать вместе с Arduino для включения/выключения встроенного в плату Arduino светодиода.
Установка Python на ваш компьютер
В данном разделе статьи будет рассмотрена установка языка программирования на компьютер с 32 или 64-битной windows. Установка Python на компьютеры под управлением MAC и Linux будет отличаться.
Для установки Python выполните следующую последовательность шагов:
1. Установите 32-битную версию Python 2.7.9 IDLE на ваш компьютер. Не скачивайте 64-битную версию Python или его более свежую версию поскольку они могут быть не совместимы с используемыми нами библиотеками Arduino. Даже если ваш компьютер работает на 64-битной операционной системе, то вы все равно можете использовать на нем 32-битную версию Python.
Примечание : оригинал данной статьи был написан в 2017 году, поэтому, возможно, сейчас Arduino IDE уже поддерживает совместимость с более свежими версиями Python (этот вопрос будет уточняться в дальнейшем).
2. Запустите на выполнение скачанный установочный файл и установите эту версию языка Python на ваш компьютер. Не изменяйте каталог для установки Python, оставьте его по умолчанию — C:\Python27.
3. Возможно, во время установки Python на него будет “ругаться” антивирус – не обращайте на это внимание.
После установки Python вы можете проверить действительно ли он установлен на ваш компьютер введя в строке поиска Windows строку “Python IDLE”.
После его запуска вы должны увидеть на экране компьютера “Python shell” (оболочка Python) как показано на следующем рисунке.
Вы можете непосредственно писать программу в этой оболочке или же создать новый файл и писать и проверять программу в нем. Теперь давайте удостоверимся в том, что Python работает. Для этого напечатайте “print (1+1)” и нажмите enter. Вы должны после этого увидеть в оболочке напечатанный результат вычислений – 2.
Установка PySerial в Python
Следующим шагом необходимо установить программу PySerial, которая представляет собой Python API module (модуль прикладного программного интерфейса Python’а), с помощью которого можно считывать и записывать данные в последовательном виде в плату Arduino или любой другой микроконтроллер.
Кликните на Pyserial Windows чтобы скачать PySerial. По приведенной ссылке вы можете скачать установочный файл этого приложения и установить его. Не изменяйте настройки (в том числе и каталог для установки) во время установки приложения – оставьте их по умолчанию.
Теперь давайте убедимся в том, что PySerial корректно установлена и работает. Для этого снова откройте Python Shell и напечатайте в нем “import serial”. Если библиотека успешно установлена, то после этого вы не увидите никаких сообщений об ошибке как показано на следующем рисунке.
Дальнейший материал статьи предполагает что вы хотя бы немного знакомы с платформой Arduino и умеете загружать в нее программы. Если это не так, то советуем ознакомиться с руководством по Arduino для начинающих.
Наша первая совместная программа на Arduino и Python
Как отмечалось ранее, в этой программе мы будем управлять встроенным в плату Arduino светодиодом.
Программа для Arduino
Полный текст программы для платы Arduino приведен в конце статьи, здесь же обсудим наиболее важные его фрагменты.
Внутри функции setup мы инициализируем последовательную связь со скоростью 9600 бод/с и зададим режим работы для контакта, с которого будем управлять светодиодом. Также мы передадим приветственное сообщение в Python при помощи последовательной связи.
Как я писал код для Arduino с помощью Python
Картинка для привлечения внимания
На днях появилась подработка, поступил заказ записать скетч на ардуино. Простенький, но объёмный. С повторяющимися блоками. Нужно было управлять каждым портом Arduino Mega отдельно, при получении команды по Uart. Отправляешь символ — и светодиод (к примеру) загорается на определенное время. Написал скетч на 2 команды, скинул заказчику для тестов, получил предоплату. Дальше, нужно было масштабировать на все порты.
Для начала я честно попробовал руками. Написав первые 26 #define, энтузиазм иссяк. Я пошел подышать свежим воздухом, и вспомнил, что у меня на ПК (Win 7 x64), уже установлен Python 3.6 из дистрибутива Anaconda. Кстати, это наиболее удобный способ установки Python`а на Windows, т.к. всё уже включено и настроено по умолчанию, и есть пакетный менеджер.
Итак, приступим.
Создаем папку, в ней пустой файл, я назвал его «arduino_gen.py» и bat файл «start_py.bat» со следующим содержимым:
python.exe arduino_gen.py > code_out.txt
@pause
Этот файл нам потребуется, для запуска программы на Python`е
Теперь мы напишем программку, которая сгенерирует нам необходимый код для Arduino.
Для начала, создадим два списка со всеми необходимыми нам значениями, которые мы будем подставлять в код. Имена могут быть любыми, дело вкуса.
И две переменные, для перебора списков
И теперь создадим цикл для генерации #define PIN_a 2… #define PIN_Z 53
Сохраняем, запускаем файл «start_py.bat»
Если мы хотим вывести результат сразу в файл, тогда допишем:
python.exe arduino_gen.py > code_out.txt
@pause
В результате, мы получим файл «code_out.txt » из которого, код удобно копировать в скетч в лучших традициях Arduino.
Уже на этом этапе, у меня возник вопрос, хватит ли у Arduino памяти, если сгенерировать большое количество переменных. Однако, забегая вперед, скажу, что памяти вполне хватило, в чем можно убедиться про компиляции скетча.
Далее, я приведу остальной код, в котором несложно разобраться. Но, для начала, рассмотрим
Здесь, нужно сгенерировать 4 блока кода в начале. И два блока в конце. В последствии, заказчик захотел изменить логику работы, чтобы при приходе заглавной буквы менялось состояние выхода. Я переписал участок кода:
И масштабировал при помощи Python’а
Вот, что в итоге получилось.
// Задаем пины
#define PIN_a 2
#define PIN_b 3
#define PIN_c 4
#define PIN_d 5
#define PIN_e 6
#define PIN_f 7
#define PIN_g 8
#define PIN_h 9
#define PIN_i 10
#define PIN_j 11
#define PIN_k 12
#define PIN_l 13
#define PIN_m 14
#define PIN_n 15
#define PIN_o 16
#define PIN_p 17
#define PIN_q 18
#define PIN_r 19
#define PIN_s 20
#define PIN_t 21
#define PIN_u 22
#define PIN_v 23
#define PIN_w 24
#define PIN_x 25
#define PIN_y 26
#define PIN_z 27
#define PIN_A 28
#define PIN_B 29
#define PIN_C 30
#define PIN_D 31
#define PIN_E 32
#define PIN_F 33
#define PIN_G 34
#define PIN_H 35
#define PIN_I 36
#define PIN_J 37
#define PIN_K 38
#define PIN_L 39
#define PIN_M 40
#define PIN_N 41
#define PIN_O 42
#define PIN_P 43
#define PIN_Q 44
#define PIN_R 45
#define PIN_S 46
#define PIN_T 47
#define PIN_U 48
#define PIN_V 49
#define PIN_W 50
#define PIN_X 51
#define PIN_Y 52
#define PIN_Z 53
//Задаем время
//Здесь, скорее всего, потребуется поправка
//Например, 1 секунда может быть не 1000, а 865, к примеру.
//Нужно будет секундомером померить, и, если необходимо,
// уменьшить на некий коофициент
#define TIME_a 1000
#define TIME_b 1000
#define TIME_c 1000
#define TIME_d 1000
#define TIME_e 1000
#define TIME_f 1000
#define TIME_g 1000
#define TIME_h 1000
#define TIME_i 1000
#define TIME_j 1000
#define TIME_k 1000
#define TIME_l 1000
#define TIME_m 1000
#define TIME_n 1000
#define TIME_o 1000
#define TIME_p 1000
#define TIME_q 1000
#define TIME_r 1000
#define TIME_s 1000
#define TIME_t 1000
#define TIME_u 1000
#define TIME_v 1000
#define TIME_w 1000
#define TIME_x 1000
#define TIME_y 1000
#define TIME_z 1000
#define TIME_A 1000
#define TIME_B 1000
#define TIME_C 1000
#define TIME_D 1000
#define TIME_E 1000
#define TIME_F 1000
#define TIME_G 1000
#define TIME_H 1000
#define TIME_I 1000
#define TIME_J 1000
#define TIME_K 1000
#define TIME_L 1000
#define TIME_M 1000
#define TIME_N 1000
#define TIME_O 1000
#define TIME_P 1000
#define TIME_Q 1000
#define TIME_R 1000
#define TIME_S 1000
#define TIME_T 1000
#define TIME_U 1000
#define TIME_V 1000
#define TIME_W 1000
#define TIME_X 1000
#define TIME_Y 1000
#define TIME_Z 1000
//логическое состояние светодиода (да / нет)
boolean ledState_a = false;
boolean ledState_b = false;
boolean ledState_c = false;
boolean ledState_d = false;
boolean ledState_e = false;
boolean ledState_f = false;
boolean ledState_g = false;
boolean ledState_h = false;
boolean ledState_i = false;
boolean ledState_j = false;
boolean ledState_k = false;
boolean ledState_l = false;
boolean ledState_m = false;
boolean ledState_n = false;
boolean ledState_o = false;
boolean ledState_p = false;
boolean ledState_q = false;
boolean ledState_r = false;
boolean ledState_s = false;
boolean ledState_t = false;
boolean ledState_u = false;
boolean ledState_v = false;
boolean ledState_w = false;
boolean ledState_x = false;
boolean ledState_y = false;
boolean ledState_z = false;
boolean ledState_A = false;
boolean ledState_B = false;
boolean ledState_C = false;
boolean ledState_D = false;
boolean ledState_E = false;
boolean ledState_F = false;
boolean ledState_G = false;
boolean ledState_H = false;
boolean ledState_I = false;
boolean ledState_J = false;
boolean ledState_K = false;
boolean ledState_L = false;
boolean ledState_M = false;
boolean ledState_N = false;
boolean ledState_O = false;
boolean ledState_P = false;
boolean ledState_Q = false;
boolean ledState_R = false;
boolean ledState_S = false;
boolean ledState_T = false;
boolean ledState_U = false;
boolean ledState_V = false;
boolean ledState_W = false;
boolean ledState_X = false;
boolean ledState_Y = false;
boolean ledState_Z = false;
//Переменные, для хранения времени
int time_a = 0;
int time_b = 0;
int time_c = 0;
int time_d = 0;
int time_e = 0;
int time_f = 0;
int time_g = 0;
int time_h = 0;
int time_i = 0;
int time_j = 0;
int time_k = 0;
int time_l = 0;
int time_m = 0;
int time_n = 0;
int time_o = 0;
int time_p = 0;
int time_q = 0;
int time_r = 0;
int time_s = 0;
int time_t = 0;
int time_u = 0;
int time_v = 0;
int time_w = 0;
int time_x = 0;
int time_y = 0;
int time_z = 0;
int time_A = 0;
int time_B = 0;
int time_C = 0;
int time_D = 0;
int time_E = 0;
int time_F = 0;
int time_G = 0;
int time_H = 0;
int time_I = 0;
int time_J = 0;
int time_K = 0;
int time_L = 0;
int time_M = 0;
int time_N = 0;
int time_O = 0;
int time_P = 0;
int time_Q = 0;
int time_R = 0;
int time_S = 0;
int time_T = 0;
int time_U = 0;
int time_V = 0;
int time_W = 0;
int time_X = 0;
int time_Y = 0;
int time_Z = 0;
void setup() <
// не стал переписывать инициализацию
Serial.begin(9600);
for (int i = 2; i 0) <
int x = Serial.read();
//Проверяем, что у нас пришло
//a
if(x == ‘a’) <
ledState_a = true;
time_a = TIME_a;
x = 0;
>
//b
if(x == ‘b’) <
ledState_b = true;
time_b = TIME_b;
x = 0;
>
//c
if(x == ‘c’) <
ledState_c = true;
time_c = TIME_c;
x = 0;
>
//d
if(x == ‘d’) <
ledState_d = true;
time_d = TIME_d;
x = 0;
>
//e
if(x == ‘e’) <
ledState_e = true;
time_e = TIME_e;
x = 0;
>
//f
if(x == ‘f’) <
ledState_f = true;
time_f = TIME_f;
x = 0;
>
//g
if(x == ‘g’) <
ledState_g = true;
time_g = TIME_g;
x = 0;
>
//h
if(x == ‘h’) <
ledState_h = true;
time_h = TIME_h;
x = 0;
>
//i
if(x == ‘i’) <
ledState_i = true;
time_i = TIME_i;
x = 0;
>
//j
if(x == ‘j’) <
ledState_j = true;
time_j = TIME_j;
x = 0;
>
//k
if(x == ‘k’) <
ledState_k = true;
time_k = TIME_k;
x = 0;
>
//l
if(x == ‘l’) <
ledState_l = true;
time_l = TIME_l;
x = 0;
>
//m
if(x == ‘m’) <
ledState_m = true;
time_m = TIME_m;
x = 0;
>
//n
if(x == ‘n’) <
ledState_n = true;
time_n = TIME_n;
x = 0;
>
//o
if(x == ‘o’) <
ledState_o = true;
time_o = TIME_o;
x = 0;
>
//p
if(x == ‘p’) <
ledState_p = true;
time_p = TIME_p;
x = 0;
>
//q
if(x == ‘q’) <
ledState_q = true;
time_q = TIME_q;
x = 0;
>
//r
if(x == ‘r’) <
ledState_r = true;
time_r = TIME_r;
x = 0;
>
//s
if(x == ‘s’) <
ledState_s = true;
time_s = TIME_s;
x = 0;
>
//t
if(x == ‘t’) <
ledState_t = true;
time_t = TIME_t;
x = 0;
>
//u
if(x == ‘u’) <
ledState_u = true;
time_u = TIME_u;
x = 0;
>
//v
if(x == ‘v’) <
ledState_v = true;
time_v = TIME_v;
x = 0;
>
//w
if(x == ‘w’) <
ledState_w = true;
time_w = TIME_w;
x = 0;
>
//x
if(x == ‘x’) <
ledState_x = true;
time_x = TIME_x;
x = 0;
>
//y
if(x == ‘y’) <
ledState_y = true;
time_y = TIME_y;
x = 0;
>
//z
if(x == ‘z’) <
ledState_z = true;
time_z = TIME_z;
x = 0;
>
//Когда приходит большая буква — меняем состояние
//A
if(x == ‘A’) <
digitalWrite (PIN_A, !digitalRead(PIN_A));
x = 0;
>
//B
if(x == ‘B’) <
digitalWrite (PIN_B, !digitalRead(PIN_B));
x = 0;
>
//C
if(x == ‘C’) <
digitalWrite (PIN_C, !digitalRead(PIN_C));
x = 0;
>
//D
if(x == ‘D’) <
digitalWrite (PIN_D, !digitalRead(PIN_D));
x = 0;
>
//E
if(x == ‘E’) <
digitalWrite (PIN_E, !digitalRead(PIN_E));
x = 0;
>
//F
if(x == ‘F’) <
digitalWrite (PIN_F, !digitalRead(PIN_F));
x = 0;
>
//G
if(x == ‘G’) <
digitalWrite (PIN_G, !digitalRead(PIN_G));
x = 0;
>
//H
if(x == ‘H’) <
digitalWrite (PIN_H, !digitalRead(PIN_H));
x = 0;
>
//I
if(x == ‘I’) <
digitalWrite (PIN_I, !digitalRead(PIN_I));
x = 0;
>
//J
if(x == ‘J’) <
digitalWrite (PIN_J, !digitalRead(PIN_J));
x = 0;
>
//K
if(x == ‘K’) <
digitalWrite (PIN_K, !digitalRead(PIN_K));
x = 0;
>
//L
if(x == ‘L’) <
digitalWrite (PIN_L, !digitalRead(PIN_L));
x = 0;
>
//M
if(x == ‘M’) <
digitalWrite (PIN_M, !digitalRead(PIN_M));
x = 0;
>
//N
if(x == ‘N’) <
digitalWrite (PIN_N, !digitalRead(PIN_N));
x = 0;
>
//O
if(x == ‘O’) <
digitalWrite (PIN_O, !digitalRead(PIN_O));
x = 0;
>
//P
if(x == ‘P’) <
digitalWrite (PIN_P, !digitalRead(PIN_P));
x = 0;
>
//Q
if(x == ‘Q’) <
digitalWrite (PIN_Q, !digitalRead(PIN_Q));
x = 0;
>
//R
if(x == ‘R’) <
digitalWrite (PIN_R, !digitalRead(PIN_R));
x = 0;
>
//S
if(x == ‘S’) <
digitalWrite (PIN_S, !digitalRead(PIN_S));
x = 0;
>
//T
if(x == ‘T’) <
digitalWrite (PIN_T, !digitalRead(PIN_T));
x = 0;
>
//U
if(x == ‘U’) <
digitalWrite (PIN_U, !digitalRead(PIN_U));
x = 0;
>
//V
if(x == ‘V’) <
digitalWrite (PIN_V, !digitalRead(PIN_V));
x = 0;
>
//W
if(x == ‘W’) <
digitalWrite (PIN_W, !digitalRead(PIN_W));
x = 0;
>
//X
if(x == ‘X’) <
digitalWrite (PIN_X, !digitalRead(PIN_X));
x = 0;
>
//Y
if(x == ‘Y’) <
digitalWrite (PIN_Y, !digitalRead(PIN_Y));
x = 0;
>
//Z
if(x == ‘Z’) <
digitalWrite (PIN_Z, !digitalRead(PIN_Z));
x = 0;
>
>
//a
if(ledState_a == true) <
time_a = time_a — 1;
digitalWrite(PIN_a, HIGH);
>
if(time_a == 0) <
ledState_a = false;
>
if(ledState_a == false) <
digitalWrite(PIN_a, LOW);
>
//b
if(ledState_b == true) <
time_b = time_b — 1;
digitalWrite(PIN_b, HIGH);
>
if(time_b == 0) <
ledState_b = false;
>
if(ledState_b == false) <
digitalWrite(PIN_b, LOW);
>
//c
if(ledState_c == true) <
time_c = time_c — 1;
digitalWrite(PIN_c, HIGH);
>
if(time_c == 0) <
ledState_c = false;
>
if(ledState_c == false) <
digitalWrite(PIN_c, LOW);
>
//d
if(ledState_d == true) <
time_d = time_d — 1;
digitalWrite(PIN_d, HIGH);
>
if(time_d == 0) <
ledState_d = false;
>
if(ledState_d == false) <
digitalWrite(PIN_d, LOW);
>
//e
if(ledState_e == true) <
time_e = time_e — 1;
digitalWrite(PIN_e, HIGH);
>
if(time_e == 0) <
ledState_e = false;
>
if(ledState_e == false) <
digitalWrite(PIN_e, LOW);
>
//f
if(ledState_f == true) <
time_f = time_f — 1;
digitalWrite(PIN_f, HIGH);
>
if(time_f == 0) <
ledState_f = false;
>
if(ledState_f == false) <
digitalWrite(PIN_f, LOW);
>
//g
if(ledState_g == true) <
time_g = time_g — 1;
digitalWrite(PIN_g, HIGH);
>
if(time_g == 0) <
ledState_g = false;
>
if(ledState_g == false) <
digitalWrite(PIN_g, LOW);
>
//h
if(ledState_h == true) <
time_h = time_h — 1;
digitalWrite(PIN_h, HIGH);
>
if(time_h == 0) <
ledState_h = false;
>
if(ledState_h == false) <
digitalWrite(PIN_h, LOW);
>
//i
if(ledState_i == true) <
time_i = time_i — 1;
digitalWrite(PIN_i, HIGH);
>
if(time_i == 0) <
ledState_i = false;
>
if(ledState_i == false) <
digitalWrite(PIN_i, LOW);
>
//j
if(ledState_j == true) <
time_j = time_j — 1;
digitalWrite(PIN_j, HIGH);
>
if(time_j == 0) <
ledState_j = false;
>
if(ledState_j == false) <
digitalWrite(PIN_j, LOW);
>
//k
if(ledState_k == true) <
time_k = time_k — 1;
digitalWrite(PIN_k, HIGH);
>
if(time_k == 0) <
ledState_k = false;
>
if(ledState_k == false) <
digitalWrite(PIN_k, LOW);
>
//l
if(ledState_l == true) <
time_l = time_l — 1;
digitalWrite(PIN_l, HIGH);
>
if(time_l == 0) <
ledState_l = false;
>
if(ledState_l == false) <
digitalWrite(PIN_l, LOW);
>
//m
if(ledState_m == true) <
time_m = time_m — 1;
digitalWrite(PIN_m, HIGH);
>
if(time_m == 0) <
ledState_m = false;
>
if(ledState_m == false) <
digitalWrite(PIN_m, LOW);
>
//n
if(ledState_n == true) <
time_n = time_n — 1;
digitalWrite(PIN_n, HIGH);
>
if(time_n == 0) <
ledState_n = false;
>
if(ledState_n == false) <
digitalWrite(PIN_n, LOW);
>
//o
if(ledState_o == true) <
time_o = time_o — 1;
digitalWrite(PIN_o, HIGH);
>
if(time_o == 0) <
ledState_o = false;
>
if(ledState_o == false) <
digitalWrite(PIN_o, LOW);
>
//p
if(ledState_p == true) <
time_p = time_p — 1;
digitalWrite(PIN_p, HIGH);
>
if(time_p == 0) <
ledState_p = false;
>
if(ledState_p == false) <
digitalWrite(PIN_p, LOW);
>
//q
if(ledState_q == true) <
time_q = time_q — 1;
digitalWrite(PIN_q, HIGH);
>
if(time_q == 0) <
ledState_q = false;
>
if(ledState_q == false) <
digitalWrite(PIN_q, LOW);
>
//r
if(ledState_r == true) <
time_r = time_r — 1;
digitalWrite(PIN_r, HIGH);
>
if(time_r == 0) <
ledState_r = false;
>
if(ledState_r == false) <
digitalWrite(PIN_r, LOW);
>
//s
if(ledState_s == true) <
time_s = time_s — 1;
digitalWrite(PIN_s, HIGH);
>
if(time_s == 0) <
ledState_s = false;
>
if(ledState_s == false) <
digitalWrite(PIN_s, LOW);
>
//t
if(ledState_t == true) <
time_t = time_t — 1;
digitalWrite(PIN_t, HIGH);
>
if(time_t == 0) <
ledState_t = false;
>
if(ledState_t == false) <
digitalWrite(PIN_t, LOW);
>
//u
if(ledState_u == true) <
time_u = time_u — 1;
digitalWrite(PIN_u, HIGH);
>
if(time_u == 0) <
ledState_u = false;
>
if(ledState_u == false) <
digitalWrite(PIN_u, LOW);
>
//v
if(ledState_v == true) <
time_v = time_v — 1;
digitalWrite(PIN_v, HIGH);
>
if(time_v == 0) <
ledState_v = false;
>
if(ledState_v == false) <
digitalWrite(PIN_v, LOW);
>
//w
if(ledState_w == true) <
time_w = time_w — 1;
digitalWrite(PIN_w, HIGH);
>
if(time_w == 0) <
ledState_w = false;
>
if(ledState_w == false) <
digitalWrite(PIN_w, LOW);
>
//x
if(ledState_x == true) <
time_x = time_x — 1;
digitalWrite(PIN_x, HIGH);
>
if(time_x == 0) <
ledState_x = false;
>
if(ledState_x == false) <
digitalWrite(PIN_x, LOW);
>
//y
if(ledState_y == true) <
time_y = time_y — 1;
digitalWrite(PIN_y, HIGH);
>
if(time_y == 0) <
ledState_y = false;
>
if(ledState_y == false) <
digitalWrite(PIN_y, LOW);
>
//z
if(ledState_z == true) <
time_z = time_z — 1;
digitalWrite(PIN_z, HIGH);
>
if(time_z == 0) <
ledState_z = false;
>
if(ledState_z == false) <
digitalWrite(PIN_z, LOW);
>