Как связать ардуино и питон

Обновлено: 18.04.2024

In this tutorial, we are going to learn how we can install python on our computer and how to use it with Arduino, it allows us to send data between a computer though Arduino's serial.

Step 1: Install Python on Your Computer

You can skip this step if you have installed the Python IDLE already in your computer.

1. Go to the python website and download it (here) .

2. Once you have done downloading, you can move on to installation by keeping the directory in which the python is getting installed by default.

Step 2: Install PySerial

PySerial is a Python API module which is used to read and write serial data to Arduino or any other Microcontroller. To install on Windows, simply visit PySerial's Download Page and following the steps bellow :

1. Download the PySerial from the link above or Open CMD and type

2. Install it by keeping the setting as the default. You should be sure that Pyserial worked correctly, To check this You can open IDLE and type in

If you are not getting any error, it means you installed it correct, else you can check your installation.

Step 3: Python Code

First up, we need a simple program to get the Python sending data over the serial port.

Очень часто, у начинающих и не только разработчиков возникают вопросы. Как управлять с Arduino с компьютера? А если компьютер — не Raspberry Pi, а обычный домашний компьютер? А если не хочется мучится с ESP8266 и управлять через веб интерфейс? Неужели надо каждый раз открывать Arduino IDE и отправлять команды через Монитор порта? Именно о том, как создать своё собственное приложение с графическим интерфейсом для управления 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.

Данная статья является вводной и обзорной, более полную информацию можно найти например тут:

Картинка для привлечения внимания

На днях появилась подработка, поступил заказ записать скетч на ардуино. Простенький, но объёмный. С повторяющимися блоками. Нужно было управлять каждым портом Arduino Mega отдельно, при получении команды по Uart. Отправляешь символ — и светодиод (к примеру) загорается на определенное время. Написал скетч на 2 команды, скинул заказчику для тестов, получил предоплату. Дальше, нужно было масштабировать на все порты.

Итак, приступим.

Создаем папку, в ней пустой файл, я назвал его «arduino_gen.py» и bat файл «start_py.bat» со следующим содержимым:

python.exe arduino_gen.py > code_out.txt
@pause

Этот файл нам потребуется, для запуска программы на Python`е
Теперь мы напишем программку, которая сгенерирует нам необходимый код для Arduino.

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

И две переменные, для перебора списков

Сохраняем, запускаем файл «start_py.bat»

Если мы хотим вывести результат сразу в файл, тогда допишем:

python.exe arduino_gen.py > code_out.txt
@pause

В результате, мы получим файл «code_out.txt » из которого, код удобно копировать в скетч в лучших традициях Arduino.

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

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

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

И масштабировал при помощи Python'а

Вот, что в итоге получилось.

//логическое состояние светодиода (да / нет)
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 pinMode(i, OUTPUT);
>
void loop() <
if (Serial.available() >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);
>

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

P.P.S.: Заказчик был ужасно доволен, заплатил больше, чем договаривались, и даже разрешил поделиться кодом с читателями.

Цифровые и аналоговые датчики, подключенные к Arduino, генерируют большие объёмы информации, которая требует обработки в реальном масштабе времени [1].

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

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

Использование CSV-файлов для хранения данных полученных от датчиков, работающих с Arduino

Потенциометр подключён к аналоговому выводу 0, а датчик движения PIR к цифровому выводу 11, как показано на следующей схеме:

Для работы данной схемы, необходимо загрузить в Python модуль pyFirmata и эскиз StandardFirmata в плату Arduino.

В любом файле Python разместим следующий код, который запускает и останавливает запись данных от обеих датчиков в файл SensorDataStore.csv:

В результате работы листинга №1, получим запись данных в файл 'SensorDataStore.csv':

Рассмотрим код связанный с хранением данных датчиков. Первая строка записи в CSV файл– строка заголовка, которая объясняет содержимое столбцов: w.writerow([«Number», «Potentiometer», «Motion sensor»]).

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

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

Можно изменить номера выводов Arduino и количество выводов, которые будут использоваться. Это можно сделать, добавив в код Python и эскиз StandardFirmata в Arduino строки дополнительных значений для новых датчиков.
CSV-файл: имя файла и его местоположение можно изменить с SensorDataStore.csv на то, которое относится к вашему приложению.
Частоту записей m в файл SensorDataStore.csv можно изменить, изменяя шаг, а длительность записи изменяя число циклов при постоянном шаге.

Графический анализ данных из файла CSV

Используя файл SensorDataStore.csv создадим программу для поучений массивов данных от потенциометра и датчика движения и построения графиков по данным массивам:

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

В этой программе мы создали два массива значений датчиков — pValues и mValues — путем чтения файла SensorDataStore.csv по строкам. Здесь pValues и mValues представляют данные датчика для потенциометра и датчика движения соответственно. С использованием методов matplotlib построим два графика на одной форме.

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

Однако метод хранения и визуализации данных имеет следующие особенности – весь набор данных сначала записываются в файл SensorDataStore.csv (Листинг №1), а затем считываются из этого файла (Листинг №2). Графики должны перерисовываться каждый раз, когда поступают новые значения от Arduino. Поэтому нужно разработать такую программу, в которой планирование и обновление графиков происходит в реальном времени, а не строится весь набор значений датчиков, как в листингах №1,2.[2].

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

В результате работы листинга №3, получим график.

Планирование в реальном времени в этом упражнении достигается с помощью комбинации функций pyplot ion (), draw (), set_xdata () и set_data (). Метод ion () инициализирует интерактивный режим pyplot. Интерактивный режим помогает динамически изменять значения x и y графиков на рисунке pyplot.ion ().

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

Как вы можете видеть в следующей строке кода, после настройки платы Arduino и интерактивного режима pyplot, мы инициализировали график с набором пустых данных, в нашем случае 0: pData = [0] * 25.

Этот массив для значений y, pData, затем используется для добавления значений из датчика в цикле while. Цикл while продолжает добавлять новые значения в этот массив данных и перерисовывает график с этими обновленными массивами для значений x и y.

В листинге №3 мы добавляем новые значения датчиков в конце массива, одновременно удаляя первый элемент массива, чтобы ограничить размер массива:

Методы set_xdata () и set_ydata () используются для обновления данных осей x и y из этих массивов. Эти обновленные значения наносятся с использованием метода draw () на каждой итерации цикла while:

Вы также заметите, что мы используем функцию xrange () для генерации диапазона значений в соответствии с предоставленной длиной, которая равна 25 в нашем случае. Фрагмент кода [i for i in xrange(25)] будет генерировать список из 25 целых чисел, которые начинаются постепенно с 0 и заканчиваются на 24.

Интеграция графиков в окне Tkinter

Благодаря мощным возможностям интеграции Python, очень удобно связать графики, созданные библиотекой matplotlib, с графическим интерфейсом Tkinter. Напишем программу для соединения между Tkinter и matplotlib.

В результате работы листинга №4, получим встроенный в окно Tkinter. график с элементами кнопочного интерфейса – startButton, pauseButton и exitButton.

Кнопки «Start» и «Exit» предоставляют контрольные точки для операций matplotlib, та-кие как обновление графика и закрытие графика с помощью соответствующих функций onStartButtonPress () и onExitButtonPress (). Функция onStartButtonPress () также состоит из точки взаимодействия между библиотеками matplotlib и pyFirmata. Как вы можете видеть из следующего фрагмента кода, мы начнем обновлять график, используя метод draw () и окно Tkinter, используя метод update () для каждого наблюдения с аналогового вывода a0, который получается с помощью метода read ().

Функция onExitButtonPress () реализует функцию exit, как описано в самом имени. Она закрывает фигуру pyplot и окно Tkinter перед отключением платы Arduino от последовательного порта.

При подготовке материалов данной публикации принимал участие Мисов О. П.

Выводы

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

In this tutorial, we are going to learn how we can install python on our computer and how to use it with Arduino,It allows us to send data.

130,228 views
6 comments
29 respects

Components and supplies

Apps and online services

About this project

In this tutorial, we are going to learn how we can install python on our computer and how to use it with Arduino,It allows us to send data back and forth between a computer though Arduino's serial.

So, I'm going to show you how to tell your arduino to blink using Python code. Once you understand this,You would touch lots of possibilities since python has an increased productivity with its ability to interact with other platforms.

Obviously,The main idea of this tutorial is to turn ON the LED when I type '1' and '0' to turn OFF.

Читайте также: