Rozszerzenie C dla MicroPythona na Raspberry Pi Pico

To jest przewodnik, jak napisać i uruchomić podstawowe rozszerzenie C dla MicroPython na Raspberry Pi Pico. Omówię powody dla rozszerzenia MicroPython, jak napisać moduł rozszerzenia, jak go skompilować i jak zainstalować go na Pico. Jeśli chcesz przeczytać więcej na ten temat, odsyłam do https://docs.micropython.org/en/latest/develop/extendingmicropython.html

Wstęp

Dlaczego warto rozszerzyć MicroPython?

Może być wiele powodów, dla których chciałbyś rozszerzyć MicroPythona. Ponieważ jest to okrojona wersja Pythona, MicroPython nie radzi sobie zbyt dobrze, jeśli chodzi o zadania wymagające dużych mocy obliczeniowych (podobnie jak Python). Z drugiej strony, język C jest naprawdę dobrze przystosowany do takich zadań. Rozszerzenie C dla Micropythona umożliwia wykonywanie tych obliczeń w języku C i wykorzystywanie ich wyników w MicroPythonie. Może to przyspieszyć niektóre procesy o rząd wielkości.

Drugim powodem może być chęć podłączenia sprzętu, który używa C API z poziomu MicroPythona. 

Typy rozszerzeń MicroPython C

Istnieją różne sposoby rozszerzania MicroPythona: zewnętrzne moduły C oraz natywny kod maszynowy w plikach .mpy.

Aby uruchomić zewnętrzny moduł w języku C, należy go przekompilować do firmware'u MicroPythona. Jest to dość skomplikowany proces, dlatego w tym poradniku skupimy się na drugiej alternatywie. Jeśli jednak jesteś zainteresowany tym podejściem, możesz przeczytać więcej na ten temat na tych stronach:                https://docs.micropython.org/en/latest/develop/cmodules.html                      https://www.raspberrypi.org/forums/viewtopic.php?t=300352

.mpy jest plikiem, który przechowuje skompilowany natywny kod maszynowy i może być łączony dynamicznie. To czyni go znacznie bardziej elastycznym, ponieważ nie trzeba rekompilować całego firmware MicroPythona.

Napisać moduł rozszerzenia

Napisanie modułu rozszerzeń jest najprostszą częścią rozszerzania MicroPythona. Pokażę Ci, jak to zrobić, na prostym przykładzie. Na początek utworzymy nowy katalog o nazwie factfib. Otwórz nowe okno terminala, cd do nowego katalogu i utwórz nowy plik o nazwie faktfib.c. Jeśli utworzyłeś katalog na Raspberry Pi pod Dekstopem, polecenie wygląda tak.

cd ~/Desktop/factfib

touch factfib.c

Otwórz faktfib.c w swoim ulubionym edytorze tekstu i wprowadź następujący kod:

#include "py/dynruntime.h

STATIC mp_int_t factorial_helper(mp_int_t x) {
   if (x < 1) {
      return 1;
   }
   return x*factorial_helper(x-1);
}

STATIC mp_obj_t factorial(mp_obj_t x_obj) {
   mp_int_t x = mp_obj_get_int(x_obj);
   mp_int_t rslt = factorial_helper(x);
   return rslt;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);

STATIC mp_int_t fibonacci_helper(mp_int_t x) {
   if (x <= 0) {
      return 0;
   }
   else if (x == 1) {
      return 1;
   }
   else {
      return (fibonacci_helper(x-1) + fibonacci_helper(x-2));
   }
}

STATIC mp_obj_t fibonacci(mp_obj_t x_obj) {
   mp_int_t x = mp_obj_get_int(x_obj);
   mp_int_t rslt = fibonacci_helper(x);
   return mp_obj_new_int(rslt);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_1(fibonacci_obj, fibonacci);

mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
   MP_DYNRUNTIME_INIT_ENTRY

   mp_store_global(MP_QSTR_factorial, MP_OBJ_FROM_PTR(&factorial_obj));
   mp_store_global(MP_QSTR_fibonacci, MP_OBJ_FROM_PTR(&fibonacci_obj));

   MP_DYNRUNTIME_INIT_EXIT
}

Pozwól mi wyjaśnić powyższy kod: W MicroPythonie i Pythonie każda zmienna jest obiektem. Dlatego w C reprezentujemy je jako mp_obj_t. Ale program w języku C może pracować tylko ze zmiennymi typu C, dlatego musimy przekształcić obiekt w typ C. Nazywa się to Marshalling, a MicroPython dostarcza funkcji do wyodrębnienia dowolnego typu C z obiektu.

Ta strona autorstwa Olivera Robsona jest naprawdę pomocna w Marshallingu https://mpy-c-gen.oliverrobson.tech/. Ponadto możesz znaleźć przykłady Marshalling w dokumentacji MicroPythona https://docs.micropython.org/en/latest/develop/natmod.html. Radzę przeczytać ten artykuł, jeśli potrzebujesz dalszych wyjaśnień.

Zbuduj rozszerzenie

Budujemy rozszerzenie do pliku .mpy za pomocą pliku Makefile. Ale najpierw musimy skonfigurować kilka rzeczy. Upewnij się, że twój terminal jest wciąż otwarty w trybie factfib katalog. Następnie sklonuj repozytorium MicroPython GitHub.

sudo apt-get install build-essential libreadline-dev libffi-dev git pkg-config gcc-arm-none-eabi libnewlib-arm-none-eabi

git clone --recurse-submodules https://github.com/micropython/micropython.git

pip3 install 'pyelftools>=0.25'

Te instalacje zajmą trochę czasu, jeśli chcesz go zaoszczędzić i wiesz co robisz, wystarczy sklonować katalogi /py i /tools z repozytorium micropythona i umieścić je w katalogu micropython folder wewnątrz factfib folder (pomiń drugie polecenie).

Podczas gdy instalacja jest uruchomiona, możemy wykorzystać ten czas na napisanie pliku Makefile. Po prostu wykonaj

touch Makefile

i otwórz nowo utworzony plik w edytorze tekstu.

MPY_DIR = micropython

MOD = factfib

SRC = factfib.c

ARCH = armv7m

include $(MPY_DIR)/py/dynruntime.mk

Być może zauważyłeś, że ustawiliśmy ARCH zmienna do armv7m chociaż pico jest armv6m. Musimy to zrobić, ponieważ armv6m architektura jest (w momencie pisania tego artykułu) nie wspierana przez dynruntime.mk narzędzie.

Ale na szczęście wciąż możemy skompilować działające rozszerzenie dla Pico. Musimy tylko zmodyfikować dynruntime.mk plik, który powinien znajdować się pod micropython/py/dynruntime.mk. Otwórz go i pod Architecture configuration w armv7m znajdź zmienną CFLAGS (powinna być w linii 64). Zmień -mcpu=cortex-m3 do -mcpu=cortex-m0 i zapisać plik.

Następnie, gdy wszystko jest już zainstalowane, wykonaj

make

i factfib.mpy zostanie utworzony plik.

Zainstaluj i przetestuj rozszerzenie

Ostatnim krokiem jest instalacja i testowanie. W tym celu wykorzystujemy system plików, który Micropython tworzy na Raspberry Pi Pico. Najpierw musimy sflashować Pico z firmware MicroPython. Najprostszym sposobem na to jest użycie Thonny IDE (preinstalowanego na Raspbian/Raspberry Pi OS).

Jeśli nie używasz Raspberry Pi do programowania Pico lub jeśli nigdy nie używałeś MicroPython na Pico przed, proszę odnieść się do rozpoczęcia z MicroPython przewodnik przez Raspberry Pi https://www.raspberrypi.org/documentation/rp2040/getting-started/#getting-started-with-micropython

Jeśli używasz systemu Windows należy sprawdzić ten blog Post o Raspberry Pi Pico i MicroPython w systemie Windows https://picockpit.com/raspberry-pi/raspberry-pi-pico-and-micropython-on-windows/

Zamknij Thonny'ego po przepłukaniu Pico firmware'em MicroPython i zainstaluj rshell. Używamy rshell, aby uzyskać dostęp do systemu plików z linii poleceń.

sudo pip3 install rshell
rshell --version

Spowoduje to wydrukowanie wersji rhsell, jeśli wszystko jest poprawnie skonfigurowane. Następnie odłączamy pico i podłączamy je ponownie (bez trzymania przycisku BOOTSEL) aby upewnić się, że nic nie próbuje uzyskać dostępu do systemu plików. Teraz musimy wykonać

rshell -p /dev/ttyACM0 --buffer-size 512

cp factfib.mpy /pyboard/factfib.mpy

Aby przetestować instalację, możesz użyć rshell lub Thonny IDE do zapisania twojej .py na Pico, ale zademonstruję jak używać interpretera MicroPython na minicomie.

Więc najpierw naciśnij Ctrl+c aby opuścić rshell, a następnie zainstalować minicom przez

sudo apt install minicom

teraz możemy uzyskać dostęp do Picos REPL (pętla Read-eval-print)

minicom -o -D /dev/ttyACM0

Trzy zamykające nawiasy kątowe >>> wskazują, że interpreter MicroPython jest uruchomiony. Teraz możemy zaimportować nasze rozszerzenie i pracować z nim jak zwykle.

>>> import factfib as ff

>>> ff.factorial(5)

>>> 120

>>> ff.fibonacci(7)

>>> 13

Gratulacje! Stworzyłeś swoje pierwsze rozszerzenie MicroPython C dla Pico! Następnym krokiem jest nauczenie się pisania i kompilowania bardziej złożonych modułów. Dobrym sposobem na rozpoczęcie jest przetestowanie, jak działa Marshalling list i dicts (patrz strona Marshalling powyżej).

Jeśli masz jakieś pytania dotyczące tego wpisu, napisz komentarz.