ESP32 Basic Starter
Sett

Pakkeliste

ESP32 Introduksjon

Ny på ESP32? Start her! ESP32 er en serie lavkost- og laveffekts System on a Chip (SoC) mikrokontrollere utviklet av Espressif som inkluderer trådløse Wi-Fi- og Bluetooth-funksjoner og dual-core prosessor. Hvis du er kjent med ESP8266, er ESP32 dens etterfølger, lastet med mange nye funksjoner.ESP32 spesifikasjoner
Hvis du ønsker å bli litt mer teknisk og spesifikk, kan du ta en titt på følgende detaljerte spesifikasjoner for ESP32 (kilde: http://esp32.net/)—for mer informasjon, sjekk databladet):

• Trådløs tilkobling WiFi: 150.0 Mbps datahastighet med HT40
• Bluetooth: BLE (Bluetooth Low Energy) og Bluetooth Classic
• Prosessor: Tensilica Xtensa Dual-Core 32-bits LX6 mikroprosessor, kjører på 160 eller 240 MHz
• Hukommelse:
• ROM: 448 KB (for oppstart og kjernefunksjoner)
• SRAM: 520 KB (for data og instruksjoner)
• RTC fas SRAM: 8 KB (for datalagring og hoved-CPU under RTC-oppstart fra dyp dvalemodus)
• RTC sakte SRAM: 8KB (for co-prosessor tilgang under dyp hvilemodus) eFuse: 1 Kbit (hvorav 256 biter brukes til systemet (MAC-adresse og chipkonfigurasjon) og de resterende 768 bitene er reservert for kundeapplikasjoner, inkludert Flash-kryptering og brikke-ID)

Innebygd blits: blits tilkoblet internt via IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 og SD_DATA_1 på ESP32-D2WD og ESP32-PICO-D4.

• 0 MiB (ESP32-D0WDQ6, ESP32-D0WD og ESP32-S0WD brikker)
• 2 MiB (ESP32-D2WD-brikke)
• 4 MiB (ESP32-PICO-D4 SiP-modul)

Low Power: sikrer at du fortsatt kan bruke ADC-konverteringer, for eksempelample, under dyp søvn.
Perifer inn/utgang:

• perifert grensesnitt med DMA som inkluderer kapasitiv berøring
• ADC-er (Analog-til-Digital Converter)
• DAC-er (Digital-til-Analog Converter)
• I²C (interintegrert krets)
• UART (Universal Asynchronous Receiver/Sender)
• SPI (Serial Peripheral Interface)
• I²S (integrert interchip-lyd)
• RMII (redusert medieuavhengig grensesnitt)
• PWM (Pulse-Width Modulation)

Sikkerhet: maskinvareakseleratorer for AES og SSL/TLS

ESP32 utviklingstavler

ESP32 refererer til den nakne ESP32-brikken. Imidlertid brukes "ESP32"-begrepet også for å referere til ESP32-utviklingskort. Å bruke ESP32 bare brikker er ikke lett eller praktisk, spesielt når du lærer, tester og prototyping. Mesteparten av tiden vil du bruke et ESP32-utviklingskort.
Vi kommer til å bruke ESP32 DEVKIT V1-kortet som referanse. Bildet nedenfor viser ESP32 DEVKIT V1-kortet, versjon med 30 GPIO-pinner.Spesifikasjoner – ESP32 DEVKIT V1
Følgende tabell viser et sammendrag av ESP32 DEVKIT V1 DOIT-kortfunksjoner og spesifikasjoner:

Antall kjerner	2 (dobbel kjerne)
Wi-Fi	2.4 GHz opp til 150 Mbits/s
Bluetooth	BLE (Bluetooth Low Energy) og eldre Bluetooth
Arkitektur	32 biter
Klokkefrekvens	Opp til 240 MHz
VÆR	512 KB
Pinner	30 (avhengig av modell)

Periferiutstyr	Kapasitiv berøring, ADC (analog til digital omformer), DAC (digital til analog omformer), 12C (Inter-Integrated Circuit), UART (universell asynkron mottaker/sender), CAN 2.0 (Controller Area Netwokr), SPI (Serial Peripheral Interface) , 12S (integrert inter-IC Lyd), RMII (redusert mediauavhengig grensesnitt), PWM (pulsbreddemodulasjon) og mer.
Innebygde knapper	RESET og BOOT-knapper
Innebygde lysdioder	innebygd blå LED koblet til GPIO2; innebygd rød LED som viser at kortet får strøm
USB til UART bro	CP2102

Den kommer med et microUSB-grensesnitt som du kan bruke til å koble kortet til datamaskinen for å laste opp kode eller sette på strøm.
Den bruker CP2102-brikken (USB til UART) for å kommunisere med datamaskinen din via en COM-port ved hjelp av et serielt grensesnitt. En annen populær brikke er CH340. Sjekk hva som er USB til UART-brikkekonverteren på kortet ditt fordi du må installere de nødvendige driverne slik at datamaskinen kan kommunisere med kortet (mer informasjon om dette senere i denne veiledningen).
Dette brettet kommer også med en RESET-knapp (kan være merket EN) for å starte brettet på nytt og en BOOT-knapp for å sette brettet i blinkende modus (tilgjengelig for å motta kode). Merk at noen brett kanskje ikke har en BOOT-knapp.
Den kommer også med en innebygd blå LED som er internt koblet til GPIO 2. Denne LED er nyttig for feilsøking for å gi en slags visuell fysisk utgang. Det er også en rød LED som lyser når du gir strøm til brettet.ESP32 Pinout
ESP32-tilbehøret inkluderer:

• 18 Analog-til-Digital Converter (ADC) kanaler
• 3 SPI-grensesnitt
• 3 UART-grensesnitt
• 2 I2C-grensesnitt
• 16 PWM utgangskanaler
• 2 digital-til-analog-omformere (DAC)
• 2 I2S-grensesnitt
• 10 kapasitive sensing GPIOer

Funksjonene ADC (analog til digital omformer) og DAC (digital til analog omformer) er tilordnet spesifikke statiske pinner. Du kan imidlertid bestemme hvilke pinner som er UART, I2C, SPI, PWM, etc - du trenger bare å tilordne dem i koden. Dette er mulig på grunn av ESP32-brikkens multipleksingsfunksjon.
Selv om du kan definere pinneegenskapene på programvaren, er det pinner tildelt som standard som vist i følgende figurI tillegg er det pinner med spesifikke funksjoner som gjør dem egnet eller ikke for et bestemt prosjekt. Tabellen nedenfor viser hvilke pinner som er best å bruke som innganger, utganger og hvilke du trenger for å være forsiktig.
Pinnene uthevet i grønt er OK å bruke. De som er uthevet i gult er OK å bruke, men du må være oppmerksom fordi de kan ha en uventet oppførsel hovedsakelig ved oppstart. Pinnene uthevet i rødt anbefales ikke å bruke som innganger eller utganger.

GP IO	Inndata	Produksjon	Notater
0	trukket opp	OK	sender ut PWM-signal ved oppstart, må være LAV for å gå inn i blinkende modus
1	TX pinne	OK	feilsøke utgang ved oppstart
2	OK	OK	koblet til innebygd LED, må stå flytende eller LAV for å gå inn i blinkende modus
3	OK	RX pinne	HØY ved støvelen
4	OK	OK
5	OK	OK	sender ut PWM-signal ved oppstart, stropping pin
12	OK	OK	støvelen svikter hvis den trekkes høyt, festestift
13	OK	OK
14	OK	OK	sender ut PWM-signal ved oppstart
15	OK	OK	sender ut PWM-signal ved oppstart, stropping pin

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		kun input
35	OK		kun input
36	OK		kun input
39	OK		kun input

Fortsett å lese for en mer detaljert og dyptgående analyse av ESP32 GPIOene og dens funksjoner.
Inngang kun pinner
GPIO-er 34 til 39 er GPI-er – kun inndatapinner. Disse pinnene har ikke interne pull-up eller pull-down motstander. De kan ikke brukes som utganger, så bruk disse pinnene kun som innganger:

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

SPI-blits integrert på ESP-WROOM-32
GPIO 6 til GPIO 11 er eksponert i noen ESP32-utviklingskort. Disse pinnene er imidlertid koblet til den integrerte SPI-blitsen på ESP-WROOM-32-brikken og anbefales ikke for annen bruk. Så ikke bruk disse pinnene i prosjektene dine:

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

Kapasitive berørings-GPIOer
ESP32 har 10 interne kapasitive berøringssensorer. Disse kan føle variasjoner i alt som har en elektrisk ladning, som menneskehuden. Så de kan oppdage variasjoner indusert når de berører GPIO-ene med en finger. Disse pinnene kan enkelt integreres i kapasitive puter og erstatte mekaniske knapper. De kapasitive berøringspinnene kan også brukes til å vekke ESP32 fra dyp søvn. Disse interne berøringssensorene er koblet til disse GPIO-ene:

• 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 til digital omformer (ADC)
ESP32 har 18 x 12 bits ADC-inngangskanaler (mens ESP8266 bare har 1x 10 bits ADC). Dette er GPIOene som kan brukes som ADC og 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)

Note: ADC2-pinner kan ikke brukes når Wi-Fi brukes. Så hvis du bruker Wi-Fi og du har problemer med å få verdien fra en ADC2 GPIO, kan du vurdere å bruke en ADC1 GPIO i stedet. Det burde løse problemet ditt.
ADC-inngangskanalene har en 12-bits oppløsning. Dette betyr at du kan få analoge avlesninger fra 0 til 4095, hvor 0 tilsvarer 0V og 4095 til 3.3V. Du kan også stille inn oppløsningen til kanalene dine på koden og ADC-området.
ESP32 ADC-pinnene har ikke en lineær oppførsel. Du vil sannsynligvis ikke kunne skille mellom 0 og 0.1V, eller mellom 3.2 og 3.3V. Du må huske på det når du bruker ADC-pinnene. Du vil få en oppførsel som ligner på den som vises i følgende figur.Digital til Analog Converter (DAC)
Det er 2 x 8 bits DAC-kanaler på ESP32 for å konvertere digitale signaler til analog voltage signalutganger. Dette er DAC-kanalene:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

RTC GPIOer
Det er RTC GPIO-støtte på ESP32. GPIO-ene som er rutet til RTC-lavstrømsundersystemet kan brukes når ESP32 er i dyp søvn. Disse RTC GPIOene kan brukes til å vekke ESP32 fra dyp søvn når Ultra Low
Strøm (ULP) co-prosessor kjører. Følgende GPIO-er kan brukes som en ekstern vekkekilde.

• 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-kontrolleren har 16 uavhengige kanaler som kan konfigureres til å generere PWM-signaler med forskjellige egenskaper. Alle pinner som kan fungere som utganger kan brukes som PWM pinner (GPIOs 34 til 39 kan ikke generere PWM).
For å stille inn et PWM-signal, må du definere disse parameterne i koden:

• Signalets frekvens;
• Driftssyklus;
• PWM-kanal;
• GPIO hvor du vil sende ut signalet.

I2C
ESP32 har to I2C-kanaler og hvilken som helst pinne kan settes som SDA eller SCL. Når du bruker ESP32 med Arduino IDE, er standard I2C-pinnene:

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

Hvis du vil bruke andre pinner når du bruker ledningsbiblioteket, trenger du bare å ringe:
Wire.begin(SDA, SCL);
SPI
Som standard er pin-tilordningen for SPI:

SPI	DAWDLE	MISO	CLK	CS
VSPI	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

avbryter
Alle GPIOer kan konfigureres som avbrudd.
Strapping Pins
ESP32-brikken har følgende stropping pins:

• GPIO 0 (må være LAV for å gå inn i oppstartsmodus)
• GPIO 2 (må være flytende eller LAV under oppstart)
• GPIO 4
• GPIO 5 (må være HØY under oppstart)
• GPIO 12 (må være LAV under oppstart)
• GPIO 15 (må være HØY under oppstart)

Disse brukes til å sette ESP32 i bootloader eller blinkende modus. På de fleste utviklingskort med innebygd USB/Serial, trenger du ikke bekymre deg for tilstanden til disse pinnene. Brettet setter pinnene i riktig tilstand for blinking eller oppstartsmodus. Mer informasjon om ESP32 Boot Mode Selection finner du her.
Men hvis du har eksterne enheter koblet til disse pinnene, kan det hende du har problemer med å prøve å laste opp ny kode, blinke ESP32 med ny fastvare eller tilbakestille kortet. Hvis du har noen periferiutstyr koblet til stroppingpinnene og du får problemer med å laste opp kode eller blinke ESP32, kan det være fordi disse periferienhetene hindrer ESP32 fra å gå inn i riktig modus. Les dokumentasjonen for valg av oppstartsmodus for å veilede deg i riktig retning. Etter tilbakestilling, blinking eller oppstart fungerer disse pinnene som forventet.
Pinner HØY ved Boot
Noen GPIO-er endrer tilstanden til HØY eller sender ut PWM-signaler ved oppstart eller tilbakestilling.
Dette betyr at hvis du har utganger koblet til disse GPIO-ene, kan du få uventede resultater når ESP32 tilbakestiller eller starter opp.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 til GPIO 11 (koblet til ESP32 integrert SPI-flashminne – anbefales ikke å bruke).
• GPIO 14
• GPIO 15

Aktiver (NO)
Enable (EN) er 3.3V-regulatorens aktiveringspinne. Den er trukket opp, så koble til jord for å deaktivere 3.3V-regulatoren. Dette betyr at du kan bruke denne pinnen koblet til en trykknapp for å starte din ESP32 på nytt, for eksempelample.
GPIO-strøm trukket
Den absolutte maksimale strømmen som trekkes per GPIO er 40mA i henhold til delen "Anbefalte driftsbetingelser" i ESP32-dataarket.
ESP32 innebygd halleffektsensor
ESP32 har også en innebygd halleffektsensor som oppdager endringer i magnetfeltet i omgivelsene
ESP32 Arduino IDE
Det er et tillegg for Arduino IDE som lar deg programmere ESP32 ved å bruke Arduino IDE og dets programmeringsspråk. I denne opplæringen viser vi deg hvordan du installerer ESP32-kortet i Arduino IDE enten du bruker Windows, Mac OS X eller Linux.
Forutsetninger: Arduino IDE installert
Før du starter denne installasjonsprosedyren, må du ha Arduino IDE installert på datamaskinen. Det er to versjoner av Arduino IDE du kan installere: versjon 1 og versjon 2.
Du kan laste ned og installere Arduino IDE ved å klikke på følgende lenke: arduino.cc/en/Main/Software
Hvilken Arduino IDE-versjon anbefaler vi? For øyeblikket er det noen plugins for ESP32 (som SPIFFS Filesystem Uploader Plugin) som ennå ikke støttes på Arduino 2. Så hvis du har tenkt å bruke SPIFFS plugin i fremtiden, anbefaler vi å installere den eldre versjonen 1.8.X. Du trenger bare å bla ned på Arduino-programvaresiden for å finne den.
Installerer ESP32 Add-on i Arduino IDE
For å installere ESP32-kortet i din Arduino IDE, følg disse neste instruksjonene:

1. I din Arduino IDE, gå til File> Innstillinger
2. Skriv inn følgende i «Ekstra styreleder URLs" felt:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Klikk deretter på "OK"-knappen:Note: hvis du allerede har ESP8266-kortene URL, kan du skille URLs med komma som følger:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Åpne Boards Manager. Gå til Verktøy > Styre > Styreleder...Søk etter ESP32 and press install button for the “ESP32 by Espressif Systems“:Det er det. Den skal installeres etter noen sekunder.

Last opp testkode

Koble ESP32-kortet til datamaskinen. Med Arduino IDE åpen, følg disse trinnene:

1. Velg styret ditt i Verktøy > Brett-menyen (i mitt tilfelle er det ESP32 DEV-modulen）
2. Velg porten (hvis du ikke ser COM-porten i din Arduino IDE, må du installere CP210x USB til UART Bridge VCP-drivere):
3. Åpne følgende eksample under File > Eksamples > WiFi
   (ESP32) > WiFiScan
4. En ny skisse åpnes i din Arduino IDE:
5. Trykk på Last opp-knappen i Arduino IDE. Vent noen sekunder mens koden kompileres og lastes opp til tavlen.
6. Hvis alt gikk som forventet, bør du se en «Ferdig opplasting». beskjed.
7. Åpne Arduino IDE Serial Monitor med en baudhastighet på 115200:
8. Trykk på ESP32 innebygd aktiveringsknapp og du skal se nettverkene som er tilgjengelige i nærheten av din ESP32:

Feilsøking

Hvis du prøver å laste opp en ny skisse til din ESP32 og du får denne feilmeldingen "En fatal error occurred: Failed to connect to ESP32: Timeout... Connecting...". Det betyr at din ESP32 ikke er i blinkende/opplastingsmodus.
Når du har valgt rett styrenavn og COM por, følger du disse trinnene:
Hold nede "BOOT"-knappen på ESP32-kortet ditt

• Trykk på "Last opp"-knappen i Arduino IDE for å laste opp skissen din:
• Etter at du ser "Kobler til...." melding i Arduino IDE, slipp fingeren fra "BOOT"-knappen:
• Etter det skal du se meldingen "Opplasting ferdig".
  Det er det. Din ESP32 skal ha den nye skissen kjørende. Trykk på "ENABLE"-knappen for å starte ESP32 på nytt og kjøre den nye opplastede skissen.
  Du må også gjenta den knappesekvensen hver gang du vil laste opp en ny skisse.

Prosjekt 1 ESP32 Innganger Utganger

I denne startveiledningen lærer du hvordan du leser digitale innganger som en knappbryter og kontrollerer digitale utganger som en LED ved hjelp av ESP32 med Arduino IDE.
Forutsetninger
Vi programmerer ESP32 med Arduino IDE. Så sørg for at du har ESP32-korttillegget installert før du fortsetter:

• Installerer ESP32 Add-on i Arduino IDE

ESP32 Kontroller digitale utganger
Først må du angi GPIOen du vil kontrollere som en OUTPUT. Bruk pinMode()-funksjonen som følger:
pinMode(GPIO, OUTPUT);
For å kontrollere en digital utgang trenger du bare å bruke digitalWrite() funksjonen, som aksepterer som argumenter, GPIO (int nummer) du refererer til, og tilstanden, enten HØY eller LAV.
digitalWrite(GPIO, STATE);
Alle GPIO-er kan brukes som utganger unntatt GPIO-er 6 til 11 (koblet til den integrerte SPI-blitsen) og GPIO-er 34, 35, 36 og 39 (GPIO-er kun for inngang);
Lær mer om ESP32 GPIOs: ESP32 GPIO Reference Guide
ESP32 Les digitale innganger
Sett først GPIOen du vil lese som INPUT, ved å bruke pinMode()-funksjonen som følger:
pinMode(GPIO, INPUT);
For å lese en digital inngang, som en knapp, bruker du digitalRead()-funksjonen, som aksepterer som argument, GPIO (int-nummer) du refererer til.
digitalRead(GPIO);
Alle ESP32 GPIO-er kan brukes som innganger, bortsett fra GPIO-er 6 til 11 (koblet til den integrerte SPI-blitsen).
Lær mer om ESP32 GPIOs: ESP32 GPIO Reference Guide
Prosjekt Eksample
For å vise deg hvordan du bruker digitale innganger og digitale utganger, bygger vi et enkelt prosjekt f.eksample med en trykknapp og en LED. Vi vil lese tilstanden til trykknappen og tenne lysdioden tilsvarende som illustrert i følgende figur.

Deler påkrevd
Her er en liste over delene du trenger for å bygge kretsen:

• ESP32 DEVKIT V1
• 5 mm LED
• 220 Ohm motstand
• Push
• 10k ohm motstand
• Brødbrett
• Jumper ledninger

Skjematisk diagram
Før du fortsetter, må du sette sammen en krets med en LED og en trykknapp.
Vi kobler LED-en til GPIO 5 og trykknappen til GPIO 4.Kode
Åpne koden Project_1_ESP32_Inputs_Outputs.ino i arduino IDEHvordan koden fungerer
I de følgende to linjene lager du variabler for å tilordne pinner:

Knappen er koblet til GPIO 4 og lysdioden er koblet til GPIO 5. Når du bruker Arduino IDE med ESP32, tilsvarer 4 GPIO 4 og 5 tilsvarer GPIO 5.
Deretter oppretter du en variabel for å holde knappens tilstand. Som standard er den 0 (ikke trykket).
int buttonState = 0;
I oppsettet() initialiserer du knappen som en INNGANG, og lysdioden som en UTGANG.
Til det bruker du pinMode()-funksjonen som godtar pinnen du refererer til, og modusen: INPUT eller OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
I loopen() leser du knappens tilstand og stiller inn lysdioden tilsvarende.
På neste linje leser du knappens tilstand og lagrer den i variabelen buttonState.
Som vi har sett tidligere, bruker du digitalRead()-funksjonen.
buttonState = digitalRead(buttonPin);
Følgende if-setning kontrollerer om knappens tilstand er HØY. Hvis den er det, slår den på LED-en ved å bruke digitalWrite()-funksjonen som godtar ledPin-en og tilstanden HIGH som argument.
if (knappState == HØY)Hvis knappens tilstand ikke er HØY, slår du av lysdioden. Bare sett LOW som et andre argument til i digitalWrite()-funksjonen.Laster opp koden
Før du klikker på opplastingsknappen, gå til Verktøy > Brett, og velg brettet :DOIT ESP32 DEVKIT V1.
Gå til Verktøy > Port og velg COM-porten ESP32 er koblet til. Deretter trykker du på opplastingsknappen og venter på meldingen "Ferdig opplasting".Merk: Hvis du ser mange prikker (kobler til...__...__) i feilsøkingsvinduet og meldingen "Kunnet ikke koble til ESP32: Tidsavbrudd venter på pakkeoverskrift", betyr det at du må trykke på ESP32 innebygd BOOT knappen etter prikkene
begynner å vises. Feilsøking

Demonstrasjon

Etter å ha lastet opp koden, test kretsen din. Din LED skal lyse når du trykker på trykknappen:Og slå av når du slipper den:

Prosjekt 2 ESP32 analoge innganger

Dette prosjektet viser hvordan du leser analoge innganger med ESP32 ved å bruke Arduino IDE.
Analog avlesning er nyttig for å lese verdier fra variable motstander som potensiometre eller analoge sensorer.
Analoge innganger (ADC)
Å lese en analog verdi med ESP32 betyr at du kan måle varierende volumtage nivåer mellom 0 V og 3.3 V.
Voltage målt tilordnes da en verdi mellom 0 og 4095, hvor 0 V tilsvarer 0, og 3.3 V tilsvarer 4095. Eventuell volumtage mellom 0 V og 3.3 V vil gis tilsvarende verdi i mellom.ADC er ikke-lineær
Ideelt sett ville du forvente en lineær oppførsel når du bruker ESP32 ADC-pinnene.
Det skjer imidlertid ikke. Det du får er en oppførsel som vist i følgende diagram:Denne oppførselen betyr at din ESP32 ikke er i stand til å skille 3.3 V fra 3.2 V.
Du vil få samme verdi for begge voltages: 4095.
Det samme skjer for svært lav voltage-verdier: for 0 V og 0.1 V får du samme verdi: 0. Du må ha dette i bakhodet når du bruker ESP32 ADC-pinnene.
analogRead() funksjon
Å lese en analog inngang med ESP32 ved å bruke Arduino IDE er like enkelt som å bruke analogRead()-funksjonen. Den godtar som argument, GPIOen du vil lese:
analogRead(GPIO);
Bare 15 er tilgjengelige i DEVKIT V1board (versjon med 30 GPIOer).
Ta tak i ESP32-kortets pinout og finn ADC-pinnene. Disse er uthevet med rød kant i figuren under.Disse analoge inngangspinnene har 12-biters oppløsning. Dette betyr at når du leser en analog inngang, kan området variere fra 0 til 4095.
Merk: ADC2-pinner kan ikke brukes når Wi-Fi brukes. Så hvis du bruker Wi-Fi og du har problemer med å få verdien fra en ADC2 GPIO, kan du vurdere å bruke en ADC1 GPIO i stedet, det burde løse problemet ditt.
For å se hvordan alt henger sammen, lager vi en enkel eksample for å lese en analog verdi fra et potensiometer.
Deler påkrevd
For denne eksample, du trenger følgende deler:

• ESP32 DEVKIT V1-kort
• Potensiometer
• Brødbrett
• Jumper ledninger

Skjematisk
Koble et potensiometer til din ESP32. Potensiometerets midtstift skal kobles til GPIO 4. Du kan bruke følgende skjematiske diagram som referanse.Kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Åpne koden Project_2_ESP32_Inputs_Outputs.ino i arduino IDEDenne koden leser ganske enkelt verdiene fra potensiometeret og skriver ut disse verdiene i seriemonitoren.
I koden starter du med å definere GPIOen potensiometeret er koblet til. I denne eksample, GPIO 4.I oppsettet(), initialiser en seriell kommunikasjon med en overføringshastighet på 115200.I loop(), bruk analogRead()-funksjonen for å lese den analoge inngangen fra potPin.Skriv til slutt ut verdiene avlest fra potensiometeret i seriemonitoren.Last opp koden som er gitt til din ESP32. Sørg for at du har valgt riktig kort og COM-port i Verktøy-menyen.
Tester eksample
Etter å ha lastet opp koden og trykket på ESP32-reset-knappen, åpner du seriemonitoren med en overføringshastighet på 115200. Roter potensiometeret og se verdiene endre seg.Den maksimale verdien du får er 4095 og minimumsverdien er 0.

Innpakning

I denne artikkelen har du lært hvordan du leser analoge innganger ved å bruke ESP32 med Arduino IDE. Oppsummert:

• ESP32 DEVKIT V1 DOIT-kortet (versjon med 30 pinner) har 15 ADC-pinner du kan bruke til å lese analoge innganger.
• Disse pinnene har en oppløsning på 12 biter, noe som betyr at du kan få verdier fra 0 til 4095.
• For å lese en verdi i Arduino IDE, bruker du ganske enkelt analogRead()-funksjonen.
• ESP32 ADC-pinnene har ikke en lineær oppførsel. Du vil sannsynligvis ikke kunne skille mellom 0 og 0.1V, eller mellom 3.2 og 3.3V. Du må huske på det når du bruker ADC-pinnene.

Project 3 ESP32 PWM (analog utgang)

I denne opplæringen viser vi deg hvordan du genererer PWM-signaler med ESP32 ved å bruke Arduino IDE. Som eksampvi skal bygge en enkel krets som dimmer en LED ved hjelp av LED PWM-kontrolleren til ESP32.ESP32 LED PWM-kontroller
ESP32 har en LED PWM-kontroller med 16 uavhengige kanaler som kan konfigureres til å generere PWM-signaler med forskjellige egenskaper.
Her er trinnene du må følge for å dimme en LED med PWM ved å bruke Arduino IDE:

1. Først må du velge en PWM-kanal. Det er 16 kanaler fra 0 til 15.
2. Deretter må du stille inn PWM-signalfrekvensen. For en LED er en frekvens på 5000 Hz greit å bruke.
3. Du må også stille inn signalets driftssyklusoppløsning: du har oppløsninger fra 1 til 16 biter. Vi bruker 8-biters oppløsning, noe som betyr at du kan kontrollere LED-lysstyrken med en verdi fra 0 til 255.
4.  Deretter må du spesifisere hvilke GPIO eller GPIOer signalet skal vises på. Til det bruker du følgende funksjon:
   ledcAttachPin(GPIO, kanal)
   Denne funksjonen aksepterer to argumenter. Den første er GPIOen som vil sende ut signalet, og den andre er kanalen som genererer signalet.
5. Til slutt, for å kontrollere LED-lysstyrken ved hjelp av PWM, bruker du følgende funksjon:

ledcWrite(kanal, arbeidssyklus)
Denne funksjonen aksepterer som argumenter kanalen som genererer PWM-signalet, og driftssyklusen.
Deler påkrevd
For å følge denne opplæringen trenger du disse delene:

• ESP32 DEVKIT V1-kort
• 5mm LED
• 220 Ohm motstand
•  Brødbrett
• Jumper ledninger

Skjematisk
Koble en LED til din ESP32 som i følgende skjematiske diagram. LED-en skal være koblet til GPIO 4.Note: du kan bruke hvilken som helst pinne du vil, så lenge den kan fungere som en utgang. Alle pinner som kan fungere som utganger kan brukes som PWM pinner. For mer informasjon om ESP32 GPIO-ene, les: ESP32 Pinout Reference: Hvilke GPIO-pinner bør du bruke?
Kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Åpne koden Project_3_ESP32_PWM.ino i arduino IDEDu starter med å definere pinnen LED-en er festet til. I dette tilfellet er LED-en koblet til GPIO 4.Deretter angir du PWM-signalegenskapene. Du definerer en frekvens på 5000 Hz, velger kanal 0 for å generere signalet, og setter en oppløsning på 8 biter. Du kan velge andre egenskaper, annerledes enn disse, for å generere forskjellige PWM-signaler.I setup() må du konfigurere LED PWM med egenskapene du har definert tidligere ved å bruke ledcSetup()-funksjonen som aksepterer som argumenter, ledChannel, frekvensen og oppløsningen, som følger:Deretter må du velge GPIOen du vil få signalet fra. For det bruk ledcAttachPin()-funksjonen som aksepterer som argumenter GPIOen der du vil hente signalet, og kanalen som genererer signalet. I denne eksample, vi får signalet i ledPin GPIO, som tilsvarer GPIO 4. Kanalen som genererer signalet er ledChannel, som tilsvarer kanal 0.I loopen vil du variere driftssyklusen mellom 0 og 255 for å øke LED-lysstyrken.Og så mellom 255 og 0 for å redusere lysstyrken.For å stille inn lysstyrken til LED-en, trenger du bare å bruke ledcWrite()-funksjonen som aksepterer som argumenter kanalen som genererer signalet, og driftssyklusen.Ettersom vi bruker 8-bits oppløsning, vil driftssyklusen bli kontrollert med en verdi fra 0 til 255. Merk at i ledcWrite()-funksjonen bruker vi kanalen som genererer signalet, og ikke GPIO.

Tester eksample

Last opp koden til din ESP32. Kontroller at du har valgt riktig kort og COM-port. Se på kretsen din. Du bør ha en dimmer LED som øker og reduserer lysstyrken.

Project 4 ESP32 PIR bevegelsessensor

Dette prosjektet viser hvordan du oppdager bevegelse med ESP32 ved hjelp av en PIR-bevegelsessensor. Summeren vil avgi en alarm når bevegelse oppdages, og stoppe alarmen når ingen bevegelse oppdages i en forhåndsinnstilt tid (for eksempel 4 sekunder)
Slik fungerer HC-SR501 bevegelsessensor
.Arbeidsprinsippet til HC-SR501-sensoren er basert på endringen av den infrarøde strålingen på det bevegelige objektet. For å bli oppdaget av HC-SR501-sensoren, må objektet oppfylle to krav:

• Objektet sender ut den infrarøde måten.
• Objektet beveger seg eller rister

Så:
Hvis et objekt sender ut den infrarøde strålen, men IKKE beveger seg (f.eks. en person står stille uten å bevege seg), oppdages det IKKE av sensoren.
Hvis en gjenstand beveger seg, men IKKE sender ut den infrarøde strålen (f.eks. robot eller kjøretøy), blir den IKKE oppdaget av sensoren.
Vi introduserer timere
I denne eksampvi vil også introdusere tidtakere. Vi vil at LED-en skal være på i et forhåndsbestemt antall sekunder etter at bevegelse er oppdaget. I stedet for å bruke en delay()-funksjon som blokkerer koden din og ikke lar deg gjøre noe annet i et bestemt antall sekunder, bør vi bruke en timer.Delay() funksjonen
Du bør være kjent med funksjonen delay() da den er mye brukt. Denne funksjonen er ganske enkel å bruke. Den aksepterer et enkelt int-tall som et argument.
Dette tallet representerer tiden i millisekunder programmet må vente til det går videre til neste kodelinje.Når du gjør forsinkelse (1000) stopper programmet på den linjen i 1 sekund.
delay() er en blokkeringsfunksjon. Blokkeringsfunksjoner hindrer et program i å gjøre noe annet før den aktuelle oppgaven er fullført. Hvis du trenger at flere oppgaver skal utføres samtidig, kan du ikke bruke delay().
For de fleste prosjekter bør du unngå å bruke forsinkelser og bruke tidtakere i stedet.
Millis()-funksjonen
Ved å bruke en funksjon kalt millis() kan du returnere antall millisekunder som har gått siden programmet startet.Hvorfor er denne funksjonen nyttig? For ved å bruke litt matematikk kan du enkelt verifisere hvor mye tid som har gått uten å blokkere koden din.
Deler påkrevd
For å følge denne opplæringen trenger du følgende deler

• ESP32 DEVKIT V1-kort
• PIR bevegelsessensor (HC-SR501)
• Aktiv summer
• Jumper ledninger
• Brødbrett

SkjematiskNote: Arbeidsvoltage av HC-SR501 er 5V. Bruk Vin-pinnen til å drive den.
Kode
Før du fortsetter med denne opplæringen bør du ha ESP32-tillegget installert i Arduino IDE. Følg en av de følgende veiledningene for å installere ESP32 på Arduino IDE, hvis du ikke allerede har gjort det.(Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Åpne koden Project_4_ESP32_PIR_Motion_Sensor.ino i arduino IDE.
Demonstrasjon
Last opp koden til ESP32-kortet ditt. Kontroller at du har valgt riktig kort og COM-port. Last opp kodereferansetrinn.
Åpne seriell monitor med en overføringshastighet på 115200.Beveg hånden din foran PIR-sensoren. Summeren skal slås på, og meldingen skrives ut i seriemonitoren som sier "Bevegelse oppdaget! Buzzer alarm".
Etter 4 sekunder skal summeren slå seg av.

Project 5 ESP32 Switch Web Server

I dette prosjektet skal du lage en frittstående web server med en ESP32 som kontrollerer utganger (to lysdioder) ved hjelp av Arduino IDE-programmeringsmiljøet. De web serveren er mobilresponsiv og kan nås med alle enheter som er en nettleser på det lokale nettverket. Vi viser deg hvordan du lager web server og hvordan koden fungerer trinn for trinn.
Prosjekt overview
Før du går rett til prosjektet, er det viktig å skissere hva vår web server vil gjøre det, slik at det er lettere å følge trinnene senere.

• De web serveren du bygger kontrollerer to lysdioder koblet til ESP32 GPIO 26 og GPIO 27;
• Du kan få tilgang til ESP32 web server ved å skrive inn ESP32 IP-adressen i en nettleser i det lokale nettverket;
• Ved å klikke på knappene på din web server kan du umiddelbart endre tilstanden til hver LED.

Deler påkrevd
For denne opplæringen trenger du følgende deler:

• ESP32 DEVKIT V1-kort
• 2x 5mm LED
• 2x 200 Ohm motstand
• Brødbrett
• Jumper ledninger

Skjematisk
Start med å bygge kretsen. Koble to lysdioder til ESP32 som vist i følgende skjematiske diagram – en lysdiode koblet til GPIO 26, og den andre til GPIO 27.
Note: Vi bruker ESP32 DEVKIT DOIT-kortet med 36 pinner. Før du monterer kretsen, sørg for at du sjekker pinouten for kortet du bruker.Kode
Her gir vi koden som lager ESP32 web server. Åpne koden Project_5_ESP32_Switch _Web_Server.ino i arduino IDE, men ikke last det opp ennå. Du må gjøre noen endringer for å få det til å fungere for deg.
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Angi nettverkslegitimasjon
Du må endre følgende linjer med nettverkslegitimasjonen din: SSID og passord. Koden er godt kommentert hvor du bør gjøre endringene.Laster opp koden
Nå kan du laste opp koden og og web serveren vil fungere umiddelbart.
Følg de neste trinnene for å laste opp kode til ESP32:

1. Koble ESP32-kortet til datamaskinen;
2. I Arduino IDE velg styret ditt i Verktøy > Brett (i vårt tilfelle bruker vi ESP32 DEVKIT DOIT brett);
3. Velg COM-porten i Verktøy > Port.
4. Trykk på Last opp-knappen i Arduino IDE og vent noen sekunder mens koden kompileres og lastes opp til brettet ditt.
5. Vent på meldingen «Fullført med opplasting».

Finne ESP IP-adressen
Etter at du har lastet opp koden, åpner du seriemonitoren med en overføringshastighet på 115200.Trykk på ESP32 EN-knappen (tilbakestill). ESP32 kobler til Wi-Fi, og sender ut ESP IP-adressen på seriemonitoren. Kopier den IP-adressen, fordi du trenger den for å få tilgang til ESP32 web server.Få tilgang til Web Server
For å få tilgang til web server, åpne nettleseren din, lim inn ESP32 IP-adressen, og du vil se følgende side.
Note: Nettleseren din og ESP32 skal være koblet til samme LAN.Hvis du tar en titt på den serielle monitoren, kan du se hva som skjer i bakgrunnen. ESP-en mottar en HTTP-forespørsel fra en ny klient (i dette tilfellet nettleseren din).Du kan også se annen informasjon om HTTP-forespørselen.
Demonstrasjon
Nå kan du teste om din web serveren fungerer som den skal. Klikk på knappene for å kontrollere lysdiodene.Samtidig kan du ta en titt på Serial Monitor for å se hva som skjer i bakgrunnen. For eksample, når du klikker på knappen for å slå PÅ GPIO 26, mottar ESP32 en forespørsel på /26/on URL.Når ESP32 mottar den forespørselen, slår den lysdioden som er koblet til GPIO 26 PÅ og oppdaterer statusen på web side.Knappen for GPIO 27 fungerer på lignende måte. Test at den fungerer som den skal.

Hvordan koden fungerer

I denne delen vil vi se nærmere på koden for å se hvordan den fungerer.
Det første du må gjøre er å inkludere WiFi-biblioteket.Som nevnt tidligere, må du sette inn ssid og passord i de følgende linjene i de doble anførselstegnene.Deretter setter du din web server til port 80.Følgende linje oppretter en variabel for å lagre overskriften til HTTP-forespørselen:Deretter oppretter du hjelpevariabler for å lagre den nåværende tilstanden til utgangene dine. Hvis du vil legge til flere utdata og lagre tilstanden, må du opprette flere variabler.Du må også tilordne en GPIO til hver av utgangene dine. Her bruker vi GPIO 26 og GPIO 27. Du kan bruke alle andre passende GPIOer.oppsett()
La oss nå gå inn i oppsettet(). Først starter vi en seriell kommunikasjon med en overføringshastighet på 115200 for feilsøkingsformål.Du definerer også GPIOene dine som OUTPUT-er og setter dem til LAV.Følgende linjer starter Wi-Fi-tilkoblingen med WiFi.begin(ssid, passord), vent på en vellykket tilkobling og skriv ut ESP IP-adressen i seriemonitoren.loop()
I loop() programmerer vi hva som skjer når en ny klient etablerer en forbindelse med web server.
ESP32 lytter alltid etter innkommende klienter med følgende linje:Når en forespørsel mottas fra en klient, lagrer vi innkommende data. While-løkken som følger vil kjøre så lenge klienten forblir tilkoblet. Vi anbefaler ikke å endre følgende del av koden med mindre du vet nøyaktig hva du gjør.Den neste delen av if and else-setningene sjekker hvilken knapp som ble trykket på i din web side, og kontrollerer utgangene deretter. Som vi har sett tidligere, sender vi en forespørsel om forskjellige URLs avhengig av knappen som trykkes.For eksample, hvis du har trykket på GPIO 26 ON-knappen, mottar ESP32 en forespørsel på /26/ON URL (vi kan se den informasjonen på HTTP-overskriften på seriellmonitoren). Så vi kan sjekke om overskriften inneholder uttrykket GET /26/on. Hvis den inneholder, endrer vi output26state-variabelen til ON, og ESP32 slår på LED-en.
Dette fungerer på samme måte for de andre knappene. Så hvis du vil legge til flere utganger, bør du endre denne delen av koden for å inkludere dem.
Viser HTML web side
Det neste du må gjøre er å lage web side. ESP32 vil sende et svar til nettleseren din med litt HTML-kode for å bygge web side.
De web siden sendes til klienten ved å bruke dette uttrykket client.println(). Du bør legge inn det du vil sende til klienten som argument.
Det første vi bør sende er alltid følgende linje, som indikerer at vi sender HTML.Deretter gjør den følgende linjen web side responsiv i enhver web nettleser.Og følgende brukes for å forhindre forespørsler på favorittikonet. – Du trenger ikke bekymre deg for denne linjen.

Styling av Web Side

Deretter har vi litt CSS-tekst for å style knappene og web sideutseende.
Vi velger Helvetica-fonten, definerer innholdet som skal vises som en blokk og justeres i midten.Vi styler knappene våre med #4CAF50-fargen, uten kant, tekst i hvit farge, og med denne polstringen: 16px 40px. Vi setter også tekstdekorasjonen til ingen, definerer skriftstørrelsen, margen og markøren til en peker.Vi definerer også stilen for en annen knapp, med alle egenskapene til knappen vi har definert tidligere, men med en annen farge. Dette vil være stilen for av-knappen.

Innstilling av Web Side første overskrift
I neste linje kan du angi den første overskriften til din web side. Her har vi "ESP32 Web Server", men du kan endre denne teksten til hva du vil.Viser knappene og tilsvarende tilstand
Deretter skriver du et avsnitt for å vise gjeldende status for GPIO 26. Som du kan se bruker vi output26State-variabelen, slik at tilstanden oppdateres umiddelbart når denne variabelen endres.Deretter viser vi på- eller av-knappen, avhengig av gjeldende tilstand til GPIO. Hvis gjeldende tilstand for GPIO er av, viser vi PÅ-knappen, hvis ikke, viser vi AV-knappen.Vi bruker samme prosedyre for GPIO 27.
Lukke tilkoblingen
Til slutt, når svaret avsluttes, sletter vi header-variabelen, og stopper forbindelsen med klienten med client.stop().

Innpakning

I denne opplæringen har vi vist deg hvordan du bygger en web server med ESP32. Vi har vist deg en enkel eksample som styrer to lysdioder, men ideen er å erstatte disse lysdiodene med et relé, eller en annen utgang du vil kontrollere.

Project 6 RGB LED Web Server

I dette prosjektet viser vi deg hvordan du fjernstyrer en RGB LED med et ESP32-kort ved hjelp av en web server med en fargevelger.
Prosjekt overview
Før du begynner, la oss se hvordan dette prosjektet fungerer:

• ESP32 web serveren viser en fargevelger.
• Når du velger en farge, sender nettleseren din en forespørsel om en URL som inneholder R-, G- og B-parametrene for den valgte fargen.
• Din ESP32 mottar forespørselen og deler verdien for hver fargeparameter.
• Deretter sender den et PWM-signal med den tilsvarende verdien til GPIO-ene som styrer RGB-LED.

Hvordan fungerer RGB-lysdioder?
I en felles katode RGB LED deler alle tre LED en negativ tilkobling (katode). Alle inkluderte i settet er felles katode RGB.Hvordan lage forskjellige farger?
Med en RGB LED kan du selvfølgelig produsere rødt, grønt og blått lys, og ved å konfigurere intensiteten til hver LED kan du produsere andre farger også.
For eksample, for å produsere rent blått lys, setter du den blå LED-en til høyeste intensitet og den grønne og røde LED-en til den laveste intensiteten. For et hvitt lys, ville du satt alle tre LED-ene til høyeste intensitet.
Blande farger
For å produsere andre farger kan du kombinere de tre fargene i forskjellige intensiteter. For å justere intensiteten til hver LED kan du bruke et PWM-signal.
Fordi LED-ene er veldig nær hverandre, ser øynene våre resultatet av kombinasjonen av farger, i stedet for de tre fargene hver for seg.
For å ha en idé om hvordan du kan kombinere fargene, ta en titt på følgende diagram.
Dette er det enkleste fargeblandingsdiagrammet, men gir deg en ide om hvordan det fungerer og hvordan du produserer forskjellige farger.Deler påkrevd
For dette prosjektet trenger du følgende deler:

• ESP32 DEVKIT V1-kort
• RGB LED
• 3x 220 ohm motstander
• Jumper ledninger
• Brødbrett

SkjematiskKode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)

• Installerer ESP32 Add-on i Arduino IDE

Etter å ha satt sammen kretsen, åpne koden
Project_6_RGB_LED_Web_Server.ino i arduino IDE.
Før du laster opp koden, ikke glem å sette inn nettverkslegitimasjonen din slik at ESP kan koble til ditt lokale nettverk.Hvordan koden fungerer
ESP32-skissen bruker WiFi.h-biblioteket.Følgende linjer definerer strengvariabler for å holde R-, G- og B-parametrene fra forespørselen.De neste fire variablene brukes til å dekode HTTP-forespørselen senere.Lag tre variabler for GPIO-ene som vil kontrollere parametrene for strip R, G og B. I dette tilfellet bruker vi GPIO 13, GPIO 12 og GPIO 14.Disse GPIOene må sende ut PWM-signaler, så vi må konfigurere PWM-egenskapene først. Sett PWM-signalfrekvensen til 5000 Hz. Tilknytt deretter en PWM-kanal for hver fargeOg til slutt, sett oppløsningen til PWM-kanalene til 8-bitI oppsettet(), tilordne PWM-egenskapene til PWM-kanaleneKoble PWM-kanalene til de tilsvarende GPIO-eneFølgende kodedel viser fargevelgeren i din web side og gjør en forespørsel basert på fargen du har valgt.Når du velger en farge, mottar du en forespørsel med følgende format.

Så vi må dele denne strengen for å få R-, G- og B-parametrene. Parametrene lagres i variablene redString, greenString og blueString og kan ha verdier mellom 0 og 255.For å kontrollere stripen med ESP32, bruk ledcWrite()-funksjonen til å generere PWM-signaler med verdiene dekodet fra HTTP forespørsel.Note: lær mer om PWM med ESP32: Project 3 ESP32 PWM (analog utgang)
For å kontrollere stripen med ESP8266 trenger vi bare å bruke
analogWrite()-funksjonen for å generere PWM-signaler med verdiene dekodet fra HTPP-forespørselen.
analogWrite(redPin, redString.toInt());
analogWrite(grønnPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Fordi vi får verdiene i en strengvariabel, må vi konvertere dem til heltall ved å bruke toInt()-metoden.
Demonstrasjon
Etter å ha satt inn nettverkslegitimasjonen, velg riktig kort og COM-port og last opp koden til ESP32. Last opp kodereferansetrinn.
Etter opplasting åpner du den serielle monitoren med en overføringshastighet på 115200 og trykker på ESP Enable/Reset-knappen. Du bør få styrets IP-adresse.Åpne nettleseren og sett inn ESP IP-adressen. Bruk nå fargevelgeren til å velge en farge for RGB LED.
Deretter må du trykke på "Endre farge"-knappen for at fargen skal tre i kraft.For å slå av RGB-LED, velg den svarte fargen.
De sterkeste fargene (øverst i fargevelgeren), er de som vil gi bedre resultater.

Prosjekt 7 ESP32-relé Web Server

Å bruke et relé med ESP32 er en fin måte å fjernstyre AC-husholdningsapparater. Denne opplæringen forklarer hvordan du styrer en relémodul med ESP32.
Vi tar en titt på hvordan en relémodul fungerer, hvordan du kobler reléet til ESP32 og bygger en web server for å fjernstyre et relé.
Vi introduserer reléer
Et relé er en elektrisk drevet bryter og som enhver annen bryter, kan den slås på eller av, la strømmen gå gjennom eller ikke. Den kan styres med lav voltages, som 3.3V levert av ESP32 GPIOs og lar oss kontrollere høy volumtages som 12V, 24V eller nettvoltage (230V i Europa og 120V i USA).På venstre side er det to sett med tre stikkontakter for å koble til høyvolumtages, og pinnene på høyre side (low-voltage) koble til ESP32 GPIOene.
Strømnett Voltage TilkoblingerRelémodulen vist på det forrige bildet har to kontakter, hver med tre kontakter: vanlig (COM), Normally Closed (NC) og Normally Open (NO).

• COM: koble til strømmen du vil kontrollere (nettvoltagog).
• NC (Normalt lukket): den normalt lukkede konfigurasjonen brukes når du vil at releet skal være lukket som standard. NC er COM-pinner koblet til, noe som betyr at strømmen flyter med mindre du sender et signal fra ESP32 til relémodulen for å åpne kretsen og stoppe strømstrømmen.
• NEI (Normalt åpen): den normalt åpne konfigurasjonen fungerer omvendt: det er ingen forbindelse mellom NO- og COM-pinnene, så kretsen er brutt med mindre du sender et signal fra ESP32 om å lukke kretsen.

KontrollpinnerDen lave voltage side har et sett med fire pinner og et sett med tre pinner. Det første settet består av VCC og GND for å slå på modulen, og inngang 1 (IN1) og inngang 2 (IN2) for å kontrollere henholdsvis bunn- og toppreléer.
Hvis relémodulen din bare har én kanal, har du bare én IN-pinne. Hvis du har fire kanaler, har du fire IN-pinner, og så videre.
Signalet du sender til IN-pinnene, avgjør om reléet er aktivt eller ikke. Reléet utløses når inngangen går under ca. 2V. Dette betyr at du har følgende scenarier:

• Normalt lukket konfigurasjon (NC):
• HØYT signal – strømmen flyter
• LAVT signal – strømmen flyter ikke
• Normalt åpen konfigurasjon (NO):
• HØYT signal – strømmen flyter ikke
• LAVT signal – strøm i flyt

Du bør bruke en normalt lukket konfigurasjon når strømmen skal flyte mesteparten av gangene, og du bare ønsker å stoppe den av og til.
Bruk en normalt åpen konfigurasjon når du vil at strømmen skal flyte av og til (f.eksample, slå på alamp iblant).
Valg av strømforsyningDet andre settet med pinner består av GND-, VCC- og JD-VCC-pinner.
JD-VCC-pinnen driver elektromagneten til reléet. Legg merke til at modulen har en jumperhette som forbinder VCC- og JD-VCC-pinnene; den som vises her er gul, men din kan ha en annen farge.
Med jumperhetten på, er VCC- og JD-VCC-pinnene tilkoblet. Det betyr at relé-elektromagneten får strøm direkte fra ESP32-strømpinnen, så relémodulen og ESP32-kretsene er ikke fysisk isolert fra hverandre.
Uten jumperhetten må du sørge for en uavhengig strømkilde for å slå opp reléets elektromagnet gjennom JD-VCC-pinnen. Den konfigurasjonen isolerer reléene fysisk fra ESP32 med modulens innebygde optokobler, som forhindrer skade på ESP32 i tilfelle elektriske pigger.
SkjematiskAdvarsel: Bruk av høy voltagStrømforsyninger kan forårsake alvorlig skade.
Derfor brukes 5 mm LED-er i stedet for høy forsyningsvoltage pærer i forsøket. Hvis du ikke er kjent med nettvoltage spør noen som skal hjelpe deg. Mens du programmerer ESP eller kobler kretsen din, må du sørge for at alt er koblet fra strømnettettage.Installere biblioteket for ESP32
Å bygge dette web server, bruker vi ESPAsyncWebServerbibliotek og AsyncTCP-bibliotek.
Installerer ESPAsyncWebServerbibliotek
Følg de neste trinnene for å installere ESPAsyncWebServer bibliotek:

1. Klikk her for å laste ned ESPAsyncWebServerbibliotek. Det burde du ha
   en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få ESPAsyncWebServer-master-mappe
3. Gi nytt navn til mappen din fra ESPAsyncWebServer-master til ESPAsyncWebServer
4. Flytt ESPAsyncWebServermappen til mappen Arduino IDE-installasjonsbiblioteker

Alternativt, i din Arduino IDE, kan du gå til Sketch > Inkluder
Bibliotek > Legg til .ZIP-bibliotek... og velg biblioteket du nettopp har lastet ned.
Installere AsyncTCP-biblioteket for ESP32
De ESPAsyncWebServer biblioteket krever AsyncTCP biblioteket for å jobbe. Følge
de neste trinnene for å installere det biblioteket:

1. Klikk her for å laste ned AsyncTCP-biblioteket. Du bør ha en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få AsyncTCP-master-mappen
   1. Gi nytt navn til mappen din fra AsyncTCP-master til AsyncTCP
   3. Flytt AsyncTCP-mappen til mappen med Arduino IDE-installasjonsbiblioteker
   4. Åpne til slutt Arduino IDE på nytt

Alternativt, i din Arduino IDE, kan du gå til Sketch > Inkluder
Bibliotek > Legg til .ZIP-bibliotek... og velg biblioteket du nettopp har lastet ned.
Kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Etter å ha installert de nødvendige bibliotekene, åpne koden Project_7_ESP32_Relay_Web_Server.ino i arduino IDE.
Før du laster opp koden, ikke glem å sette inn nettverkslegitimasjonen din slik at ESP kan koble til ditt lokale nettverk.Demonstrasjon
Etter å ha gjort de nødvendige endringene, last opp koden til ESP32. Last opp kodereferansetrinn.
Åpne seriellmonitoren med en overføringshastighet på 115200 og trykk på ESP32 EN-knappen for å få IP-adressen. Åpne deretter en nettleser i ditt lokale nettverk og skriv inn ESP32 IP-adressen for å få tilgang til web server.
Åpne seriellmonitoren med en overføringshastighet på 115200 og trykk på ESP32 EN-knappen for å få IP-adressen. Åpne deretter en nettleser i ditt lokale nettverk og skriv inn ESP32 IP-adressen for å få tilgang til web server.Note: Nettleseren din og ESP32 skal være koblet til samme LAN.
Du bør få noe som følger med to knapper som antall releer du har definert i koden din.Nå kan du bruke knappene til å kontrollere reléene dine ved hjelp av smarttelefonen.

Project_8_Output_State_Synchronization_ Web_Server

Dette prosjektet viser hvordan du kontrollerer ESP32- eller ESP8266-utgangene ved hjelp av en web server og en fysisk knapp samtidig. Utgangstilstanden oppdateres på web side om den endres via fysisk knapp eller web server.
Prosjekt overview
La oss ta en rask titt på hvordan prosjektet fungerer.ESP32 eller ESP8266 er vert for en web server som lar deg kontrollere tilstanden til en utgang;

• Gjeldende utgangstilstand vises på web server;
• ESP er også koblet til en fysisk trykknapp som styrer samme utgang;
• Hvis du endrer utgangstilstanden ved hjelp av den fysiske trykkknappen, oppdateres dens nåværende tilstand også på web server.

Oppsummert lar dette prosjektet deg kontrollere den samme utgangen ved å bruke en web server og en trykknapp samtidig. Når utgangstilstanden endres, vil web serveren er oppdatert.
Deler påkrevd
Her er en liste over delene du trenger for å bygge kretsen:

• ESP32 DEVKIT V1-kort
• 5 mm LED
• 220Ohm motstand
• Push
• 10k ohm motstand
• Brødbrett
• Jumper ledninger

SkjematiskInstallere biblioteket for ESP32
Å bygge dette web server, bruker vi ESPAsyncWebServerbibliotek og AsyncTCP-bibliotek.(Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESPAsyncWebServerbibliotek
Følg de neste trinnene for å installere ESPAsyncWebServerbibliotek:

1. Klikk her for å laste ned ESPAsyncWebServerbibliotek. Det burde du ha
   en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få ESPAsyncWebServer-master-mappe
3. Gi nytt navn til mappen din fra ESPAsyncWebServer-master til ESPAsyncWebServer
4. Flytt ESPAsyncWebServermappen til mappen Arduino IDE-installasjonsbiblioteker
   Alternativt, i din Arduino IDE, kan du gå til Sketch > Inkluder
   Bibliotek > Legg til .ZIP-bibliotek... og velg biblioteket du nettopp har lastet ned.

Installere AsyncTCP-biblioteket for ESP32
ESPAsyncWebServerbiblioteket krever at AsyncTCP-biblioteket fungerer. Følg de neste trinnene for å installere det biblioteket:

1. Klikk her for å laste ned AsyncTCP-biblioteket. Du bør ha en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få AsyncTCP-master-mappen
3. Gi nytt navn til mappen din fra AsyncTCP-master til AsyncTCP
4. Flytt AsyncTCP-mappen til mappen Arduino IDE-installasjonsbiblioteker
5. Til slutt, åpne Arduino IDE på nytt
   Alternativt, i din Arduino IDE, kan du gå til Sketch > Inkluder
   Bibliotek > Legg til .ZIP-bibliotek... og velg biblioteket du nettopp har lastet ned.

Kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Etter å ha installert de nødvendige bibliotekene, åpne koden
Project_8_Output_State_Synchronization_Web_Server.ino i arduino IDE.
Før du laster opp koden, ikke glem å sette inn nettverkslegitimasjonen din slik at ESP kan koble til ditt lokale nettverk.

Hvordan koden fungerer

Knappstatus og utdatatilstand
LEDState-variabelen holder LED-utgangstilstanden. Som standard, når web serveren starter, den er LAV.

buttonState og lastButtonState brukes til å oppdage om trykknappen ble trykket eller ikke.Knapp (web server)
Vi inkluderte ikke HTML for å lage knappen på index_html-variabelen.
Det er fordi vi ønsker å kunne endre det avhengig av gjeldende LED-tilstand som også kan endres med trykknappen.
Så vi har laget en plassholder for knappen %BUTTONPLACEHOLDER% som vil bli erstattet med HTML-tekst for å lage knappen senere på koden (dette gjøres i prosessor()-funksjonen).prosessor()
Prosessor()-funksjonen erstatter eventuelle plassholdere i HTML-teksten med faktiske verdier. Først sjekker den om HTML-tekstene inneholder noen
plassholdere %BUTTONPLACEHOLDER%.Deretter kaller du theoutputState()-funksjonen som returnerer gjeldende utdatatilstand. Vi lagrer den i outputStateValue-variabelen.Etter det, bruk den verdien for å lage HTML-teksten for å vise knappen med riktig tilstand:HTTP GET-forespørsel om å endre utdatatilstand (JavaScript)
Når du trykker på knappen, kalles thetoggleCheckbox()-funksjonen. Denne funksjonen vil gjøre en forespørsel på forskjellige URLs for å slå lysdioden på eller av.For å slå på LED, sender den en forespørsel på /update?state=1 URL:Ellers sender den en forespørsel på /update?state=0 URL.
HTTP GET-forespørsel om å oppdatere tilstand (JavaScript)
For å holde utdatatilstanden oppdatert på web server, kaller vi følgende funksjon som lager en ny forespørsel på /staten URL hvert sekund.Håndter forespørsler
Deretter må vi håndtere hva som skjer når ESP32 eller ESP8266 mottar forespørsler om disse URLs.
Når en forespørsel mottas på roten /URL, sender vi HTML-siden så vel som prosessoren.Følgende linjer sjekker om du mottok en forespørsel på /update?state=1 eller /update?state=0 URL og endrer ledState tilsvarende.Når en forespørsel er mottatt på /staten URL, sender vi gjeldende utgangstilstand:loop()
I løkken(), vipper vi ut trykknappen og slår lysdioden på eller av avhengig av verdien til ledState variabel.Demonstrasjon
Last opp koden til ESP32-kortet ditt. Last opp kodereferansetrinn.
Deretter åpner du seriemonitoren med en overføringshastighet på 115200. Trykk på den innebygde EN/RST-knappen for å få IP-adressen.Åpne en nettleser på ditt lokale nettverk, og skriv inn ESP IP-adressen. Du bør ha tilgang til web server som vist nedenfor.
Note: Nettleseren din og ESP32 skal være koblet til samme LAN.Du kan slå på knappen på web server for å slå på LED.Du kan også styre samme LED med den fysiske trykknappen. Dens tilstand vil alltid bli oppdatert automatisk på web server.

Prosjekt 9 ESP32 DHT11 Web Server

I dette prosjektet lærer du hvordan du bygger en asynkron ESP32 web server med DHT11 som viser temperatur og fuktighet ved hjelp av Arduino IDE.
Forutsetninger
De web serveren vi bygger oppdaterer avlesningene automatisk uten å måtte oppdatere web side.
Med dette prosjektet lærer du:

• Hvordan lese temperatur og fuktighet fra DHT-sensorer;
• Bygg en asynkron web server som bruker ESPAsyncWebServerbibliotek;
• Oppdater sensoravlesningene automatisk uten å måtte oppdatere web side.

Asynkron Web Server
Å bygge web server vi bruker ESPAsyncWebServerbibliotek som gir en enkel måte å bygge en asynkron web server. Bygge en asynkron web serveren har flere advantages som nevnt på bibliotekets GitHub-side, for eksempel:

• "Håndter mer enn én tilkobling samtidig";
• "Når du sender svaret, er du umiddelbart klar til å håndtere andre tilkoblinger mens serveren tar seg av å sende svaret i bakgrunnen";
• "Enkel malbehandlingsmotor for å håndtere maler";

Deler påkrevd
For å fullføre denne opplæringen trenger du følgende deler:

• ESP32 utviklingskort
• DHT11 modul
• Brødbrett
• Jumper ledninger

SkjematiskInstallere biblioteker
Du må installere et par biblioteker for dette prosjektet:

• De DHT og den Adafruit Unified Sensor Driverbiblioteker for å lese fra DHT-sensoren.
• ESPAsyncWebServer og Asynkron TCP biblioteker for å bygge den asynkrone web server.
  Følg de neste instruksjonene for å installere disse bibliotekene:

Installere DHT-sensorbiblioteket
For å lese fra DHT-sensoren ved å bruke Arduino IDE, må du installere DHT-sensorbibliotek. Følg de neste trinnene for å installere biblioteket.

1. Klikk her for å laste ned DHT-sensorbiblioteket. Du bør ha en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få DHT-sensor-library-master-mappen
3. Gi nytt navn til mappen din fra DHT-sensor-library-master til DHT_sensor
4. Flytt mappen DHT_sensor til mappen med Arduino IDE-installasjonsbiblioteker
5. Til slutt, åpne Arduino IDE på nytt

Installere Adafruit Unified Sensor Driver
Du må også installere Adafruit Unified Sensor Driver-bibliotek å jobbe med DHT-sensoren. Følg de neste trinnene for å installere biblioteket.

1. Klikk her for å laste ned Adafruit Unified Sensor-biblioteket. Du bør ha en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få Adafruit_sensor-master-mappen
3. Gi nytt navn til mappen din fra Adafruit_sensor-master til Adafruit_sensor
4. Flytt Adafruit_sensor-mappen til mappen med Arduino IDE-installasjonsbiblioteker
5. Til slutt, åpne Arduino IDE på nytt

Installerer ESPAsyncWebServerbibliotek

Følg de neste trinnene for å installere ESPAsyncWebServer bibliotek:

1. Klikk her for å laste ned ESPAsyncWebServerbibliotek. Det burde du ha
   en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør
   få ESPAsyncWebServer-master-mappe
3. Gi nytt navn til mappen din fra ESPAsyncWebServer-master til ESPAsyncWebServer
4. Flytt ESPAsyncWebServermappen til mappen Arduino IDE-installasjonsbiblioteker

Installere Async TCP Library for ESP32
De ESPAsyncWebServer biblioteket krever AsyncTCP biblioteket for å jobbe. Følg de neste trinnene for å installere det biblioteket:

1. Klikk her for å laste ned AsyncTCP-biblioteket. Du bør ha en .zip-mappe i nedlastingsmappen
2. Pakk ut .zip-mappen og du bør få AsyncTCP-master-mappen
3. Gi nytt navn til mappen din fra AsyncTCP-master til AsyncTCP
4. Flytt AsyncTCP-mappen til mappen Arduino IDE-installasjonsbiblioteker
5. Til slutt, åpne Arduino IDE på nytt

Kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDE
Etter å ha installert de nødvendige bibliotekene, åpne koden
Project_9_ESP32_DHT11_Web_Server.ino i arduino IDE.
Før du laster opp koden, ikke glem å sette inn nettverkslegitimasjonen din slik at ESP kan koble til ditt lokale nettverk.Hvordan koden fungerer
I de følgende avsnittene vil vi forklare hvordan koden fungerer. Fortsett å lese hvis du vil lære mer eller gå til Demonstrasjon-delen for å se det endelige resultatet.
Importerer biblioteker
Først importerer du de nødvendige bibliotekene. WiFi, ESPAsyncWebServer og ESPAsyncTCP er nødvendig for å bygge web server. Adafruit_Sensor- og DHT-bibliotekene er nødvendige for å lese fra DHT11- eller DHT22-sensorene.Variabledefinisjon
Definer GPIOen som DHT-datapinnen er koblet til. I dette tilfellet er den koblet til GPIO 4.Deretter velger du DHT-sensortypen du bruker. I vår eksample, vi bruker DHT22. Hvis du bruker en annen type, trenger du bare å fjerne kommentaren til sensoren din og kommentere alle de andre.

Instantier et DHT-objekt med typen og pinne vi har definert tidligere.Opprett en AsyncWebServerobjekt på port 80.Les temperatur- og fuktighetsfunksjoner
Vi har laget to funksjoner: en for å lese temperaturen Vi har laget to funksjoner: en for å lese temperaturen (readDHTTemperature()) og den andre for å lese fuktighet (readDHTHumidity()).Å få sensoravlesninger er like enkelt som å bruke Å få sensoravlesninger er like enkelt som å bruke metodene readTemperature() og readHumidity() på dht-objektet.Vi har også en tilstand som returnerer to streker (–) i tilfelle sensoren ikke klarer å få avlesningene.Avlesningene returneres som strengtype. For å konvertere en float til en streng, bruk String()-funksjonenSom standard leser vi temperaturen i Celsius-grader. For å få temperaturen i Fahrenheit-grader, kommenter temperaturen i Celsius og fjern kommentaren til temperaturen i Fahrenheit, slik at du har følgende:Last opp koden
Nå laster du opp koden til din ESP32. Kontroller at du har valgt riktig kort og COM-port. Last opp kodereferansetrinn.
Etter opplasting åpner du den serielle monitoren med en overføringshastighet på 115200. Trykk på ESP32 reset-knappen. ESP32 IP-adressen skal skrives ut i serien følge.Demonstrasjon
Åpne en nettleser og skriv inn ESP32 IP-adressen. Din web serveren skal vise de siste sensoravlesningene.
Note: Nettleseren din og ESP32 skal være koblet til samme LAN.
Legg merke til at temperatur- og fuktighetsavlesningene oppdateres automatisk uten behov for å oppdatere web side.

Project_10_ESP32_OLED_Display

Dette prosjektet viser hvordan du bruker den 0.96 tommers SSD1306 OLED-skjermen med ESP32 ved å bruke Arduino IDE.
Vi introduserer 0.96 tommers OLED-skjerm
De OLED-skjerm som vi skal bruke i denne opplæringen er SSD1306-modellen: en ensfarget 0.96 tommers skjerm med 128×64 piksler som vist i følgende figur.OLED-skjermen krever ikke bakgrunnsbelysning, noe som gir en veldig fin kontrast i mørke omgivelser. I tillegg bruker pikslene bare energi når de er på, så OLED-skjermen bruker mindre strøm sammenlignet med andre skjermer.
Fordi OLED-skjermen bruker I2C-kommunikasjonsprotokoll, er kabling veldig enkelt. Du kan bruke følgende tabell som referanse.

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

SkjematiskInstallerer SSD1306 OLED Library – ESP32
Det er flere tilgjengelige biblioteker for å kontrollere OLED-skjermen med ESP32.
I denne opplæringen bruker vi to Adafruit-biblioteker: Adafruit_SSD1306 bibliotek og Adafruit_GFX-biblioteket.
Følg de neste trinnene for å installere disse bibliotekene.

1. Åpne Arduino IDE og gå til Sketch> Inkluder bibliotek> Administrer biblioteker. Biblioteksjefen skal åpnes.
2. Skriv "SSD1306" i søkeboksen og installer SSD1306-biblioteket fra Adafruit.
3. Etter å ha installert SSD1306-biblioteket fra Adafruit, skriv "GFX" i søkeboksen og installer biblioteket.
4. Etter å ha installert bibliotekene, start Arduino IDE på nytt.

Kode
Etter å ha installert de nødvendige bibliotekene, åpne Project_10_ESP32_OLED_Display.ino i arduino IDE. kode
Vi programmerer ESP32 med Arduino IDE, så sørg for at du har ESP32-tillegget installert før du fortsetter: (Hvis du allerede har gjort dette trinnet, kan du hoppe til neste trinn.)
Installerer ESP32 Add-on i Arduino IDEHvordan koden fungerer
Importerer biblioteker
Først må du importere de nødvendige bibliotekene. Wire-biblioteket for å bruke I2C og Adafruit-bibliotekene for å skrive til skjermen: Adafruit_GFX og Adafruit_SSD1306.Initialiser OLED-skjermen
Deretter definerer du OLED-bredden og -høyden. I denne eksampvi bruker en 128×64 OLED-skjerm. Hvis du bruker andre størrelser, kan du endre det i variablene SCREEN_WIDTH og SCREEN_HEIGHT.Initialiser deretter et visningsobjekt med bredden og høyden definert tidligere med I2C kommunikasjonsprotokoll (&Wire).Parameteren (-1) betyr at OLED-skjermen din ikke har en RESET-pinne. Hvis OLED-skjermen din har en RESET-pin, bør den kobles til en GPIO. I så fall bør du sende GPIO-nummeret som en parameter.
I oppsettet(), initialiser den serielle monitoren med en baud raute på 115200 for feilsøkingsformål.Initialiser OLED-skjermen med start()-metoden som følger:Dette utdraget skriver også ut en melding på seriellskjermen, i tilfelle vi ikke kan koble til skjermen.

Hvis du bruker en annen OLED-skjerm, må du kanskje endre OLED-adressen. I vårt tilfelle er adressen 0x3C.Etter initialisering av skjermen, legg til en forsinkelse på to sekunder, slik at OLED-en har nok tid til å initialisere før du skriver tekst:Tydelig display, angi skriftstørrelse, farge og skriv tekst
Etter initialisering av skjermen, tøm skjermbufferen med clearDisplay()-metoden:

Før du skriver tekst, må du angi tekststørrelse, farge og hvor teksten skal vises i OLED-en.
Angi skriftstørrelsen ved å bruke setTextSize()-metoden:Angi skriftfargen med metoden setTextColor():
WHITE setter hvit skrift og svart bakgrunn.
Definer posisjonen der teksten starter ved å bruke setCursor(x,y)-metoden. I dette tilfellet setter vi teksten til å starte ved (0,0) koordinatene – øverst til venstre.Til slutt kan du sende teksten til skjermen ved å bruke println()-metoden, som følgerDeretter må du kalle opp display()-metoden for å faktisk vise teksten på skjermen.

Adafruit OLED-biblioteket gir nyttige metoder for enkelt å rulle tekst.

• startscrollright(0x00, 0x0F): rull tekst fra venstre til høyre
• startscrollleft(0x00, 0x0F): rull tekst fra høyre til venstre
• startscrolldiagleft(0x00, 0x07): rull tekst fra nedre venstre hjørne til høyre øvre hjørne startscrolldiagleft(0x00, 0x07): rull tekst fra nedre høyre hjørne til venstre øvre hjørne

Last opp koden
Last opp koden til ESP32. Last opp kodereferansetrinn.
Etter å ha lastet opp koden, vil OLED-en vise rulletekst.

Dokumenter / Ressurser

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

Referanser

• Brukerhåndbok