Komma igång med Python för ESP8266 och ESP32: 6 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

Bakgrund

ESP8266 och den yngre storebror ESP32 är billiga Wi-Fi-mikrochips med full TCP/IP-stack och mikrokontroller. ESP8266-chipet uppmärksammades först av tillverkargemenskapen redan 2014. Sedan dess har det låga priset (<5 USD), dess Wi-Fi-kapacitet, ett inbyggt flashminne på 1 eller 4 MB och en mängd olika utvecklingsmöjligheter styrelser, har gjort ESP-chipet till en av de mest populära mikrokontrollerna för WiFi och IoT DIY-projekt.

MicroPython är en smal och effektiv implementering av det alltmer populära Python -programmeringsspråket som innehåller en liten delmängd av Python -standardbiblioteket och är optimerad för att köras på mikrokontroller.

Kombinationen av dessa två är ett mycket intressant alternativ för DIY -projekt, både för nybörjare och mer avancerade användare.

MiPy-ESP-projektet

Tillbaka 2015 började mina första projekt med ESP8266 med ESP-01-chipet med Arudions för att köra chip AT-kommandon över seriell anslutning. Efter det använde jag under de närmaste åren Arduino -kärnan för ESP8266 för att programmera chipsen med C ++ - språket. Detta fungerar bra, men för en Python -entusiast var min upptäckt av MicroPython -implementeringen av Python 3 goda nyheter.

MiPy-ESP-projektet är ett flexibelt ramverk som tillämpar MicroPython för Python IoT-projekt med full stack på ESP-familjens mikrokontroller.

Ramverket är utvecklat av LeGarage Technical Comité Software Developer Team (LG-TC-SWDT-01) som syftar till att ersätta redan etablerad C ++-baserad kod för våra applikationer för mikrokontroller.

Projektet ger grundläggande funktioner som t.ex.

• Nätverksanslutningsprocedurer
• Chips åtkomstpunkts webbserver (för wifi -anslutning och servering av chipwebbsidor för data -I/O)
• MQTT -funktioner
• Loggning/felsökning
• Schemaläggning av mikrokontrollerhändelser
• I/O -rutiner för hårdvara

Med ett huvudkompakt kodskript (main.py), alla med global konfiguration (config.py).

Denna mictocontroller -kod körs med robust underhåll av chipanslutningar till WiFi -nätverk och MQTT -mäklare. Befintliga MicroPython -moduler för olika hårdvaror kan enkelt integreras i systemet.

MiPy-ESP-ramverket har blivit ryggraden i alla våra hobbyelektronik-IoT-projekt som involverar ESP-familjens mikrokontroller. Det har testats på flera ESP-familjekort, som NodeMCU, Wemos och Lolin-kort.

Följande handledning är en guide för hur du kommer igång med ESP-familjens mikrokontroller och MicroPython med MiPy-ESP-ramverket.

Steg 1: Wemos D1 Mini ESP8266 -kortet

MiPy-ESP-ramverket fungerar med de flesta ESP8266-baserade mikrokontroller.

Wemos D1 mini-utvecklingskortet är baserat på ESP-8266EX-chip. På ett fotavtryck på 2,5 x 3,5 cm har den 4MB flashminne, 11 digitala in-/utgångsstiften, alla stift stöder avbrott, PWM, I2C, SPI, seriell och 1 analog ingång med 3,3V maximal ingång, kan köras på 5V ström, har mikro -USB -anslutning och är brödbräda kompatibel. Det låga priset och dess lilla storlek har gjort det till min favorit ESP -bräda.

Dessutom levereras D1 mini pro -versionen av kortet med alternativ för anslutning av en extern antenn, vilket ökar anslutningsområdet betydligt (+100 m räckvidd). Utöver det kommer brädet också med en mängd olika förlängningskort med out-of-the-box med liknande kompakt storlek.

Steg 2: Gör dig redo för MicroPython på ESP -chipet

I det här första steget kommer du

• Anslut ESP -kortet via USB till din dator
• Installera Esptool -programvaran för att blinka chipet
• Radera chipminne
• Flasha chipet med MicroPython -firmware
• Installera Rshell för att möjliggöra kommandoradsinteraktion med ditt chip
• Installera mpy-cross (för sammanställning av.py-filer till binär)

Att ansluta kortet till din dator via USB-kort med en inbyggd USB-seriell port gör UART tillgänglig för din dator och är det enklaste alternativet för att komma igång. För kort utan USB -anslutning kan en FTDI -modul med USB till seriell användas för att ansluta GPIO -stiften för blinkning ansluten till omvärlden, men detta omfattas inte av denna handledning.

För MicroPython som använder MiPy-ESP-koden är minimikravet för flash-flashstorlek 1 MB. Det finns också en speciell konstruktion för brädor med 512 kB, men detta har inget stöd för ett filsystem, vilket MiPy-ESP är beroende av.

När du använder en USB -kabel får kortet ström från din dator medan den är ansluten. Detta möjliggör också programmering och felsökning över den seriella anslutningen. När projektkoden laddas upp och ditt projekt distribueras, appliceras extern ström över strömförsörjningstapparna på kortet.

Installera EsptoolInformation om Esptool -programvaran finns i Esptool GitHub -förvaret. Om du vill använda Windows/Linux/OSX (MAC) täcker länken ovan också det. Python -paketet kan installeras av

pip installera esptool

För Linux -användare underhålls paket för Esptool för Debian och Ubuntu och kan också installeras med

sudo apt installera esptool

Radera ESP -flashminne Med Esptool raderar du sedan ESP -flashminnet med kommandot

esptool.py --port /dev /ttyUSB0 erase_flash

Ladda ner MicroPyton -programvaran MicroPython -firmware finns i en.bin -fil som kan laddas ner från MicroPython -webbplatsen.

Nuvarande projektmastergren i repo har testats och fungerar med Micropython v.1.12. För att säkerställa framgång med MiPY-ESP-ramverket, ladda ner filen 'esp8266-20191220-v1.12.bin' från den här länken och skriv in firmware till chipet med kommandot:

esptool.py --port /dev /ttyUSB0 --baud 460800 write_flash --flash_size = detect 0 esp8266-20191220-v1.12.bin

Installera Rshell Rshell -paketet möjliggör kommandoradsinteraktion med din MicroPython -miljö installerad på chipet. Det finns i denna länk. Rshell är ett enkelt skal som körs på värden och använder MicroPythons raw-REPL för att skicka pythonavsnitt till pyboard för att få filsysteminformation och för att kopiera filer till och från MicroPythons filsystem. REPL står för Read Evaluate Print Loop och är namnet på den interaktiva MicroPython -prompten som du kan komma åt på ESP8266. Att använda REPL är det överlägset enklaste sättet att testa din kod och köra kommandon. Installera Rshell med kommandot:

sudo pip installera rshell

Installation av mpy-cross-kompilatorn MicroPython kan tillämpas med ascii.py-filer som laddas upp till chipfilsystemet. MicroPython definierar också begreppet.mpy -filer som är ett binärt containerfilformat som innehåller förkompilerad kod och som kan importeras som en vanlig.py -modul. Genom att kompilera.py -filer till.mpy kommer mer RAM -minne att finnas tillgängligt för din löpande kod - och detta behövs för att ha en fungerande kärnmodul i MiPy -ESP -ramverket.

För implementering av MiPy-ESP-kod sammanställer en mpy-cross MicroPython-cross-kompilatorn.py-skripten till.mpy före chipöverföring. Installera mpy-cross-paketet enligt instruktionerna i den här länken. Alternativt kan kommandot mpy-cross installeras med Python pip-kommandot eller köras från sökvägen mpy-cross om du klonar MicroPython-förvaret från GitHub här.

Du har nu MicroPython och alla nödvändiga verktyg installerade för att komma igång med att bygga ditt första MiPy-ESP-projekt

Steg 3: Komma igång med MiPy-ESP

I det här steget kommer du

Ladda ner MyPy-ESP-ramverket

Ladda ner MiPy-ESP-ramverket MiPy-ESP-projektet finns på GitHub i detta kodlager. Från GitHub kan du ladda ner lagringsfilstrukturen eller klona den till din dator med

git -klon

Med kodlagret installerat på din dator har du nu alla kodmoduler du behöver för att bygga ett out-of-the-box ESP IoT-projekt. Mer information om verktygslådan i nästa steg.

Steg 4: MiPy-ESP Framework Architecture

I det här steget kommer du

lära dig mer om MiPy-ESP-kodens arbetsflöde

MiPy-ESP kodarkitektur

Alla Python-rammoduler finns i mappen /src i MiPY-ESP-kodlagret. Mappen src/core innehåller kärnmodulerna som ingår i varje projekt. Mappen src/drivers har ett urval av moduler för olika hårdvaror som ska anslutas till ditt chip. Mappen src/utilities innehåller valfria verktygsmoduler att inkludera i ditt projekt.

Filerna main.py och config.py finns i src/ mappen. Det här är de viktigaste filerna som ska redigeras för att bygga ditt projekt:

config.py:

Den här filen är den globala konfigurationsfilen för ditt projekt. Den har olika inställningar, alla med beskrivande kommentarer i filen.

main.py:

Detta är huvudskriptet för mikrocontrollerns kodslinga. Den innehåller den applikationsspecifika koden i ramverket. Vid chipstart startar och importerar main.py alla projektberoende moduler med angivna ingångar från filen config.py. Ovanstående flödesschema visar layouten för main.py -skriptet.

Figuren ovan beskriver arbetsflödet för main.py:

1. Vid start försöker koden att ansluta chipet till Wi-Fi-nätverk Tidigare tillämpade nätverk och deras lösenord (krypterade på chip) lagras i flashminne. Nätverks-SSID och deras lösenord kan tillhandahållas i filen wifi.json i formatet {" SSID1 ":" Lösenord "," SSID ":" Lösenord2 "}. De angivna nätverken i den här filen lagras, lösenord krypteras och filen raderas vid start.
2. Om inga redan kända nätverk hittas, ställer koden in en åtkomstpunkt (AP) webbserver Chip -AP -serverns SSID och lösenord ställs in i filen config.py. Genom att logga in på chipets SSID visas en webbsida för inloggning av chipet till Wi-Fi på 192.168.4.1 Upptäckta nätverk visas i en meny, eller så kan SSID anges manuellt (dolda nätverk) tillsammans med Wi-Fi-lösenord. Efter lyckad anslutning av chipet till Wi-Fi stängs AP-servern av och main.py-koden fortsätter till nästa steg.

3. I avsnittet Setup i main.py,

   • funktioner för jobb och återuppringning (etc. MQTT -återuppringning) och vanliga händelser definieras.
   • Olika tidsinställda jobb för körfunktioner har ställts in.
   • MQTT -mäklarklient är etablerad

4. Koden går sedan in i huvudmikrostyrenhetens slinga,

   • kontinuerlig kontroll av nätverks- och MQTT -mäklaranslutningar,
   • MQTT -prenumerationer,
   • hårdvara I/O
   • och schemalagda jobb.
   • Vid förlorat nätverk eller MQTT-mäklaranslutning försöker koden återupprätta.

Steg 5: Förbereda din projektkod

I det här steget kommer du

• lära dig mer om MiPy-ESP-arkivfilstrukturen
• förbered din projektkod för chipöverföring

Lagringsmappstruktur Figuren ovan beskriver lagringsmappstrukturen och listar de nuvarande modulerna i ramverket. Ditt projekt är etapper i src/ mappen. Core MiPy-ESP-rammoduler finns i src/core, valfria verktygsmoduler i src/verktyg och hårdvarumoduler i src/drivrutiner.

De flesta tillgängliga MicroPython -hårdvarubibliotek kan gå in i drivrutinerna/ mappen utan några ändringar. Alla nuvarande drivrutiner testas med MiPy-ESP-ramverket. När det gäller moduler i verktygen/ mappen kommer fler att läggas till när de kommer till liv.

Lagring av projektkod Din projektspecifika kod bör placeras i src/ mappen. Redan där finns main.py- och config.py -filerna som du kan redigera. Kopiera också de önskade projektverktygen från src/utilities och src/drivers till src/.

Om du vill tillhandahålla kända Wi-Fi-nätverk och lösenord till chipet, lägg till filen wifi.json till src/.

Kompilera och förbereda för uppladdning En förutsatt att Makefile kan tillämpas för att förbereda filer för överföring till chip genom att kompilera.py -filer i / src, kompilera kärnmodulerna och överföra de kompilerade filerna till en ny mapp med namnet build / med kommandot

göra bygga

Filerna i build är redo att laddas upp till chipfilsystemet. Som standard sammanställs inte main.py och config.py till binära för att enkelt komma åt dem för inspektion av utplacerade marker. Kommandot:

göra rent

Tar bort build/ mappen och dess innehåll.

Steg 6: Kompilera och ladda upp koden till mikrokontrollern

I det här avsnittet kommer du

• ladda upp de förberedda filerna i build/ från förra avsnittet
• starta och övervaka körkoden

Överför bygg/ filer med Rshell

Ladda upp alla filer i /build -katalogen till ESP -chip med Rshell. Med mikrokontrollern ansluten till USB, starta Rshell med kommandot från build/ mappen

rshell -p /dev /ttyUSB0

Inspektera sedan chipfilerna (om sådana finns) av

ls /pyboard

Alla filer på chip kan tas bort med

rm /pyboard/*.*

Kopiera alla projektfiler i build/ till chipet:

cp *. * /pyboard

Starta sedan den interaktiva Python -terminalen med kommandot

ers

Du kan nu åberopa Python-kommandon eller importera moduler och övervaka seriell chiputgång från MiPy-ESP-loggmodulen.

Starta om chippet genom att trycka på återställningsknappen eller från kommandoraden med

import huvud

eller

importmaskin

och då

machine.reset ()

Beroende på dina loggnings-/felsökningsinställningar i projektkonfigurationsfilen kommer ersättaren nu att visa felsökningsmeddelanden från ESP -chipet över den seriella anslutningen.

Detta borde förhoppningsvis komma igång.