ESP32 Basic Starter
Utrustning

Packlista

ESP32 Introduktion

Ny på ESP32? Börja här! ESP32 är en serie lågkostnads- och energisnåla System on a Chip-mikrokontroller (SoC) utvecklade av Espressif som inkluderar trådlösa Wi-Fi- och Bluetooth-funktioner och en dubbelkärnig processor. Om du är bekant med ESP8266 är ESP32 dess efterträdare, laddad med massor av nya funktioner.Specifikationer för ESP32
Om du vill bli lite mer teknisk och specifik kan du ta en titt på följande detaljerade specifikationer för ESP32 (källa: http://esp32.net/)—för mer information, kontrollera databladet):

• Trådlös anslutning WiFi: 150.0 Mbps datahastighet med HT40
• Bluetooth: BLE (Bluetooth Low Energy) och Bluetooth Classic
• Processor: Tensilica Xtensa Dual-Core 32-bitars LX6 mikroprocessor, körs på 160 eller 240 MHz
• Minne:
• ROM: 448 KB (för uppstart och kärnfunktioner)
• SRAM: 520 KB (för data och instruktioner)
• RTC fas SRAM: 8 KB (för datalagring och huvudprocessor under RTC-start från djupt viloläge)
• RTC långsam SRAM: 8KB (för medprocessoråtkomst under djupt viloläge) eFuse: 1 Kbit (varav 256 bitar används för systemet (MAC-adress och chipkonfiguration) och de återstående 768 bitarna är reserverade för kundapplikationer, inklusive Flash-kryptering och Chip-ID)

Inbäddad blixt: blixt ansluten internt via IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 och SD_DATA_1 på ESP32-D2WD och ESP32-PICO-D4.

• 0 MiB (ESP32-D0WDQ6, ESP32-D0WD och ESP32-S0WD chips)
• 2 MiB (ESP32-D2WD-chip)
• 4 MiB (ESP32-PICO-D4 SiP-modul)

Low Power: säkerställer att du fortfarande kan använda ADC-konverteringar, till exempelample, under djup sömn.
Perifer ingång/utgång:

• perifert gränssnitt med DMA som inkluderar kapacitiv beröring
• ADC:er (Analog-till-Digital Converter)
• DAC:er (Digital-to-Analog Converter)
• I²C (Inter-Integrated Circuit)
• UART (Universal Asynchronous Receiver/Transmitter)
• SPI (Serial Peripheral Interface)
• I²S (Integrated Interchip Sound)
• RMII (Reduced Media-Independent Interface)
• PWM (Pulse-Width Modulation)

Säkerhet: hårdvaruacceleratorer för AES och SSL/TLS

ESP32 utvecklingstavlor

ESP32 hänvisar till det nakna ESP32-chippet. Men termen "ESP32" används också för att hänvisa till ESP32-utvecklingskort. Det är inte lätt eller praktiskt att använda ESP32 blottade chips, särskilt när man lär sig, testar och skapar prototyper. För det mesta vill du använda ett ESP32-utvecklingskort.
Vi kommer att använda ESP32 DEVKIT V1-kortet som referens. Bilden nedan visar ESP32 DEVKIT V1-kortet, version med 30 GPIO-stift.Specifikationer – ESP32 DEVKIT V1
Följande tabell visar en sammanfattning av ESP32 DEVKIT V1 DOIT-kortets funktioner och specifikationer:

Antal kärnor	2 (dubbelkärnig)
Wi-Fi	2.4 GHz upp till 150 Mbits/s
Bluetooth	BLE (Bluetooth Low Energy) och äldre Bluetooth
Arkitektur	32 bitar
Klockfrekvens	Upp till 240 MHz
RAM	512 KB
Pins	30 (beroende på modell)

Kringutrustning	Kapacitiv touch, ADC (analog till digital omvandlare), DAC (digital till analog omvandlare), 12C (Inter-Integrated Circuit), UART (universell asynkron mottagare/sändare), CAN 2.0 (Controller Area Netwokr), SPI (Serial Peripheral Interface) , 12S (integrerad inter-IC Ljud), RMII (Reduced Media-Independent Interface), PWM (pulsbreddsmodulering) och mer.
Inbyggda knappar	RESET och BOOT-knappar
Inbyggda lysdioder	inbyggd blå LED ansluten till GPIO2; inbyggd röd lysdiod som visar att kortet får ström
USB till UART bro	CP2102

Den levereras med ett microUSB-gränssnitt som du kan använda för att ansluta kortet till din dator för att ladda upp kod eller slå på ström.
Den använder CP2102-kretsen (USB till UART) för att kommunicera med din dator via en COM-port med ett seriellt gränssnitt. Ett annat populärt chip är CH340. Kontrollera vad som är USB till UART-chipomvandlaren på ditt kort eftersom du måste installera de nödvändiga drivrutinerna så att din dator kan kommunicera med kortet (mer information om detta senare i den här guiden).
Detta kort kommer också med en RESET-knapp (kan vara märkt EN) för att starta om brädet och en BOOT-knapp för att sätta brädan i blinkande läge (tillgänglig för att ta emot kod). Observera att vissa brädor kanske inte har en BOOT-knapp.
Den kommer också med en inbyggd blå LED som är internt ansluten till GPIO 2. Denna LED är användbar för felsökning för att ge någon form av visuell fysisk utdata. Det finns också en röd lysdiod som tänds när du ger ström till kortet.ESP32 Pinout
ESP32 kringutrustning inkluderar:

• 18 ADC-kanaler (Analog-to-Digital Converter).
• 3 SPI-gränssnitt
• 3 UART-gränssnitt
• 2 I2C-gränssnitt
• 16 PWM-utgångskanaler
• 2 digital-till-analog-omvandlare (DAC)
• 2 I2S-gränssnitt
• 10 kapacitiva avkännings-GPIO:er

Funktionerna ADC (analog till digital omvandlare) och DAC (digital till analog omvandlare) är tilldelade specifika statiska stift. Du kan dock bestämma vilka stift som är UART, I2C, SPI, PWM, etc - du behöver bara tilldela dem i koden. Detta är möjligt tack vare ESP32-chipets multiplexeringsfunktion.
Även om du kan definiera stiftegenskaperna i programvaran, finns stift tilldelade som standard som visas i följande figurDessutom finns det stift med specifika egenskaper som gör dem lämpliga eller inte för ett visst projekt. Följande tabell visar vilka stift som är bäst att använda som ingångar, utgångar och vilka du behöver vara försiktig.
Stiften markerade i grönt är OK att använda. De som är markerade i gult är OK att använda, men du måste vara uppmärksam eftersom de kan ha ett oväntat beteende främst vid start. Stiften som är markerade i rött rekommenderas inte att använda som ingångar eller utgångar.

GP IO	Input	Produktion	Anteckningar
0	drog upp	OK	matar ut PWM-signal vid start, måste vara LÅG för att gå in i blinkande läge
1	TX-stift	OK	felsöka utdata vid uppstart
2	OK	OK	ansluten till inbyggd LED, måste lämnas flytande eller LÅG för att gå in i blinkande läge
3	OK	RX-stift	HÖG vid start
4	OK	OK
5	OK	OK	matar ut PWM-signal vid start, bandningsstift
12	OK	OK	stöveln misslyckas om den dras högt, spännstift
13	OK	OK
14	OK	OK	matar ut PWM-signal vid uppstart
15	OK	OK	matar ut PWM-signal vid start, bandningsstift

16	OK	OK
17	OK	OK
18	OK	OK
19	OK	OK
21	OK	OK
22	OK	OK
23	OK	OK
25	OK	OK
26	OK	OK
27	OK	OK
32	OK	OK
33	OK	OK
34	OK		endast ingång
35	OK		endast ingång
36	OK		endast ingång
39	OK		endast ingång

Fortsätt läsa för en mer detaljerad och djupgående analys av ESP32 GPIO och dess funktioner.
Ingång endast stift
GPIO:er 34 till 39 är GPI:er – endast ingångsstift. Dessa stift har inte interna pull-up eller pull-down motstånd. De kan inte användas som utgångar, så använd dessa stift endast som ingångar:

• GPIO 34
• GPIO 35
• GPIO 36
• GPIO 39

SPI-blixt integrerad på ESP-WROOM-32
GPIO 6 till GPIO 11 är exponerade i vissa ESP32-utvecklingskort. Dessa stift är dock anslutna till den integrerade SPI-blixten på ESP-WROOM-32-chippet och rekommenderas inte för annan användning. Så använd inte dessa stift i dina projekt:

• GPIO 6 (SCK/CLK)
• GPIO 7 (SDO/SD0)
• GPIO 8 (SDI/SD1)
• GPIO 9 (SHD/SD2)
• GPIO 10 (SWP/SD3)
• GPIO 11 (CSC/CMD)

Kapacitiv berörings-GPIO
ESP32 har 10 interna kapacitiva touchsensorer. Dessa kan känna av variationer i allt som har en elektrisk laddning, som den mänskliga huden. Så de kan upptäcka variationer som induceras när de rör vid GPIO:erna med ett finger. Dessa stift kan enkelt integreras i kapacitiva kuddar och ersätta mekaniska knappar. De kapacitiva beröringsstiften kan också användas för att väcka ESP32 från djup sömn. Dessa interna peksensorer är anslutna till dessa GPIO:er:

• T0 (GPIO 4)
• T1 (GPIO 0)
• T2 (GPIO 2)
• T3 (GPIO 15)
• T4 (GPIO 13)
• T5 (GPIO 12)
• T6 (GPIO 14)
• T7 (GPIO 27)
• T8 (GPIO 33)
• T9 (GPIO 32)

Analog till digital omvandlare (ADC)
ESP32 har 18 x 12 bitars ADC-ingångskanaler (medan ESP8266 bara har 1x 10 bitars ADC). Det här är GPIO:er som kan användas som ADC och respektive kanaler:

• ADC1_CH0 (GPIO 36)
• ADC1_CH1 (GPIO 37)
• ADC1_CH2 (GPIO 38)
• ADC1_CH3 (GPIO 39)
• ADC1_CH4 (GPIO 32)
• ADC1_CH5 (GPIO 33)
• ADC1_CH6 (GPIO 34)
• ADC1_CH7 (GPIO 35)
• ADC2_CH0 (GPIO 4)
• ADC2_CH1 (GPIO 0)
• ADC2_CH2 (GPIO 2)
• ADC2_CH3 (GPIO 15)
• ADC2_CH4 (GPIO 13)
• ADC2_CH5 (GPIO 12)
• ADC2_CH6 (GPIO 14)
• ADC2_CH7 (GPIO 27)
• ADC2_CH8 (GPIO 25)
• ADC2_CH9 (GPIO 26)

Notera: ADC2-stift kan inte användas när Wi-Fi används. Så om du använder Wi-Fi och du har problem med att få värdet från en ADC2 GPIO, kan du överväga att använda en ADC1 GPIO istället. Det borde lösa ditt problem.
ADC-ingångskanalerna har en 12-bitars upplösning. Det betyder att du kan få analoga avläsningar från 0 till 4095, där 0 motsvarar 0V och 4095 till 3.3V. Du kan också ställa in upplösningen för dina kanaler på koden och ADC-intervallet.
ESP32 ADC-stiften har inte ett linjärt beteende. Du kommer förmodligen inte att kunna skilja mellan 0 och 0.1V, eller mellan 3.2 och 3.3V. Du måste ha det i åtanke när du använder ADC-stiften. Du kommer att få ett beteende som liknar det som visas i följande figur.Digital till Analog Converter (DAC)
Det finns 2 x 8 bitars DAC-kanaler på ESP32 för att konvertera digitala signaler till analog volymtage signalutgångar. Dessa är DAC-kanalerna:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

RTC GPIO
Det finns stöd för RTC GPIO på ESP32. GPIO:erna som dirigeras till RTC-lågeffektundersystemet kan användas när ESP32 är i djup sömn. Dessa RTC GPIOs kan användas för att väcka ESP32 från djup sömn när Ultra Low
Power (ULP) co-processor körs. Följande GPIO:er kan användas som en extern väckningskälla.

• RTC_GPIO0 (GPIO36)
• RTC_GPIO3 (GPIO39)
• RTC_GPIO4 (GPIO34)
• RTC_GPIO5 (GPIO35)
• RTC_GPIO6 (GPIO25)
• RTC_GPIO7 (GPIO26)
• RTC_GPIO8 (GPIO33)
• RTC_GPIO9 (GPIO32)
• RTC_GPIO10 (GPIO4)
• RTC_GPIO11 (GPIO0)
• RTC_GPIO12 (GPIO2)
• RTC_GPIO13 (GPIO15)
• RTC_GPIO14 (GPIO13)
• RTC_GPIO15 (GPIO12)
• RTC_GPIO16 (GPIO14)
• RTC_GPIO17 (GPIO27)

PWM
ESP32 LED PWM-kontrollern har 16 oberoende kanaler som kan konfigureras för att generera PWM-signaler med olika egenskaper. Alla stift som kan fungera som utgångar kan användas som PWM-stift (GPIO 34 till 39 kan inte generera PWM).
För att ställa in en PWM-signal måste du definiera dessa parametrar i koden:

• Signalens frekvens;
• Arbetscykel;
• PWM-kanal;
• GPIO där du vill mata ut signalen.

I2C
ESP32 har två I2C-kanaler och vilket stift som helst kan ställas in som SDA eller SCL. När du använder ESP32 med Arduino IDE är standard I2C-stiften:

• GPIO 21 (SDA)
• GPIO 22 (SCL)

Om du vill använda andra stift när du använder trådbiblioteket behöver du bara ringa:
Wire.begin(SDA, SCL);
SPI
Som standard är pin-mappningen för SPI:

SPI	SLÅ DANK	MISO	CLK	CS
VSPI	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

avbrott
Alla GPIO:er kan konfigureras som avbrott.
Spännstift
ESP32-chippet har följande bandstift:

• GPIO 0 (måste vara LÅG för att gå in i startläge)
• GPIO 2 (måste vara flytande eller LÅG under uppstart)
• GPIO 4
• GPIO 5 (måste vara HÖG under uppstart)
• GPIO 12 (måste vara LÅG under uppstart)
• GPIO 15 (måste vara HÖG under uppstart)

Dessa används för att sätta ESP32 i bootloader eller blinkande läge. På de flesta utvecklingskort med inbyggd USB/Serial behöver du inte oroa dig för tillståndet för dessa stift. Kortet sätter stiften i rätt läge för blinkande eller startläge. Mer information om ESP32 Boot Mode Selection finns här.
Men om du har kringutrustning ansluten till dessa stift kan du ha problem med att försöka ladda upp ny kod, blinka ESP32 med ny firmware eller återställa kortet. Om du har några kringutrustning ansluten till bandstiften och du får problem med att ladda upp kod eller blinka ESP32, kan det bero på att dessa kringutrustningar hindrar ESP32 från att gå in i rätt läge. Läs dokumentationen för val av startläge för att guida dig i rätt riktning. Efter återställning, blinkning eller uppstart fungerar dessa stift som förväntat.
Nålar HÖGT vid start
Vissa GPIO:er ändrar sitt tillstånd till HÖG eller matar ut PWM-signaler vid start eller återställning.
Detta innebär att om du har utgångar anslutna till dessa GPIO:er kan du få oväntade resultat när ESP32 återställs eller startar.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 till GPIO 11 (ansluten till ESP32 integrerat SPI-flashminne – rekommenderas inte att använda).
• GPIO 14
• GPIO 15

Aktivera (EN)
Enable (EN) är 3.3V-regulatorns aktiveringsstift. Den är uppdragen, så anslut till jord för att inaktivera 3.3V-regulatorn. Detta innebär att du kan använda denna stift kopplad till en tryckknapp för att starta om din ESP32, till exempelample.
GPIO-ström dras
Den absoluta maximala strömmen som dras per GPIO är 40mA enligt avsnittet "Rekommenderade driftförhållanden" i ESP32-databladet.
ESP32 Inbyggd Hall Effect Sensor
ESP32 har också en inbyggd halleffektsensor som upptäcker förändringar i magnetfältet i omgivningen
ESP32 Arduino IDE
Det finns ett tillägg för Arduino IDE som låter dig programmera ESP32 med Arduino IDE och dess programmeringsspråk. I den här handledningen visar vi dig hur du installerar ESP32-kortet i Arduino IDE oavsett om du använder Windows, Mac OS X eller Linux.
Förutsättningar: Arduino IDE installerad
Innan du startar den här installationsproceduren måste du ha Arduino IDE installerad på din dator. Det finns två versioner av Arduino IDE du kan installera: version 1 och version 2.
Du kan ladda ner och installera Arduino IDE genom att klicka på följande länk: arduino.cc/en/Main/Software
Vilken Arduino IDE-version rekommenderar vi? För tillfället finns det några plugins för ESP32 (som SPIFFS Filesystem Uploader Plugin) som ännu inte stöds på Arduino 2. Så om du tänker använda SPIFFS plugin i framtiden rekommenderar vi att du installerar den äldre versionen 1.8.X. Du behöver bara scrolla ner på Arduinos mjukvarusida för att hitta den.
Installerar ESP32-tillägget i Arduino IDE
För att installera ESP32-kortet i din Arduino IDE, följ följande instruktioner:

1. I din Arduino IDE, gå till File> Inställningar
2. Skriv in följande i "Extra styrelsechef URLs” fält:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Klicka sedan på "OK"-knappen:Notera: om du redan har ESP8266-korten URL, kan du separera URLs med kommatecken enligt följande:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Öppna Boards Manager. Gå till Verktyg > Styrelse > Styrelsehanterare...Leta efter ESP32 and press install button for the “ESP32 by Espressif Systems“:Det är allt. Den bör installeras efter några sekunder.

Ladda upp testkod

Anslut ESP32-kortet till din dator. Med din Arduino IDE öppen, följ dessa steg:

1. Välj ditt kort i Verktyg > Bräde-menyn (i mitt fall är det ESP32 DEV-modulen)
2. Välj porten (om du inte ser COM-porten i din Arduino IDE måste du installera CP210x USB till UART Bridge VCP-drivrutiner):
3. Öppna följande example under File > Examples > WiFi
   (ESP32) > WiFiScan
4. En ny skiss öppnas i din Arduino IDE:
5. Tryck på knappen Ladda upp i Arduino IDE. Vänta några sekunder medan koden kompileras och laddas upp till din tavla.
6. Om allt gick som förväntat bör du se en "Klar med uppladdning." meddelande.
7. Öppna Arduino IDE Serial Monitor med en baudhastighet på 115200:
8. Tryck på ESP32 inbyggd aktiveringsknapp och du bör se nätverken som är tillgängliga nära din ESP32:

Felsökning

Om du försöker ladda upp en ny skiss till din ESP32 och du får det här felmeddelandet "Ett allvarligt fel inträffade: Det gick inte att ansluta till ESP32: Timeout... Ansluter...". Det betyder att din ESP32 inte är i blinkande/uppladdningsläge.
När du har valt rätt kortnamn och COM por, följ dessa steg:
Håll ned "BOOT"-knappen på ditt ESP32-kort

• Tryck på knappen "Ladda upp" i Arduino IDE för att ladda upp din skiss:
• När du ser "Ansluter...." meddelande i din Arduino IDE, släpp fingret från "BOOT"-knappen:
• Efter det bör du se meddelandet "Klar med uppladdning".
  Det är det. Din ESP32 bör ha den nya skissen igång. Tryck på "ENABLE"-knappen för att starta om ESP32 och köra den nya uppladdade skissen.
  Du måste också upprepa den knappsekvensen varje gång du vill ladda upp en ny skiss.

Projekt 1 ESP32 Ingångar Utgångar

I den här startguiden kommer du att lära dig hur du läser digitala ingångar som en knappbrytare och styr digitala utgångar som en LED med ESP32 med Arduino IDE.
Förutsättningar
Vi programmerar ESP32 med Arduino IDE. Så se till att du har tillägget ESP32-kort installerat innan du fortsätter:

• Installerar ESP32-tillägget i Arduino IDE

ESP32 Styr digitala utgångar
Först måste du ställa in den GPIO du vill styra som en OUTPUT. Använd pinMode()-funktionen enligt följande:
pinMode(GPIO, OUTPUT);
För att styra en digital utgång behöver du bara använda digitalWrite()-funktionen, som accepterar som argument, GPIO (int-nummer) du refererar till och tillståndet, antingen HIGH eller LOW.
digitalWrite(GPIO, STATE);
Alla GPIO:er kan användas som utgångar förutom GPIO:er 6 till 11 (anslutna till den integrerade SPI-blixten) och GPIO:er 34, 35, 36 och 39 (GPIO:er endast ingång);
Lär dig mer om ESP32 GPIO:er: ESP32 GPIO Reference Guide
ESP32 Läs digitala ingångar
Ställ först in den GPIO du vill läsa som INPUT, med hjälp av pinMode()-funktionen enligt följande:
pinMode(GPIO, INPUT);
För att läsa en digital ingång, som en knapp, använder du digitalRead()-funktionen, som accepterar som argument, GPIO (int-nummer) du refererar till.
digitalRead(GPIO);
Alla ESP32 GPIO kan användas som ingångar, förutom GPIO 6 till 11 (anslutna till den integrerade SPI-blixten).
Lär dig mer om ESP32 GPIO:er: ESP32 GPIO Reference Guide
Projekt Example
För att visa dig hur du använder digitala ingångar och digitala utgångar, bygger vi ett enkelt projekt exampmed en tryckknapp och en LED. Vi läser av tryckknappens status och tänder lysdioden i enlighet med detta som illustreras i följande figur.

Delar krävs
Här är en lista över de delar du behöver för att bygga kretsen:

• ESP32 DEVKIT V1
• 5 mm LED
• 220 Ohm motstånd
• tryckknapp
• 10k Ohm motstånd
• Bakbord
• Bygeltrådar

Schematiskt diagram
Innan du fortsätter måste du montera en krets med en LED och en tryckknapp.
Vi kopplar lysdioden till GPIO 5 och tryckknappen till GPIO 4.Koda
Öppna koden Project_1_ESP32_Inputs_Outputs.ino i arduino IDEHur koden fungerar
På följande två rader skapar du variabler för att tilldela stift:

Knappen är ansluten till GPIO 4 och lysdioden är ansluten till GPIO 5. När du använder Arduino IDE med ESP32 motsvarar 4 GPIO 4 och 5 motsvarar GPIO 5.
Därefter skapar du en variabel för att hålla knappens status. Som standard är den 0 (inte nedtryckt).
int buttonState = 0;
I setup() initierar du knappen som en INPUT och LED som en OUTPUT.
För det använder du funktionen pinMode() som accepterar stiftet du hänvisar till, och läget: INPUT eller OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
I loop() läser du knappens status och ställer in lysdioden därefter.
På nästa rad läser du knappens status och sparar den i variabeln buttonState.
Som vi har sett tidigare använder du digitalRead()-funktionen.
buttonState = digitalRead(buttonPin);
Följande if-sats kontrollerar om knappens status är HÖG. Om så är fallet tänds lysdioden med funktionen digitalWrite() som accepterar ledPin och tillståndet HIGH som argument.
if (knappState == HÖG)Om knappens status inte är HÖG stänger du av lysdioden. Ställ bara in LOW som ett andra argument till i digitalWrite()-funktionen.Ladda upp koden
Innan du klickar på uppladdningsknappen, gå till Verktyg > Styrelse och välj kortet :DOIT ESP32 DEVKIT V1.
Gå till Verktyg > Port och välj den COM-port som ESP32 är ansluten till. Tryck sedan på uppladdningsknappen och vänta på meddelandet "Klar med uppladdning".Obs: Om du ser många punkter (ansluter...__...__) i felsökningsfönstret och meddelandet "Det gick inte att ansluta till ESP32: Tidsgräns väntar på pakethuvud" betyder det att du måste trycka på ESP32:s inbyggda BOOT knappen efter prickarna
börja dyka upp. Felsökning

Demonstration

Efter att ha laddat upp koden, testa din krets. Din LED ska lysa när du trycker på tryckknappen:Och stäng av när du släpper den:

Projekt 2 ESP32 analoga ingångar

Detta projekt visar hur man läser analoga ingångar med ESP32 med Arduino IDE.
Analog avläsning är användbar för att läsa värden från variabla motstånd som potentiometrar eller analoga sensorer.
Analoga ingångar (ADC)
Att läsa ett analogt värde med ESP32 innebär att du kan mäta varierande volymtage nivåer mellan 0 V och 3.3 V.
Voltage uppmätt tilldelas sedan ett värde mellan 0 och 4095, där 0 V motsvarar 0 och 3.3 V motsvarar 4095. Valfri volymtage mellan 0 V och 3.3 V kommer att ges motsvarande värde däremellan.ADC är icke-linjär
Helst skulle du förvänta dig ett linjärt beteende när du använder ESP32 ADC-stiften.
Det händer dock inte. Vad du får är ett beteende som visas i följande diagram:Detta beteende betyder att din ESP32 inte kan skilja 3.3 V från 3.2 V.
Du får samma värde för båda voltages: 4095.
Samma sak händer för mycket låg volymtage-värden: för 0 V och 0.1 V får du samma värde: 0. Du måste ha detta i åtanke när du använder ESP32 ADC-stiften.
analogRead() Funktion
Att läsa en analog ingång med ESP32 med Arduino IDE är lika enkelt som att använda analogRead()-funktionen. Den accepterar som argument den GPIO du vill läsa:
analogRead(GPIO);
Endast 15 är tillgängliga i DEVKIT V1board (version med 30 GPIO).
Ta tag i din ESP32-kortstift och lokalisera ADC-stiften. Dessa är markerade med en röd ram i figuren nedan.Dessa analoga ingångsstift har 12-bitars upplösning. Det betyder att när du läser en analog ingång kan dess intervall variera från 0 till 4095.
Obs: ADC2-stift kan inte användas när Wi-Fi används. Så om du använder Wi-Fi och du har problem med att få värdet från en ADC2 GPIO, kan du överväga att använda en ADC1 GPIO istället, det borde lösa ditt problem.
För att se hur allt hänger ihop ska vi göra ett enkelt example för att läsa ett analogt värde från en potentiometer.
Delar krävs
För detta example, du behöver följande delar:

• ESP32 DEVKIT V1-kort
• Potentiometer
• Bakbord
• Bygeltrådar

Schematisk
Anslut en potentiometer till din ESP32. Potentiometerns mittstift ska anslutas till GPIO 4. Du kan använda följande schematiska diagram som referens.Koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
Öppna koden Project_2_ESP32_Inputs_Outputs.ino i arduino IDEDenna kod läser helt enkelt värdena från potentiometern och skriver ut dessa värden i den seriella monitorn.
I koden börjar du med att definiera den GPIO potentiometern är ansluten till. I detta example, GPIO 4.I setup(), initiera en seriell kommunikation med en baudhastighet på 115200.I loop(), använd analogRead()-funktionen för att läsa den analoga ingången från potPin.Skriv slutligen ut de värden som avläses från potentiometern i den seriella monitorn.Ladda upp koden som tillhandahålls till din ESP32. Se till att du har valt rätt kort och COM-port i menyn Verktyg.
Testar example
Efter att ha laddat upp koden och tryckt på ESP32-återställningsknappen, öppna den seriella monitorn med en baudhastighet på 115200. Vrid potentiometern och se värdena ändras.Det högsta värdet du får är 4095 och det lägsta värdet är 0.

Avslutning

I den här artikeln har du lärt dig hur du läser analoga ingångar med ESP32 med Arduino IDE. Sammanfattningsvis:

• ESP32 DEVKIT V1 DOIT-kortet (version med 30 stift) har 15 ADC-stift som du kan använda för att läsa analoga ingångar.
• Dessa stift har en upplösning på 12 bitar, vilket innebär att du kan få värden från 0 till 4095.
• För att läsa ett värde i Arduino IDE använder du helt enkelt analogRead()-funktionen.
• ESP32 ADC-stiften har inte ett linjärt beteende. Du kommer förmodligen inte att kunna skilja mellan 0 och 0.1V, eller mellan 3.2 och 3.3V. Du måste ha det i åtanke när du använder ADC-stiften.

Project 3 ESP32 PWM (analog utgång)

I den här handledningen visar vi dig hur du genererar PWM-signaler med ESP32 med Arduino IDE. Som exampvi kommer att bygga en enkel krets som dämpar en lysdiod med LED PWM-kontrollern på ESP32.ESP32 LED PWM Controller
ESP32 har en LED PWM-kontroller med 16 oberoende kanaler som kan konfigureras för att generera PWM-signaler med olika egenskaper.
Här är stegen du måste följa för att dämpa en LED med PWM med Arduino IDE:

1. Först måste du välja en PWM-kanal. Det finns 16 kanaler från 0 till 15.
2. Sedan måste du ställa in PWM-signalens frekvens. För en LED är en frekvens på 5000 Hz bra att använda.
3. Du måste också ställa in signalens arbetscykelupplösning: du har upplösningar från 1 till 16 bitar. Vi kommer att använda 8-bitars upplösning, vilket innebär att du kan styra LED-ljusstyrkan med ett värde från 0 till 255.
4.  Därefter måste du ange till vilka GPIO eller GPIO:er signalen ska visas på. För det kommer du att använda följande funktion:
   ledcAttachPin(GPIO, kanal)
   Denna funktion accepterar två argument. Den första är GPIO som kommer att mata ut signalen, och den andra är kanalen som genererar signalen.
5. Slutligen, för att styra LED-ljusstyrkan med PWM använder du följande funktion:

ledcWrite(kanal, arbetscykel)
Den här funktionen accepterar som argument kanalen som genererar PWM-signalen och arbetscykeln.
Delar krävs
För att följa denna handledning behöver du dessa delar:

• ESP32 DEVKIT V1-kort
• 5mm LED
• 220 Ohm motstånd
•  Bakbord
• Bygeltrådar

Schematisk
Anslut en LED till din ESP32 enligt följande schematiska diagram. Lysdioden ska vara ansluten till GPIO 4.Notera: du kan använda vilket stift du vill, så länge det kan fungera som en utgång. Alla stift som kan fungera som utgångar kan användas som PWM-stift. För mer information om ESP32 GPIO, läs: ESP32 Pinout Referens: Vilka GPIO-stift ska du använda?
Koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
Öppna koden Project_3_ESP32_PWM.ino i arduino IDEDu börjar med att definiera stiftet som lysdioden är fäst vid. I detta fall är lysdioden ansluten till GPIO 4.Sedan ställer du in PWM-signalegenskaperna. Du definierar en frekvens på 5000 Hz, väljer kanal 0 för att generera signalen och ställer in en upplösning på 8 bitar. Du kan välja andra egenskaper, annorlunda än dessa, för att generera olika PWM-signaler.I setup() måste du konfigurera LED PWM med egenskaperna du har definierat tidigare genom att använda ledcSetup()-funktionen som accepterar som argument, ledChannel, frekvensen och upplösningen, enligt följande:Därefter måste du välja den GPIO du ska få signalen från. Använd för det funktionen ledcAttachPin() som accepterar som argument GPIO där du vill hämta signalen och kanalen som genererar signalen. I detta example, vi får signalen i ledPin GPIO, som motsvarar GPIO 4. Kanalen som genererar signalen är ledChannel, som motsvarar kanal 0.I slingan kommer du att variera arbetscykeln mellan 0 och 255 för att öka LED-ljusstyrkan.Och sedan, mellan 255 och 0 för att minska ljusstyrkan.För att ställa in ljusstyrkan på lysdioden behöver du bara använda ledcWrite()-funktionen som accepterar kanalen som genererar signalen och arbetscykeln som argument.Eftersom vi använder 8-bitars upplösning kommer arbetscykeln att styras med ett värde från 0 till 255. Observera att i ledcWrite()-funktionen använder vi kanalen som genererar signalen, och inte GPIO.

Testar example

Ladda upp koden till din ESP32. Se till att du har valt rätt kort och COM-port. Titta på din krets. Du bör ha en dimmer LED som ökar och minskar ljusstyrkan.

Project 4 ESP32 PIR-rörelsesensor

Detta projekt visar hur man upptäcker rörelse med ESP32 med hjälp av en PIR-rörelsesensor. Summern ljuder ett larm när rörelse detekteras och stoppar larmet när ingen rörelse upptäcks under en förinställd tid (som 4 sekunder)
Hur HC-SR501 rörelsesensor fungerar
.Funktionsprincipen för HC-SR501-sensorn är baserad på förändringen av den infraröda strålningen på det rörliga objektet. För att kunna detekteras av HC-SR501-sensorn måste objektet uppfylla två krav:

• Objektet avger den infraröda vägen.
• Objektet rör sig eller skakar

Så:
Om ett föremål sänder ut den infraröda strålen men INTE rör sig (t.ex. en person står stilla utan att röra sig) detekteras det INTE av sensorn.
Om ett föremål rör sig men INTE avger den infraröda strålen (t.ex. robot eller fordon), detekteras det INTE av sensorn.
Introduktion av timer
I detta exampvi kommer också att introducera timers. Vi vill att lysdioden ska vara tänd i ett förutbestämt antal sekunder efter att rörelse har upptäckts. Istället för att använda en delay()-funktion som blockerar din kod och inte tillåter dig att göra något annat under ett bestämt antal sekunder, bör vi använda en timer.Funktionen delay().
Du bör vara bekant med funktionen delay() eftersom den används flitigt. Denna funktion är ganska enkel att använda. Den accepterar ett enda int-tal som ett argument.
Detta nummer representerar tiden i millisekunder som programmet måste vänta tills det går vidare till nästa kodrad.När du gör delay(1000) stannar ditt program på den linjen i 1 sekund.
delay() är en blockerande funktion. Blockeringsfunktioner hindrar ett program från att göra något annat tills just den uppgiften är klar. Om du behöver flera uppgifter samtidigt kan du inte använda delay().
För de flesta projekt bör du undvika att använda förseningar och använda timers istället.
Millis()-funktionen
Med hjälp av en funktion som heter millis() kan du returnera antalet millisekunder som har gått sedan programmet startade.Varför är den funktionen användbar? För genom att använda lite matematik kan du enkelt verifiera hur mycket tid som har gått utan att blockera din kod.
Delar krävs
För att följa denna handledning behöver du följande delar

• ESP32 DEVKIT V1-kort
• PIR-rörelsesensor (HC-SR501)
• Aktiv summer
• Bygeltrådar
• Bakbord

SchematiskNotera: Den arbetande voltage av HC-SR501 är 5V. Använd Vin-stiftet för att driva den.
Koda
Innan du fortsätter med denna handledning bör du ha ESP32-tillägget installerat i din Arduino IDE. Följ en av följande handledningar för att installera ESP32 på Arduino IDE, om du inte redan har gjort det. (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
Öppna koden Project_4_ESP32_PIR_Motion_Sensor.ino i arduino IDE.
Demonstration
Ladda upp koden till ditt ESP32-kort. Se till att du har valt rätt kort och COM-port. Ladda upp kodreferenssteg.
Öppna den seriella monitorn med en baudhastighet på 115200.Flytta handen framför PIR-sensorn. Summern bör slås på, och meddelandet skrivs ut i seriemonitorn som säger "Rörelse detekterat! Summerlarm".
Efter 4 sekunder bör summern stängas av.

Project 5 ESP32 Switch Web Server

I det här projektet skapar du en fristående web server med en ESP32 som styr utgångar (två lysdioder) med hjälp av Arduino IDE-programmeringsmiljön. De web servern är mobilresponsiv och kan nås med vilken enhet som helst som en webbläsare i det lokala nätverket. Vi visar dig hur du skapar web server och hur koden fungerar steg för steg.
Projekt överview
Innan vi går direkt till projektet är det viktigt att beskriva vad vi web server kommer att göra, så att det är lättare att följa stegen senare.

• De web servern du kommer att bygga styr två lysdioder anslutna till ESP32 GPIO 26 och GPIO 27;
• Du kan komma åt ESP32 web server genom att skriva ESP32 IP-adressen i en webbläsare i det lokala nätverket;
• Genom att klicka på knapparna på din web server kan du omedelbart ändra status för varje lysdiod.

Delar krävs
För den här handledningen behöver du följande delar:

• ESP32 DEVKIT V1-kort
• 2x 5mm LED
• 2x 200 Ohm motstånd
• Bakbord
• Bygeltrådar

Schematisk
Börja med att bygga kretsen. Anslut två lysdioder till ESP32 som visas i följande schematiska diagram – en lysdiod ansluten till GPIO 26 och den andra till GPIO 27.
Notera: Vi använder ESP32 DEVKIT DOIT-kort med 36 stift. Innan du monterar kretsen, se till att du kontrollerar pinouten för kortet du använder.Koda
Här tillhandahåller vi koden som skapar ESP32 web server. Öppna koden Project_5_ESP32_Switch _Web_Server.ino i arduino IDE, men ladda inte upp det än. Du måste göra några ändringar för att få det att fungera för dig.
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
Ställa in dina nätverksuppgifter
Du måste ändra följande rader med dina nätverksuppgifter: SSID och lösenord. Koden är väl kommenterad var du ska göra ändringarna.Ladda upp koden
Nu kan du ladda upp koden och och web servern kommer att fungera direkt.
Följ nästa steg för att ladda upp kod till ESP32:

1. Anslut ditt ESP32-kort till din dator;
2. I Arduino IDE väljer du ditt kort i Verktyg > Board (i vårt fall använder vi ESP32 DEVKIT DOIT-kortet);
3. Välj COM-porten i Verktyg > Port.
4. Tryck på knappen Ladda upp i Arduino IDE och vänta några sekunder medan koden kompileras och laddas upp till ditt kort.
5. Vänta på meddelandet "Klar med uppladdning".

Hitta ESP IP-adressen
När du har laddat upp koden öppnar du den seriella monitorn med en baudhastighet på 115200.Tryck på ESP32 EN-knappen (återställ). ESP32 ansluter till Wi-Fi och matar ut ESP IP-adressen på den seriella monitorn. Kopiera den IP-adressen, eftersom du behöver den för att komma åt ESP32 web server.Tillgång till Web Server
För att komma åt web server, öppna din webbläsare, klistra in ESP32 IP-adressen så ser du följande sida.
Notera: Din webbläsare och ESP32 bör vara anslutna till samma LAN.Om du tar en titt på den seriella monitorn kan du se vad som händer i bakgrunden. ESP:n tar emot en HTTP-begäran från en ny klient (i det här fallet din webbläsare).Du kan också se annan information om HTTP-förfrågan.
Demonstration
Nu kan du testa om din web servern fungerar korrekt. Klicka på knapparna för att styra lysdioderna.Samtidigt kan du ta en titt på Serial Monitor för att se vad som händer i bakgrunden. Till exempelample, när du klickar på knappen för att slå PÅ GPIO 26, får ESP32 en begäran på /26/on URL.När ESP32 tar emot den förfrågan tänder den lysdioden som är ansluten till GPIO 26 och uppdaterar dess status på web sida.Knappen för GPIO 27 fungerar på liknande sätt. Testa att den fungerar som den ska.

Hur koden fungerar

I det här avsnittet kommer vi att titta närmare på koden för att se hur den fungerar.
Det första du behöver göra är att inkludera WiFi-biblioteket.Som nämnts tidigare måste du infoga ditt ssid och lösenord på följande rader inom de dubbla citattecken.Sedan ställer du in din web server till port 80.Följande rad skapar en variabel för att lagra headern för HTTP-begäran:Därefter skapar du hjälpvariabler för att lagra det aktuella tillståndet för dina utgångar. Om du vill lägga till fler utgångar och spara dess tillstånd måste du skapa fler variabler.Du måste också tilldela en GPIO till var och en av dina utgångar. Här använder vi GPIO 26 och GPIO 27. Du kan använda andra lämpliga GPIO:er.setup()
Låt oss nu gå in i setup(). Först startar vi en seriell kommunikation med en baudhastighet på 115200 för felsökningsändamål.Du definierar också dina GPIO:er som OUTPUTs och ställer in dem på LOW.Följande rader börjar Wi-Fi-anslutningen med WiFi.begin(ssid, lösenord), vänta på en lyckad anslutning och skriv ut ESP IP-adressen i den seriella monitorn.slinga()
I loop() programmerar vi vad som händer när en ny klient upprättar en anslutning med web server.
ESP32 lyssnar alltid efter inkommande klienter med följande rad:När en förfrågan tas emot från en kund sparar vi inkommande data. While-slingan som följer kommer att köras så länge klienten är ansluten. Vi rekommenderar inte att du ändrar följande del av koden om du inte vet exakt vad du gör.Nästa avsnitt av if and else-satser kontrollerar vilken knapp som trycktes i din web sida och kontrollerar utgångarna därefter. Som vi har sett tidigare gör vi en begäran om olika URLs beroende på vilken knapp som trycks in.Till exempelample, om du har tryckt på GPIO 26 ON-knappen, tar ESP32 emot en begäran på /26/ON URL (vi kan se den informationen i HTTP-huvudet på seriell övervakare). Så vi kan kontrollera om rubriken innehåller uttrycket GET /26/on. Om den innehåller ändrar vi output26state-variabeln till ON, och ESP32 tänder lysdioden.
Detta fungerar på samma sätt för de andra knapparna. Så om du vill lägga till fler utgångar bör du modifiera den här delen av koden för att inkludera dem.
Visar HTML web sida
Nästa sak du behöver göra är att skapa web sida. ESP32 kommer att skicka ett svar till din webbläsare med lite HTML-kod för att bygga web sida.
De web sidan skickas till klienten med detta uttryckande client.println(). Du ska ange vad du vill skicka till klienten som argument.
Det första vi ska skicka är alltid följande rad, som indikerar att vi skickar HTML.Sedan gör följande rad till web sida responsiv i någon web webbläsare.Och följande används för att förhindra förfrågningar på favicon. – Du behöver inte oroa dig för den här linjen.

Styling av Web Sida

Därefter har vi lite CSS-text för att utforma knapparna och web sidans utseende.
Vi väljer typsnittet Helvetica, definierar innehållet som ska visas som ett block och riktas i mitten.Vi stylar våra knappar med färgen #4CAF50, utan kant, text i vit färg och med denna stoppning: 16px 40px. Vi ställer också in textdekorationen till ingen, definierar teckenstorleken, marginalen och markören till en pekare.Vi definierar också stilen för en andra knapp, med alla egenskaper för knappen som vi har definierat tidigare, men med en annan färg. Detta kommer att vara stilen för av-knappen.

Ställa in Web Sidans första rubrik
På nästa rad kan du ställa in den första rubriken för din web sida. Här har vi "ESP32 Web Server”, men du kan ändra denna text till vad du vill.Visar knappar och motsvarande status
Sedan skriver du ett stycke för att visa GPIO 26:s nuvarande tillstånd. Som du kan se använder vi variabeln output26State, så att tillståndet uppdateras omedelbart när denna variabel ändras.Sedan visar vi på eller av-knappen, beroende på det aktuella tillståndet för GPIO. Om det aktuella tillståndet för GPIO är avstängt visar vi ON-knappen, om inte visar vi OFF-knappen.Vi använder samma procedur för GPIO 27.
Stänger anslutningen
Slutligen, när svaret slutar, rensar vi rubrikvariabeln och stoppar anslutningen till klienten med client.stop().

Avslutning

I den här handledningen har vi visat dig hur du bygger en web server med ESP32. Vi har visat dig ett enkelt examplä som styr två lysdioder, men tanken är att ersätta dessa lysdioder med ett relä, eller någon annan utgång du vill styra.

Projekt 6 RGB LED Web Server

I det här projektet visar vi dig hur du fjärrstyr en RGB-LED med ett ESP32-kort med hjälp av en web server med en färgväljare.
Projekt överview
Innan vi börjar, låt oss se hur det här projektet fungerar:

• ESP32 web servern visar en färgväljare.
• När du väljer en färg gör din webbläsare en förfrågan på en URL som innehåller parametrarna R, G och B för den valda färgen.
• Din ESP32 tar emot begäran och delar upp värdet för varje färgparameter.
• Sedan skickar den en PWM-signal med motsvarande värde till GPIO:erna som styr RGB-lysdioden.

Hur fungerar RGB-lysdioder?
I en gemensam katod RGB LED delar alla tre lysdioderna en negativ anslutning (katod). Allt som ingår i satsen är gemensam katod RGB.Hur skapar man olika färger?
Med en RGB LED kan du naturligtvis producera rött, grönt och blått ljus, och genom att konfigurera intensiteten på varje LED kan du producera andra färger också.
Till exempelample, för att producera rent blått ljus, skulle du ställa in den blå lysdioden på högsta intensitet och de gröna och röda lysdioderna på den lägsta intensiteten. För ett vitt ljus skulle du ställa in alla tre lysdioderna på högsta intensitet.
Blanda färger
För att producera andra färger kan du kombinera de tre färgerna i olika intensiteter. För att justera intensiteten på varje lysdiod kan du använda en PWM-signal.
Eftersom lysdioderna är väldigt nära varandra ser våra ögon resultatet av kombinationen av färger, snarare än de tre färgerna individuellt.
För att få en idé om hur man kombinerar färgerna, ta en titt på följande diagram.
Detta är det enklaste färgblandningsdiagrammet, men ger dig en uppfattning om hur det fungerar och hur man producerar olika färger.Delar krävs
För detta projekt behöver du följande delar:

• ESP32 DEVKIT V1-kort
• RGB LED
• 3x 220 ohm motstånd
• Bygeltrådar
• Bakbord

SchematiskKoda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)

• Installerar ESP32-tillägget i Arduino IDE

Efter montering av kretsen, Öppna koden
Project_6_RGB_LED_Web_Server.ino i arduino IDE.
Innan du laddar upp koden, glöm inte att infoga dina nätverksuppgifter så att ESP:n kan ansluta till ditt lokala nätverk.Hur koden fungerar
ESP32-skissen använder WiFi.h-biblioteket.Följande rader definierar strängvariabler för att hålla parametrarna R, G och B från begäran.De följande fyra variablerna används för att avkoda HTTP-begäran senare.Skapa tre variabler för GPIO:erna som styr parametrarna för remsan R, G och B. I det här fallet använder vi GPIO 13, GPIO 12 och GPIO 14.Dessa GPIO:er behöver mata ut PWM-signaler, så vi måste konfigurera PWM-egenskaperna först. Ställ in PWM-signalfrekvensen till 5000 Hz. Koppla sedan en PWM-kanal för varje färgOch slutligen, ställ in upplösningen för PWM-kanalerna till 8-bitarsI setup(), tilldela PWM-egenskaperna till PWM-kanalernaFäst PWM-kanalerna till motsvarande GPIOFöljande kodavsnitt visar färgväljaren i din web sida och gör en begäran baserat på den färg du har valt.När du väljer en färg får du en förfrågan med följande format.

Så vi måste dela den här strängen för att få parametrarna R, G och B. Parametrarna sparas i variablerna redString, greenString och blueString och kan ha värden mellan 0 och 255.För att styra remsan med ESP32, använd ledcWrite()-funktionen för att generera PWM-signaler med värdena avkodade från HTTP begäran.Notera: lär dig mer om PWM med ESP32: Project 3 ESP32 PWM(Analog Output)
För att styra remsan med ESP8266 behöver vi bara använda
funktionen analogWrite() för att generera PWM-signaler med värdena avkodade från HTPP-begäran.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Eftersom vi får värdena i en strängvariabel måste vi konvertera dem till heltal med metoden toInt().
Demonstration
När du har infogat dina nätverksuppgifter, välj rätt kort och COM-port och ladda upp koden till din ESP32. Ladda upp kodreferenssteg.
Efter uppladdningen öppnar du den seriella monitorn med en baudhastighet på 115200 och trycker på ESP Enable/Reset-knappen. Du bör få kortets IP-adress.Öppna din webbläsare och ange ESP IP-adressen. Använd nu färgväljaren för att välja en färg för RGB LED.
Sedan måste du trycka på knappen "Ändra färg" för att färgen ska träda i kraft.Välj den svarta färgen för att stänga av RGB-lampan.
De starkaste färgerna (överst i färgväljaren) är de som ger bättre resultat.

Projekt 7 ESP32 Relä Web Server

Att använda ett relä med ESP32 är ett utmärkt sätt att fjärrstyra AC-hushållsapparater. Denna handledning förklarar hur man styr en relämodul med ESP32.
Vi ska ta en titt på hur en relämodul fungerar, hur man ansluter reläet till ESP32 och bygger en web server för att fjärrstyra ett relä.
Introduktion av reläer
Ett relä är en elektriskt manövrerad strömbrytare och precis som alla andra strömbrytare kan den slås på eller av, låta strömmen gå igenom eller inte. Den kan styras med låg volymtages, som 3.3V som tillhandahålls av ESP32 GPIOs och låter oss styra hög volymtagär som 12V, 24V eller elnätsvolymtage (230V i Europa och 120V i USA).På vänster sida finns två set med tre uttag för att ansluta hög volymtages, och stiften på höger sida (lågvoltage) anslut till ESP32 GPIO:erna.
Mains Voltage AnslutningarRelämodulen som visas på föregående bild har två kontakter, var och en med tre uttag: gemensam (COM), Normally Closed (NC) och Normally Open (NO).

• COM: anslut den ström du vill styra (nätvoltagoch).
• NC (Normalt stängd): den normalt stängda konfigurationen används när du vill att reläet ska vara stängt som standard. NC är COM-stiften anslutna, vilket betyder att strömmen flyter om du inte skickar en signal från ESP32 till relämodulen för att öppna kretsen och stoppa strömflödet.
• NO (Normally Open): den normalt öppna konfigurationen fungerar tvärtom: det finns ingen koppling mellan NO- och COM-stiften, så kretsen är bruten om du inte skickar en signal från ESP32 för att stänga kretsen.

KontrollstiftLågvolymentagE sidan har en uppsättning med fyra stift och en uppsättning med tre stift. Den första uppsättningen består av VCC och GND för att slå på modulen, och ingång 1 (IN1) och ingång 2 (IN2) för att styra de nedre respektive övre reläerna.
Om din relämodul bara har en kanal, har du bara ett IN-stift. Om du har fyra kanaler har du fyra IN-stift och så vidare.
Signalen du skickar till IN-stiften avgör om reläet är aktivt eller inte. Reläet utlöses när ingången går under ca 2V. Det betyder att du har följande scenarier:

• Normalt stängd konfiguration (NC):
• HÖG signal – ström flyter
• LÅG signal – ström flyter inte
• Normalt öppen konfiguration (NEJ):
• HÖG signal – ström flyter inte
• LÅG signal – ström i flytande

Du bör använda en normalt stängd konfiguration när strömmen oftast ska flyta och du bara vill stoppa den ibland.
Använd en normalt öppen konfiguration när du vill att strömmen ska flöda ibland (example, slå på alamp ibland).
Val av strömförsörjningDen andra uppsättningen stift består av GND-, VCC- och JD-VCC-stift.
JD-VCC-stiftet driver reläets elektromagnet. Observera att modulen har ett bygellock som ansluter VCC- och JD-VCC-stiften; den som visas här är gul, men din kan ha en annan färg.
Med bygelkåpan på, är VCC- och JD-VCC-stiften anslutna. Det betyder att reläelektromagneten drivs direkt från ESP32-strömstiftet, så relämodulen och ESP32-kretsarna är inte fysiskt isolerade från varandra.
Utan bygellocket måste du tillhandahålla en oberoende strömkälla för att slå på reläets elektromagnet genom JD-VCC-stiftet. Den konfigurationen isolerar reläerna fysiskt från ESP32 med modulens inbyggda optokopplare, vilket förhindrar skador på ESP32 i händelse av elektriska spikar.
SchematiskVarning: Användning av hög voltage nätaggregat kan orsaka allvarliga skador.
Därför används 5 mm lysdioder istället för hög matningsvolymtage lökar i experimentet. Om du inte är bekant med elnätet voltage fråga någon som ska hjälpa dig. När du programmerar ESP eller ansluter din krets, se till att allt är bortkopplat från elnätettage.Installera biblioteket för ESP32
Att bygga detta web server använder vi ESPAsyncWebServerbibliotek och AsyncTCP-bibliotek.
Installation av ESPAsyncWebServerbibliotek
Följ nästa steg för att installera ESPAsyncWebServer bibliotek:

1. Klicka här för att ladda ner ESPAsyncWebServerbibliotek. Du borde ha gjort det
   en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få ESPAsyncWebServer-master-mapp
3. Byt namn på din mapp från ESPAsyncWebServer-master till ESPAsyncWebServer
4. Flytta ESPAsyncWebServermappen till din Arduino IDE-installationsbiblioteksmapp

Alternativt, i din Arduino IDE, kan du gå till Sketch > Inkludera
Bibliotek > Lägg till .ZIP-bibliotek... och välj det bibliotek du just har laddat ner.
Installera AsyncTCP-biblioteket för ESP32
De ESPAsyncWebServer biblioteket kräver AsyncTCP biblioteket att arbeta. Följa
nästa steg för att installera det biblioteket:

1. Klicka här för att ladda ner AsyncTCP-biblioteket. Du bör ha en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få AsyncTCP-master-mappen
   1. Byt namn på din mapp från AsyncTCP-master till AsyncTCP
   3. Flytta AsyncTCP-mappen till din Arduino IDE-installationsbiblioteksmapp
   4. Öppna slutligen din Arduino IDE igen

Alternativt, i din Arduino IDE, kan du gå till Sketch > Inkludera
Bibliotek > Lägg till .ZIP-bibliotek... och välj det bibliotek du just har laddat ner.
Koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
När du har installerat de nödvändiga biblioteken, öppna koden Project_7_ESP32_Relay_Web_Server.ino i arduino IDE.
Innan du laddar upp koden, glöm inte att infoga dina nätverksuppgifter så att ESP:n kan ansluta till ditt lokala nätverk.Demonstration
När du har gjort de nödvändiga ändringarna laddar du upp koden till din ESP32. Ladda upp kodreferenssteg.
Öppna den seriella monitorn med en baudhastighet på 115200 och tryck på ESP32 EN-knappen för att få dess IP-adress. Öppna sedan en webbläsare i ditt lokala nätverk och skriv ESP32 IP-adressen för att få tillgång till web server.
Öppna den seriella monitorn med en baudhastighet på 115200 och tryck på ESP32 EN-knappen för att få dess IP-adress. Öppna sedan en webbläsare i ditt lokala nätverk och skriv ESP32 IP-adressen för att få tillgång till web server.Notera: Din webbläsare och ESP32 bör vara anslutna till samma LAN.
Du bör få något som följer med två knappar som antalet reläer du har definierat i din kod.Nu kan du använda knapparna för att styra dina reläer med din smartphone.

Project_8_Output_State_Synchronization_ Web_Server

Detta projekt visar hur man styr ESP32- eller ESP8266-utgångarna med en web server och en fysisk knapp samtidigt. Utdatatillståndet uppdateras på web sida om den ändras via fysisk knapp eller web server.
Projekt överview
Låt oss ta en snabb titt på hur projektet fungerar.ESP32 eller ESP8266 är värd för en web server som låter dig kontrollera tillståndet för en utgång;

• Det aktuella utgångsläget visas på web server;
• ESP:n är också ansluten till en fysisk tryckknapp som styr samma utgång;
• Om du ändrar utdatatillståndet med hjälp av den fysiska tryckknappen, uppdateras dess aktuella status också på web server.

Sammanfattningsvis låter detta projekt dig styra samma utdata med hjälp av en web server och en tryckknapp samtidigt. Närhelst utgångsläget ändras, web servern är uppdaterad.
Delar krävs
Här är en lista över de delar du behöver för att bygga kretsen:

• ESP32 DEVKIT V1-kort
• 5 mm LED
• 220 Ohm motstånd
• tryckknapp
• 10k Ohm motstånd
• Bakbord
• Bygeltrådar

SchematiskInstallera biblioteket för ESP32
Att bygga detta web server använder vi ESPAsyncWebServerbibliotek och AsyncTCP-bibliotek.(Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installation av ESPAsyncWebServerbibliotek
Följ nästa steg för att installera ESPAsyncWebServerbibliotek:

1. Klicka här för att ladda ner ESPAsyncWebServerbibliotek. Du borde ha gjort det
   en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få ESPAsyncWebServer-master-mapp
3. Byt namn på din mapp från ESPAsyncWebServer-master till ESPAsyncWebServer
4. Flytta ESPAsyncWebServermappen till din Arduino IDE-installationsbiblioteksmapp
   Alternativt, i din Arduino IDE, kan du gå till Sketch > Inkludera
   Bibliotek > Lägg till .ZIP-bibliotek... och välj det bibliotek du just har laddat ner.

Installera AsyncTCP-biblioteket för ESP32
ESPAsyncWebServerbiblioteket kräver att AsyncTCP-biblioteket fungerar. Följ nästa steg för att installera det biblioteket:

1. Klicka här för att ladda ner AsyncTCP-biblioteket. Du bör ha en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få AsyncTCP-master-mappen
3. Byt namn på din mapp från AsyncTCP-master till AsyncTCP
4. Flytta AsyncTCP-mappen till din Arduino IDE-installationsbiblioteksmapp
5. Slutligen, öppna din Arduino IDE igen
   Alternativt, i din Arduino IDE, kan du gå till Sketch > Inkludera
   Bibliotek > Lägg till .ZIP-bibliotek... och välj det bibliotek du just har laddat ner.

Koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
När du har installerat de nödvändiga biblioteken öppnar du koden
Project_8_Output_State_Synchronization_Web_Server.ino i arduino IDE.
Innan du laddar upp koden, glöm inte att infoga dina nätverksuppgifter så att ESP:n kan ansluta till ditt lokala nätverk.

Hur koden fungerar

Knapptillstånd och utgångstillstånd
Variabeln ledState håller LED-utgångsstatusen. Som standard, när web servern startar, den är LÅG.

buttonState och lastButtonState används för att upptäcka om tryckknappen trycktes ned eller inte.Knapp (web server)
Vi inkluderade inte HTML för att skapa knappen på variabeln index_html.
Det beror på att vi vill kunna ändra det beroende på det aktuella LED-läget som också kan ändras med tryckknappen.
Så vi har skapat en platshållare för knappen %BUTTONPLACEHOLDER% som kommer att ersättas med HTML-text för att skapa knappen senare i koden (detta görs i processor()-funktionen).processor()
Funktionen processor() ersätter alla platshållare i HTML-texten med faktiska värden. Först kontrollerar den om HTML-texterna innehåller några
platshållare %BUTTONPLACEHOLDER%.Anrop sedan funktionen outputState() som returnerar det aktuella utdatatillståndet. Vi sparar den i variabeln outputStateValue.Därefter använder du det värdet för att skapa HTML-texten för att visa knappen med rätt tillstånd:HTTP GET-begäran om att ändra utdatatillstånd (JavaScript)
När du trycker på knappen anropas funktionen thetoggleCheckbox(). Den här funktionen kommer att göra en begäran om olika URLs för att slå på eller av lysdioden.För att slå på lysdioden gör den en begäran på /update?state=1 URL:Annars gör den en begäran på /update?state=0 URL.
HTTP GET-begäran om uppdateringstillstånd (JavaScript)
För att hålla utdatatillståndet uppdaterat på web server, anropar vi följande funktion som gör en ny begäran på /staten URL varannan.Hantera förfrågningar
Sedan måste vi hantera vad som händer när ESP32 eller ESP8266 tar emot förfrågningar om dessa URLs.
När en begäran tas emot på roten /URL, skickar vi HTML-sidan såväl som processorn.Följande rader kontrollerar om du fick en begäran på /update?state=1 eller /update?state=0 URL och ändrar ledState i enlighet med detta.När en begäran tas emot på /staten URL, skickar vi det aktuella utgångsläget:slinga()
I loop() studsar vi av tryckknappen och sätter på eller släcker lysdioden beroende på värdet på ledState variabel.Demonstration
Ladda upp koden till ditt ESP32-kort. Ladda upp kodreferenssteg.
Öppna sedan den seriella monitorn med en baudhastighet på 115200. Tryck på den inbyggda EN/RST-knappen för att få IP-adressen.Öppna en webbläsare i ditt lokala nätverk och skriv ESP IP-adressen. Du bör ha tillgång till web server som visas nedan.
Notera: Din webbläsare och ESP32 bör vara anslutna till samma LAN.Du kan växla knappen på web server för att slå på lysdioden.Du kan också styra samma lysdiod med den fysiska tryckknappen. Dess tillstånd kommer alltid att uppdateras automatiskt på web server.

Projekt 9 ESP32 DHT11 Web Server

I det här projektet kommer du att lära dig hur du bygger en asynkron ESP32 web server med DHT11 som visar temperatur och luftfuktighet med Arduino IDE.
Förutsättningar
De web server vi bygger uppdaterar avläsningarna automatiskt utan att behöva uppdatera web sida.
Med det här projektet lär du dig:

• Hur man avläser temperatur och luftfuktighet från DHT-sensorer;
• Bygg en asynkron web server som använder ESPAsyncWebServerbibliotek;
• Uppdatera sensoravläsningarna automatiskt utan att behöva uppdatera web sida.

Asynkron Web Server
Att bygga web server vi använder ESPAsyncWebServerbibliotek som ger ett enkelt sätt att bygga en asynkron web server. Att bygga en asynkron web servern har flera advantages som nämns på bibliotekets GitHub-sida, såsom:

• "Hantera mer än en anslutning samtidigt";
• "När du skickar svaret är du omedelbart redo att hantera andra anslutningar medan servern tar hand om att skicka svaret i bakgrunden";
• "Enkel mallbearbetningsmotor för att hantera mallar";

Delar krävs
För att slutföra denna handledning behöver du följande delar:

• ESP32 utvecklingskort
• DHT11-modul
• Bakbord
• Bygeltrådar

SchematiskInstallera bibliotek
Du måste installera ett par bibliotek för detta projekt:

• De DHT och den Adafruit Unified Sensor Drivrutinsbibliotek att läsa från DHT-sensorn.
• ESPAsyncWebServer och Asynkroniserad TCP bibliotek för att bygga den asynkrona web server.
  Följ nästa instruktioner för att installera dessa bibliotek:

Installera DHT-sensorbiblioteket
För att läsa från DHT-sensorn med Arduino IDE måste du installera DHT-sensorbibliotek. Följ nästa steg för att installera biblioteket.

1. Klicka här för att ladda ner DHT-sensorbiblioteket. Du bör ha en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få DHT-sensor-library-master-mappen
3. Byt namn på din mapp från DHT-sensor-library-master till DHT_sensor
4. Flytta mappen DHT_sensor till din Arduino IDE-installationsbiblioteksmapp
5. Slutligen, öppna din Arduino IDE igen

Installera Adafruit Unified Sensor Driver
Du måste också installera Adafruit Unified Sensor Driver-bibliotek att arbeta med DHT-sensorn. Följ nästa steg för att installera biblioteket.

1. Klicka här för att ladda ner Adafruit Unified Sensor-biblioteket. Du bör ha en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få Adafruit_sensor-master-mappen
3. Byt namn på din mapp från Adafruit_sensor-master till Adafruit_sensor
4. Flytta Adafruit_sensor-mappen till din Arduino IDE-installationsbiblioteksmapp
5. Slutligen, öppna din Arduino IDE igen

Installation av ESPAsyncWebServerbibliotek

Följ nästa steg för att installera ESPAsyncWebServer bibliotek:

1. Klicka här för att ladda ner ESPAsyncWebServerbibliotek. Du borde ha gjort det
   en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du borde
   skaffa ESPAsyncWebServer-master-mapp
3. Byt namn på din mapp från ESPAsyncWebServer-master till ESPAsyncWebServer
4. Flytta ESPAsyncWebServermappen till din Arduino IDE-installationsbiblioteksmapp

Installera Async TCP Library för ESP32
De ESPAsyncWebServer biblioteket kräver AsyncTCP biblioteket att arbeta. Följ nästa steg för att installera det biblioteket:

1. Klicka här för att ladda ner AsyncTCP-biblioteket. Du bör ha en .zip-mapp i mappen Nedladdningar
2. Packa upp .zip-mappen och du bör få AsyncTCP-master-mappen
3. Byt namn på din mapp från AsyncTCP-master till AsyncTCP
4. Flytta AsyncTCP-mappen till din Arduino IDE-installationsbiblioteksmapp
5. Slutligen, öppna din Arduino IDE igen

Koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDE
När du har installerat de nödvändiga biblioteken öppnar du koden
Project_9_ESP32_DHT11_Web_Server.ino i arduino IDE.
Innan du laddar upp koden, glöm inte att infoga dina nätverksuppgifter så att ESP:n kan ansluta till ditt lokala nätverk.Hur koden fungerar
I följande stycken kommer vi att förklara hur koden fungerar. Fortsätt läsa om du vill lära dig mer eller hoppa till demonstrationssektionen för att se det slutliga resultatet.
Importerar bibliotek
Importera först de nödvändiga biblioteken. WiFi, ESPAsyncWebServer och ESPAsyncTCP behövs för att bygga web server. Adafruit_Sensor och DHT-biblioteken behövs för att läsa från DHT11- eller DHT22-sensorerna.Variabler definition
Definiera GPIO som DHT-datastiftet är anslutet till. I det här fallet är den ansluten till GPIO 4.Välj sedan den DHT-sensortyp du använder. I vårt example, vi använder DHT22. Om du använder en annan typ behöver du bara avkommentera din sensor och kommentera alla andra.

Instantiera ett DHT-objekt med typen och stiftet som vi har definierat tidigare.Skapa en AsyncWebServerobjekt på port 80.Läs temperatur- och luftfuktighetsfunktioner
Vi har skapat två funktioner: en för att läsa temperaturen Vi har skapat två funktioner: en för att läsa temperaturen (readDHTTemperature()) och den andra för att läsa av fuktighet (readDHTHumidity()).Att få sensoravläsningar är lika enkelt som att använda Att få sensoravläsningar är lika enkelt som att använda metoderna readTemperature() och readHumidity() på dht-objektet.Vi har också ett tillstånd som returnerar två streck (–) om sensorn inte lyckas få avläsningarna.Avläsningarna returneras som strängtyp. För att konvertera en float till en sträng, använd String()-funktionenSom standard läser vi temperaturen i grader Celsius. För att få temperaturen i Fahrenheit grader, kommentera temperaturen i Celsius och avkommentera temperaturen i Fahrenheit, så att du har följande:Ladda upp koden
Ladda nu upp koden till din ESP32. Se till att du har valt rätt kort och COM-port. Ladda upp kodreferenssteg.
Efter uppladdning öppnar du den seriella monitorn med en baudhastighet på 115200. Tryck på ESP32-återställningsknappen. ESP32 IP-adressen ska skrivas ut i serien övervaka.Demonstration
Öppna en webbläsare och skriv ESP32 IP-adressen. Din web servern ska visa de senaste sensoravläsningarna.
Notera: Din webbläsare och ESP32 bör vara anslutna till samma LAN.
Observera att temperatur- och luftfuktighetsavläsningarna uppdateras automatiskt utan att behöva uppdatera web sida.

Project_10_ESP32_OLED_Display

Det här projektet visar hur man använder 0.96-tums SSD1306 OLED-skärm med ESP32 med Arduino IDE.
Vi presenterar 0.96 tums OLED-skärm
De OLED-skärm som vi kommer att använda i den här handledningen är SSD1306-modellen: en enfärgad 0.96-tumsskärm med 128×64 pixlar som visas i följande figur.OLED-skärmen kräver ingen bakgrundsbelysning, vilket ger en mycket fin kontrast i mörka miljöer. Dessutom förbrukar dess pixlar energi bara när de är på, så OLED-skärmen förbrukar mindre ström jämfört med andra skärmar.
Eftersom OLED-skärmen använder I2C-kommunikationsprotokoll är kabeldragningen mycket enkel. Du kan använda följande tabell som referens.

OLED-stift	ESP32
Vin	3.3V
GND	GND
SCL	GPIO 22
SDA	GPIO 21

SchematiskInstallerar SSD1306 OLED Library – ESP32
Det finns flera tillgängliga bibliotek för att styra OLED-skärmen med ESP32.
I den här handledningen kommer vi att använda två Adafruit-bibliotek: Adafruit_SSD1306 bibliotek och Adafruit_GFX-biblioteket.
Följ nästa steg för att installera dessa bibliotek.

1. Öppna din Arduino IDE och gå till Sketch > Inkludera bibliotek > Hantera bibliotek. Bibliotekshanteraren bör öppnas.
2. Skriv "SSD1306" i sökrutan och installera SSD1306-biblioteket från Adafruit.
3. Efter att ha installerat SSD1306-biblioteket från Adafruit, skriv "GFX" i sökrutan och installera biblioteket.
4. När du har installerat biblioteken, starta om din Arduino IDE.

Koda
När du har installerat de nödvändiga biblioteken, öppna Project_10_ESP32_OLED_Display.ino i arduino IDE. koda
Vi programmerar ESP32 med Arduino IDE, så se till att du har ESP32-tillägget installerat innan du fortsätter: (Om du redan har gjort det här steget kan du hoppa till nästa steg.)
Installerar ESP32-tillägget i Arduino IDEHur koden fungerar
Importerar bibliotek
Först måste du importera de nödvändiga biblioteken. Wire-biblioteket för att använda I2C och Adafruit-biblioteken för att skriva till displayen: Adafruit_GFX och Adafruit_SSD1306.Initiera OLED-skärmen
Sedan definierar du din OLED-bredd och -höjd. I detta exampvi använder en 128×64 OLED-skärm. Om du använder andra storlekar kan du ändra det i variablerna SCREEN_WIDTH och SCREEN_HEIGHT.Initiera sedan ett visningsobjekt med den bredd och höjd som definierats tidigare med I2C-kommunikationsprotokoll (&Wire).Parametern (-1) betyder att din OLED-skärm inte har ett RESET-stift. Om din OLED-skärm har ett RESET-stift bör den anslutas till en GPIO. I så fall bör du skicka GPIO-numret som en parameter.
I setup(), initiera den seriella monitorn med en baud raute på 115200 för felsökningsändamål.Initiera OLED-skärmen med metoden begin() enligt följande:Det här utdraget skriver också ut ett meddelande på den seriella monitorn, om vi inte kan ansluta till skärmen.

Om du använder en annan OLED-skärm kan du behöva ändra OLED-adressen. I vårt fall är adressen 0x3C.Efter initialisering av skärmen, lägg till en två sekunders fördröjning så att OLED:n har tillräckligt med tid att initiera innan du skriver text:Rensa display, ställ in teckenstorlek, färg och skriv text
Efter att ha initierat skärmen, rensa visningsbufferten med metoden clearDisplay():

Innan du skriver text måste du ställa in textstorlek, färg och var texten ska visas i OLED.
Ställ in teckenstorleken med metoden setTextSize():Ställ in teckensnittsfärgen med metoden setTextColor():
WHITE anger vitt teckensnitt och svart bakgrund.
Definiera positionen där texten börjar med metoden setCursor(x,y). I det här fallet ställer vi in ​​texten så att den börjar vid (0,0) koordinaterna – i det övre vänstra hörnet.Slutligen kan du skicka texten till displayen med metoden println() enligt följandeSedan måste du anropa display()-metoden för att faktiskt visa texten på skärmen.

Adafruit OLED-biblioteket ger användbara metoder för att enkelt rulla text.

• startscrollright(0x00, 0x0F): rulla text från vänster till höger
• startscrollleft(0x00, 0x0F): rulla text från höger till vänster
• startscrolldiagright(0x00, 0x07): rulla text från nedre vänstra hörnet till högra övre hörn startscrolldiagleft(0x00, 0x07): rulla text från nedre högra hörnet till övre vänstra hörnet

Ladda upp koden
Ladda nu upp koden till din ESP32. Ladda upp kodreferenssteg.
Efter att ha laddat upp koden visar OLED:n rullande text.

Dokument/resurser

LAFVIN ESP32 Basic Starter Kit [pdf] Bruksanvisning ESP32 Basic Starter Kit, ESP32, Basic Starter Kit, Starter Kit

Referenser

• Användarmanual