Arduino с Python: как начать

Оглавление

Платформа Arduino
- Оборудование Arduino
- Программное обеспечение Arduino
“ Привет, Мир!” С помощью Arduino
“ Привет, Мир!” С помощью Arduino и Python
Заключение
Читать далее

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

Вы познакомитесь с основами Arduino на Python и узнаете, как:

Настройка электронных схем
Настройка протокола Firmata на Arduino
Написание базовых приложений для Arduino на Python
Управление аналоговыми и цифровыми входами и выходами
Интегрируйте датчики и переключатели Arduino с приложениями более высокого уровня
Запускайте уведомления на вашем ПК и отправляйте электронные письма с помощью Arduino

Платформа Arduino

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

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

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

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

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

Аппаратное обеспечение Arduino

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

На Arduino Uno или другой совместимой плате
Стандартный светодиод любого цвета
Кнопка
Потенциометр на 10 Ком
Резистор на 470 Ом
Резистор на 10 Ком
Макетная плата
Соединительные провода различных цветов и размеров

Давайте подробнее рассмотрим некоторые из этих компонентов.

Компонентом 1 является Arduino Uno или другая совместимая плата. Arduino - это проект, который включает в себя множество плат и модулей различного назначения, и Arduino Uno является самым базовым из них. Это также самая используемая и документированная плата из всего семейства Arduino, поэтому это отличный выбор для разработчиков, которые только начинают работать с электроникой.

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

Компоненты 5 и 6 являются резисторами. Большинство резисторов обозначаются цветными полосками в соответствии с цветовым кодом. Как правило, первые три цвета представляют значение резистора, в то время как четвертый цвет представляет его допуск. Для резистора емкостью 470 Ом первые три цвета - желтый, фиолетовый и коричневый. Для резистора емкостью 10 Ком первые три цвета - коричневый, черный и оранжевый.

Компонент 7 представляет собой макетную плату, которую вы используете для подключения всех остальных компонентов и сборки схем. Хотя макетная плата не требуется, рекомендуется приобрести ее, если вы собираетесь начать работать с Arduino.

Программное обеспечение Arduino

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

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

Подключите плату к компьютеру
Установите и откройте Arduino IDE
Настройте параметры платы
Напишите код
Нажмите кнопку в IDE, чтобы загрузить программу на панель управления

Чтобы установить Arduino IDE на свой компьютер, загрузите соответствующую версию для вашей операционной системы с веб-сайта Arduino. Инструкции по установке приведены в документации:

Если вы используете Windows, то воспользуйтесь установщиком Windows, чтобы убедиться, что вы загрузили необходимые драйверы для использования Arduino в Windows. Ознакомьтесь с Документацией по Arduino для получения более подробной информации.
Если вы используете Linux, то вам, возможно, придется добавить своего пользователя в некоторые группы, чтобы использовать последовательный порт для программирования Arduino. Этот процесс описан в руководстве по установке Arduino для Linux .
Если вы используете macOS, то вы можете установить Arduino IDE, следуя Руководству по установке Arduino для OS X.

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

Теперь, когда вы установили Arduino IDE и собрали все необходимые компоненты, вы готовы приступить к работе с Arduino! Далее вы загрузите программу “Привет, мир!” на свою плату.

“Привет, мир!” С помощью Arduino

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

Загрузка примера эскиза Blink

Для начала подключите плату Arduino к компьютеру с помощью USB-кабеля и запустите Arduino IDE. Чтобы открыть пример эскиза Blink, откройте меню Файл и выберите Примеры, затем 01.Основы и, наконец, Мигает:

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

Для настройки платы откройте меню Сервис, а затем Плата. Для Arduino Uno вам следует выбрать Arduino/Genuino Uno:

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

Названия портов могут отличаться в зависимости от используемой операционной системы. В Windows порты будут называться COM4, COM5, или что-то подобное. В macOS или Linux вы можете увидеть что-то вроде /dev/ttyACM0 или /dev/ttyUSB0. Если у вас возникли какие-либо проблемы с настройкой порта, ознакомьтесь со страницей устранения неполадок Arduino .

После того, как вы настроили плату и порт, вы можете загрузить эскиз на свой Arduino. Для этого вам просто нужно нажать кнопку Загрузить на панели инструментов IDE:

Когда вы нажимаете Загрузить, среда IDE компилирует эскиз и загружает его на вашу доску. Если вы хотите проверить, нет ли ошибок, то вы можете нажать Проверить перед Загрузкой, которая только скомпилирует ваш эскиз.

USB-кабель обеспечивает последовательное подключение как для загрузки программы, так и для питания платы Arduino. Во время загрузки на плате будут мигать светодиоды. Через несколько секунд загруженная программа запустится, и вы увидите, как светодиод мигает раз в секунду:

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

Подключение внешних компонентов

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

Хотя эти соединения обычно называются контактами, вы можете видеть, что это не совсем физические контакты. Скорее, контакты представляют собой отверстия в разъеме, к которым можно подключить соединительные провода. На рисунке выше вы можете видеть различные группы контактов:

Оранжевый прямоугольник: Это 13 цифровых контактов, которые вы можете использовать в качестве входов или выходов. Они предназначены только для работы с цифровыми сигналами, которые имеют 2 различных уровня:
1. Уровень 0: представлен напряжением 0 В
2. Уровень 1: представлен напряжением 5 В
Зеленый прямоугольник: Это 6 аналоговых выводов, которые вы можете использовать в качестве аналоговых входов. Они предназначены для работы с произвольным напряжением от 0 до 5 В.
Синий прямоугольник: Это 5 выводов питания. В основном они используются для питания внешних компонентов.

Чтобы начать работу с внешними компонентами, необходимо подключить внешний светодиод для запуска примера эскиза мигания. Встроенный светодиод подключен к цифровому контакту #13. Итак, давайте подключим внешний светодиод к этому выводу и проверим, мигает ли он. (Стандартный светодиод - это один из компонентов, которые вы видели в списке ранее.)

Перед подключением чего-либо к плате Arduino рекомендуется отключить это устройство от компьютера. Отсоединив USB-кабель, вы сможете подключить светодиод к плате:

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

Использование макета

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

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

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

Подсоедините одно отверстие на красной линии к источнику питания.
Соедините одно отверстие на синей линии с землей.

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

Вы можете использовать макетную плату для сборки схемы, использованной в примере эскиза Blink:

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

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

Резистор подключен к цифровому выводу 13 на плате Arduino.
Анод светодиода подключен к другому выводу резистора.
Катод светодиода подключен к земле (GND) через синюю линию отверстий.

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

После завершения подключения подключите Arduino обратно к ПК и повторно запустите Blink sketch:

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

“Привет, мир!” С помощью Arduino и Python

В предыдущем разделе вы загрузили эскиз Blink на свою плату Arduino. Эскизы Arduino написаны на языке, похожем на C++, и компилируются и записываются во флэш-память микроконтроллера при нажатии кнопки Загрузить. Хотя вы можете использовать другой язык для непосредственного программирования микроконтроллера Arduino, это не тривиальная задача!

Однако есть несколько подходов, которые вы можете использовать для использования Arduino с Python или другими языками. Одна из идей заключается в том, чтобы запустить основную программу на ПК и использовать последовательное соединение для связи с Arduino через USB-кабель. Эскиз будет отвечать за считывание входных данных, отправку информации на ПК и получение обновлений с ПК для обновления выходов Arduino.

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

ЗНАЧЕНИЕ ВЫВОДА 13 ВЫСОКОЕ: используется для информирования ПК о состоянии выводов цифрового входа
УСТАНОВИТЕ НИЗКИЙ уровень вывода 11: используется для указания Arduino установить состояния выходных выводов

Определив протокол, вы могли бы написать эскиз Arduino для отправки сообщений на ПК и обновления состояний контактов в соответствии с протоколом. На ПК вы могли бы написать программу для управления Arduino через последовательное соединение, основанную на разработанном вами протоколе. Для этого вы можете использовать любой язык и библиотеки, которые вам больше нравятся, такие как Python и библиотека PySerial.

К счастью, для всего этого существуют стандартные протоколы! Firmata - один из них. Этот протокол устанавливает формат последовательной связи, который позволяет считывать данные с цифровых и аналоговых входов, а также отправлять информацию на цифровые и аналоговые выходы.

Arduino IDE включает в себя готовые эскизы, которые позволят Arduino использовать Python с протоколом Firmata. На стороне ПК существуют реализации протокола на нескольких языках, включая Python. Чтобы начать работу с Firmata, давайте используем ее для реализации программы “Привет, мир!”.

Загрузка эскиза Firmata

Прежде чем вы напишете свою программу на Python для управления Arduino, вам необходимо загрузить эскиз Firmata, чтобы вы могли использовать этот протокол для управления платой. Эскиз доступен во встроенных примерах Arduino IDE. Чтобы открыть его, откройте меню Файл, затем Примеры, затем Данные о фирмах и, наконец Подтверждение стандарта:

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

Подключите USB-кабель к компьютеру.
Выберите соответствующую плату и порт в IDE.
Нажмите Загрузить.

После завершения загрузки вы не заметите никакой активности на Arduino. Чтобы управлять им, вам все равно понадобится программа, которая может взаимодействовать с платой через последовательное соединение. Для работы с протоколом Firmata в Python вам понадобится пакет pyFirmata, который вы можете установить с помощью pip:

$ pip install pyfirmata

После завершения установки вы можете запустить эквивалентное приложение Blink, используя Python и Firmata:

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6while True:
 7    board.digital[13].write(1)
 8    time.sleep(1)
 9    board.digital[13].write(0)
10    time.sleep(1)

Вот как работает эта программа . Вы импортируете pyfirmata и используете его для установления последовательного соединения с платой Arduino, которая представлена объектом board в строке 4. Вы также можете настроить порт в этой строке, передав аргумент в pyfirmata.Arduino(). Вы можете использовать Arduino IDE для поиска порта.

board.digital это список, элементы которого представляют цифровые контакты Arduino. У этих элементов есть методы read() и write(), которые будут считывать и записывать состояние контактов. Как и большинство программ для встроенных устройств, эта программа в основном состоит из бесконечного цикла:

В строке 7 включен цифровой вывод 13, который включает светодиод на одну секунду.
В строке 9, этот вывод выключен, что приводит к выключению светодиода на одну секунду.

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

Считывание цифровых входов

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

Value	Level	Voltage
0	Low	0V
1	High	5V

Для управления светодиодом вы будете использовать кнопку для отправки цифровых входных значений в Arduino. При отпускании кнопки на плату должно подаваться напряжение 0 В, а при нажатии - 5 В. На рисунке ниже показано, как подключить кнопку к плате Arduino:

Вы можете заметить, что светодиод подключен к Arduino на цифровом выводе 13, как и раньше. Цифровой вывод 10 используется в качестве цифрового входа. Чтобы подключить нажимную кнопку, вы должны использовать резистор 10 Ком, который в этой схеме выполняет функцию опускающего . Резистор , опускающий , гарантирует, что при отпускании кнопки на цифровом входе будет 0 В.

Когда вы отпускаете кнопку, вы размыкаете соединение между двумя проводами на кнопке. Поскольку ток через резистор не протекает, вывод 10 просто подключается к земле (GND). На цифровой вход поступает 0 В, что соответствует состоянию 0 (или низкий уровень). Когда вы нажимаете на кнопку, вы подаете напряжение 5 В как на резистор, так и на цифровой вход. Через резистор протекает ток, и на цифровой вход поступает напряжение 5 В, которое соответствует состоянию 1 (или высокий).

Вы также можете использовать макетную плату для сборки приведенной выше схемы:

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

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6it = pyfirmata.util.Iterator(board)
 7it.start()
 8
 9board.digital[10].mode = pyfirmata.INPUT
10
11while True:
12    sw = board.digital[10].read()
13    if sw is True:
14        board.digital[13].write(1)
15    else:
16        board.digital[13].write(0)
17    time.sleep(0.1)

Давайте пройдемся по этой программе:

Строки 1 и 2 импорт pyfirmata и time.
В строке 4 используется pyfirmata.Arduino() для установки соединения с платой Arduino.
Строка 6 назначает итератор, который будет использоваться для считывания состояния входов схемы.
Строка 7 запускает итератор, который выполняет цикл параллельно с вашим основным кодом. Цикл выполняется board.iterate() для обновления входных значений, полученных с платы Arduino.
Строка 9 устанавливает вывод 10 в качестве цифрового входа с помощью pyfirmata.INPUT. Это необходимо, поскольку конфигурация по умолчанию предусматривает использование цифровых выводов в качестве выходов.
Строка 11 запускает бесконечный цикл while. Этот цикл считывает состояние входного контакта, сохраняет его в sw и использует это значение для включения или выключения светодиода путем изменения значения контакта 13.
Строка 17 ожидает 0,1 секунды между итерациями цикла while. В этом нет строгой необходимости, но это хороший способ избежать перегрузки центрального процессора, который достигает 100% загрузки, когда в цикле нет команды ожидания.

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

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6it = pyfirmata.util.Iterator(board)
 7it.start()
 8
 9digital_input = board.get_pin('d:10:i')
10led = board.get_pin('d:13:o')
11
12while True:
13    sw = digital_input.read()
14    if sw is True:
15        led.write(1)
16    else:
17        led.write(0)
18    time.sleep(0.1)

В этой версии вы используете board.get_pin() для создания двух объектов. digital_input представляет состояние цифрового входа, а led - состояние светодиода. Когда вы запускаете этот метод, вы должны передать строковый аргумент, состоящий из трех элементов, разделенных двоеточиями:

Тип вывода (a для аналогового или d для цифрового)
Номер пин-кода
Режим вывода (i для ввода или o для вывода)

Поскольку digital_input является цифровым входом, использующим вывод 10, вы передаете аргумент 'd:10:i'. Состояние светодиода устанавливается на цифровой выход с помощью контакта 13, поэтому аргументом led является 'd:13:o'.

Когда вы используете board.get_pin(), нет необходимости явно настраивать вывод 10 в качестве входных данных, как вы делали ранее с pyfirmata.INPUT. После установки контактов вы можете получить доступ к состоянию цифрового входного контакта с помощью read() и установить состояние цифрового выходного контакта с помощью write().

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

Считывание данных с аналоговых входов

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

Для считывания аналогового напряжения Arduino использует аналого-цифровой преобразователь (АЦП), который преобразует входное напряжение к цифровому числу с фиксированным числом битов. Это определяет разрешающую способность преобразования. Arduino Uno использует 10-разрядный АЦП и может определять 1024 различных уровня напряжения.

Диапазон напряжений на аналоговом входе кодируется числами в диапазоне от 0 до 1023. Когда подается напряжение 0 В, Arduino кодирует его в число 0. При подаче напряжения 5 В кодируемое число равно 1023. Все промежуточные значения напряжения кодируются пропорционально.

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

В этой схеме светодиод настроен так же, как и раньше. Концевые клеммы потенциометра подключены к контактам заземления (GND) и 5 В. Таким образом, центральный вывод (курсор), подключенный к Arduino через аналоговый вывод A0, может иметь любое напряжение в диапазоне от 0 В до 5 В в зависимости от его положения.

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

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

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5it = pyfirmata.util.Iterator(board)
 6it.start()
 7
 8analog_input = board.get_pin('a:0:i')
 9
10while True:
11    analog_value = analog_input.read()
12    print(analog_value)
13    time.sleep(0.1)

В строке 8 вы устанавливаете analog_input в качестве аналогового входного контакта A0 с аргументом 'a:0:i'. Внутри бесконечного цикла while вы считываете это значение, сохраняете его в analog_value и выводите на консоль с помощью print(). Когда вы перемещаете потенциометр во время выполнения программы, вы должны выводить примерно следующее:

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

Чтобы изменить частоту мигания светодиода, вы можете использовать analog_value для управления продолжительностью горения светодиода:

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5it = pyfirmata.util.Iterator(board)
 6it.start()
 7
 8analog_input = board.get_pin('a:0:i')
 9led = board.get_pin('d:13:o')
10
11while True:
12    analog_value = analog_input.read()
13    if analog_value is not None:
14        delay = analog_value + 0.01
15        led.write(1)
16        time.sleep(delay)
17        led.write(0)
18        time.sleep(delay)
19    else:
20        time.sleep(0.1)

Здесь вы вычисляете delay как analog_value + 0.01, чтобы избежать значения delay, равного нулю. В противном случае, обычно получается analog_value из None в течение первых нескольких итераций. Чтобы избежать появления ошибки при запуске программы, вы используете условное обозначение в строке 13, чтобы проверить, соответствует ли analog_value None. Затем вы управляете периодом мигания светодиода.

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

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

Использование аналоговых выходов

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

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

Не все цифровые контакты Arduino можно использовать в качестве ШИМ-выходов. Те, которые могут быть использованы, обозначены тильдой (~):

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

Когда ШИМ-сигнал подается на светодиод, его яркость изменяется в зависимости от рабочего цикла ШИМ-сигнала. Вы собираетесь использовать следующую схему:

Эта схема идентична той, которая использовалась в предыдущем разделе для тестирования аналогового входа, за исключением одного отличия. Поскольку невозможно использовать ШИМ с выводом 13, вывод цифрового выхода, используемый для светодиода, - это вывод 11.

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

После сборки схемы вы можете управлять светодиодом с помощью ШИМ с помощью следующей программы:

 1import pyfirmata
 2import time
 3
 4board = pyfirmata.Arduino('/dev/ttyACM0')
 5
 6it = pyfirmata.util.Iterator(board)
 7it.start()
 8
 9analog_input = board.get_pin('a:0:i')
10led = board.get_pin('d:11:p')
11
12while True:
13    analog_value = analog_input.read()
14    if analog_value is not None:
15        led.write(analog_value)
16    time.sleep(0.1)

Есть несколько отличий от программ, которые вы использовали ранее:

В строке 10 вы переводите led в режим ШИМ, передавая аргумент 'd:11:p'.
В строке 15 вы вызываете led.write() с analog_value в качестве аргумента. Это значение от 0 до 1, считываемое с аналогового входа.

Здесь вы можете увидеть поведение светодиода при перемещении потенциометра:

Для отображения изменений в рабочем цикле к выводу 11 подключен осциллограф. Когда потенциометр находится в нулевом положении, вы можете видеть, что светодиод выключен, так как на выводе 11 указано 0 В. Когда вы поворачиваете потенциометр, светодиод становится ярче по мере увеличения рабочего цикла ШИМ. Когда вы поворачиваете потенциометр до упора, рабочий цикл достигает 100%. Светодиод постоянно горит на максимальной яркости.

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

Использование датчика для запуска уведомления

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

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

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

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

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

 1import pyfirmata
 2import time
 3import tkinter
 4from tkinter import messagebox
 5
 6root = tkinter.Tk()
 7root.withdraw()
 8
 9board = pyfirmata.Arduino('/dev/ttyACM0')
10
11it = pyfirmata.util.Iterator(board)
12it.start()
13
14digital_input = board.get_pin('d:10:i')
15led = board.get_pin('d:13:o')
16
17while True:
18    sw = digital_input.read()
19    if sw is True:
20        led.write(1)
21        messagebox.showinfo("Notification", "Button was pressed")
22        root.update()
23        led.write(0)
24    time.sleep(0.1)

Эта программа аналогична программе, используемой в примере с цифровым входом, с некоторыми изменениями:

Строки 3 и 4 импортируйте библиотеки, необходимые для настройки Tkinter.
Строка 6 создает главное окно Tkinter.
В строке 7 указано, что Tkinter не должен отображать главное окно на экране. В этом примере вам нужно увидеть только окно сообщения.
Строка 17 запускает цикл while:
1. При нажатии кнопки загорается светодиод и messagebox.showinfo() отображается окно с сообщением.
2. Цикл приостанавливается до тех пор, пока пользователь не нажмет OK. Таким образом, индикатор будет гореть до тех пор, пока сообщение не появится на экране.
3. После того, как пользователь нажмет OK, root.update() окно сообщения исчезнет с экрана, а индикатор погаснет.

Чтобы расширить пример уведомления, вы могли бы даже использовать кнопку для отправки электронного письма при нажатии:

 1import pyfirmata
 2import time
 3import smtplib
 4import ssl
 5
 6def send_email():
 7    port = 465  # For SSL
 8    smtp_server = "smtp.gmail.com"
 9    sender_email = "<your email address>"
10    receiver_email = "<destination email address>"
11    password = "<password>"
12    message = """Subject: Arduino Notification\n The switch was turned on."""
13
14    context = ssl.create_default_context()
15    with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
16        print("Sending email")
17        server.login(sender_email, password)
18        server.sendmail(sender_email, receiver_email, message)
19
20board = pyfirmata.Arduino('/dev/ttyACM0')
21
22it = pyfirmata.util.Iterator(board)
23it.start()
24
25digital_input = board.get_pin('d:10:i')
26
27while True:
28    sw = digital_input.read()
29    if sw is True:
30        send_email()
31        time.sleep(0.1)

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

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

На примере этих приложений вы увидели, как использовать Firmata для взаимодействия с более сложными приложениями на Python. Firmata позволяет использовать любой датчик, подключенный к Arduino, для получения данных для вашего приложения. Затем вы можете обрабатывать данные и принимать решения в рамках основного приложения. Вы даже можете использовать Firmata для отправки данных на выходы Arduino, управляющие переключатели или ШИМ-устройства.

Если вы заинтересованы в использовании Firmata для взаимодействия с более сложными приложениями, попробуйте некоторые из этих проектов:

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

Заключение

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

Вы узнали, как:

Разрабатывайте приложения с помощью Arduino и Python
Используйте протокол Firmata
Управление аналоговыми и цифровыми входами и выходами
Интеграция датчиков с приложениями Python более высокого уровня

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

Читать далее

Теперь, когда вы знаете основы управления Arduino с помощью Python, вы можете приступить к работе над более сложными приложениями. Существует несколько руководств, которые помогут вам разрабатывать интегрированные проекты. Вот несколько идей:

REST API: Они широко используются для интеграции различных приложений. Вы могли бы использовать REST с Arduino для создания API, которые получают информацию от датчиков и отправляют команды исполнительным механизмам. Чтобы узнать больше об API-интерфейсах REST, ознакомьтесь с API-интерфейсами Python REST с использованием Flask, Connexion и SQLAlchemy.
Альтернативные графические интерфейсы: В этом руководстве вы использовали Tkinter для создания графического приложения. Однако существуют и другие графические библиотеки для настольных приложений. Чтобы ознакомиться с альтернативой, ознакомьтесь с Как создать приложение с графическим интерфейсом Python с помощью wxPython.
Многопоточность: Бесконечный цикл while, который вы использовали в этом руководстве, является очень распространенной функцией приложений Arduino. Однако использование потока для запуска основного цикла позволит вам одновременно выполнять другие задачи. Чтобы узнать, как использовать потоки, ознакомьтесь с Введением к потоковой обработке в Python.
Распознавание лиц: Приложения Интернета вещей часто интегрируют алгоритмы машинного обучения и компьютерного зрения. С их помощью вы могли бы создать систему оповещения, которая, например, запускает уведомление при обнаружении лиц на камере. Чтобы узнать больше о системах распознавания лиц, ознакомьтесь с Традиционное распознавание лиц с помощью Python.

Наконец, существуют и другие способы использования Python в микроконтроллерах, помимо Firmata и Arduino:

pySerial: Arduino Uno не может запускать Python напрямую, но вы можете создать свой собственный эскиз Arduino и использовать pySerial для установления последовательного соединения. Затем вы сможете управлять Arduino с помощью Python, используя свой собственный протокол.
MicroPython: Если вы заинтересованы в запуске Python непосредственно на микроконтроллере, ознакомьтесь с проектом MicroPython. Это обеспечивает эффективную реализацию Python для выполнения на некоторых микроконтроллерах, таких как ESP8266 и ESP32.
SBC: Другой вариант - использовать одноплатный компьютер (SBC), такой как Raspberry Pi для запуска Python. SBC - это полноценные компьютеры размером с Arduino, которые могут работать под управлением операционной системы на базе Linux, позволяя вам использовать vanilla Python. Поскольку большинство SBC имеют Входных и выходных контактов общего назначения , вы можете использовать его для замены Arduino в большинстве приложений.