можно ли программировать ардуино на питоне
Управление Arduino с помощью оболочки Python
Приводим пример одного из способов по управлению платами и микроконтроллерами Arduino с помощью оболочки языка Python.
Наиболее эффективным и простым в изучении языком программирования в современном мире является python. Имея миллионы приложений и максимально удобный интерфейс, мы можем с ним почти все.
В этой статье я попытался объединить среду Arduino с оболочкой Python.
Из комплектующих нам понадобятся только Arduino Uno (Genuino Uno) и Arduino IDE.
Установка Python
Сначала, вам нужно будет скачать python на свой компьютер, чтобы продолжить работу с платой.
Выполните следующие шаги, которые я привел ниже.
Упомянутые ниже шаги применимы только для пользователей Windows, работающих на 32-битной или 64-битной ОС. Процедура установки для MAC и Linux отличается.
Нам нужно скачать среду с официального сайта «Питона» отсюда.
Импорт Pyserial
Теперь вам нужно будет импортировать модуль Pyserial в ваш IDLE.
Нажмите на Pyserial Windows (ссылка), чтобы загрузить PySerial. В результате вы получите исполняемый exe-файл, который можно установить напрямую. Не меняйте никаких настроек во время установки. Оставьте его в каталоге по умолчанию и с настройками по умолчанию.
Теперь давайте проверим, правильно ли установлен PySerial. Для этого снова откройте Python Shell и введите:
import serial
Если библиотека была успешно установлена, вы не должны получить никаких сообщений об ошибках.
Внутри функции настройки мы инициализируем последовательную связь со скоростью 9600 бод и объявляем, что будем использовать встроенный светодиод в качестве выхода, и выставляем его на минимальный уровень при запуске программы.
Коды проекта
Вы можете скопировать коды для проекта ниже.
Код Python :
Код Ардуино #1:
Код Ардуино #2:
Мы также отправили приветственное сообщение на python с помощью последовательной вывод, как показано в коде Python #2:
Внутри функции цикла loop мы читаем любые данные, поступающие последовательно, и присваиваем значение переменной «data». Теперь, основываясь на значении этой переменной («data»), мы переключаем встроенный светодиод, как показано в коде Python #1.
Вышеупомянутые фрагменты кода будут написаны в Arduino IDE. Вышеупомянутый код должен быть написан на Python в режиме ожидания для Windows. Затем вам просто нужно загрузить код Ардуино (выше) в вашу оболочку python для управления встроенным светодиодом на вашем Arduino.
Arduino + Python: программирование платы на «питоне»
Материал по основам взаимодействия плат Arduino и языка программирования Python.
Вступление
В начале у вас может возникнуть ряд сложностей по взаимодействию Arduino и Python, но надеюсь, что этот материал объяснит основы всем, кто хочет начать использовать последовательные функции, которые предоставляет Arduino.
Также я предполагаю, что раз вы читаете эту публикацию, то у вас есть некоторые знания о том, как работает Arduino, как загружать скетчи и тому подобное. Если нет, то вы можете пройти мой курс «Ардуино для начинающих». Но в любом случае я объясню ниже код Arduino и Python, который довольно простой. Сама программа не так сложна для понимания, как понимание работы последовательной связи.
Ниже мы разберем как заставить мигать светодиод Arduino, используя компьютер. Надеюсь эти знания позволят вам в дальнейшем расширить код Python и код Arduino для своих собственных проектов.
Установка Python и библиотек
Очевидно, что нам на нашем компьютере понадобится Python, если мы хотим что-то сделать. Если у вас не установлен Python, то вам нужно зайти на официальный сайт python и скачать: python.org (ссылка). Вы скорее всего скачаете файл с расширением .exe. Запустите файл и пройдите все необходимые шаги установки. Она очень простая.
Как только у нас будет установлен Python, вам понадобится новая дополнительная библиотека под названием PySerial. Данная библиотека обеспечит все функции и методы, которые нам понадобятся для общения с нашим Arduino.
Также вы можете посмотреть на GitHub:
Для установки используем встроенный менеджер пакетов pip:
Чтобы убедиться, что все установлено правильно, откройте Idle и введите: Import Serial. Если ошибок нет, значит, все хорошо.
Вы можете проверить доступные порты таким образом:
По ссылкам выше можно найти документацию по работе с библиотекой в Windows, macOS, Linux. Если вы используете Eclipse, то вам может пригодиться дополнение Python для Eclipse, если вы хотите программировать в среде Eclipse. Теперь, когда всё установлено, мы можем начать писать нашу программу на Python.
Код Python
Теперь мы можем начать программирование. Также ниже разберем код программы более детально.
Чтобы реально использовать методы PySerial, нам нужно импортировать последовательную библиотеку, прежде чем мы попытаемся ее использовать, что мы и делаем в первой строке программы.
Далее я объявляю переменную, которая будет действовать как флаг, когда последовательное соединение Arduino открывается. Мы не будем пытаться отправлять что-либо в Arduino, пока плата не отправит что-нибудь нам.
Затем мы инициализируем последовательную переменную ser, которая будет связываться с Arduino. Два параметра отправляются при инициализации последовательной переменной.
Во-первых, вы должны указать порт по которому мы будем общаться (в моем случае это COM11, но в вашем случае может отличаться). Чтобы узнать, какой порт использует ваш Arduino, подключите его к компьютеру и откройте диспетчер устройств. Arduino IDE также сообщит вам, какой порт она использует.
Далее мы используем функцию записи, которая отправляет число 1 в Arduino, чтобы заставить светодиод мигать. Плата мигнет дважды.
Далее мы ждем пока Arduino скажет нам, что она мигнула дважды. Цикл while будет работать пока не получит сообщение. Когда мы получаем сообщение от Arduino, мы можем закрыть последовательный порт и завершить программу. Так что это все, что нам нужно для программы на Python, всего 10 строк кода.
Есть еще один пример кода Python. Посмотрите на него самостоятельно и попробуйте разобраться в нем:
Для второго примера кода Питона ниже я приведу соответствующий код программы Ардуино.
Во втором примере вам также нужно иметь в виду два основных момента. Нужно определить к какому последовательному порту подключена ваша Arduino. Что бы это ни было, это должно быть в кавычках в строке 3 программы Python.
Вы также можете изменить скорость передачи данных в строке 3 программы Python и строке 2 программы Arduino, если они не изменяются.
После запуска программы она выведет большинство символов ASCII, сначала отправив их в Arduino, который, в свою очередь, отправит их обратно на компьютер, который затем выведет Python.
Скетч Ардуино
Скетч Ардуино для первого примера со светодиодом ниже:
Я изначально предполагаю, что у вас установлено и работает программное обеспечение Arduino. Так как мы просто хотим мигнуть светодиодом, то мы можем просто использовать светодиод платы Arduino или подключить светодиод к контакту 13 и заземлению.
В void setup() мы запускаем последовательный монитор со скоростью 9600 бод. Скорость не имеет значения, просто убедитесь, что она соответствует скорости в бодах в программе Python.
Затем мы создаем выходной контакт, к которому подключен светодиод. Наконец, мы пишем в последовательный порт, чтобы программа на Python знала, что мы готовы.
В void loop() у нас есть одно большое выражение в виде условного if. Суть в ожидании момента, когда программа python отправит что-то через последовательный порт. Когда Arduino что-то получит, светодиод мигнет дважды.
После двух миганий Arduino отправляет сообщение о том, что плата прекратила мигать. Программа Python увидит это и затем остановится.
Для второго варианта наш скетч Ардуино будет выглядеть так:
Загрузите скетч на свою плату и запустите программу Python. Если все сделано правильно, вы должны увидеть мигание светодиода из первого примера. Далее, для эксперимента вы можете попробовать добавить еще один светодиод и сделать их чередующимися. На этом всё. Хороших вам проектов.
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, кроме его кроссплатформенности — наличие гигантского числа библиотек. Нам понадобятся:
Установка
Для установки, воспользуемся встроенным менеджером пакетов — pip.
Для удобства создания GUI можно установить программу QTDesigner.
Интерфейс
Поскольку данная программа предназначена скорее, для демонстрации возможностей, пользователь может выбрать порт из предложенных, а так же скорость, с которой будет происходить общение.
Исходный код
Вся работа с устройством происходит благодаря библиотеке PySerial. Но есть несколько нюансов. Например, как узнать, в какой из портов подключено устройство?
На всем прекрасно известном сайте stackoverflow, пользователь с ником Thomas предложил уже готовое решение, которое я и использовал.
Кроме этого необходимо хранить список доступных скоростей:
Основной класс, содержащий в себе всю логику программы
Переменные self.Port и self.Speed — это выпадающие списки, содержащие в себе значения доступных портов и скоростей.
При нажатии на кнопку self.ConnectButton вызывается функция connect, в которой производится попытка подключения к заданному порту с заданной скоростью. Если подключение успешно, то кнопка окрашивается в зелёный цвет, и меняется надпись.
Функция send отправляет в наш порт байтовую строку — заставляющую включить режим мигания.
Таким образом можно управлять различными устройствами, подключёнными к USB.
Данная статья является вводной и обзорной, более полную информацию можно найти например тут:
Как я писал код для 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(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);
>