Karat3.ru

Доброго всем дня!
Время идёт, технологии продвигаются вперёд, и понадобилось мне больше вычислительной мощности и скорости.
Атмега328 чип безусловно отличный - простой в программировании, содержит много периферии, но ... 32 килобайта памяти программ это прям мало.
Из простых решений получила развитие линейка "малины" Raspberry Pi.
"Полноформатные" малины довольно горячи и энергожручи, но с 2021 года запустили микроконтроллерную версию Pico.
Это недорогая плата на RP2040 - два ядра ARM Cortex-M0+ на частоте 133 МГц с встроенной 264 КБ ОЗУ, и внешняя флэш-память в виде впаянной микрухи на 16 МБ.

С тех пор китайцы шлёпают свои платки
Например
https://ali.click/5blf41m - 256 руб (3,2 $)

Всё это носит наименование Raspberry Pi Pico (чип RP2040 без модуля WiFi) и Raspberry Pi Pico W (чип RP2040 с модулем WiFi и Bluetooth).

Однако, в 2024 году вышло второе поколение Raspberry Pi Pico 2 на чипе RP2350 - два ядра Arm Cortex-M33 150 МГц и 520 КБ ОЗУ.

Модули RP2350 стоят подороже
https://ali.click/94mf41f - 568 руб (7,1 $)
Есть версии RP2350A и RP2350B (у В больше пинов).

Такие модули мне пока не нужны, попробую поработать со "стареньким" RP2040

P.S.
Версии плат на 4 МБ (вместо 16 МБ) стоят несколько дешевле.

Особенность "программирования" таких плат - самого процесса прошивки как такового нет.
Плата может работать в двух режимах:
- обычный, который стартует сразу после подачи питания,
- режим загрузки (BOOT), когда плата видится в системе как флэшка объёмом 128 МБ (это неправда, на плате 16МБ или 4 МБ).

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

Вся линейка малин призвана популяризировать язык Python, поэтому прослеживается направленность именно на работу с Питоном.
Адафрут пошла дальше и выпустила оболочку для RP2040/2350 - CircuitPython.
После её установки плата видится как флэшка на 14,9 МБ в которую можно сразу перекидывать файлы программы написанной на Питоне. Оболочка интерпретирует и выполняет их "на лету".

Ещё есть вариант работы с платой через Thonny, но он требует установки CDC-драйверов. Сходу победить эту методику у меня не получилось, поэтому пока работаю с CircuitPython.

Так как сейчас кругом всякие блокировки, сервисы то работают, то недоступны, то выложу сюда все инструкции и файлы.

У меня вот такая чёрная китайская плата
с тремя кнопками - RST, BOOT и USR.
. .
При подключении питания трёхцветный светодиод начинает перемигивать разные цвета.

Итак, ставим оболочку CircuitPython.
На данный момент последняя версия CircuitPython 10.1.4, скачиваем её отсюда
https://circuitpython.org/board/adafrui ... er_rp2040/

старые прошивки:
https://adafruit-circuit-python.s3.amaz ... rp2040/ru/

На случай, если сервис недоступен .

Для прошивки оболочки нужно плату перевести в режим BOOT.
Для этого:
1. подключаем плату к компьютеру через USB type-C,
2. нажимаем и держим кнопку RST,
3. нажимаем и держим кнопку BOOT,
4. отпускаем кнопку RST,
5. отпускаем кнопку BOOT.
Компьютер должен увидеть новую флэшку.

Если вы раньше ставили драйвера на RP-2 Boot device (как это делал я, пытаясь запустить работу с Thonny), то флэшка может и не определиться... но не будем о грустном.

Перекидываем на флэшку файл adafruit-circuitpython-raspberry_pi_pico2-ru-10.1.4.uf2
Плата уходит в перезагрузку.

После этого у вас появляется диск с именем CIRCUITPY.
Он будет определяться каждый раз при присоединении к компьютеру, снова переводить плату в режим BOOT не нужно.
. .
Внутри лежит файл Code.py - это та программа на Питоне, которая будет выполняться при подаче питания.
В папку lib можно положить дополнительные библиотеки, которыми будет пользоваться ваш код.
Чтобы проверить, работает ли это всё, я открыл в блокноте и вписал следующий код

import board
import time
from digitalio import DigitalInOut, Direction

# Конфигурация пина со светодиодом
led = DigitalInOut(board.LED)
led.direction = Direction.OUTPUT

# Наш рабочий бесконечный цикл
while True:
    # Переключить светодиод
    led.value = not led.value
    time.sleep(0.1)

В результате синенький светодиод рядом с разъёмом type-C очень быстро мигает

P.S.
Стандартная оболочка CircuitPython 10.1.4 уже включает в себя следующие модули: Дополнительные модули можно положить в папку lib.

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

Сделал так:
1. Установил среду разработки Mu Editor
Говорят, она уже не поддерживается, но в Thonny напихана поддержка Украины и я подозреваю из-за этого она у меня и не работает (пространство RU).
Тут скачиваем установщик и ставим
https://codewith.mu/en/download
По ходу установки он что-то подтягивает с интернета, видимо Питона

Если что, Mu Editor есть на гитхаб
https://github.com/mu-editor

2. Подключаем плату с прошитой оболочкой CircuitPython (см. выше) к USB-порту.
Выбираем режим - CircuitPython
Среда прям для самых новичков - как раз для меня!
. 3. Пишем код, который каждую секунду будет отправлять сообщение

import time

while True:
    print("Hello, Pico!")
    time.sleep(1) # Задержка 1 секунда

нажимаем "Сохранить" - код сохраняется в файл code.py во флеш-памяти платы.

Нажимаем "Последовательный" - появляется нижнее окно для сообщения по последовательному порту от платы.
. 4. Нажимаем Ctrl+C - это команда остановки выполнения кода платы.
Получаем в нижнем окне сообщение об установленной оболочке и версии платы
5. Нажимаем Ctrl+D - это мягкая перезагрузка платы.
Если на плате нажать RST, то жёсткий ресет разорвёт связи софта с платой и Mu Editor напишет, что плата не определена.
Поэтому софт ресет.

Поехали сообщения!

К самой плате:
на ногах назначены по два порта 2×UART, 2×I2C, 2×SPI следующим образом
. .
Подкинем пару модулей:
- часы с батарейкой и небольшой флэш-памятью,
- си5351

Сама плата работает на уровнях +3,3 В, но питается от +5В.
Входное напряжение - на ноге Vout
Подведём его к модулю на си5351 через pnp транзистор (чтобы в паузах выключать сишку, предварительно это будет маяк - батарейку надо экономить).
Модуль часов тоже надо питать, но поблизости линии +5В нету - подключаю его к линии +3,3В, должно сгодится.

Линии SDL/SCA часов подключаю к GPIO 20/21 - это порт I2C0.
Линии SDL/SCA си5351 подключаю к GPIO 18/19 - это порт I2C1.
Двумя модулями я занял сразу оба порта, хотя можно было на один. Но хотелось сишку повешать на отдельный порт. И для начала лучше всё же разделить.
База транзистора включения питания сишки подключена к GPIO16, но это пока не так важно.
Начать надо с часов.

Получилось как-то так

Разбираемся с часами.

Чтобы работать с модулем часов на DS3231M потребуются библиотеки.
https://circuitpython.org/libraries

Адафрутовские библиотеки для CircuitPython лежат в бандле.
Свежий на момент 30.03.2026:
https://github.com/adafruit/Adafruit_Ci ... g/20260328

Понадобятся библиотеки: .
Взяты из этого бандла.
Их нужно распаковать и перенести в папку lib платы.
adafruit_ds3231.mpy - файлом,
adafruit_register и adafruit_bus_device - папками.

У меня модуль подключен SDA к GPIO 20, SCL к GPIO 21.
Пишем программу.

import time
import board
import busio
import adafruit_ds3231

# Инициализация I2C: SDA = GPIO20 (GP20), SCL = GPIO21 (GP21)
i2c = busio.I2C(scl=board.GP21, sda=board.GP20)
rtc = adafruit_ds3231.DS3231(i2c)

# Установка времени (выполнить один раз)
# Раскомментировать для установки текущего времени:
rtc.datetime = time.struct_time((2026, 3, 30, 14, 24, 0, 4, -1, -1))
# (год, месяц, день, часы, минуты, секунды, день недели, юлианский день, DST)
# День недели: 0 — понедельник, 6 — воскресенье

# Чтение времени
current_time = rtc.datetime
print("Текущее время от DS3231:")
print(f"Год: {current_time.tm_year}")
print(f"Месяц: {current_time.tm_mon}")
print(f"День: {current_time.tm_mday}")
print(f"Часы: {current_time.tm_hour}")
print(f"Минуты: {current_time.tm_min}")
print(f"Секунды: {current_time.tm_sec}")
print(f"День недели: {current_time.tm_wday} (0=Пн, 6=Вс)")

# Форматированный вывод времени и даты
print(f"\nФорматированное время: "
      f"{current_time.tm_hour:02d}:{current_time.tm_min:02d}:"
      f"{current_time.tm_sec:02d}")
print(f"Дата: {current_time.tm_mday:02d}."
      f"{current_time.tm_mon:02d}.{current_time.tm_year}")

# Чтение температуры
temperature = rtc.temperature
print(f"\nТемпература от DS3231: {temperature:.2f} °C")

# Отслеживание времени в реальном времени
print("\nОтслеживание времени (Ctrl+C для выхода):")
try:
    while True:
        current_time = rtc.datetime
        print(f"{current_time.tm_hour:02d}:"
              f"{current_time.tm_min:02d}:"
              f"{current_time.tm_sec:02d}", end="\r")
        time.sleep(1)
except KeyboardInterrupt:
    print("\nПрограмма завершена.")

При старте устанавливается дата/время.
Потом эту строчку (12) нужно закомментировать.

Библиотеки скопированы, код написан - нажимаем "Сохранить"

Пошло время тикать

Что ж, попробую уж и сишку запустить.

Ставим библиотеку с поддержкой квадратурного режима
Копируем файл silicon5351.py в папку lib.

Пишем код.
Важно сначала дать питание на сишку и только потом её инициализировать.
Иначе будет ошибка: "RuntimeError: На SDA или SCL не обнаружено подтягивания; проверь свою проводку"

import time
import board
import busio
import digitalio
import adafruit_ds3231
from silicon5351 import SI5351_I2C

# Инициализация I2C: SDA = GPIO20 (GP20), SCL = GPIO21 (GP21)
i2c = busio.I2C(scl=board.GP21, sda=board.GP20)
rtc = adafruit_ds3231.DS3231(i2c)

# Создаём объект для пина GPIO16
pin16 = digitalio.DigitalInOut(board.GP16)
# Настраиваем пин как выход
pin16.direction = digitalio.Direction.OUTPUT
# Устанавливаем низкий уровень (0В)
pin16.value = False  # или pin16.value = 0
# Устанавливаем высокий уровень (3,3 В)
# pin16.value = True  # или pin16.value = 1

# Инициализация I2C с указанием пинов: SCL=GPIO19, SDA=GPIO18
i2cc = busio.I2C(scl=board.GP19, sda=board.GP18)

# Ожидание готовности I2C-шины
while not i2cc.try_lock():
    pass

# Создание объекта SI5351
# crystal — частота внешнего кристалла (обычно 25 МГц)
si = SI5351_I2C(i2cc, crystal=25_000_000)

# Настройка PLL A (умножение частоты кристалла)
# Пример: 25 МГц × 36 = 900 МГц
si.setup_pll(pll=0, mul=36)

# Инициализация выходов:
# Выход 0: обычный сигнал (quadrature=False)
si.init_clock(output=0, pll=0, quadrature=False, invert=False)
# Выход 1: квадратурный сигнал (quadrature=True)
si.init_clock(output=1, pll=0, quadrature=True, invert=False)

# Установка частоты для обоих выходов (одинаковая частота)
# Например, 10 МГц
freq = 10_000_000
si.set_freq_fixedpll(output=0, freq=freq)
si.set_freq_fixedpll(output=1, freq=freq)

# Включение выходов
si.enable_output(output=0)
si.enable_output(output=1)

print(f"Квадратурный генератор запущен:")
print(f"Выход 0: {freq/1_000_000:.1f} МГц (обычный)")
print(f"Выход 1: {freq/1_000_000:.1f} МГц (квадратурный)")

# Установка времени (выполнить один раз)
# Раскомментировать для установки текущего времени:
# rtc.datetime = time.struct_time((2026, 3, 30, 14, 39, 0, 4, -1, -1))
# (год, месяц, день, часы, минуты, секунды, день недели, юлианский день, DST)
# День недели: 0 — понедельник, 6 — воскресенье

# Чтение времени
current_time = rtc.datetime
print("Текущее время от DS3231:")
print(f"Год: {current_time.tm_year}")
print(f"Месяц: {current_time.tm_mon}")
print(f"День: {current_time.tm_mday}")
print(f"Часы: {current_time.tm_hour}")
print(f"Минуты: {current_time.tm_min}")
print(f"Секунды: {current_time.tm_sec}")
print(f"День недели: {current_time.tm_wday} (0=Пн, 6=Вс)")

# Форматированный вывод времени и даты
print(f"\nФорматированное время: "
      f"{current_time.tm_hour:02d}:{current_time.tm_min:02d}:"
      f"{current_time.tm_sec:02d}")
print(f"Дата: {current_time.tm_mday:02d}."
      f"{current_time.tm_mon:02d}.{current_time.tm_year}")

# Чтение температуры
temperature = rtc.temperature
print(f"\nТемпература от DS3231: {temperature:.2f} °C")

# Отслеживание времени в реальном времени
print("\nОтслеживание времени (Ctrl+C для выхода):")
try:
    while True:
        current_time = rtc.datetime
        print(f"{current_time.tm_hour:02d}:"
              f"{current_time.tm_min:02d}:"
              f"{current_time.tm_sec:02d}", end=" \r")
        time.sleep(10)
except KeyboardInterrupt:
    # Отключение выходов при завершении
    si.disable_output(output=0)
    si.disable_output(output=1)
    print("Выходы отключены.")
    print("\nПрограмма завершена.")

Запускаем.
Ошибок вроде нет, надо теперь проверить выходы сишки осциллографом

Генерация 10 МГц на выходах si5351 есть, сдвиг фаз тоже есть
. .
Общий осцилла зацепил за общий платы, поэтому сигнал корявенький.

Вот подумал, что 12 бит как-то совсем мало.
Есть мысль попробовать внешний АЦП, например модуль на PCM1808

24-BIT, 96-kHz STEREO A/D CONVERTER

https://ali.click/1e1j41c - 145 руб (1,9 $)

Узнал, что оказывается, у RP2040 на каждом пине есть программируемые модули ввода-вывода (PIO).
Чтобы узнать, как ими пользоваться, надо разбираться в структуре чипа RP2040.
На первый взгляд ничего сложного:
. .
Начнём с питания.
Питается чип от +3,3 В (в некоторых случаях от +1,8 В), и имеет встроенный регулятор напряжения питания ядра = 1,10 В.
В нормальных условиях ядро питается от 1,05 до 1,16 В, но можно регулировать от 0,85 до 1,30 В с шагом 0,05 В, т.е. возможен разгон

Тактовые генераторы PLL, их два:
- фиксированный на 48 МГц для АЦП и шины USB,
- перестраиваемый до 133 МГц для ядра.
Эти генераторы получают сигнал от VCO - высокочастотного перестраиваемого генератора, который работает на частотах 750...1600 МГц и стабилизирован внешним опорным кварцевым генератором (от 1 до 15 МГц, обычно на 12 МГц).
Для уменьшения дрожания фазы, тактовая частота ядер по умолчанию установлена 125 МГц (133 МГц максимальная).
Но, если поднять питание ядер до 1.15 В, то можно разогнать частоту до 200 МГц.

Ядра, ОЗУ, DMA, шинная матрица (bus fabric)
Матрица позволяет обоим ядрам Cortex-M0+ и контроллеру DMA обращаться к разным банкам памяти SRAM одновременно.
Для четырёх мастеров (ядро 0, ядро 1, DMA чтение, DMA запись), которые могут генерировать адреса обращения, через AHB-Lite Crossbar создаются 4 независимых канала доступа к 10 портам.
Ширина шины 32 бита.
. .
Один из этих портов - AHB-Lite Splitter - может подключить мастера к PIO0, PIO1 или USB.

Вот PIO0 и PIO1 нас интересуют!

Один из блоков PIO: .
Каждый блок PIO состоит из 8 буферов, 4 стейт-машин, и мультиплексор пинов (к какому пину какую стейт-машину подключить).
Мастера обращаются к пинам через буферы FIFO. Процессор (или DMA) «кидает» данные в очередь, а стейт-машина PIO забирает их и превращает в электрические сигналы на пинах.

Стейт-машины - это высокоскоростные крошечные процессоры, которые могут выполнять свои программы параллельно основным ядрам Cortex-M0+.
У каждой стейт-машины имеется:
- два 32-разрядных регистра общего назначения (X и Y),
- два 32-битных сдвиговых регистра (ISR и OSR),
- FIFO-буферы (входной и выходной),
- Контроллер управления пинами (Mapping Logic),
- Блок гибкого деления частоты (Clock Divider),
- Счетчик команд (PC - Program Counter).

В каждом блоке (PIO0 и PIO1) есть своя память на 32 инструкции. Эти 32 ячейки делятся между всеми четырьмя стейт-машинами этого блока.
Вы можете загрузить одну программу на 32 инструкции и запустить её на всех четырёх машинах одновременно, либо загрузить четыре разные программы по 8 инструкций для каждой машины.
Стейт-машины и память инструкций работают на частоте системной шины (по умолчанию - 125 МГц), что позволяет считывать и выполнять одну инструкцию за один такт без задержек.

Кстати, у PIO нет АЛУ (арифметико-логического устройства) в привычном понимании — она не умеет складывать или умножать, зато умеет молниеносно двигать биты и проверять условия.