MicroPython med Arduino-kort: Komplett praktisk guide

Hem » Python » MicroPython med Arduino-kort: Komplett praktisk guide

Om du redan känner dig bekväm med "vanlig" Python och precis har snubblat över MicroPython, är du inte ensam.Många utvecklare gör exakt samma upptäckt när de börjar experimentera med mikrokontroller som Arduino, ESP32 eller Raspberry Pi Pico. Vid första anblicken ser syntaxen nästan identisk ut med CPython, men plötsligt finns det nya moduler, hårdvaruspecifika klasser och ett annat sätt att flasha och köra kod på kort.

Den här guiden sammanställer viktig information från de bäst rankade engelskspråkiga resurserna om MicroPython och Arduino och blandar den med praktiska, verkliga kontexter.Du får se var den officiella MicroPython-koden finns, vilka Arduino-kompatibla kort som faktiskt kan köra MicroPython, vilken typ av drivrutiner och bibliotek som finns tillgängliga och hur du kommer igång om du har ett kort i Arduino-stil, till exempel en ESP-baserad NodeMCU, en Nano ESP32, en Nano RP2040 Connect eller en Portenta.

Vad MicroPython är och hur det relaterar till Arduino

MicroPython är en smidig implementering av Python-språket, utformad för att köras direkt på mikrokontroller.Istället för att köras på ett komplett skrivbords-OS körs MicroPython på små kretsar med begränsat RAM-minne och flashminne, vilket ger dig en Python-prompt direkt på enheten. Språkkärnan förblir mycket lik CPython, så dina befintliga Python-kunskaper överförs till stor del, men du får extra moduler som Maskinen, nät or UOS att kommunicera med pinnar, sensorer, bussar och lagring.

Relationen med Arduino handlar mest om hårdvara och API:er, inte om den traditionella Arduino-miljön "C++ sketches"MicroPython riktar sig mot specifika kort och chip (portar) som ESP32, ESP8266, RP2040, nRF51/nRF52, STM32, SAMD, Renesas RA, och så vidare. Många moderna Arduino-märkta kort är byggda på just dessa mikrokontroller, vilket är det som gör dem kompatibla med MicroPython.

Den klassiska Arduino Uno, baserad på ATmega328P 8-bitars AVR, har ingen officiell MicroPython-port.Den är helt enkelt för begränsad vad gäller flashminne och RAM, och MicroPython VM är inte designad för ett så litet chip. Det är därför du kommer att se frågor från communityn som "Hur kör jag MicroPython på Arduino Uno?" och det korta, ärliga svaret är: det kan du vanligtvis inte, och om du på något sätt gör det kommer det att vara extremt begränsat och inte officiellt stödt.

Där Arduino och MicroPython verkligen möts är på nyare "Arduino"-kort som använder 32-bitars mikrokontroller med tillräckligt med resurser.Brädor som Arduino Nano ESP32, Arduino Nano RP2040 Connect, Arduino Nano 33 BLE Sense, Arduino Giga, Effekt H7, Portenta C33, Nicla Vision, Nicla Sense Env och Opta WiFi sitter ovanpå chip som ESP32, RP2040, STM32H7, Renesas RA6M5 och liknande familjer. Dessa mikrokontroller har officiella eller aktivt utvecklade MicroPython-portar.

Officiell MicroPython-källkod, versioner och stödda portar

MicroPython utvecklas öppet med Git för versionshantering, och det kanoniska arkivet finns på GitHub på github.com/micropython/micropython.Det arkivet innehåller den fullständiga tolkkällan, kärnbiblioteken och portarna för olika mikrokontrollerfamiljer. Om du någonsin behöver inspektera interna komponenter eller bygga din egen firmware-avbildning är det här rätt ställe att gå till.

Projektet tillhandahåller en fullständig källkodsdistribution av den senaste stabila versionen som nedladdningsbara arkiv.Dessa utgåvor samlar tolken, biblioteken och portarna i en ögonblicksbild som du kan kompilera själv. För personer som vill bo ännu närmare gränsen finns det dagliga ögonblicksbilder av GitHub-arkivet tillgängliga från MicroPython-servern. Dessa ögonblicksbilder utelämnar vanligtvis Git-undermoduler men spårar det aktuella utvecklingsläget, vilket är användbart om du testar nya funktioner eller skickar in patchar.

Utöver källkoden erbjuder MicroPython automatiskt byggda firmware-avbildningar för ett brett utbud av kort och arkitekturer.Dessa firmware genereras dagligen för olika portar, inklusive:

• Alif
• cc3200
• exp32 (med varianter som esp32c2, esp32c3, esp32c5, esp32c6, esp32p4, esp32s2, esp32s3)
• exp8266
• mimxrt (i.MX RT)
• NRF (nRF51, nRF52, nRF91)
• Renesas-ra (RA4M1, RA4W1, RA6M1, RA6M2, RA6M5, etc.)
• rp2 (RP2040, RP2350)
• samd (SAMD21, SAMD51)
• stm32 (STM32F0, F4, F411, F7, G0, G4, H5, H7, L0, L1, L4, U5, WB, WL)

De dagliga byggen är vanligtvis grupperade och filtrerbara efter funktioner, leverantör och MCU så att du snabbt kan hitta en firmware-avbildning som matchar ditt moderkort.Funktionsfilter inkluderar funktioner som Audio Codec, BLE, Batteriladdning, KAN, Kamera, DAC, Skärmar, Dubbelkärnig, Miljösensor, ethernet, Extern blixt, Externt RAM-minne, Fjäder, IMU, JST-PH/JST-SH, Lora, Mikrofonen, PoE, RGB LED, SD-kort, Säkert element, USB/USB-C, WiFi, microSDoch mikroBUSDet finns också ett leverantörsfilter där du till exempel kan begränsa resultaten till Arduino-märkta kort.

Flera Arduino-kort listas explicit eller täcks implicit via sina MCU:er.Bland Arduino-namnen som är kopplade till MicroPython-byggen hittar du:

• Giga
• Arduino Nano 33 BLE Sense
• Arduino Nano ESP32
• Arduino Nano RP2040 Connect
• Arduino Nicla Vision
• Arduino Nicla Sense Env (serveras via ett specifikt bibliotek)
• Arduino Opta WiFi
• Arduino Portenta C33
• Arduino Portenta H7 (ofta refererad till som envie_m7-varianten)

Eftersom firmware-avbildningar byggs per port och kort är ditt första steg alltid att identifiera exakt vilken MCU och variant som används av ditt Arduino-kort.Till exempel mappar en Arduino Nano ESP32 till exp32 porten, medan en Nano RP2040 Connect använder rp2 hamn. En Portenta H7 faller under stm32 exklusiv familj, och en Portenta C33 lutar sig mot Renesas-ra port. Att matcha dessa säkerställer att du flashar rätt MicroPython-binärfil.

Fungerar MicroPython på alla Arduino-kort?

Detta är en av de vanligaste frågorna från personer som upptäcker MicroPython efter att ha arbetat med Arduino-ekosystemet.Kortversionen är: MicroPython stöder inte alla Arduino-kort, men den stöder många nyare som använder 32-bitars MCU:er med tillräckligt med minne och flashminne.

Korten där MicroPython inte realistiskt sett är ett alternativ är de gammaldags AVR Arduino-kretsarna som Uno, Nano (klassisk), Mega eller Leonardo.Dessa kort använder 8-bitars AVR-mikrokontroller med begränsade resurser. Även om det har funnits experimentella portar och ultraminimala forks i communityn, fokuserar det officiella MicroPython-projektet på mer kapabla 32-bitarsarkitekturer, så du bör inte förvänta dig en polerad, officiellt underhållen MicroPython-firmware för Uno.

Däremot är NodeMCU och liknande ESP8266/ESP32-utvecklingskort en utmärkt matchning för MicroPython och stöds aktivt.NodeMCU använder vanligtvis en ESP8266 or ESP32 chip, som båda har stabila och populära MicroPython-portar. Att flasha MicroPython till en NodeMCU ger dig ett mycket användarvänligt sätt att utföra WiFi-aktiverad IoT-utveckling med Python-syntax istället för Arduino C++-dialekten.

För Arduino-märkt hårdvara, fokusera på modeller som återanvänder samma mikrokontroller som vanliga MicroPython-kortDetta inkluderar en bred familj:

• Arduino Nano ESP32 — ESP32-baserad; använder esp32-porten.
• Arduino Nano RP2040 Connect — baserad på Raspberry Pi RP2040; använder rp2-porten.
• Arduino Nano 33 BLE Sense — Nordisk nRF52; stöds via nrf-porten.
• Arduino Giga — avancerad STM32H7 MCU; täckt via stm32-porten.
• Arduino Portenta H7 — STM32H7 dubbelkärnig; stöds via stm32.
• Arduino Portenta C33 — Renesas RA-mikrokontroller; kopplad till renesas-ra-porten.
• Arduino Nicla Vision och relaterade Nicla-kort — byggda kring stödda MCU:er och adresserade med specialiserade MicroPython-drivrutiner.
• Arduino Opta WiFi — industriellt inriktad, men byggd på stödda STM32-delar.

Om du håller en Arduino Uno och en NodeMCU sida vid sida, är det bara NodeMCU som verkligen är en förstklassig kandidat för MicroPython.Med Uno är det mer pragmatiskt att antingen stanna kvar vid Arduino C++ eller uppgradera till ett modernt, MicroPython-vänligt kort som fortfarande passar bra in i Arduinos ekosystem, som Nano ESP32 eller Nano RP2040 Connect.

Behöver du en ny IDE eller extra verktyg för MicroPython?

MicroPython-utveckling känns annorlunda än att sammanställa Arduino-skisser, men du behöver inte nödvändigtvis en tungviktare ny IDE.Eftersom MicroPython kör en interpreter på kortet arbetar man vanligtvis med klartext .py-filer och en seriell REPL istället för kompilerade .hex- eller .bin-skisser.

De väsentliga kraven är ett sätt att flasha firmware till kortet och ett verktyg för att ladda upp Python-filer och kommunicera med REPL:en.För flashing förlitar du dig vanligtvis på leverantörsverktyg eller kommandoradsverktyg som esptool.py (för ESP8266/ESP32), eller så använder du kortet's bootloader-stöd (UF2 för RP2040, DFU för STM32, etc.). Många MicroPython-webbsidor och dokument ger dig konkreta flashinstruktioner per port.

För redigering och filöverföring kan du fortsätta använda din favoritkodredigerare och bara lägga till en MicroPython-medveten hjälpare.. Vanliga alternativ inkluderar:

• Thonny — en enkel Python IDE med inbyggt MicroPython-stöd, seriell REPL och filhantering.
• Mu-redaktör — nybörjarvänlig redigerare som talar MicroPython och CircuitPython.
• VS-kod med tillägg — du kan använda vanligt Python-stöd tillsammans med tillägg som hanterar MicroPython-uppladdning/ERSÄTTNING.
• ampy / rshell / mpremote — kommandoradsverktyg för att ladda upp skript, lista filer och interagera med REPL på enheten.

På vissa Arduino-märkta kort hittar du även integrationsvägar som låter dig hålla dig nära Arduino-världen samtidigt som du skriver MicroPython-kod.Vissa verktyg och bibliotek låter dig strukturera dina MicroPython-program med en Arduino-liknande uppstart() och slinga()och exponera bekanta funktioner som digital skriv or analogläsning bakom kulisserna. Detta gör att erfarna Arduino-användare känner sig mer hemma, även om den underliggande körtiden är MicroPython.

I praktiken innebär ett byte till MicroPython vanligtvis att du slutar använda den klassiska Arduino IDE för dessa projekt och övergår till ett Python-orienterat arbetsflöde.Med det sagt, din mentala modell av "kort + pinnar + bibliotek + exempel" förblir intakt, och efter en dag eller två av mixtrande känns MicroPython-editorn + REPL-kombinationen väldigt naturlig.

Komma igång: från Arduino Uno och NodeMCU till MicroPython

Om ditt mål är att köra MicroPython på en Arduino Uno, kommer du sannolikt att stöta på en hård vägg.Tolkaren är helt enkelt för stor för Unos ATmega328P, och det officiella projektet tillhandahåller inte en underhållen portning. Du kan hitta experimentella forks eller mycket avskalade derivator, men de kommer inte att bete sig som en vanlig MicroPython-miljö, och många bibliotek kommer inte att passa. För de flesta är det pragmatiska draget att acceptera att Uno är ett "klassiskt Arduino C++"-kort och välja en annan enhet för MicroPython-experiment.

Med en NodeMCU (ESP8266- eller ESP32-variant) kan du dock följa en enkel väg till MicroPython.De exakta stegen skiljer sig något mellan chippen, men det allmänna flödet är:

• 1. Ladda ner lämplig MicroPython-firmware för din esp8266- eller esp32-port från MicroPython-nedladdningssidan eller servern för dagliga byggen. Se till att bygget matchar din flash-storlek och kortfamilj.
• 2. Radera och flasha kortet med hjälp av esptool.py (eller motsvarande) från din dator. Detta raderar den befintliga firmware (ofta NodeMCU Lua- eller Arduino-skisser) och installerar MicroPython istället.
• 3. Anslut en seriell terminal eller ett REPL-verktyg (som Thonny, Mu, mpremote eller en generisk seriell konsol) med rätt baudhastighet. Du bör se den välbekanta >>> Python-prompten om allt gick bra.
• 4. Skapa och ladda upp skript som heter boot.py och main.pyeller andra moduler som du vill importera. Dessa kommer att köras automatiskt eller vara tillgängliga för interaktiv import.

Samma mönster gäller för många Arduino-märkta kort som är MicroPython-vänliga, med den enda verkliga skillnaden i den exakta flashande verktygsuppsättningen och bootloader-beteendet.Till exempel kommer en RP2040-baserad Arduino att använda UF2-bootloadern (dra och släpp en .uf2-fil), medan en Portenta H7 kommer att förlita sig på STM32-startmekanismer eller tillverkarens verktyg. När den har flashats ser Python-sidan väldigt lik ut: maskin.PIN för GPIO, maskin.I2C för sensorer och så vidare.

En extra bekvämlighet som finns tillgänglig i Arduino-ekosystemet är ett MicroPython-hjälpbibliotek som låter dig skriva kod i en skissliknande stil.Det här biblioteket tillhandahåller Arduino-liknande API:er och till och med en MicroPython-implementering av uppstart() och slinga()Du kan till exempel skriva något konceptuellt liknande en Arduino-skiss, men under huven körs det på en MicroPython-körningstid med Python-syntax och semantik. Det gör övergången smidigare för personer som har många års vana vid Arduino.

MicroPython-paket och bibliotek för Arduino-kompatibla kort

En av MicroPythons starkaste sidor på Arduino-kort är det växande ekosystemet av hårdvarudrivrutiner och hjälpbibliotek.MicroPython-communityn upprätthåller en MicroPython-paketindex som listar återanvändbara moduler som kan installeras eller kopieras till stödda kort, inklusive många med explicit verifiering på Arduino-produkter.

Bidragsriktlinjerna för detta index beskriver hur man skickar in nya paket, dokumenterar dem korrekt och märker dem med relevanta funktioner.Detta säkerställer att när du söker efter en sensor eller skärm kan du snabbt hitta en drivrutin som är känd för att fungera med specifika mikrokontrollerportar eller till och med specifika Arduino-kort.

Bland de tillgängliga biblioteken är vissa specifikt dedikerade till Arduino-hårdvara, medan andra är generiska drivrutiner som råkar fungera utmärkt på Arduino-märkta kort.Till exempel finns det en MicroPython-bibliotek för att styra Arduino Modulinos, vilka är modulära tillägg som integreras tätt med Arduino-hårdvara. Ett annat anmärkningsvärt paket är ett MicroPython-bibliotek för Arduino Nicla Sense Env, fokuserad på kortetts miljöavkännande kapacitet.

Det finns också en utmärkt hjälpfunktion som gör det enkelt att skriva kod med Arduino-liknande mönster som setup/loop och välbekanta API:er samtidigt som man fortsätter att använda MicroPython.Detta paket överbryggar effektivt den konceptuella klyftan mellan "Arduino-skisser" och Python-moduler, vilket låter användare behålla muskelminnet som att anropa [program/anrop]. digital skriv samtidigt som man faktiskt utnyttjar MicroPythons runtime och REPL.

Förutom de Arduino-inspirerade biblioteken innehåller ekosystemet en lång lista med sensor-, display-, lagrings- och verktygsdrivrutiner som stöder MicroPython på vanliga mikrokontroller och kort.Många av dessa har testats på kretskort som arduino:esp32:nano_nora, Diverse esp32s3 enheter och avancerade mbed_portenta varianter. Verifieringsanteckningarna specificerar ofta vilken MicroPython-version och vilket kort-ID som används, så du vet att biblioteket inte är teoretiskt.

Anmärkningsvärda MicroPython-drivrutiner och verktyg som du kan använda

MicroPython Package Index innehåller en omfattande samling drivrutiner som täcker miljösensorer, skärmkontroller, IO-expanderare, lagring, kommunikationsprotokoll och mer.Om du bygger projekt på kompatibla Arduino-kort är oddsen hög att det finns en färdig drivrutin för den hårdvara du vill ha.

Miljö- och gassensorer är väl representeradeDu hittar en MicroPython-drivrutin för BME280 sensor (ofta refererad med Pycom-enheter som ett mål) och en annan för BME680 utbrott, kommunicera över I²CDessa drivrutiner hanterar temperatur-, fuktighets-, tryck- och gasavläsningar, vilket gör att du kan ansluta ett kort som Nano ESP32 eller Nano RP2040 till miljösensorer med bara några rader Python.

Skärmkontrollen är lika väl täcktDet finns Python-drivrutiner för Holtek HT16K33 styrenheten, som driver enheter som Adafruit 0.8-tums 8×16 LED Matrix FeatherWing eller vissa Raspberry Pi Pico-skärmar. Dessa drivrutiner stöder båda CircuitPython och mikropyton via I²C, vilket gör dem mångsidiga och återanvändbara över olika ekosystem. Du får även MicroPython-drivrutiner för bildskärmskontroller som SH1106 och SH1107, som används i olika OLED-paneler, såväl som paket för HD44780teckenbaserade LCD-skärmar (modellerna 1602 och 2004) drivna över I²C.

För analog-till-digital-omvandling och IO-expansion finns flera robusta paket tillgängliga.Det finns en MicroPython-drivrutin för ADS1x15 serie ADC:er, som ofta används för att lägga till analoga ingångar med högre upplösning. Ett annat bibliotek stöder MCP23017 16-bitars I/O-expander med I2C-gränssnitt, vilket gör att du dramatiskt kan öka antalet digitala pinnar som ditt Arduino-kort exponerar, allt styrt från MicroPython.

En mängd olika LED-drivrutiner täcker visuell feedback och displayerDu hittar ett MicroPython-bibliotek för MAX7219 8×8 LED-matrisdrivrutin med SPI och bildbuffert, samt en drivrutin för fyrkantiga 7-segments LED-displayer baserad på TM1637 chip. Det finns också ett bibliotek för 10-segments LED-stapeldiagram med MY9221 drivrutin och separata MicroPython-moduler för adresserbara lysdioder som t.ex. WS2812B och SK6812 (ofta allmänt kända som neopixlar) på Raspberry Pi Pico. Dessa passar alla bra ihop med Arduino-märkta kort som delar samma MCU-familjer.

Realtidsklockor och användningsområden för dataloggning stöds via dedikerade moduler.En förare riktar in sig på DS3231 RTC kombinerat med AT24C32 EEPROM, vilket gör det enkelt att hålla exakt tid och lagra konfiguration eller små loggar över strömcykler. Kombinerat med SDCard- och microSD-funktioner som finns tillgängliga i specifika portar kan du sätta ihop seriösa dataloggningsinställningar med hjälp av endast MicroPython-skript.

Beröringsfri temperaturavkänning och kapacitiv ingång är också enkla tack vare fokuserade drivenheterDet finns ett MicroPython-bibliotek för Melexis MLX90614 IR-temperatursensor, som möjliggör fjärrmätning av temperaturen, och en annan för MPR121 Kapacitiv pekskärm och breakout-kort, användbara för pekbaserade användargränssnitt. Båda integreras smidigt över I²C och kan användas med Arduino-kompatibla MicroPython-kort.

För biometrisk och ljudrelaterad hårdvara hittar du specialiserade MicroPython-portar.Det finns ett paket för MAX30102 sensor, en populär pulsoximeter-/pulsmodul som ursprungligen stöddes av SparkFuns drivrutin, nu anpassad till MicroPython. Ljuduppspelningsmoduler täcks av en MicroPython-implementering av DFPlayer-kontroll över UART, vilket gör MP3-uppspelning tillgänglig utan tung kod.

Timing-, rörelse- och inmatningsenheter får sina egna robusta implementeringarEn MicroPython-drivrutin för roterande pulsgivare använder GPIO-avbrott och debouncing för att ge noggranna, icke-jitteriga avläsningar på kort som Pyboard, Raspberry Pi Pico, ESP8266 och ESP32. Servostyrning på Raspberry Pi Pico hanteras genom drivrutiner som använder PDM (Pulsdensitetsmodulering) eller enklare PWM-baserade wrappers, och det finns små hjälpklasser fokuserade på styrning av 9g servon från MicroPython.

Infraröd kommunikation hanteras av ett par icke-blockerande drivrutiner för mottagare och blasterEtt bibliotek fokuserar på att ta emot IR-fjärrkontrollkoder, medan ett annat hanterar IR-överföring för "blaster"-applikationer. Båda är utformade för icke-blockerande drift så att de kan köras bekvämt tillsammans med andra MicroPython-uppgifter.

För termisk utskrift och visning finns en MicroPython-port av Adafruits Python Thermal Printer-bibliotek tillgänglig.Det här paketet låter dig driva termiska kvittoskrivare från kort som ESP32 eller RP2040, återigen med MicroPython som styrmiljö.

Utöver hårdvarudrivrutiner finns det verktyg som gör Arduino-drivna IoT-projekt mycket enklareEn som sticker ut är en Python-klient för Arduino IoT Cloud som fungerar i både CPython och MicroPython. Detta paket, som finns på GitHub under Arduino-organisationen och licensieras under Mozilla Public License 2.0, tillåter MicroPython-enheter att ansluta till Arduino IoT Cloud för telemetri, dashboards och fjärrstyrning. Det har verifierats på arduino:mbed_portenta:envie_m7 plattform som kör MicroPython, vilket visar att avancerade Arduino-kort sömlöst kan integreras i Arduinos molntjänster från en Python-körning.

Vissa display- och inmatningsbibliotek är initialt utformade kring Pycom-varianten av MicroPython men fungerar fortfarande bra på många Arduino-kort.Till exempel finns det ett I2C LCD-teckenskärmsgränssnittspaket skräddarsytt för Pycom, och en MicroPython-port på ucPack bibliotek, vilka båda ofta kan återanvändas eller anpassas för andra MicroPython-portar när den underliggande buss- och pinkonfigurationen matchar.

Varför MicroPython på Arduino-klassad hårdvara är värd att utforska

När du kombinerar MicroPythons dynamiska, högkvalitativa känsla med det enorma utbudet av Arduino-kompatibel hårdvara får du en mycket flexibel prototypplattform.Istället för att ständigt kompilera om skisser kan du iterera interaktivt: öppna REPL:en, sticka ut pins, läsa av sensorer, justera logik och se omedelbar feedback. Bara det kan kraftigt minska utvecklingstiden för hobbyprojekt, snabba demonstrationer eller till och med professionella prototyper.

Ekosystemet av MicroPython-paket, med explicit stöd och verifiering på Arduino-kort, innebär att du sällan behöver börja från början med råa register eller komplexa C-drivrutiner.Bibliotek för sensorer som BME280/BME680, displayer som drivs av HT16K33, SH1106 eller HD44780, IO-expanderare som MCP23017 och infrastrukturdelar som ModBus TCP/RTU-klienter och värdar hjälper dig att stå på communityns axlar.

Samtidigt bidrar Arduino-universumet med molnintegrationer och välkonstruerade kortdesigner.Den dedikerade Arduino IoT Cloud Python-klient är ett bra exempel på hur de två ekosystemen möts: du kan skriva MicroPython-kod på ett Portenta-klasskort, men ändå utnyttja Arduinos dashboards och IoT-verktyg. Avancerade kort som Giga eller Portenta H7 samlar dual-core MCU:er, Ethernet, WiFi, BLE, USB-C och mer under ett tak, som alla kan utövas från MicroPython-firmware.

Det finns naturligtvis avvägningarVissa lågnivåapplikationer som är kritiska för tidpunkten kan fortfarande vara bättre skrivna i C/C++ som klassiska Arduino-skisser, och mycket resursbegränsade kort som originalet Uno är helt enkelt inte lämpade för MicroPython. Men för en stor kategori av projekt som involverar sensorer, displayer, anslutning och måttliga realtidskrav är MicroPython på kompatibel Arduino-hårdvara en snabb, lättillgänglig och förvånansvärt kraftfull kombination.

För alla som kommer från standard Python, erbjuder en övergång till MicroPython på moderna Arduino-kort som ESP32-baserade Nanos, RP2040 Connect eller Portenta-enheter en smidig introduktion till inbäddad utveckling samtidigt som man återanvänder sina språkkunskaper, utnyttjar ett omfattande paketindex och drar nytta av den robusta, väl dokumenterade hårdvaran som gjorde Arduino så populär från första början..