Raspberry pi pico

Сравнительно недавно Raspberry Pi Foundation выпустила плату Raspberry Pi Pico, основанную на микроконтроллере (Micro Controller Unit, MCU) RP2040. Эта плата привлекла большое внимание членов сообщества разработчиков различных электронных устройств. Появилось довольно много проектов, в которых используются программируемые модули ввода-вывода (Programmable I/O, PIO) Raspberry Pi Pico. Например, это проект PicoDVI, в котором конечные автоматы PIO используются для вывода DVI-сигнала.



Но с появлением Raspberry Pi Pico связано не только радостное возбуждение разработчиков электроники. Это событие заставило сообщество задаться важным вопросом о том, окажет ли появление платы какое-то ощутимое влияние на тех, кто пользуется STM32, SAM и другими микроконтроллерами, основанными на Cortex-M. Станет ли микроконтроллер RP2040 жизнеспособным выбором для некоторых из проектов, в которых используются похожие MCU? Учитывая то, что в состав RP2040 входит двухъядерный процессор ARM Cortex-M0+, кажется справедливой идея использования этого микроконтроллера там же, где применяются 32-битные MCU от ведущих производителей компонентов такого рода, в частности, от STMicroelectronics.

Сможет ли небольшой проект Raspberry Pi Foundation показать инженерам STM как надо делать микроконтроллеры, или создателям платы на RP2040 стоит пересмотреть некоторые из своих гипотез? Сложно ли будет портировать на RP2040 низкоуровневый код, рассчитанный на STM32?

Сложно ли перенести STM32-проект на RP2040?

Короче говоря, когда я обратила внимание на RP2040, мне подумалось, что будет интересно попытаться портировать на новый микроконтроллер мой C++-фреймворк для STM32. Правда, эта идея меня заинтересовала не из-за двухъядерного ARM Cortex-M0+. У меня есть двухъядерные микроконтроллеры STM32H7 (M4 и M7), которые, за счёт более совершенных характеристик, легко обойдут RP2040. Сильнее всего меня заинтриговали программируемые модули ввода-вывода RP2040, возникало такое ощущение, что они достойны того, чтобы познакомиться с ними поближе.


Плата Raspberry Pi Pico, основанная на RP2040 подключена к одноплатному компьютеру Raspberry Pi, играющему роль SWD-адаптера (оригинал)

Основываясь на опыте работы с STM32 я поняла, что смогу быстро портировать некоторые файлы, создав в репозитории проекта ветку RP, рассчитанную на другую архитектуру, и принявшись за дело. Ведь и в основном проекте, и в новой ветке код будет рассчитан на Cortex-M. Обычно работа с новым ARM-микроконтроллером заключается в том, чтобы найти даташит, справочное руководство и CMSIS-файлы для соответствующего устройства. А потом существующий низкоуровневый код можно легко адаптировать под новый подход к именованию периферийных устройств и под новую схему регистров, учитывая то, что фундаментальные компоненты нового и старого микроконтроллеров (SysTick, NVIC и так далее) ничем не отличаются.

Может, я поступила слишком опрометчиво, но я заказала плату Raspberry Pi Pico, даже не поинтересовавшись тем, есть ли для неё CMSIS-файлы, и даже не взглянув в справочное руководство по ней. Позже я, к своему удивлению, выяснила, что пока нет даже и речи о наличии CMSIS-файлов для Raspberry Pi Pico, или хотя бы о возможности взаимодействия RP2040 с другими устройствами из экосистемы Cortex-M. Но при этом SVD-файл для MCU RP2040 имеется в Pico SDK, а на основе этого файла можно создать заголовочный файл для устройства. Благодаря проекту cmsis-pi-pico в моём распоряжении, в итоге, оказалось рабочее решение.

Решение моей задачи можно было бы и упростить

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


Последовательность загрузки RP2040 (даташит RP2040, рисунок 15) (оригинал)

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

Первая сложность, которую нужно было преодолеть для того чтобы научиться работать с RP2040, заключалась в понимании особенностей цепочечного процесса загрузки микроконтроллера. Тут всё очень похоже на то, как в прошлом, на обычных компьютерах, была организована загрузка с дискет, или то, как устроена загрузка с HDD/SSD. А именно внешняя QSPI Flash ROM рассматривается MCU лишь как устройство, которое, возможно, содержит загрузочные данные. Загрузчик первой фазы загрузки интегрирован в MCU и располагается в ROM по адресу 0x0000 0000. Он обращается к интерфейсу QSPI и пытается загрузить из него 256 байт данных. Потом будет проверен CRC32-хеш этих данных. Если проверка пройдёт успешно, они будут признаны загрузчиком второй фазы загрузки.

Загрузчик второй фазы может решать множество задач, при этом некоторые задачи он должен решать в обязательном порядке. Этот процесс, реализованный в RP2040, если сравнить его с аналогичным процессом в некоторых знаменитых клонах STM32, тоже имеющих SPI ROM (вроде отличных клонов компании GigaDevice), не так понятен, не так хорошо документирован, не так прозрачен, как мог бы быть. В нём много такого, в чём можно запутаться.

Говорят, что хорошие художники копируют

У меня ушло достаточно много времени на то, чтобы понять, как подход к управлению тактированием периферийных устройств, принятый в STM32, соотносится с системной архитектурой RP2040. Я внимательно читала даташит RP2040 и всех вокруг спрашивала об этом. Как оказалось, RP2040-версия системы управления тактированием периферии называется RESETS. Эта система является полной противоположностью той, что применяется в STM32. А именно, нужно установить условие сброса периферийного блока в 0 для того чтобы включить его тактирование. Так, чтобы включить тактирование GPIO, нужно переключить бит 8 в RESETS_RESET (PADS_BANK0).


Функциональная схема GPIO-пина RP2040 (оригинал)

Когда я это поняла, я посмотрела раздел документации по GPIO-периферии (раздел 2.19). И кое-что тут же бросилось мне в глаза. А именно, то, что я там увидела, совершенно не похоже на то, как устроена практически вся GPIO-периферия, с которой я когда-либо сталкивалась. В частности, речь идёт о периферии STM32, AVR и SAM.

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

А теперь, когда я через всё это прошла, полагаю, можно будет просто переписать мой код, после чего он заработает на RP2040?

Причуды загрузки

Как уже было сказано, загрузчик второй фазы загрузки должен быть расположен в начале образа прошивки. Я считала, что это должен быть какой-то достаточно стандартный код, поэтому просто взяла готовый ASM-код, который выдал официальный Pico SDK, и использовала его при сборке примера Blinky. Добавив этот код к RP2040-порту моего проекта Nodate, я смогла без проблем собрать Blinky.

Запись результирующего ELF-бинарника в RP2040 стала ещё одним приключением. Дело в том, что на плате Raspberry Pi Pico нет встроенного SWD-адаптера, чего-то в духе ST-Link. А микроконтроллеру на двухъядерном Cortex-M нужен могоканальный SWD-адаптер. Единственным подобным устройством, которое было у меня под рукой, оказался адаптер, интегрированный в плату Nucleo-STM32H7. Поэтому я решила использовать кастомный форк OpenOCD, созданный Raspberry Pi Foundation. Его я запустила на Raspberry Pi.

После столь основательной подготовки мне удалось успешно прошить RP2040, но ничего не заработало. Беглая проверка вызвала у меня такое ощущение, что в ходе загрузки мне не удалось выйти за пределы исходного загрузчика и добраться до прошивки, находящейся в SPI ROM. Сейчас мне сложно дать ответ о причинах происходящего. Это могла быть проблема с ASM-кодом второй фазы загрузки, это могла быть ошибка в экспериментальных CMSIS-файлах RP2040, которые создавала не я. Это могло быть и что-то совершенно иное.

Продолжение следует?

Raspberry Pi Pico (оригинал)

После того, как я потратила много часов на то, чтобы завести RP2040 с использованием CMSIS-файлов и файлов загрузчика второй фазы загрузки, мне кажется, что можно немного отстраниться от ситуации и переоценить происходящее. А именно, с того момента, когда начинала формироваться моя точка зрения на Raspberry Pi Pico, в запросе по поводу CMSIS-файлов появились сведения о том, что официальные CMSIS-файлы, возможно, появятся в Pico SDK 1.2.0. Это довольно-таки приятно.

Полагаю, любому, кто хочет поближе познакомиться с RP2040, пользуясь инструментами, ставшими индустриальным стандартом, имеет смысл дождаться этого релиза Pico SDK. А после того, как в моём распоряжении окажутся официальные CMSIS-файлы, я, вероятно, начну с переделывания примера Nodate Blinky, а потом попробую поработать с PIO. Перспектива создавать собственные интерфейсы кажется мне весьма привлекательной. И хотя возможности Raspberry Pi Pico не так мощны, как возможности CPLD или FPGA, они, всё равно, способны лечь в основу интереснейших проектов.

Возникает такое ощущение, что авторы даташита для RP2040 (он, скорее, похож на смесь справочного руководства и даташита) иногда забывают о том, что в нём должно быть описание микроконтроллера, а не чего-то другого. В эти моменты он превращается в учебное руководство по Pico SDK. Хотя материалы этого даташита и способны принести пользу тем, кто стремится освоить Pico SDK, тем, кто хочет написать что-то своё, пользы от него, однозначно, меньше, чем от более привычного даташита.

Полагаю, тех, кто захочет написать для Raspberry Pi Pico что-то своё, не особенно порадуют такие особенности платы, как запутанная работа с GPIO-периферией, сложный процесс загрузки, необходимость в загрузчике второй фазы загрузки, непрозрачность внешней ROM. В общем тому, кому интересна плата Raspberry Pi Pico, пока приходится ориентироваться на официальный SDK.

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

Пользовались ли вы Raspberry Pi Pico?

Пару дней назад Raspberry Foundation представила новую плату Raspberry Pi Pico на собственном кремнии всего за 4 доллара США. Плата, конечно, менее функциональна, чем старшие модели линейки, но и она может предложить большое количество возможностей для разработчиков.

Эту плату уже успели протестировать, оценив ее функции, достоинства и недостатки. Обо всем этом под катом.

Немного о характеристиках

Основа платы двухъядерный чип Arm Cortex M0+, с частотой работы ядра в 133 МГц. У платы 264 КБ ОЗУ и 2 МБ флеш-памяти. Кроме того, есть разъем USB 1.1 и I/O каналы, из которых пользователю доступны 26. Есть возможность задействовать интерфейсы 2 UART, 2 I²C, 2 SPI (всего до 16 Мбайт QSPI Flash с XIP), а также 16 PWM-каналов. Также в наличии температурный датчик и 4 ADC-канала.

Разработчики заявили, что работа над собственным чипом велась с 2016 года. По словам команды, им нужен был чип с возможностями, которых не было ни у одного из чипов других производителей. В 2018 году был готов прототип, который затем доработали, получив систему, ставшую основой одноплатника Pico.

Мы получили огромный опыт в ходе разработки этого чипа. Он эволюционировал, совершенствовался с первого дня разработки. И сейчас у нас в руках отличный чип с большим количеством возможностей и низкой ценой. Чипы изготовили для нас на фабрике TSMC по 40-нм техпроцессу, сообщил COO Raspberry Pi Джеймс Адамс.

Чип действительно уникален, ведь двухъядерных систем такой стоимости на рынке больше нет. Оперативной памяти достаточно для этого девайса и задач, которые он может выполнять. А есть еще и оптимизированные библиотеки с плавающей запятой, которые добавили в загрузочное ПЗУ, плюс ядро USB, которое можно использовать в качестве ведущего или ведомого.

Что особенного в Pico?

Вообще говоря, это не одноплатный ПК, как тот же Raspberry Pi Zero или старшие модели, а, скорее, микроконтроллер, как Arduino. Плату Pico можно подружить с любой из других малинок, разрабатывая сложные проекты. У Pico есть GPIO с напряжением 3.3В, как и у других Raspberry Pi и Arduino. И это не недостаток, подключать можно и 5В при помощи конвертеров.


Разработчики провели тестирование платы, подключив ее к 12 светодиодам Neopixel на полной яркости от источника питания 5В. В итоге потребляемый платой ток всего 140 мА, с 0,7Вт. А вот Raspberry Pi 4 при тех же условиях потребляет уже 4-5 Вт. Так что если проекту требуется минимальное энергопотребление лучшего варианта, чем Pico, не найти.

Подключить питание к Raspberry Pi Pico можно через micro USB или посредством контактов VSYS GPIO. В этом случае можно подвести от 1.8 В до 5.5 В. Если нужна батарея, то придется подключить дополнительный модуль сторонних производителей. Вот здесь подробно описано, как это сделать.


Выше упоминалось, что Pico скорее микроконтроллер, чем плата. И это реально так. Систему можно рассматривать в качестве достойной альтернативы Adafruit Feather или Teensy. Размеры платы всего 51 x 21 мм, так что она даже меньше Raspberry Pi Zero.


Pico удобно использовать с макетными платами и несущими платами для поверхностного монтажа. Но 40 контактов Raspberry Pi Pico нужно припаять самостоятельно.


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

Работа с Raspberry Pi Pico

У платы нет дополнительных портов, так что для того, чтобы ее использовать в большинстве проектов, понадобится компьютер. Это может быть любой ПК, под управлением любой ОС Windows, Mac и Linux.

Важный момент документация к плате. Там два раздела, для языка С и для MicroPython. Последний разработан на основе Python 3 для микроконтроллеров. Для установки нужен UF2 файл, скопированный в Pico. При нажатии на кнопку BOOTSEL после подключения micro USB-кабеля появляется интерфейс диска. Копируем файл, и после этого появляется доступ к Python Shell на плате.

Для написания кода и сохранения файлов в ПЗУ платы нужен редактор. Неплохой выбор Thonny. В целом, установка проходит без проблем, сохранение кода тоже.

Две новых возможности для Raspberry Pi PIO и аналоговые входы. PIO универсальный интерфейс, который можно использовать для создания таких интерфейсов, как I²C, SPI, I²S и даже VGA / DPI. Все зависит от проекта и квалификации разработчика.

Что касается языка С на Pico, то с ним все сложнее. Правда, на помощь приходит официальный мануал. Но времени на разработку в этом случае понадобится больше, чем в случае с MicroPython. Кроме того, потребуется работать либо с командной строкой, либо использовать Visual Studio Code.

Разработчики советуют работать с MicroPython.

А что можно разработать с Pico?

Плата предназначена для встраивания в железные проекты. Это недорогая альтернатива Arduino. Роботы, подсветка, IoT и многие другие системы можно разрабатывать с использованием новинки. При этом, как и говорилось выше, Pico потребляет очень мало энергии.

Это быстрая плата, которая делает то, что должна.


Единственная проблема полное отсутствие беспроводной связи, так что в этом плане возможности платы ограничены. Конечно, можно подключить внешний элемент и решить эту проблему, но в этом случае понадобится больше времени и ресурсов. Те же ESP32 и ESP8266 работают с WiFi из коробки, так что если требуется связь лучше выбрать их, тем более, что цена примерно та же.

В качестве вывода

Raspberry Pi Pico интересная плата. Правда, это больше микроконтроллер, чем одноплатный компьютер. Если нужно что-то простое и энергоэффективное, то плата подходит идеально. Если же требуется проект посложнее, стоит приобрести Raspberry Pi Zero W.

Начало

Raspberry Pi Foundation всегда знает чем порадовать или удивить нас, а так же как подталкивать других производителей на интересные шаги и решения для хорошей конкуренции.
В четверг (рыбный день, кстати) 21-ого января 2021 года был анонсирован выпуск нового микроконтроллера RP2040 и небольшой платы с его применением, которая получила название Raspberry Pi Pico.



Честно говоря, я прочитал эту новость и не планировал ничего делать по этому поводу. Но потом случайно заметил несколько особенностей этого микроконтроллера, что разбудило любопытство во мне и подтолкнуло к покупке пары плат для дальнейших экспериментов. Очень привлекло наличие PIO блоков и множество PWM. Справедливости ради, PWM можно как-то решить, а вот с PIO есть смысл поиграться.

После пары дней занимательной возни я решил поделиться своим небольшим опытом с Хабром и его гостями.

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

Введение

Raspberry Pi Pico является платой с микроконтроллером RP2040.

Надо помнить, что это не компьютер, на котором запущена взрослая ОС типа Linux, а именно микроконтроллер и поэтому цели применения у Pico отличаются от той же Raspberry Pi Zero и других старших продуктов семейства Raspberry Pi.

Приведу часть технических характеристик:

• Два ядра Arm Cortex-M0+ @ 133 МГц
• 264 КБ памяти (284 КБ если отключить XIP кеширование и использовать память USB)
• 2 МБ флеш-память с XIP кешированием. В RP2040 нет встроенной флеш-памяти, поэтому чип распаян на плате. У RP2040 есть поддержка до 16 МБ внешней флеш-памяти
• DMA контроллер
• 4 x 12-разрядных аналоговых входа (на Pico доступно для пользователя 3 из них)
• 2 UART
• 2 SPI
• 2 I²C
• 16 PWM каналов
• Встроенный сенсор температуры
• Всего 30 GPIO пинов (3,3 вольта)
• MicroUSB B порт с USB 1.1 контроллером и поддержкой хоста
• 2 PIO блока для своих собственных интерфейсов
• 2 x PLL (один для USB, второй для остального)
• Поддержка UF2 для загрузки бинарников
• Поддержка SWD для загрузки и отладки
• Поддержка спящих режимов и пониженной частоты для снижения потребления

RP2040 декодируется как:

RP: Raspberry Pi
2: два ядра
0: ядра M0+
4: минимум 256 КБ памяти
0: нет встроенной флеш-памяти

PIO блоки дают возможность создавать свои интерфейсы. Например, можно запрограммировать интерфейс WS2812, добавить I²S, SDIO или VGA и т.п.

Ещё одна интересная штука: ядро Cortex-M0+ не содержит в себе блока вычислений с плавающей запятой. Обычно это эмулируется библиотеками GCC, но тут Raspberry Pi использует более быстрое оптимизированное решение от автора Qfplib, которое лицензировано для использования на RP2040.

Более подробный datasheet на плату Pico
Тут можно найти datasheet на сам RP2040

Плата

Немного о самой плате Raspberry Pi Pico.

Плата имеет удобный размер 21мм x 51мм. Есть даже отверстия для монтирования, чем может похвастаться не каждая похожая плата.

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



На Pico стоит понижающий преобразователь на 3,3 Вольта. И это не просто линейный преобразователь, которые часто встречаются на недорогих аналогичных платах, а buck-boost SMPS на Richtek RT6150B. Благодаря этому входное питание платы может быть в пределах 1,8 5,5 Вольт.

Флеш-память W25Q16JV, хоть, и стоит внешняя, но перепаивать её будет не такой уж и тривиальной задачей, так как чип в корпусе USON-8 (мне лично точно не под силу).
Есть кнопка BOOTSEL и светодиод на GPIO25. Так же выведен SWD для отладки.

Кстати, можно использовать вторую плату Pico как отладчик по SWD.

Входы-выходы

На Raspberry Pi Pico выведено почти все входные-выходные пины (26 из 30). Официальная распиновка платы:



Некоторые пины задействованы для внутреннего применения:

GPIO23: выход для контроля энергосбережения SMPS. Можно регулировать пульсации за счёт изменения КПД преобразователя
GPIO24: вход для VBUS sense (1 если VBUS по MicroUSB подключен)
GPIO25: выход на светодиод, расположенный на плате
GPIO29: аналоговый вход для измерения VSYS/3
Сам USB порт дополнительно выведен на точки TP1, TP2 и TP3 внизу платы.

Разработка

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

• C/C++ с использованием предлагаемого Pico SDK
• CircuitPython для Pico
• MicroPython для Pico

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

Попробую вкратце пройтись по каждому из этих подходов.

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

RP2040 имеет встроенный загрузчик, который поддерживает UF2 (разработка Microsoft) для загрузки бинарников. Это представляет из себя внешний USB накопитель, на который можно просто скопировать бинарник.

Когда я купил плату в магазине, то во флеш-памяти ничего не было и UF2 активировался автоматически при подключении по USB. Когда программа записана на флеш-памяти, то UF2 режим можно активировать удерживанием кнопки BOOTSEL при подачи питания по USB. Появится накопитель RPI-RP2, который можно использовать для копирования бинарных файлов uf2.

Для отладки можно использовать SWD. Если нет подходящего отладчика, то можно использовать ещё одну плату Pico с прошитым отладчиком.

Как более простой вариант Pico может выводить данные стандартного вывода на UART или прикидываться USB CDC и выводить в обычный терминал типа PuTTY, minicom или аналогичный с параметрами по-умолчанию 115200 8n1.

C/C++ с Pico SDK

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

В своё время для ESP8266 мне пришлось пройти достаточно длинный квест для установки и настройки SDK. Но первоначальная установка окружения для RP2040 мне показалась намного более простой и удобной.

В оригинальном документе достаточно подробно описаны шаги для установки SDK на Linux, macOS и Windows.

Вариант с разработкой на Raspberry Pi 4B или 400 с Linux будет самым простым, так как есть скрипты, которые сделают первоначальную конфигурацию (даже установку Visual Studio Code):

git clone https://github.com/raspberrypi/pico-setup.gitpico-setup/pico_setup.sh

У меня все Raspberry Pi 4 оказались в каких-то своих тёмных делах, да и как-то привычнее разрабатывать на более удобных компах. По этой причине был выбран путь установки окружения вручную. Тем более, это оказалось не таким уж и сложным.

Весь процесс начальной подготовки сводится к следующим шагам (в данном случае шаги выполнялись на macOS и Linux):

# Создать общую директорию для всего:mkdir pico && cd pico# Забрать Pico SDK:git clone --recursive https://github.com/raspberrypi/pico-sdk.git# Забрать примеры:git clone https://github.com/raspberrypi/pico-examples.git# Linux: установить необходимые инструменты для сборки через "apt":apt update && apt install cmake gcc-arm-none-eabi build-essential# OSX: установить инструменты используя "brew" (список может немного меняться в зависимости от текущих установленных пакетов):# (gcc-arm-embedded будет установлен в /usr/local/bin. Эта информация нужна будет при конфигурировании Visual Studio Code)brew install cmake gcc-arm-embedded# Настроить переменную PICO_SDK_PATH (можно занести значение во что-то типа .profile по вкусу):export PICO_SDK_PATH=`pwd`/pico-sdk

Пример кода для мигания светодиодом с использованием Pico SDK:

#include "pico/stdlib.h"int main() {    // Конфигурация пина со светодиодом    const uint LED_PIN = 25;    gpio_init(LED_PIN);    gpio_set_dir(LED_PIN, GPIO_OUT);    // Наш рабочий бесконечный цикл    while (true) {        // Переключить светодиод        gpio_put(LED_PIN, 1);        sleep_ms(250);        gpio_put(LED_PIN, 0);        sleep_ms(250);    }}

Можно попробовать собрать эту мигалку из примеров:

cd pico-examplesmkdir buildcd buildcmake ..cd blinkmake -j8

Если всё прошло без ошибок, то в результате мы получим файлы, среди которых будет blink.uf2. Этот файл можно скопировать на Pico в режиме UF2 (надо удерживать кнопку BOOTSEL во время подачи питания по USB).

После копирования Pico автоматически перезагрузится и можно наслаждаться hello world на микроконтроллере.

В pico-examples есть достаточно много интересных примеров. В том числе и примеры с использованием PIO. Выглядит очень интересно. Возможно, расскажу об этом потом, но надо самому разобраться для начала.

Для создания начального шаблона для своего проекта есть инструмент от Raspberry Pi.

Он создаёт шаблоны под Pico SDK, Visual Studio и добавляет поддержку разных библиотек на разную периферию.

CircuitPython

Я много слышал про MicroPython и CircuitPython, но никогда не сталкивался. А тут появилась хорошая возможность пощупать.

CircuitPython является форком MicroPython, но со своими плюшками. Пожалуй, самая заметная плюшка в том, что CircuitPython создаёт USB флешку со своей файловой системой, где можно напрямую редактировать скрипты на Python'е в своём любимом IDE. При любой записи изменённого скрипта происходит автоматический перезапуск платы и выполнение кода.
В терминале можно видеть результат или запустить интерактивный режим для выполнения команд в нём, что тоже помогает в отладке.

Установка CircuitPython достаточно проста:

1. Скачать файл UF2 файл с CircuitPython'ом на circuitpython.org/board/raspberry_pi_pico
2. Перевести Pico в режим UF2 удержанием BOOTSEL во время подачи питания USB
3. Скопировать файл из #1 на флешку RPI-RP2, после чего Pico перезапустится автоматически

После этого из системы уйдёт RPI-RP2 и вместо него появится новый накопитель CIRCUITPY. На этом новом накопители должен быть файл code.py, с которого начинается выполнение кода. Так же там будет пустая директория lib, куда можно добавлять сторонние и свои библиотеки.
Файл code.py можно изменять прямо на этом накопителе в своём любимом редакторе. Adafruit советует использовать свой MU Editor, но у меня он зависает при запуске. Наверно, это даже к лучшему, так как я всё равно пользовался бы чем-то другим.

Так же доступна консоль на последовательном порту с параметрами 115200 8n1. При подключении можно получить доступ к интерактивному Python'у и выводу в консоль через print в скриптах.

Наша мигалка на CircuitPyhon будет выглядеть примерно так:

import boardimport timefrom digitalio import DigitalInOut, Direction# Конфигурация пина со светодиодомled = DigitalInOut(board.LED)led.direction = Direction.OUTPUT# Наш рабочий бесконечный циклwhile True:    # Переключить светодиод    led.value = not led.value    time.sleep(1)

Adafruit предлагает достаточно большой набор библиотек для работы с разным оборудованием.
Можно скачать .zip архив со всеми официальными доступными библиотеками для CircuitPython на circuitpython.org/libraries

Рекомендуется забирать .mpy версию. Это готовый байт-код, который откомпилирован под нужную версию CircuitPython.

MicroPython

MicroPython и CircuitPython достаточно близки друг к другу, но с некоторыми особенностями для отладки и API.

Установка MicroPython тоже достаточно проста:

1. Скачиваем UF2 со свежим релизом тут (вкладка Getting started with MicroPython)
2. Переводим Pico в режим UF2 удерживанием BOOTSEL во время подачи питания USB
3. Копируем .uf2 файл из первого шага на RPI-RP2

На этот раз RPI-RP2 уходит, но новый накопитель не появляется. Можно подключиться терминалом на только что появившийся порт (115200 8n1), по которому будет доступна интерактивная консоль Python'а.

Для работы с кодом предполагается использование Thonny (возможно, есть и другие варианты). Это минималистичный IDE, который может редактировать код напрямую на плате микроконтроллера.

Скачать Thonny можно тут

После установки Thonny в настройках надо подключить Pico. Это сделать можно через меню Tools Options, потом в закладке Interpreter выбрать MicroPython (Raspberry Pi Pico) в поле Which interpreter or device, а в поле Port выбрать порт, на котором подключена плата Pico.



Настройку лучше выполнять при подключенной Pico, что бы Thonny мог найти нужный порт.

Пример для мигания на MicroPython:

import timefrom machine import Pin# Конфигурация пина со светодиодомled = Pin(25, Pin.OUT)led.value(0)# Наш рабочий бесконечный циклwhile True:    # Переключить светодиод    led.toggle()    time.sleep(1)

Выводы (на этот раз не контроллера)

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

Уверен, что фанатам Arduino не придётся долго ждать когда Pico будет портирован на их любимую платформу. Зато пока есть хороший повод поиграться с Python'ом.

PIO выглядит очень интересной фишкой и я надеюсь заняться этим плотнее по мере появления свободного времени.

Ещё недавно я наткнулся на TensorFlow Lite Micro для Pico для запуска моделей машинного обучения.

В целом, я очень рад за новый продукт в линейке Raspberry Pi и надеюсь, что ему предстоит много приятных приключений и открытий в нашем мире.

Некоторые компании уже объявили о выходе своих плат на этом микроконтроллере (в том числе и с беспроводным интерфейсом), что должно дать больше возможностей.