MicroPython для микроконтроллеров: программирование на Python для начинающих

Для кого эта статья:

• Новички в программировании и электронике
• Энтузиасты, желающие создавать IoT-устройства

• Студенты и преподаватели, интересующиеся современными методами обучения программированию микроконтроллеров

  Программирование микроконтроллеров всегда считалось вотчиной опытных инженеров с глубокими знаниями C и ассемблера. Но это время прошло! MicroPython изменил правила игры, позволив энтузиастам и новичкам с базовыми знаниями Python создавать умные устройства без погружения в сложности низкоуровневого кода. Теперь управление светодиодами, считывание данных с датчиков и создание IoT-устройств доступно каждому, кто способен написать простой скрипт. Готовы превратить свою плату ESP32 в полноценный мини-компьютер за несколько строк понятного кода? 🐍💻

Хотите быстро освоить MicroPython и погрузиться в мир умных устройств, но не знаете, с чего начать? Курс Обучение Python-разработке от Skypro включает модуль по программированию микроконтроллеров, где вы пройдете путь от мигания светодиодом до создания полноценных IoT-систем. Наши студенты создают действующие прототипы умных устройств уже через 2 месяца обучения, применяя все преимущества Python в мире электроники.

Что такое MicroPython и почему он идеален для начинающих

MicroPython — это урезанная версия Python 3, оптимизированная для работы на микроконтроллерах и ограниченных системах. В отличие от традиционного программирования микроконтроллеров на C/C++, он предлагает более высокоуровневый подход, сохраняя при этом доступ к аппаратным возможностям устройств.

Для новичков MicroPython представляет несколько неоспоримых преимуществ над традиционными методами программирования микроконтроллеров:

• Интерактивный REPL (Read-Evaluate-Print Loop) — позволяет экспериментировать с кодом в режиме реального времени
• Синтаксическая простота — код на Python значительно лаконичнее и понятнее, чем на C
• Отсутствие необходимости компиляции — написал код и он сразу выполняется
• Кроссплатформенность — работает на множестве популярных микроконтроллерных платформ
• Встроенная поддержка периферии — готовые библиотеки для работы с распространёнными датчиками и модулями

MicroPython поддерживает широкий спектр микроконтроллеров и плат разработки, но особенно хорошо работает на следующих платформах:

Алексей Мартынов, преподаватель курсов электроники

Когда я начал внедрять MicroPython в свой курс для старшеклассников, многие коллеги сомневались в эффективности этого подхода. "Дети должны изучать настоящее программирование на C", — говорили они. Но уже через месяц мои ученики создавали проекты, для которых студентам технических ВУЗов требовался целый семестр.

Особенно запомнился случай с Максимом, 15-летним школьником, который никогда прежде не программировал. После двух занятий с MicroPython он смог запустить домашнюю метеостанцию на ESP32 с датчиками температуры и влажности, выводящую данные на OLED-дисплей и в телеграм-бота. На все это ему потребовалось менее 100 строк понятного кода. Когда я спросил его, что было самым сложным, он ответил: "Честно говоря, припаять провода к датчику. С кодом проблем не было".

Однако MicroPython имеет и свои ограничения, которые следует учитывать:

• Более низкая производительность по сравнению с нативным C-кодом
• Большое потребление памяти
• Не подходит для критических по времени приложений с микросекундными требованиями

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

Первые шаги в программировании микроконтроллеров на Python

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

Для начала вам потребуется:

• Микроконтроллер с поддержкой MicroPython (например, ESP32, ESP8266 или Raspberry Pi Pico)
• USB-кабель для подключения к компьютеру
• IDE или редактор кода (Thonny, uPyCraft, VS Code с расширением PyMakr)

Прежде чем начать писать код, необходимо прошить MicroPython на ваш микроконтроллер:

1. Скачайте прошивку с официального сайта MicroPython для вашей конкретной платы
2. Подключите микроконтроллер к компьютеру через USB
3. Используйте утилиту прошивки (esptool для ESP32/ESP8266, UF2 для Raspberry Pi Pico)

Для ESP32 процесс прошивки выглядит примерно так:

pip install esptool
esptool.py --port /dev/ttyUSB0 erase_flash
esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-20210902-v1.17.bin

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

Теперь давайте напишем первую программу — классический "Hello, World!" для микроконтроллеров: мигающий светодиод.

# Импортируем необходимые библиотеки
import machine
import time

# Настраиваем GPIO2 (на большинстве ESP плат есть встроенный светодиод)
led = machine.Pin(2, machine.Pin.OUT)

# Создаем бесконечный цикл
while True:
led.on() # Включаем светодиод
time.sleep(0.5) # Ждем 0.5 секунды
led.off() # Выключаем светодиод
time.sleep(0.5) # Ждем еще 0.5 секунды

Сохраните этот код в файл main.py на вашем микроконтроллере, и он будет автоматически запускаться при каждой перезагрузке устройства. Вот и все! Ваша первая программа на MicroPython заставляет светодиод мигать с частотой 1 Гц.

Для удобства разработки и отладки я рекомендую использовать специализированные инструменты:

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

Базовые проекты с ESP32/ESP8266 для новичков в электронике

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

Рассмотрим несколько базовых проектов, расположенных по возрастающей сложности:

1. Цифровой термометр с выводом в консоль

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

import machine, onewire, ds18x20, time

# Настройка пина для работы с датчиком
pin = machine.Pin(4) # GPIO4
sensor = ds18x20.DS18X20(onewire.OneWire(pin))

# Поиск датчиков на шине
roms = sensor.scan()
print('Найдены датчики:', roms)

while True:
sensor.convert_temp() # Запрос на преобразование температуры
time.sleep_ms(750) # Обязательная задержка для завершения преобразования

for rom in roms:
temp = sensor.read_temp(rom) # Чтение температуры
print('Температура: {:.2f} °C'.format(temp))

time.sleep(2) # Измерение каждые 2 секунды

2. Веб-сервер для управления LED

Этот проект познакомит вас с сетевыми возможностями ESP плат и базовыми понятиями веб-разработки.

import machine
import network
import socket
import time

# Настройка Wi-Fi соединения
ssid = 'Ваша_сеть'
password = 'Ваш_пароль'

station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)

while not station.isconnected():
pass

print('Подключено к WiFi')
print('IP:', station.ifconfig()[0])

# Настройка светодиода
led = machine.Pin(2, machine.Pin.OUT)

# HTML страница с кнопками управления
html = """<!DOCTYPE html>
<html>
<head>
<title>Управление светодиодом</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
body { text-align: center; font-family: Arial; }
.button {
background-color: #4CAF50;
border: none;
color: white;
padding: 16px 40px;
text-decoration: none;
font-size: 30px;
margin: 10px;
cursor: pointer;
}
.button2 {background-color: #f44336;}
</style>
</head>
<body>
<h1>Управление ESP светодиодом</h1>
<p><a href="/?led=on"><button class="button">ВКЛ</button></a></p>
<p><a href="/?led=off"><button class="button button2">ВЫКЛ</button></a></p>
</body>
</html>
"""

# Настройка веб-сервера
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(5)

while True:
conn, addr = s.accept()
print('Подключение от:', addr)
request = conn.recv(1024)
request = str(request)

led_on = request.find('/?led=on')
led_off = request.find('/?led=off')

if led_on == 6:
led.value(1)
if led_off == 6:
led.value(0)

response = html
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: close\n\n')
conn.sendall(response)
conn.close()

Игорь Соколов, инженер по встраиваемым системам

Работая над умной теплицей для своей дачи, я столкнулся с типичной дилеммой: Arduino с языком С++ или что-то более доступное для быстрого прототипирования. Решение пришло спонтанно, когда коллега показал мне ESP32 с MicroPython.

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

Ключевым моментом стало то, что для внесения изменений мне не требовалось перепрошивать устройство — я просто подключался по Wi-Fi через WebREPL и редактировал код "на лету". В середине лета, когда потребовалось срочно изменить логику полива из-за аномальной жары, я сделал это удаленно, находясь за 300 км от дачи. С традиционным подходом пришлось бы ехать на место или использовать сложные решения для удаленной перепрошивки.

3. Метеостанция с OLED дисплеем

Этот проект объединяет работу с датчиками и вывод данных на дисплей, что является основой для многих IoT устройств.

from machine import Pin, I2C
import ssd1306
import dht
import time

# Настройка OLED дисплея
i2c = I2C(scl=Pin(22), sda=Pin(21)) # SCL=GPIO22, SDA=GPIO21
display = ssd1306.SSD1306_I2C(128, 64, i2c)

# Настройка DHT22 датчика
sensor = dht.DHT22(Pin(15)) # DHT22 подключен к GPIO15

while True:
try:
# Чтение данных с датчика
sensor.measure()
temp = sensor.temperature()
hum = sensor.humidity()

# Очистка дисплея
display.fill(0)

# Вывод текста на дисплей
display.text("Температура:", 0, 0)
display.text("{:.1f} C".format(temp), 0, 10)
display.text("Влажность:", 0, 30)
display.text("{:.1f} %".format(hum), 0, 40)

# Обновление дисплея
display.show()

except Exception as e:
print("Ошибка:", e)

time.sleep(2) # Обновление каждые 2 секунды

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

• DS18B20 к ESP32: DATA → GPIO4, VCC → 3.3V, GND → GND (требуется подтягивающий резистор 4.7kΩ между DATA и VCC)
• OLED дисплей I2C: SCL → GPIO22, SDA → GPIO21, VCC → 3.3V, GND → GND
• DHT22: DATA → GPIO15, VCC → 3.3V, GND → GND

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

Подключаем датчики и дисплеи: практические задачи

Работа с внешними компонентами — ключевой аспект программирования микроконтроллеров для начинающих. В этом разделе мы разберем, как подключать различные типы датчиков и дисплеев к вашему микроконтроллеру под управлением MicroPython. 📊

Большинство внешних компонентов подключаются через стандартные интерфейсы, поддержка которых уже встроена в MicroPython:

• GPIO — простые цифровые входы/выходы
• ADC — аналогово-цифровой преобразователь для чтения аналоговых значений
• I2C — последовательная шина для подключения множества устройств по двум линиям
• SPI — высокоскоростной последовательный интерфейс
• UART — асинхронный приемопередатчик для последовательной связи
• OneWire — протокол для датчиков, использующих одну линию данных

Рассмотрим примеры подключения и программирования различных типов датчиков.

1. Аналоговый датчик (фоторезистор)

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

from machine import ADC, Pin
import time

# Настраиваем АЦП на пине 36 (ADC1_CH0)
light_sensor = ADC(Pin(36))
light_sensor.atten(ADC.ATTN_11DB) # Полный диапазон 0-3.3В

while True:
# Чтение значения (0-4095)
value = light_sensor.read()

# Преобразование в проценты (приблизительно)
light_percent = (value / 4095) * 100

print("Значение АЦП: {}, Освещенность: {:.1f}%".format(value, light_percent))

# Определение условий освещения
if light_percent < 20:
print("Темно")
elif light_percent < 50:
print("Средняя освещенность")
else:
print("Ярко")

time.sleep(1)

2. Цифровой датчик (BME280 по I2C)

BME280 — популярный датчик, измеряющий температуру, влажность и атмосферное давление. Подключается по I2C интерфейсу.

from machine import I2C, Pin
import BME280 # Требуется установка библиотеки
import time

# Инициализация I2C
i2c = I2C(scl=Pin(22), sda=Pin(21))

# Сканирование I2C устройств
devices = i2c.scan()
if devices:
print("Найдены I2C устройства по адресам:", [hex(d) for d in devices])
else:
print("I2C устройства не обнаружены!")

# Инициализация BME280
try:
sensor = BME280.BME280(i2c=i2c)

while True:
# Чтение данных с датчика
temp = sensor.temperature
hum = sensor.humidity
pres = sensor.pressure

# Вывод информации
print("Температура: {:.1f}°C".format(temp))
print("Влажность: {:.1f}%".format(hum))
print("Давление: {:.1f} гПа".format(pres/100)) # Перевод Па в гПа
print("-" * 30)

time.sleep(2)
except Exception as e:
print("Ошибка при работе с BME280:", e)

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

3. LCD дисплей с I2C адаптером

from machine import I2C, Pin
import time
import lcd_api
import i2c_lcd

# Настройка I2C
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=400000)
lcd = i2c_lcd.I2cLcd(i2c, 0x27, 2, 16) # Обычно адрес 0x27, 2 строки, 16 символов

# Пример использования
lcd.putstr("MicroPython")
lcd.move_to(0, 1) # Вторая строка
lcd.putstr("ESP32 LCD Test")

time.sleep(2)
lcd.clear()

# Анимированный текст
for i in range(10):
lcd.clear()
lcd.move_to(i, 0)
lcd.putstr("Moving text")
time.sleep(0.5)

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

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

От теории к практике: создаём умное устройство на MicroPython

Пришло время объединить все полученные знания и создать полноценное умное устройство на базе MicroPython. В качестве финального проекта мы разработаем интеллектуальную систему мониторинга окружающей среды с уведомлениями и веб-интерфейсом. 🌡️🔔

Наша система будет выполнять следующие функции:

• Измерение температуры, влажности и атмосферного давления
• Отображение данных на OLED дисплее
• Веб-интерфейс для просмотра текущих и исторических данных
• Отправка оповещений через Telegram при критических значениях
• Автономное хранение данных на устройстве

Для этого проекта нам понадобятся:

• ESP32 (более мощная, чем ESP8266 для данного проекта)
• Датчик BME280 (температура, влажность, давление)
• OLED дисплей SSD1306 128x64 с I2C интерфейсом
• Кнопка для управления интерфейсом

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

# main.py – основной файл проекта

import network
import time
import machine
import ujson
import gc
from machine import Pin, I2C, RTC
from BME280 import BME280 # Импортируем библиотеку для датчика
import ssd1306 # Библиотека для OLED дисплея
import ntptime # Для синхронизации времени
import uasyncio as asyncio
from web_server import setup_webserver
from telegram_bot import send_telegram_message
import config # Файл с настройками (WiFi, Telegram токен)

# Настройка I2C
i2c = I2C(scl=Pin(22), sda=Pin(21))
sensor = BME280(i2c=i2c)
display = ssd1306.SSD1306_I2C(128, 64, i2c)

# Настройка кнопки
button = Pin(0, Pin.IN, Pin.PULL_UP)

# Инициализация RTC
rtc = RTC()

# Переменные для хранения данных
sensor_data = {'temp': 0, 'hum': 0, 'pres': 0, 'timestamp': 0}
sensor_history = []
alarm_triggered = {'temp': False, 'hum': False}

# Подключение к WiFi
def connect_wifi():
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

if not wlan.isconnected():
print('Подключение к WiFi...')
wlan.connect(config.WIFI_SSID, config.WIFI_PASS)

# Ожидание подключения с таймаутом
timeout = 0
while not wlan.isconnected() and timeout < 20:
time.sleep(1)
timeout += 1

if wlan.isconnected():
print('WiFi подключен:', wlan.ifconfig()[0])
return True
else:
print('WiFi подключение не удалось')
return False

# Функция обновления дисплея
def update_display(page=0):
display.fill(0)

if page == 0: # Основная страница с текущими данными
display.text("Температура:", 0, 0)
display.text("{:.1f} C".format(sensor_data['temp']), 0, 10)
display.text("Влажность:", 0, 25)
display.text("{:.1f} %".format(sensor_data['hum']), 0, 35)
display.text("Давление:", 0, 50)
display.text("{:.1f} hPa".format(sensor_data['pres']/100), 0, 60)
elif page == 1: # Страница с информацией о сети
display.text("IP:", 0, 0)
ip = network.WLAN(network.STA_IF).ifconfig()[0]
display.text(ip, 0, 10)
display.text("Данные за:", 0, 30)
display.text(str(len(sensor_history)), 0, 40)
display.text("точек", 70, 40)

display.show()

# Функция чтения датчика и сохранения данных
async def read_sensor():
global sensor_data, sensor_history, alarm_triggered

while True:
try:
temp = sensor.temperature
hum = sensor.humidity
pres = sensor.pressure
timestamp = time.time()

# Обновляем текущие данные
sensor_data = {
'temp': temp, 
'hum': hum, 
'pres': pres,
'timestamp': timestamp
}

# Сохраняем в историю (не более 1000 точек)
sensor_history.append(sensor_data.copy())
if len(sensor_history) > 1000:
sensor_history.pop(0)

# Проверяем условия для тревоги
if temp > config.TEMP_HIGH and not alarm_triggered['temp']:
await send_telegram_message("Внимание! Высокая температура: {:.1f}°C".format(temp))
alarm_triggered['temp'] = True
elif temp <= config.TEMP_HIGH – 2 and alarm_triggered['temp']:
alarm_triggered['temp'] = False

if hum > config.HUM_HIGH and not alarm_triggered['hum']:
await send_telegram_message("Внимание! Высокая влажность: {:.1f}%".format(hum))
alarm_triggered['hum'] = True
elif hum <= config.HUM_HIGH – 5 and alarm_triggered['hum']:
alarm_triggered['hum'] = False

# Обновляем дисплей
update_display()

# Сохраняем данные в файл каждые 60 точек
if len(sensor_history) % 60 == 0:
save_data()

# Освобождаем память
gc.collect()

except Exception as e:
print("Ошибка чтения датчика:", e)

await asyncio.sleep(60) # Интервал чтения – 1 минута

# Функция сохранения данных
def save_data():
try:
with open('sensor_data.json', 'w') as f:
# Сохраняем только последние 100 точек для экономии памяти
data_to_save = sensor_history[-100:] if len(sensor_history) > 100 else sensor_history
ujson.dump(data_to_save, f)
print("Данные сохранены")
except Exception as e:
print("Ошибка сохранения данных:", e)

# Функция загрузки данных
def load_data():
global sensor_history
try:
with open('sensor_data.json', 'r') as f:
sensor_history = ujson.load(f)
print("Данные загружены, точек:", len(sensor_history))
except:
print("Файл данных не найден, создана новая история")
sensor_history = []

# Обработчик кнопки – циклически переключает страницы дисплея
current_page = 0
def button_handler(pin):
global current_page
current_page = (current_page + 1) % 2 # Всего 2 страницы
update_display(current_page)

# Регистрируем обработчик кнопки
button.irq(trigger=Pin.IRQ_FALLING, handler=button_handler)

# Синхронизация времени
def sync_time():
try:
ntptime.settime()
print("Время синхронизировано")
except:
print("Ошибка синхронизации времени")

# Основная асинхронная функция
async def main():
# Загружаем сохраненные данные
load_data()

# Подключаемся к WiFi
if connect_wifi():
# Синхронизируем время
sync_time()

# Запускаем веб-сервер
asyncio.create_task(setup_webserver(sensor_data, sensor_history))

# Запускаем задачу чтения датчика
asyncio.create_task(read_sensor())

# Бесконечный цикл для поддержания работы
while True:
await asyncio.sleep(1)

# Запуск программы
if __name__ == "__main__":
try:
asyncio.run(main())
except Exception as e:
print("Критическая ошибка:", e)
machine.reset() # Перезагрузка при критической ошибке

Приведенный код является основой для умного устройства. Он демонстрирует применение всех концепций, которые мы рассмотрели в предыдущих разделах:

• Асинхронное программирование для выполнения нескольких задач
• Взаимодействие с датчиками через I2C интерфейс
• Отображение информации на OLED дисплее
• Сетевое взаимодействие (WiFi, веб-сервер, Telegram API)
• Хранение и загрузка данных
• Обработка ошибок и автоматическое восстановление

Для полноценной работы этого кода потребуются дополнительные модули (webserver.py, telegrambot.py, config.py), которые можно разработать на основе ранее показанных примеров. Такой модульный подход улучшает читаемость кода и упрощает его поддержку.

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

• Добавление графиков в веб-интерфейс
• Управление дополнительными устройствами (реле, моторы)
• Интеграция с облачными сервисами (ThingSpeak, Blynk)
• Режим энергосбережения для работы от батареи
• Использование более сложных алгоритмов анализа данных

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

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

• Изучение C/C++ для программирования микроконтроллеров: основы
• ESP32: мощный микроконтроллер для создания IoT-устройств любой сложности
• ESP8266: создаем умные устройства с Wi-Fi за копейки – гайд
• Современные языки для микроконтроллеров: альтернативы языку C
• Язык программирования Arduino: основы для микроконтроллеров
• Программирование STM32: от основ к реальным проектам с примерами