Flash ESP-01 (ESP8266) Utan USB-till-seriell adapter med Raspberry Pi: 3 steg

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

Denna instruktion guidar dig om hur du börjar programmera din ESP8266 mikrokontroller på en ESP-01 WIFI-modul. Allt du behöver för att komma igång (förutom ESP-01-modulen, förstås) är

• Raspberry Pi
• Bygelkablar
• 10K motstånd

Jag ville renovera en gammal sänglampa till modern Alexa kontrollerad LED nattlampa. Inget fancy att bara slå på/av med röstkommando. Jag beställde den enklaste ESP-01 WIFI-modulen, relä och tråd med lysdioder online, och glömde helt att beställa USB-till-seriell adapter för att programmera ESP8266 mikrokontroller. Men eftersom jag hade en Raspberry Pi och både Raspberry Pi och ESP-01-kortet hade UART-pins, tänkte jag att jag kunde använda min RPi för att programmera ESP8266 utan adaptern.

Steg 1: Konfigurera Rapberry Pi

Jag använde Raspberry Pi 3 Model B+, men instruktioner bör fungera på andra versioner, särskilt på modell B.

Så, först och främst - vi måste aktivera UART på Pi.

Gå till RPi -konfigurationsinställningar. Kör i terminalfönster

$ sudo raspi-config

Gå till 5 gränssnittsalternativ och välj sedan P6 Serial. Du frågade sedan Vill du att ett inloggningsskal ska vara tillgängligt via serie? välj eftersom vi inte vill använda UART för att köra Pi -huvudet utan för att kommunicera med andra enheter, därav på följande skärm när du frågar Vill du att seriell portmaskinvara ska aktiveras? Välj. Starta om Pi enligt uppmaning. UART ska nu vara aktiverad för seriell kommunikation på RX- och TX -stiftet på Raspberry Pi 3. Obs! Efter detta bör en ny post visas, enable_uart = 1 i slutet av /boot/config.txt.

Steg 2: Anslut ESP-01 till Raspberry Pi

Nu börjar vi koppla ihop allt.

Först identifierar du på din RPi 3.3V ström och GND (jord) stift för att driva ESP8266 mikrokontroller, TXD (sänd) och RXD (mottagning) stift för att kommunicera, och två stift för allmänna ändamål för att styra ESP8266 (stift som kan ställas antingen högt eller låg). Slå upp stiftarrangemanget på pinout.xyz eller skriv in terminal:

$ pinout

Identifiera för det andra nödvändiga stift på ESP-01. Men i början måste vi ha förståelse för ESP-01-stiften. Jag hittade ett antal användbara resurser tillgängliga på internet för att hjälpa dig i det avseendet. Den här är den kortaste, medan den här ger så mycket bättre förklaring. Kort sagt: Det finns 8 stift, vi kommer att behöva 7 av dem, nämligen VCC -effekt och GND (jord) stift för ström, TXD- och RXD -stift för kommunikation, och RST (återställning), CH_PD (Chip Power Down, ibland märkt) CH_EN eller chipaktivering) och GPIO0 för att styra modulen. Vanligtvis fungerar ESP8266 i ett vanligt läge, men när du laddar upp en kod till ESP8266 vill det vara i blixtläge. För vanligt eller normalt driftläge måste modulen (uppenbarligen) anslutas till strömmen, men också stiftet CH_PD måste anslutas till VCC via en 10K (detta värde varierar i olika resurser, jag hittade värden ner till 3K) pull-up motstånd vid start. på andra sidan, för att gå in i blinkande eller programmeringsläge måste du jorda GPIO0 -stiftet vid start. För att förhindra obegränsat strömflöde via GPIO0 när den jordas rekommenderas att ansluta GPIO0 till jord via ett lågmotståndsmotstånd 300Ω - 470Ω (mer om detta här). RST -stiftet som namnet antyder återställer (eller startar om) MCU: n. Under normal drift kan den vara ansluten till VCC via ett 10K uppdragningsmotstånd, men bör jordas för att återställa mikrokontrollern. Även om det alltid är möjligt att använda fysiska knappar för att jorda RST- och GPIO0 -stift (eller till och med manuellt koppla ihop trådar för att simulera en knapp), är det mycket mer tilltalande upplevelse att använda Raspberry Pi -stift för att ställa in spänning högt och lågt på modulens RST och GPIO0 stift. Det finns också inget behov av 10K och 470Ω motstånd då.

Nu när vi är medvetna om ESP-01-stiftets särdrag kan vi börja ansluta allt tillsammans. Du kan använda följande tabell som referens tillsammans med ritningen ovan:

ESP-01 Raspberry Pi

• VCC (3.3V) stift #1 (3.3V)
• GND -stift #6 (GND)
• TXD -stift nr 10 (RXD / BCM 15)
• RXD -stift #8 (TXD / BCM 14)
• CH_PD stift #1 (3.3V)
• RST -pin #3 (BCM 2)
• GPIO 0 pin #5 (BMC 5)

Anslut den sista VCC -stiftet. Instansen du anslöt VCC-pin kommer din Wi-Fi-modul att slås på. Använd skärm eller minicom för att kontrollera om RPi och ESP8266 kan kommunicera med UART (notera: du kan behöva installera skärm eller minicom först, eftersom de inte verkar vara installerade på Raspbian som standard).

Använda skärmkörning:

$ sudo skärm /dev /serial0 115200

Använda minicom -körning:

$ sudo minicom -b 115200 -o -D /dev /serial0

Obs! Många online -resurser föreslår att du ansluter till ESP8266 on /dev /ttyAMA0, men detta fungerar inte för RPi 3 eller senare (inklusive noll W) enligt RPi -dokumentation. Anslut via /dev /serial0 istället eller /dev /ttyS0.

När du har angett skärmen eller minicom använder du AT -kommandon för att kommunicera med ESP8266. Skriv in AT, tryck sedan på Enter och tryck sedan på Ctrl+J för att skicka kommando. Du borde få OK som svar. Lista över tillgängliga AT -kommandon finns på espressiff.com eller bara här.

Enheterna är fysiskt anslutna och pratar med varandra, vi kan börja programmera RPi GPIO -stiften och slutligen själva ESP8266.

Steg 3: Programvaruinstallation (Python för drift och Arduino IDE för att programmera)

DEL 1. Använd python för att byta ESP8266 -lägen

Som nämnts ovan är det bekvämt att använda RPIs GPIO -stift för att växla driftlägen för ESP8266. Jag skrev två grundläggande pythonkoder som satte ESP8266 i vanligt eller programmeringsläge.

Vanligt läge: För att sätta mikrokontrollern i normalt driftläge behöver vi bara driva den och ansluta CH_PD via pull-up-motstånd till VCC, men för att växla MCU från programmering till normalt läge måste vi återställa den (tänk omstart). För att göra det på RPi kommer vi att dra ner RPi: s GPIO som är anslutet till RST-stift på ESP-01 en kort stund (som standard är RPi-stiftet jag använde för återställning inställt på HIGH). Hur kort? För mig är det en spekulativ fråga. Du kan prova olika tidsintervaller, men jag fann att 200 - 500 ms fungerar bra. Skriv i kommentarerna om du har en bättre idé. Spara din kod som reset.py

#!/usr/bin/python

importera RPi. GPIO som GPIO importtid GPIO.setmode (GPIO. BOARD) # ställer in GPIO -identifiering med fysiska stiftnummer resetPin = 3 # identifiera RPi fysisk stift ansluten till ESP8266 RST -stift GPIO.setup (resetPin, GPIO. OUT) # set reset pin som utgång GPIO.output (resetPin, GPIO. LOW) # fallspänning på RST -pin -tid. sov (.2) # vänta på.2 s GPIO.output (resetPin, GPIO. HIGH) # återställ spänning på RST -pin GPIO. cleanup () # återställ stiften på RPI för att förhindra framtida varningar om körning

• Programmeringsläge: För att sätta MCU i programmeringsläge måste vi driva ESP8266 med GPIO0 jordad, eller alternativt återställa den och jorda GPIO0 under uppstart (igen exakt varaktighet för spänningsfallet är inte riktigt känt för mig, så var inte strikt styrs av använda värden). Spara koden som flash.py eller ladda ner nedan. Följden av åtgärder är följande:

  • dra ner RST -stiftet
  • dra ner GPIO0 -stiftet
  • dra upp RST -stiftet
  • dra upp GPIO0 -stiftet

#!/usr/bin/python

importera RPi. GPIO som GPIO importtid GPIO.setmode (GPIO. BOARD) # ställer in GPIO -identifiering med fysiska stiftnummer resetPin = 3 # identifiera RPi fysisk stift ansluten till ESP8266 RST -stift flashPin = 5 # identifiera RPi fysisk stift ansluten till ESP8266 GPIO0 -stift GPIO.setup (resetPin, GPIO. OUT) # set reset pin som output GPIO.setup (flashPin, GPIO. OUT) # set flash pin as output GPIO.output (resetPin, GPIO. LOW) # drop voltage on RST pin time. sömn (.2) # behovet av den här väntan är spekulativ GPIO.output (flashPin, GPIO. LOW) # tappspänning på GPIO0 time.sleep (.2) # behov av denna väntan är spekulativ GPIO.output (resetPin, GPIO. HIGH) # börja starta ESP8266 time.sleep (.5) # vänta på att ESP8266 startar GPIO.ouput (flashPin. GPIO. HIGH) # återställ spänning på GPIO pinGPIO.cleanup () # återställ stiften på RPI för att förhindra framtida varningsvarningar

I terminaländringsbehörigheter:

$ sudo chmod +x flash.py

$ sudo chmod +x reset.py

Från och med nu när du behöver gå in i programmeringsläge kör i terminal:

$ python /flash.py

efter att ha laddat upp koden för att gå in i normalt driftläge:

$ python /reset.py

Vid denna tidpunkt kanske du också vill uppdatera ESP8266 -firmware. Det finns många onlinehandledning om hur man gör det, så jag kommer inte att gå in på detaljer om hur man gör det.

DEL 2. Konfigurera Arduino IDE

om du redan har Arduino IDE installerat kanske du fortfarande vill skumma igenom avsnittet och se till att din IDE är redo för ESP8266.

På Rapberry Pi kan du använda Arduino IDE för att programmera din ESP8266. Det finns två sätt att installera IDE på RPi:

• via kommandoraden från förråd med apt-get install
• ladda ner och installera manuellt från arduino.cc.

Jag föreslår starkt att du går den senare vägen. IDE -versionen från förråd verkar vara föråldrad och du kommer säkert att behöva göra mer innan du är redo att börja programmera ESP8266. För att undvika besväret, gå till Arduino.cc nedladdningssida och ladda ner Linux ARM -version. Nästa komprimera och installera: Om namnet på den nedladdade filen ser ut ungefär så här arduino-X. Y. Z-linuxarm.tar.xz, i nedladdningsmappen kör:

$ tar -xvf arduino-X. Y. Z-linuxarm.tar.xz

Detta bör komprimera filen till mappen arduino-X. Y. Z. Springa:

$ sudo./arduino-X. Y. Z/install.sh

Detta bör installera IDE. När installationen är klar startar du IDE.

• Från Arduino IDE går du till Arkiv> Inställningar. Leta efter "Ytterligare Board Manager -webbadresser" längst ned i inställningsfönstret. Ange https://arduino.esp8266.com/stable/package_esp8266com_index.json i fältet "Ytterligare styrningens webbadresser", klicka på "OK" -knappen.
• Gå till Verktyg> Board: XXX> Boards Manager. I sökfönstret eller sök ner i fönstret, välj ESP8266 -kortmenyn och klicka på installera. Vänta tills installationen är klar och stäng fönstret.
• Återigen går du till Verktyg> Kort: XXX och letar efter ESP8266 -kort. Välj generisk ESP8266 -modul.

Nu är IDE redo att programmera ESP8266. Skriv in eller klistra in önskad kod i IDE -fönstret och spara den. Klicka på Ladda upp. Från terminal kör flash.py bör detta sätta ditt kort i programmeringsläge. Vänta några minuter tills IDE: n har slutfört kompilering och uppladdning (Obs: ESP-01 levereras vanligtvis med 2 lysdioder, den blå lysdioden blinkar medan koden laddas upp) och kör reset.py. Nu är ditt ESP-01-kort klart att utföra uppgifter.