LAFVIN ESP32 Basic Starter Kit מדריך הוראות

חדש ב-ESP32? התחל כאן! ה-ESP32 היא סדרה של מיקרו-בקרי מערכת על שבב (SoC) זולים ובעלי הספק נמוך שפותחו על ידי Espressif הכוללות יכולות אלחוטיות של Wi-Fi ו-Bluetooth ומעבד כפול ליבה. אם אתם מכירים את ה-ESP8266, ה-ESP32 הוא היורש שלו, עמוס בהרבה תכונות חדשות.מפרטי ESP32
אם אתה רוצה להיות קצת יותר טכני וספציפי, אתה יכול להסתכל על המפרטים המפורטים הבאים של ה-ESP32 (מקור: http://esp32.net/)—לפרטים נוספים, בדוק את גיליון הנתונים):

קישוריות אלחוטית WiFi: קצב נתונים של 150.0 Mbps עם HT40
בלוטות': BLE (Bluetooth Low Energy) ו-Bluetooth Classic

מעבד: Tensilica Xtensa Dual-Core 32-bit LX6 מיקרו-מעבד, פועל במהירות 160 או 240 מגה-הרץ
זֵכֶר:

ROM: 448 KB (עבור אתחול ופונקציות ליבה)
SRAM: 520 KB (לנתונים והוראות)

RTC fas SRAM: 8 KB (לאחסון נתונים ומעבד ראשי במהלך אתחול RTC ממצב שינה עמוקה)
SRAM איטי RTC: 8KB (לגישה למעבד משותף במצב שינה עמוקה) eFuse: 1 Kbit (מתוכם 256 סיביות משמשות למערכת (כתובת MAC ותצורת שבב) ו-768 הסיביות הנותרות שמורות ליישומי לקוחות, כולל הצפנת פלאש ומזהה שבב)

פלאש משובץ: פלאש מחובר פנימי דרך IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 ו-SD_DATA_1 ב-ESP32-D2WD ו-ESP32-PICO-D4.

0 MiB (שבבים ESP32-D0WDQ6, ESP32-D0WD ו-ESP32-S0WD)

2 MiB (שבב ESP32-D2WD)
4 MiB (מודול SiP ESP32-PICO-D4)

כוח נמוך: מבטיח שאתה עדיין יכול להשתמש בהמרות ADC, למשלample, במהלך שינה עמוקה.
קלט/פלט היקפי:

ממשק היקפי עם DMA הכולל מגע קיבולי

ADCs (ממיר אנלוגי לדיגיטלי)
DACs (ממיר דיגיטלי לאנלוגי)

I²C (מעגל משולב)
UART (מקלט/משדר אוניברסלי אסינכרוני)

SPI (ממשק היקפי טורי)
I²S (סאונד בין שבבים משולב)

RMII (ממשק מופחת של מדיה עצמאית)
PWM (אפנון רוחב דופק)

בִּטָחוֹן: מאיצי חומרה עבור AES ו-SSL/TLS

לוחות פיתוח ESP32

ESP32 מתייחס לשבב ESP32 החשוף. עם זאת, המונח "ESP32" משמש גם להתייחסות ללוחות פיתוח ESP32. השימוש בשבבים חשופים של ESP32 אינו קל או מעשי, במיוחד בעת למידה, בדיקה ויצירת אב טיפוס. לרוב, תרצה להשתמש בלוח פיתוח ESP32.
אנו נשתמש בלוח ה-ESP32 DEVKIT V1 כהתייחסות. התמונה למטה מציגה את הלוח ESP32 DEVKIT V1, גרסה עם 30 פינים GPIO.מפרטים – ESP32 DEVKIT V1
הטבלה הבאה מציגה סיכום של התכונות והמפרטים של לוח ה-ESP32 DEVKIT V1 DOIT:

מספר ליבות	2 (ליבה כפולה)
Wi-Fi	2.4 GHz עד 150 Mbits/s
בלוטות'	BLE (Bluetooth Low Energy) ו-Bluetooth מדור קודם
אַדְרִיכָלוּת	32 ביטים
תדר שעון	עד 240 מגה-הרץ
אַיִל	512 KB
סיכות	30 (תלוי בדגם)

ציוד היקפי	מגע קיבולי, ADC (ממיר אנלוגי לדיגיטלי), DAC (ממיר דיגיטלי לאנלוגי), 12C (מעגל משולב), UART (מקלט/משדר אוניברסלי אסינכרוני), CAN 2.0 (Netwokr Area Controller), SPI (ממשק היקפי טורי) , 12S (אינטר-IC משולב סאונד), RMII (Reduced Media-Independent Interface), PWM (אפנון רוחב דופק) ועוד.
כפתורים מובנים	כפתורי RESET ו-BOOT
לדים מובנים	LED כחול מובנה המחובר ל-GPIO2; LED אדום מובנה המראה שהלוח מופעל
USB ל- UART לְגַשֵׁר	CP2102

זה מגיע עם ממשק microUSB שבו אתה יכול להשתמש כדי לחבר את הלוח למחשב שלך כדי להעלות קוד או להפעיל מתח.
הוא משתמש בשבב CP2102 (USB ל-UART) כדי לתקשר עם המחשב שלך באמצעות יציאת COM באמצעות ממשק טורי. שבב פופולרי נוסף הוא CH340. בדוק מהו ממיר שבב USB ל-UART בלוח שלך מכיוון שתצטרך להתקין את מנהלי ההתקנים הנדרשים כדי שהמחשב שלך יוכל לתקשר עם הלוח (מידע נוסף על כך בהמשך מדריך זה).
לוח זה מגיע גם עם כפתור RESET (יכול להיות מסומן EN) כדי להפעיל מחדש את הלוח וכפתור BOOT כדי להכניס את הלוח למצב מהבהב (זמין לקבלת קוד). שימו לב שייתכן שבחלק מהלוחות אין כפתור BOOT.
זה מגיע גם עם LED כחול מובנה המחובר באופן פנימי ל-GPIO 2. LED זה שימושי לניפוי באגים כדי לתת פלט פיזי ויזואלי כלשהו. יש גם נורית LED אדומה שנדלקת כאשר אתה מספק חשמל ללוח.ESP32 Pinout
הציוד ההיקפי של ESP32 כולל:

18 ערוצי ממיר אנלוגי לדיגיטלי (ADC).

3 ממשקי SPI
3 ממשקי UART

2 ממשקי I2C
16 ערוצי פלט PWM
2 ממירים דיגיטליים לאנלוגיים (DAC)
2 ממשקי I2S
10 GPIOs חישה קיבוליים

תכונות ה-ADC (ממיר אנלוגי לדיגיטלי) ו-DAC (ממיר דיגיטלי לאנלוגי) מוקצות לפינים סטטיים ספציפיים. עם זאת, אתה יכול להחליט אילו פינים הם UART, I2C, SPI, PWM וכו' - אתה רק צריך להקצות אותם בקוד. זה אפשרי בשל תכונת הריבוי של שבב ESP32.
למרות שאתה יכול להגדיר את מאפייני הפינים בתוכנה, ישנם פינים המוקצים כברירת מחדל כפי שמוצג באיור הבאבנוסף, יש סיכות עם תכונות ספציפיות שהופכות אותן למתאימים או לא לפרויקט מסוים. הטבלה הבאה מציגה באילו פינים הכי כדאי להשתמש ככניסות, יציאות ובאילו אתה צריך להיות זהיר.
ניתן להשתמש בסיכות המסומנות בירוק. אלה המודגשים בצהוב הם בסדר לשימוש, אבל אתה צריך לשים לב כי ייתכן שיש להם התנהגות בלתי צפויה בעיקר באתחול. לא מומלץ להשתמש בפינים המסומנים באדום ככניסות או יציאות.

GP IO	קֶלֶט	תְפוּקָה	הערות
0	משך למעלה	OK	מוציא אות PWM באתחול, חייב להיות נמוך כדי להיכנס למצב מהבהב
1	סיכת TX	OK	ניפוי באגים בעת האתחול
2	OK	OK	מחובר ל-LED המובנה, יש להשאירו צף או נמוך כדי להיכנס למצב מהבהב
3	OK	סיכת RX	גבוה באתחול
4	OK	OK
5	OK	OK	מוציא אות PWM באתחול, סיכת רצועה
12	OK	OK	האתחול נכשל אם נמשך גבוה, סיכת רצועה
13	OK	OK
14	OK	OK	מוציא אות PWM באתחול
15	OK	OK	מוציא אות PWM באתחול, סיכת רצועה

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		קלט בלבד
35	OK		קלט בלבד
36	OK		קלט בלבד
39	OK		קלט בלבד

המשך לקרוא לקבלת פירוט וניתוח מעמיק יותר של ה-ESP32 GPIOs ופונקציותיו.
הזן פינים בלבד
GPIOs 34 עד 39 הם GPIs - קלט רק פינים. לפינים אלה אין נגדים פנימיים למשיכה או משיכה. לא ניתן להשתמש בהם כמוצאים, אז השתמש בפינים אלה רק ככניסות:

GPIO 34
GPIO 35
GPIO 36
GPIO 39

פלאש SPI משולב ב-ESP-WROOM-32
GPIO 6 עד GPIO 11 נחשפים בחלק מלוחות הפיתוח של ESP32. עם זאת, פינים אלו מחוברים לפלאש SPI המשולב בשבב ESP-WROOM-32 ואינם מומלצים לשימושים אחרים. לכן, אל תשתמש בפינים האלה בפרויקטים שלך:

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

GPIO 11 (CSC/CMD)

GPIOs למגע קיבולי
ל-ESP32 יש 10 חיישני מגע קיבוליים פנימיים. אלה יכולים לחוש וריאציות בכל דבר שמחזיק מטען חשמלי, כמו העור האנושי. כך שהם יכולים לזהות וריאציות הנגרמות כאשר נוגעים ב-GPIOs באצבע. ניתן לשלב פינים אלו בקלות ברפידות קיבוליות ולהחליף לחצנים מכניים. ניתן להשתמש בפיני המגע הקיבוליים גם כדי להעיר את ה-ESP32 משינה עמוקה. חיישני המגע הפנימיים האלה מחוברים ל-GPIOs האלה:

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)

ממיר אנלוגי לדיגיטלי (ADC)
ל-ESP32 יש 18 x 12 סיביות ADC ערוצי קלט (בעוד ל-ESP8266 יש רק 1x 10 סיביות ADC). אלה הם ה-GPIOs שיכולים לשמש כ-ADC וערוצים בהתאמה:

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)

פֶּתֶק: לא ניתן להשתמש בפינים ADC2 כאשר נעשה שימוש ב-Wi-Fi. לכן, אם אתה משתמש ב-Wi-Fi ואתה מתקשה לקבל את הערך מ-ADC2 GPIO, אתה יכול לשקול להשתמש במקום זאת ב-ADC1 GPIO. זה אמור לפתור את הבעיה שלך.
לערוצי קלט ה-ADC יש רזולוציה של 12 סיביות. זה אומר שאתה יכול לקבל קריאות אנלוגיות הנעות בין 0 ל-4095, שבהן 0 מתאים ל-0V ו-4095 ל-3.3V. אתה יכול גם להגדיר את הרזולוציה של הערוצים שלך בקוד ובטווח ה-ADC.
לפיני ESP32 ADC אין התנהגות ליניארית. סביר להניח שלא תצליחו להבחין בין 0 ל-0.1V, או בין 3.2 ל-3.3V. אתה צריך לזכור את זה בעת שימוש בפינים ADC. תקבל התנהגות דומה לזו המוצגת באיור הבא.ממיר דיגיטלי לאנלוגי (DAC)
ישנם 2 על 8 סיביות DAC ב-ESP32 להמרת אותות דיגיטליים לנפח אנלוגיtagיציאות אות e. אלו הם ערוצי ה-DAC:

DAC1 (GPIO25)

DAC2 (GPIO26)

RTC GPIOs
יש תמיכה ב-RTC GPIO ב-ESP32. ניתן להשתמש ב-GPIOs המנותבים אל תת-מערכת RTC בצריכת חשמל נמוכה כאשר ה-ESP32 נמצא בשינה עמוקה. ניתן להשתמש ב-RTC GPIOs אלה כדי להעיר את ה-ESP32 משינה עמוקה כשה-Ultra Low
מעבד משותף כוח (ULP) פועל. ניתן להשתמש ב-GPIOs הבאים כמקור התעוררות חיצוני.

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 יש 16 ערוצים עצמאיים שניתן להגדיר ליצירת אותות PWM בעלי מאפיינים שונים. כל הפינים שיכולים לשמש כמוצאים יכולים לשמש בתור פיני PWM (GPIO 34 עד 39 לא יכולים ליצור PWM).
כדי להגדיר אות PWM, עליך להגדיר את הפרמטרים הבאים בקוד:

תדר האות;
מחזור חובה;

ערוץ PWM;
GPIO שבו אתה רוצה להוציא את האות.

I2C
ל-ESP32 שני ערוצי I2C וניתן להגדיר כל פין כ-SDA או SCL. בעת שימוש ב-ESP32 עם Arduino IDE, פיני ברירת המחדל של I2C הם:

GPIO 21 (SDA)
GPIO 22 (SCL)

אם אתה רוצה להשתמש בפינים אחרים בעת השימוש בספריית החוטים, אתה רק צריך להתקשר:
Wire.begin(SDA, SCL);
SPI
כברירת מחדל, מיפוי הפינים עבור SPI הוא:

SPI	MOSI	מיסו	CLK	CS
VSPI	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

מפריע
ניתן להגדיר את כל ה-GPIO כפסיקות.
סיכות רצועות
לשבב ESP32 יש את פיני החגורה הבאים:

GPIO 0 (חייב להיות נמוך כדי להיכנס למצב אתחול)
GPIO 2 (חייב להיות צף או נמוך במהלך האתחול)

GPIO 4
GPIO 5 (חייב להיות גבוה במהלך האתחול)
GPIO 12 (חייב להיות נמוך במהלך האתחול)

GPIO 15 (חייב להיות גבוה במהלך האתחול)

אלה משמשים להכנסת ה-ESP32 למצב אתחול או מהבהב. ברוב לוחות הפיתוח עם USB/טורי מובנה, אינך צריך לדאוג לגבי מצב הפינים הללו. הלוח שם את הפינים במצב הנכון עבור מהבהב או מצב אתחול. מידע נוסף על בחירת מצב האתחול של ESP32 ניתן למצוא כאן.
עם זאת, אם יש לך ציוד היקפי המחובר לפינים האלה, ייתכן שתתקל בבעיות בניסיון להעלות קוד חדש, להבהב את ה-ESP32 עם קושחה חדשה או לאפס את הלוח. אם יש לך כמה ציוד היקפי המחובר לסיכות הרצועה ואתה מתקשה להעלות קוד או להבהב את ה-ESP32, ייתכן שזה בגלל שציוד היקפי זה מונע מה-ESP32 להיכנס למצב הנכון. קרא את התיעוד של בחירת מצב אתחול כדי להדריך אותך בכיוון הנכון. לאחר איפוס, מהבהב או אתחול, הפינים הללו פועלים כצפוי.
סיכות HIGH באתחול
חלק מה-GPIO משנים את מצבם ל-HIGH או מוציאים אותות PWM באתחול או באיפוס.
משמעות הדבר היא שאם יש לך יציאות המחוברות ל-GPIOs אלה, אתה עלול לקבל תוצאות בלתי צפויות כאשר ה-ESP32 מתאפס או מבצע אתחול.

GPIO 1

GPIO 3
GPIO 5
GPIO 6 עד GPIO 11 (מחובר לזיכרון פלאש משולב ESP32 SPI - לא מומלץ להשתמש).

GPIO 14
GPIO 15

הפעל (EN)
Enable (EN) הוא פין ההפעלה של ווסת ה-3.3V. הוא משוך למעלה, אז חבר לאדמה כדי להשבית את הרגולטור 3.3V. זה אומר שאתה יכול להשתמש בפין הזה המחובר לכפתור כדי להפעיל מחדש את ה-ESP32 שלך, למשלample.
נמשך זרם GPIO
הזרם המרבי המוחלט שנמשך לכל GPIO הוא 40mA בהתאם לסעיף "תנאי הפעלה מומלצים" בגיליון הנתונים של ESP32.
חיישן אפקט הול מובנה ESP32
ה-ESP32 כולל גם חיישן אפקט הול מובנה המזהה שינויים בשדה המגנטי בסביבתו
ESP32 Arduino IDE
יש תוסף ל-Arduino IDE המאפשר לך לתכנת את ה-ESP32 באמצעות ה-Arduino IDE ושפת התכנות שלו. במדריך זה נראה לך כיצד להתקין את לוח ה-ESP32 ב-Arduino IDE בין אם אתה משתמש ב-Windows, Mac OS X או Linux.
דרישות מוקדמות: Arduino IDE מותקן
לפני התחלת הליך התקנה זה, עליך להתקין את Arduino IDE במחשב שלך. ישנן שתי גרסאות של Arduino IDE שאתה יכול להתקין: גרסה 1 וגרסה 2.
אתה יכול להוריד ולהתקין את Arduino IDE על ידי לחיצה על הקישור הבא: arduino.cc/en/Main/Software
על איזו גרסת Arduino IDE אנחנו ממליצים? כרגע יש כאלה plugins עבור ESP32 (כמו SPIFFS FileSystem Uploader Plugin) שעדיין אינם נתמכים ב-Arduino 2. לכן, אם אתה מתכוון להשתמש בתוסף SPIFFS בעתיד, אנו ממליצים להתקין את הגרסה הישנה 1.8.X. אתה רק צריך לגלול למטה בדף תוכנת Arduino כדי למצוא אותו.
התקנת תוסף ESP32 ב- Arduino IDE
כדי להתקין את לוח ה-ESP32 ב-Arduino IDE שלך, בצע את ההוראות הבאות:

ב-Arduino IDE שלך, עבור אל File> העדפות
הזן את הפרטים הבאים ל"מנהל מועצות נוסף URLשדה s":

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
לאחר מכן, לחץ על כפתור "אישור":פֶּתֶק: אם כבר יש לך את לוחות ה-ESP8266 URL, אתה יכול להפריד את URLs עם פסיק כדלקמן:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
פתח את מנהל הלוחות. עבור אל כלים > לוח > מנהל לוחות...חפש ESP32 and press install button for the “ESP32 by Espressif Systems“:זהו. יש להתקין אותו לאחר מספר שניות.

העלה קוד בדיקה

חבר את לוח ה-ESP32 למחשב שלך. כאשר Arduino IDE פתוח, בצע את השלבים הבאים:

בחר את הלוח שלך בתפריט כלים > לוח (במקרה שלי זה מודול ה-ESP32 DEV)
בחר את היציאה (אם אינך רואה את יציאת ה-COM ב-Arduino IDE שלך, עליך להתקין את מנהלי ההתקן של CP210x USB ל-UART Bridge VCP):

פתח את הדוגמה הבאהampלה מתחת File > דוגמהamples > WiFi
(ESP32) > WiFiScan
סקיצה חדשה נפתחת ב-Arduino IDE שלך:
לחץ על כפתור העלאה ב- Arduino IDE. המתן מספר שניות בזמן שהקוד יתחבר ויעלה ללוח שלך.

אם הכל הלך כמצופה, אתה אמור לראות את ההודעה "סיום ההעלאה". הוֹדָעָה.
פתח את הצג הטורי של Arduino IDE בקצב הבאוד של 115200:
לחץ על לחצן ההפעלה המובנה של ESP32 ואתה אמור לראות את הרשתות הזמינות ליד ה-ESP32 שלך:

פתרון בעיות

אם תנסה להעלות סקיצה חדשה ל-ESP32 שלך ואתה מקבל את הודעת השגיאה הזו "התרחשה שגיאה קטלנית: נכשל בחיבור ל-ESP32: תם הזמן הקצוב... מתחבר...". זה אומר שה-ESP32 שלך אינו במצב מהבהב/טעינה.
לאחר בחירת שם הלוח וה-COM הנכונים, בצע את השלבים הבאים:
החזק את הלחצן "BOOT" בלוח ה-ESP32 שלך

לחץ על כפתור "העלה" ב-Arduino IDE כדי להעלות את הסקיצה שלך:
לאחר שתראה את "מתחבר...." הודעה ב-Arduino IDE שלך, שחרר את האצבע מכפתור "BOOT":

לאחר מכן, אתה אמור לראות את ההודעה "סיום ההעלאה".
זהו. הסקיצה החדשה אמורה לפעול ב-ESP32 שלך. לחץ על הלחצן "EnABLE" כדי להפעיל מחדש את ה-ESP32 ולהפעיל את הסקיצה החדשה שהועלתה.
תצטרך גם לחזור על רצף הכפתורים הזה בכל פעם שתרצה להעלות סקיצה חדשה.

Project 1 ESP32 כניסות פלטים

במדריך זה לתחילת העבודה תלמד כיצד לקרוא כניסות דיגיטליות כמו מתג כפתור ולשלוט ביציאות דיגיטליות כמו LED באמצעות ה-ESP32 עם Arduino IDE.
דרישות מוקדמות
נתכנת את ה-ESP32 באמצעות Arduino IDE. לכן, ודא שהתוסף של לוחות ESP32 מותקן לפני שתמשיך:

התקנת תוסף ESP32 ב- Arduino IDE

ESP32 שליטה ביציאות דיגיטליות
ראשית, עליך להגדיר את ה-GPIO שברצונך לשלוט בו כ-OUTPUT. השתמש בפונקציה pinMode() באופן הבא:
pinMode(GPIO, OUTPUT);
כדי לשלוט בפלט דיגיטלי אתה רק צריך להשתמש בפונקציה digitalWrite() שמקבלת כארגומנטים, את ה-GPIO (מספר int) שאליו אתה מתייחס, ואת המצב, HIGH או LOW.
digitalWrite(GPIO, STATE);
כל ה-GPIOs יכולים לשמש כיציאות מלבד GPIOs 6 עד 11 (מחוברים לפלאש SPI המשולב) ו-GPIOs 34, 35, 36 ו-39 (כניסות GPIO בלבד);
למידע נוסף על ESP32 GPIOs: ESP32 GPIO Reference Guide
ESP32 קריאת כניסות דיגיטליות
ראשית, הגדר את ה-GPIO שברצונך לקרוא כ-INPUT, באמצעות הפונקציה pinMode() באופן הבא:
pinMode(GPIO, INPUT);
כדי לקרוא קלט דיגיטלי, כמו כפתור, אתה משתמש בפונקציה digitalRead(), שמקבלת כארגומנט, את ה-GPIO (מספר int) שאליו אתה מתייחס.
digitalRead(GPIO);
ניתן להשתמש בכל ה- ESP32 GPIOs ככניסות, למעט GPIOs 6 עד 11 (מחוברים לפלאש SPI המשולב).
למידע נוסף על ESP32 GPIOs: ESP32 GPIO Reference Guide
פרויקט אקסample
כדי להראות לך כיצד להשתמש בכניסות דיגיטליות וביציאות דיגיטליות, נבנה פרויקט פשוט לדוגמהample עם כפתור ונורית LED. נקרא את מצב הכפתור ונדליק את ה-LED בהתאם כפי שמוצג באיור הבא.

חלקים נדרשים
הנה רשימה של החלקים שאתה צריך כדי לבנות את המעגל:

ESP32 DEVKIT V1

LED 5 מ"מ
נגד 220 אוהם
לחץ על הכפתור

נגד 10k אוהם
קרש לחם
חוטי מגשר

תרשים סכמטי
לפני שתמשיך, אתה צריך להרכיב מעגל עם LED וכפתור.
נחבר את ה-LED ל-GPIO 5 ואת הכפתור ל-GPIO 4.קוד
פתח את הקוד Project_1_ESP32_Inputs_Outputs.ino ב-arduino IDEאיך הקוד עובד
בשתי השורות הבאות, אתה יוצר משתנים להקצאת סיכות:

הכפתור מחובר ל-GPIO 4 וה-LED מחובר ל-GPIO 5. בשימוש ב-Arduino IDE עם ה-ESP32, 4 מתאים ל-GPIO 4 ו-5 מתאים ל-GPIO 5.
לאחר מכן, אתה יוצר משתנה כדי להחזיק את מצב הכפתור. כברירת מחדל, זה 0 (לא לחוץ).
int buttonState = 0;
ב-setup(), אתה מאתחל את הכפתור כ-INPUT, ואת הנורית כ-OUTPUT.
לשם כך, אתה משתמש בפונקציה pinMode() שמקבלת את הפין שאליו אתה מתייחס, ובמצב: INPUT או OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
בלולאה() זה המקום שבו אתה קורא את מצב הכפתור ומגדיר את ה-LED בהתאם.
בשורה הבאה, אתה קורא את מצב הכפתור ושומר אותו במשתנה buttonState.
כפי שראינו בעבר, אתה משתמש בפונקציה digitalRead() .
buttonState = digitalRead(buttonPin);
הצהרת if הבא, בודקת אם מצב הכפתור הוא HIGH. אם כן, הוא מדליק את ה-LED באמצעות הפונקציה digitalWrite() שמקבלת כארגומנט את ledPin ואת המצב HIGH.
if (buttonState == HIGH)אם מצב הכפתור אינו HIGH, אתה מכבה את הנורית. פשוט הגדר את LOW כארגומנט שני בפונקציה digitalWrite() .העלאת הקוד
לפני לחיצה על כפתור ההעלאה, עבור אל כלים > לוח, ובחר את הלוח :DOIT ESP32 DEVKIT V1.
עבור אל כלים > יציאה ובחר את יציאת ה-COM שאליה מחובר ה-ESP32. לאחר מכן, לחץ על כפתור ההעלאה והמתן להודעת "סיום ההעלאה".הערה: אם אתה רואה הרבה נקודות (מתחברות...__...__) בחלון איתור הבאגים וההודעה "נכשל בחיבור ל-ESP32: הזמן הקצוב בהמתנה לכותרת מנות", זה אומר שעליך ללחוץ על ה-BOOT המובנה ב-ESP32 כפתור אחרי הנקודות
להתחיל להופיע. פתרון בעיות

הַפגָנָה

לאחר העלאת הקוד, בדוק את המעגל שלך. LED שלך אמור להידלק כאשר אתה לוחץ על הכפתור:וכבה כשתשחרר אותו:

Project 2 ESP32 כניסות אנלוגיות

פרויקט זה מראה כיצד לקרוא כניסות אנלוגיות עם ה-ESP32 באמצעות Arduino IDE.
קריאה אנלוגית שימושית לקריאת ערכים מנגדים משתנים כמו פוטנציומטרים או חיישנים אנלוגיים.
כניסות אנלוגיות (ADC)
קריאת ערך אנלוגי עם ה-ESP32 פירושה שאתה יכול למדוד נפח משתנהtage רמות בין 0 V ל-3.3 V.
כרךtage הנמדד מוקצה לאחר מכן לערך שבין 0 ל-4095, שבו 0 V מתאים ל-0, ו-3.3 V מתאים ל-4095. כל כרךtage בין 0 V ל-3.3 V יקבל את הערך המתאים ביניהם.ADC הוא לא ליניארי
באופן אידיאלי, אתה מצפה להתנהגות ליניארית בעת שימוש בפינים של ESP32 ADC.
עם זאת, זה לא קורה. מה שתקבל הוא התנהגות כפי שמוצגת בתרשים הבא:התנהגות זו פירושה שה-ESP32 שלך אינו מסוגל להבחין בין 3.3 וולט ל-3.2 וולט.
תקבל אותו ערך עבור שני כרךtages: 4095.
אותו דבר קורה לוול נמוך מאודtagערכי e: עבור 0 V ו-0.1 V תקבל את אותו ערך: 0. עליך לזכור זאת בעת שימוש בפינים ESP32 ADC.
AnalogRead() פונקציה
קריאת קלט אנלוגי עם ESP32 באמצעות Arduino IDE היא פשוטה כמו שימוש בפונקציה analogRead() . הוא מקבל כטיעון, את ה-GPIO שאתה רוצה לקרוא:
analogRead(GPIO);
רק 15 זמינים ב-DEVKIT V1board (גרסה עם 30 GPIOs).
תפוס את ה-pinout של לוח ה-ESP32 שלך ואתר את פיני ה-ADC. אלה מסומנים עם גבול אדום באיור למטה.לסיכות הקלט האנלוגיות הללו יש רזולוציה של 12 סיביות. משמעות הדבר היא שכאשר אתה קורא קלט אנלוגי, הטווח שלו עשוי להשתנות בין 0 ל-4095.
הערה: לא ניתן להשתמש בסיכות ADC2 כאשר נעשה שימוש ב-Wi-Fi. לכן, אם אתה משתמש ב-Wi-Fi ואתה מתקשה לקבל את הערך מ-ADC2 GPIO, אתה יכול לשקול להשתמש במקום זאת ב-ADC1 GPIO, זה אמור לפתור את הבעיה שלך.
כדי לראות איך הכל מתקשר ביחד, ניצור אקס פשוטample לקרוא ערך אנלוגי מפוטנציומטר.
חלקים נדרשים
עבור האקסית הזוample, אתה צריך את החלקים הבאים:

לוח ESP32 DEVKIT V1
פוטנציומטר

קרש לחם
חוטי מגשר

סכימתי
חבר פוטנציומטר ל-ESP32 שלך. יש לחבר את הפין האמצעי של הפוטנציומטר ל-GPIO 4. אתה יכול להשתמש בתרשים הסכמטי הבא בתור התייחסות.קוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
פתח את הקוד Project_2_ESP32_Inputs_Outputs.ino ב-arduino IDEקוד זה פשוט קורא את הערכים מהפוטנציומטר ומדפיס את הערכים הללו בצג הטורי.
בקוד מתחילים בהגדרת ה-GPIO אליו מחובר הפוטנציומטר. באקס זהample, GPIO 4.ב-setup(), אתחול תקשורת טורית בקצב שידור של 115200.בלולאה(), השתמשו בפונקציה analogRead() כדי לקרוא את הקלט האנלוגי מה-potPin.לבסוף, הדפס את הערכים שנקראו מהפוטנציומטר בצג הטורי.העלה את הקוד שסופק ל-ESP32 שלך. ודא שבחרתם את הלוח הנכונים ויציאת ה-COM בתפריט כלים.
בודקים את האקסample
לאחר העלאת הקוד ולחיצה על כפתור האיפוס של ESP32, פתח את המוניטור הטורי בקצב הבאוד של 115200. סובב את הפוטנציומטר וראה את הערכים משתנים.הערך המקסימלי שתקבל הוא 4095 והערך המינימלי הוא 0.

מסכם

במאמר זה למדת כיצד לקרוא כניסות אנלוגיות באמצעות ה-ESP32 עם Arduino IDE. לסיכום:

ללוח ESP32 DEVKIT V1 DOIT (גרסה עם 30 פינים) יש 15 פינים ADC שבהם אתה יכול להשתמש כדי לקרוא כניסות אנלוגיות.
לפינים אלה רזולוציה של 12 סיביות, מה שאומר שאתה יכול לקבל ערכים מ-0 עד 4095.
כדי לקרוא ערך ב- Arduino IDE, אתה פשוט משתמש בפונקציה analogRead() .
לפיני ESP32 ADC אין התנהגות ליניארית. סביר להניח שלא תצליחו להבחין בין 0 ל-0.1V, או בין 3.2 ל-3.3V. אתה צריך לזכור את זה בעת שימוש בפינים ADC.

Project 3 ESP32 PWM (פלט אנלוגי)

במדריך זה נראה לך כיצד ליצור אותות PWM עם ה-ESP32 באמצעות Arduino IDE. בתור אקסיתampנבנה מעגל פשוט המעמעם נורית באמצעות בקר LED PWM של ה-ESP32.בקר ESP32 LED PWM
ל-ESP32 יש בקר LED PWM עם 16 ערוצים עצמאיים שניתן להגדיר ליצירת אותות PWM בעלי מאפיינים שונים.
להלן השלבים שתצטרכו לבצע כדי לעמעם נורית LED עם PWM באמצעות Arduino IDE:

ראשית, עליך לבחור ערוץ PWM. ישנם 16 ערוצים מ-0 עד 15.
לאחר מכן, עליך להגדיר את תדר האות PWM. עבור LED, תדר של 5000 הרץ מתאים לשימוש.
אתה גם צריך להגדיר את רזולוציית מחזור העבודה של האות: יש לך רזולוציות מ-1 עד 16 סיביות. אנו נשתמש ברזולוציה של 8 סיביות, מה שאומר שאתה יכול לשלוט בבהירות LED באמצעות ערך מ-0 עד 255.
לאחר מכן, עליך לציין לאילו GPIO או GPIOs האות יופיע. לשם כך תשתמש בפונקציה הבאה:
ledcAttachPin(GPIO, ערוץ)
פונקציה זו מקבלת שני ארגומנטים. הראשון הוא ה-GPIO שיוציא את האות, והשני הוא הערוץ שיפיק את האות.
לבסוף, כדי לשלוט בבהירות LED באמצעות PWM, אתה משתמש בפונקציה הבאה:

ledcWrite(ערוץ, מחזור עבודה)
פונקציה זו מקבלת כארגומנטים את הערוץ שיוצר את אות PWM ואת מחזור העבודה.
חלקים נדרשים
כדי לבצע את המדריך הזה אתה צריך את החלקים הבאים:

לוח ESP32 DEVKIT V1
5mm LED
נגד 220 אוהם
קרש לחם
חוטי מגשר

סכימתי
חבר נורית LED ל-ESP32 שלך כמו בתרשים הסכמטי הבא. יש לחבר את הנורית ל-GPIO 4.פֶּתֶק: אתה יכול להשתמש בכל סיכה שאתה רוצה, כל עוד הוא יכול לפעול כפלט. כל הפינים שיכולים לשמש כמוצאים יכולים לשמש פיני PWM. למידע נוסף על ESP32 GPIOs, קרא: ESP32 Pinout Reference: באילו פיני GPIO עליך להשתמש?
קוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
פתח את הקוד Project_3_ESP32_PWM.ino ב-arduino IDEאתה מתחיל בהגדרת הפין שאליו מחובר ה-LED. במקרה זה הנורית מחוברת ל-GPIO 4.לאחר מכן, אתה מגדיר את מאפייני האות PWM. אתה מגדיר תדר של 5000 הרץ, בוחר בערוץ 0 ליצירת האות ומגדיר רזולוציה של 8 ביטים. אתה יכול לבחור מאפיינים אחרים, שונים מאלה, כדי ליצור אותות PWM שונים.ב-setup(), עליך להגדיר את LED PWM עם המאפיינים שהגדרת קודם לכן באמצעות הפונקציה ledcSetup() שמקבלת כארגומנטים, את ledChannel, את התדר והרזולוציה, כדלקמן:לאחר מכן, עליך לבחור את ה-GPIO שממנו תקבל את האות. לשם כך השתמש בפונקציה ledcAttachPin() שמקבלת כארגומנטים את ה-GPIO שבו אתה רוצה לקבל את האות, ואת הערוץ שיוצר את האות. באקס זהample, נקבל את האות ב-ledPin GPIO, שמתאים ל-GPIO 4. הערוץ שיוצר את האות הוא ledChannel, שמתאים לערוץ 0.בלולאה, תשנה את מחזור העבודה בין 0 ל-255 כדי להגביר את בהירות LED.ואז, בין 255 ל-0 כדי להפחית את הבהירות.כדי להגדיר את בהירות ה-LED, אתה רק צריך להשתמש בפונקציה ledcWrite() שמקבלת כארגומנטים את הערוץ שמייצר את האות ואת מחזור העבודה.מכיוון שאנו משתמשים ברזולוציה של 8 סיביות, מחזור העבודה יהיה נשלט באמצעות ערך מ-0 עד 255. שימו לב שבפונקציה ledcWrite() אנו משתמשים בערוץ שיוצר את האות, ולא ב-GPIO.

בודקים את האקסample

העלה את הקוד ל-ESP32 שלך. ודא שבחרתם את הלוח הנכונים ויציאת ה-COM. תסתכל על המעגל שלך. כדאי שיהיה לך LED עמום שמגביר ומקטין את הבהירות.

Project 4 ESP32 PIR תנועה חיישן

פרויקט זה מראה כיצד לזהות תנועה עם ה-ESP32 באמצעות חיישן תנועה PIR. הזמזם ישמיע אזעקה כאשר מזוהה תנועה, ויעצור את האזעקה כאשר לא מזוהה תנועה למשך זמן מוגדר מראש (כגון 4 שניות)
כיצד פועל חיישן תנועה HC-SR501
.עקרון הפעולה של חיישן HC-SR501 מבוסס על שינוי קרינת האינפרא אדום על האובייקט הנע. כדי להיות מזוהה על ידי חיישן HC-SR501, האובייקט חייב לעמוד בשתי דרישות:

האובייקט פולט בדרך האינפרא אדום.
האובייקט זז או רועד

כָּך:
אם חפץ פולט את קרן האינפרא אדום אך אינו זז (למשל, אדם עומד במקום מבלי לזוז), הוא אינו מזוהה על ידי החיישן.
אם חפץ זז אך אינו פולט את קרן האינפרא אדום (למשל רובוט או רכב), הוא אינו מזוהה על ידי החיישן.
היכרות עם טיימרים
באקס זהampנציג גם טיימרים. אנו רוצים שהנורית תישאר דולקת למשך מספר שניות קבוע מראש לאחר זיהוי תנועה. במקום להשתמש בפונקציית delay() שחוסמת את הקוד שלך ולא מאפשרת לך לעשות שום דבר אחר במשך מספר שניות מוגדר, עלינו להשתמש בטיימר.הפונקציה delay()
כדאי להכיר את הפונקציה delay() מכיוון שהיא נמצאת בשימוש נרחב. פונקציה זו די פשוטה לשימוש. הוא מקבל מספר אינט אחד כארגומנט.
מספר זה מייצג את הזמן באלפיות שניות שהתוכנית צריכה לחכות עד שתעבור לשורת הקוד הבאה.כאשר אתה עושה delay (1000) התוכנית שלך נעצרת בקו זה למשך שנייה אחת.
delay() היא פונקציית חסימה. פונקציות חסימה מונעות מתוכנית לעשות כל דבר אחר עד להשלמת משימה מסוימת זו. אם אתה צריך מספר משימות שיתרחשו בו זמנית, לא תוכל להשתמש ב-delay().
עבור רוב הפרויקטים עליך להימנע משימוש בעיכובים ולהשתמש בטיימרים במקום זאת.
הפונקציה millis()
באמצעות פונקציה שנקראת millis() ניתן להחזיר את מספר האלפיות השניות שחלפו מאז תחילת התוכנית.למה הפונקציה הזו שימושית? כי באמצעות קצת מתמטיקה, אתה יכול לאמת בקלות כמה זמן עבר מבלי לחסום את הקוד שלך.
חלקים נדרשים
כדי לעקוב אחר הדרכה זו אתה צריך את החלקים הבאים

לוח ESP32 DEVKIT V1
חיישן תנועה PIR (HC-SR501)
פעיל באזר
חוטי מגשר
קרש לחם

סכימתיפֶּתֶק: כרך העבודהtage של HC-SR501 הוא 5V. השתמש בסיכת Vin כדי להפעיל אותו.
קוד
לפני שתמשיך עם מדריך זה, עליך להתקין את התוסף ESP32 ב-Arduino IDE שלך. עקוב אחר אחד מהמדריכים הבאים כדי להתקין את ה-ESP32 על Arduino IDE, אם עדיין לא עשית זאת. (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
פתח את הקוד Project_4_ESP32_PIR_Motion_Sensor.ino ב-arduino IDE.
הַפגָנָה
העלה את הקוד ללוח ה-ESP32 שלך. ודא שבחרתם את הלוח הנכונים ויציאת ה-COM. העלאת שלבי התייחסות לקוד.
פתח את הצג הטורי בקצב העברת העברת נתונים של 115200.הזז את היד שלך לפני חיישן ה-PIR. הזמזם אמור להידלק, וההודעה מודפסת בצג הטורי האומרת "זוהה תנועה! אזעקת זמזם".
לאחר 4 שניות הזמזם אמור לכבות.

Project 5 ESP32 Switch Web שרת

בפרויקט זה תיצור עצמאי web שרת עם ESP32 השולט ביציאות (שתי נוריות LED) באמצעות סביבת התכנות Arduino IDE. ה web השרת מגיב לנייד וניתן לגשת אליו עם כל מכשיר שכדפדפן ברשת המקומית. אנו נראה לך כיצד ליצור את web שרת וכיצד הקוד עובד שלב אחר שלב.
הפרויקט הסתייםview
לפני שניגשים ישירות לפרויקט, חשוב לתאר מה שלנו web השרת יעשה זאת, כך שיהיה קל יותר לבצע את השלבים בהמשך.

ה web שרת שתבנה שולט על שתי נוריות המחוברות ל-ESP32 GPIO 26 ו-GPIO 27;
אתה יכול לגשת ל-ESP32 web שרת על ידי הקלדת כתובת ה-IP ESP32 בדפדפן ברשת המקומית;
על ידי לחיצה על הכפתורים שלך web שרת אתה יכול לשנות באופן מיידי את המצב של כל LED.

חלקים נדרשים
עבור הדרכה זו תזדקק לחלקים הבאים:

לוח ESP32 DEVKIT V1
LED 2x 5 מ"מ
2x נגד 200 אוהם
קרש לחם
חוטי מגשר

סכימתי
התחל בבניית המעגל. חבר שתי נוריות LED ל-ESP32 כפי שמוצג בתרשים הסכמטי הבא - LED אחד מחובר ל-GPIO 26, והשני ל-GPIO 27.
פֶּתֶק: אנו משתמשים בלוח ESP32 DEVKIT DOIT עם 36 פינים. לפני הרכבת המעגל, ודא שאתה בודק את ה-pinout עבור הלוח שבו אתה משתמש.קוד
כאן אנו מספקים את הקוד שיוצר את ה-ESP32 web שרת. פתח את הקוד Project_5_ESP32_Switch _Web_Server.ino ב-arduino IDE, אך אל תעלה אותו עדיין. אתה צריך לעשות כמה שינויים כדי שזה יעבוד בשבילך.
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
הגדרת אישורי הרשת שלך
עליך לשנות את השורות הבאות עם אישורי הרשת שלך: SSID וסיסמה. לקוד יש הערות טובות לגבי היכן כדאי לבצע את השינויים.העלאת הקוד
כעת, אתה יכול להעלות את הקוד ואת web השרת יעבוד מיד.
בצע את השלבים הבאים כדי להעלות קוד ל-ESP32:

חבר את לוח ה-ESP32 למחשב שלך;
ב-Arduino IDE בחר את הלוח שלך בכלים > לוח (במקרה שלנו אנחנו משתמשים בלוח ESP32 DEVKIT DOIT);
בחר את יציאת ה-COM ב'כלים' > 'יציאה'.
לחץ על כפתור ההעלאה ב-Arduino IDE והמתן מספר שניות בזמן שהקוד יתחבר ויעלה ללוח שלך.
המתן להודעת "סיום ההעלאה".

מציאת כתובת ה-IP של ESP
לאחר העלאת הקוד, פתח את הצג הטורי בקצב העברת העברת נתונים של 115200.לחץ על לחצן ESP32 EN (איפוס). ה-ESP32 מתחבר ל-Wi-Fi, ומוציא את כתובת ה-IP של ESP על הצג הטורי. העתק את כתובת ה-IP הזו, כי אתה צריך אותה כדי לגשת ל-ESP32 web שרת.גישה אל Web שרת
כדי לגשת ל web שרת, פתח את הדפדפן שלך, הדבק את כתובת ה-IP ESP32, ותראה את העמוד הבא.
פֶּתֶק: הדפדפן וה-ESP32 שלך צריכים להיות מחוברים לאותו LAN.אם תסתכל על הצג הטורי, תוכל לראות מה קורה ברקע. ה-ESP מקבל בקשת HTTP מלקוח חדש (במקרה זה, הדפדפן שלך).אתה יכול גם לראות מידע אחר על בקשת ה-HTTP.
הַפגָנָה
עכשיו אתה יכול לבדוק אם שלך web השרת עובד כמו שצריך. לחץ על הכפתורים כדי לשלוט בנורות ה-LED.במקביל, אתה יכול להציץ בצג הטורי כדי לראות מה קורה ברקע. למשלample, כאשר אתה לוחץ על הכפתור כדי להפעיל את GPIO 26, ESP32 מקבל בקשה ב- /26/on URL.כאשר ה-ESP32 מקבל את הבקשה, הוא מדליק את הנורית המחוברת ל-GPIO 26 ומעדכן את מצבו ב- web עַמוּד.הכפתור עבור GPIO 27 פועל בצורה דומה. בדוק שהוא עובד כמו שצריך.

איך הקוד עובד

בחלק זה נסתכל מקרוב על הקוד כדי לראות כיצד הוא עובד.
הדבר הראשון שעליך לעשות הוא לכלול את ספריית ה-WiFi.כפי שהוזכר קודם לכן, עליך להכניס את ה-ssid והסיסמה שלך בשורות הבאות בתוך המירכאות הכפולות.לאחר מכן, אתה קובע את שלך web שרת ליציאה 80.השורה הבאה יוצרת משתנה לאחסון הכותרת של בקשת ה-HTTP:לאחר מכן, אתה יוצר משתני עזר כדי לאחסן את המצב הנוכחי של הפלטים שלך. אם ברצונך להוסיף פלטים נוספים ולשמור את מצבו, עליך ליצור משתנים נוספים.אתה גם צריך להקצות GPIO לכל אחת מהפלטים שלך. כאן אנו משתמשים ב-GPIO 26 ו-GPIO 27. אתה יכול להשתמש בכל GPIO מתאים אחר.setup()
כעת, בוא ניכנס ל-setup(). ראשית, אנו מתחילים תקשורת טורית בקצב שידור של 115200 למטרות איתור באגים.אתה גם מגדיר את ה-GPIO שלך כפלטים ומגדיר אותם ל-LOW.השורות הבאות מתחילות את חיבור ה-Wi-Fi עם WiFi.begin(ssid, סיסמה), המתן לחיבור מוצלח והדפיס את כתובת ה-IP של ESP בצג הטורי.לוּלָאָה()
בלולאה() אנו מתכנתים מה קורה כאשר לקוח חדש יוצר חיבור עם web שרת.
ה-ESP32 תמיד מקשיב ללקוחות נכנסים עם השורה הבאה:כאשר מתקבלת בקשה מלקוח, אנו נשמור את הנתונים הנכנסים. לולאת ה-while שלאחר מכן תפעל כל עוד הלקוח יישאר מחובר. אנו לא ממליצים לשנות את החלק הבא של הקוד אלא אם כן אתה יודע בדיוק מה אתה עושה.הסעיף הבא של הצהרות if and else בודק איזה כפתור נלחץ אצלך web עמוד, ושולט על הפלטים בהתאם. כפי שראינו בעבר, אנו מבקשים בקשה אחרת URLs בהתאם ללחצן שנלחץ.למשלampאם לחצת על כפתור GPIO 26 ON, ה-ESP32 יקבל בקשה ב- /26/ON URL (אנו יכולים לראות את המידע הזה בכותרת HTTP בצג הטורי). אז, נוכל לבדוק אם הכותרת מכילה את הביטוי GET /26/on. אם הוא מכיל, אנו משנים את משתנה output26state ל-ON, וה-ESP32 מדליק את ה-LED.
זה עובד באופן דומה עבור הכפתורים האחרים. לכן, אם אתה רוצה להוסיף פלטים נוספים, עליך לשנות את החלק הזה של הקוד כך שיכלול אותם.
הצגת ה-HTML web עַמוּד
הדבר הבא שאתה צריך לעשות, הוא ליצור את web עַמוּד. ה-ESP32 ישלח תגובה לדפדפן שלך עם קוד HTML כלשהו כדי לבנות את web עַמוּד.
ה web הדף נשלח ללקוח באמצעות ביטוי זה של client.println(). עליך להזין את מה שאתה רוצה לשלוח ללקוח כטיעון.
הדבר הראשון שעלינו לשלוח הוא תמיד השורה הבאה, שמציינת שאנו שולחים HTML.לאחר מכן, השורה הבאה הופכת את web דף מגיב בכל web דפדפן.והדברים הבאים משמשים למניעת בקשות על ה-favicon. - אתה לא צריך לדאוג לגבי הקו הזה.

סטיילינג את Web עַמוּד

לאחר מכן, יש לנו טקסט CSS לסגנון הלחצנים וה- web הופעת העמוד.
אנו בוחרים בגופן Helvetica, מגדירים את התוכן שיוצג כבלוק ויישור במרכז.אנו מעצבים את הכפתורים שלנו עם הצבע #4CAF50, ללא גבול, טקסט בצבע לבן, ועם הריפוד הזה: 16px 40px. אנחנו גם מגדירים את קישוט הטקסט ללא, מגדירים את גודל הגופן, השוליים והסמן למצביע.אנחנו גם מגדירים את הסגנון של כפתור שני, עם כל המאפיינים של הכפתור שהגדרנו קודם, אבל עם צבע אחר. זה יהיה הסגנון של כפתור הכיבוי.

הגדרת ה Web כותרת עמוד ראשון
בשורה הבאה תוכל להגדיר את הכותרת הראשונה שלך web עַמוּד. כאן יש לנו "ESP32 Web שרת", אבל אתה יכול לשנות את הטקסט הזה למה שתרצה.הצגת הכפתורים והמצב המתאים
לאחר מכן, אתה כותב פסקה כדי להציג את המצב הנוכחי של GPIO 26. כפי שאתה יכול לראות אנו משתמשים במשתנה output26State, כך שהמצב מתעדכן באופן מיידי כאשר משתנה זה משתנה.לאחר מכן, אנו מציגים את כפתור ההפעלה או הכיבוי, בהתאם למצב הנוכחי של ה-GPIO. אם המצב הנוכחי של ה-GPIO כבוי, אנו מציגים את כפתור ה-ON, אם לא, אנו מציגים את כפתור ה-OFF.אנו משתמשים באותו הליך עבור GPIO 27.
סגירת החיבור
לבסוף, כאשר התגובה מסתיימת, אנו מנקים את משתנה הכותרת, ומפסיקים את החיבור עם הלקוח עם client.stop().

מסכם

במדריך זה הראינו לך כיצד לבנות א web שרת עם ESP32. הראינו לך אקס פשוטample ששולט בשתי נוריות LED, אבל הרעיון הוא להחליף את הנוריות האלה בממסר, או כל פלט אחר שאתה רוצה לשלוט בו.

פרויקט 6 RGB LED Web שרת

בפרויקט זה נראה לך כיצד לשלוט מרחוק על LED RGB עם לוח ESP32 באמצעות א web שרת עם בוחר צבעים.
הפרויקט הסתייםview
לפני שמתחילים, בואו נראה איך הפרויקט הזה עובד:

ה-ESP32 web השרת מציג בוחר צבעים.
כאשר אתה בוחר צבע, הדפדפן שלך מגיש בקשה ב-a URL שמכיל את הפרמטרים R, G ו-B של הצבע שנבחר.
ה-ESP32 שלך מקבל את הבקשה ומחלק את הערך עבור כל פרמטר צבע.
לאחר מכן, הוא שולח אות PWM עם הערך המתאים ל-GPIOs השולטים ב-RGB LED.

כיצד פועלות נוריות RGB?
בנורית RGB קתודה משותפת, כל שלוש הנוריות חולקות חיבור שלילי (קתודה). כל הכלולות בערכה הן RGB קתודה משותפת.איך ליצור צבעים שונים?
עם LED RGB ניתן, כמובן, להפיק אור אדום, ירוק וכחול, ועל ידי הגדרת עוצמת כל לד, ניתן להפיק גם צבעים אחרים.
למשלample, כדי להפיק אור כחול טהור, תגדיר את ה-LED הכחול לעוצמה הגבוהה ביותר ואת הנוריות הירוקות והאדומות לעוצמה הנמוכה ביותר. עבור אור לבן, תגדיר את כל שלושת הנוריות לעוצמה הגבוהה ביותר.
ערבוב צבעים
להפקת צבעים אחרים, ניתן לשלב את שלושת הצבעים בעוצמות שונות. כדי להתאים את עוצמת כל LED אתה יכול להשתמש באות PWM.
מכיוון שהנוריות קרובות מאוד אחת לשנייה, העיניים שלנו רואות את התוצאה של שילוב הצבעים, ולא את שלושת הצבעים בנפרד.
כדי לקבל רעיון כיצד לשלב את הצבעים, עיין בטבלה הבאה.
זוהי טבלת ערבוב הצבעים הפשוטה ביותר, אך נותנת לך מושג איך זה עובד וכיצד לייצר צבעים שונים.חלקים נדרשים
עבור פרויקט זה אתה צריך את החלקים הבאים:

לוח ESP32 DEVKIT V1
LED RGB
3x נגדים 220 אוהם
חוטי מגשר
קרש לחם

סכימתיקוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)

התקנת תוסף ESP32 ב- Arduino IDE

לאחר הרכבת המעגל, פתח את הקוד
Project_6_RGB_LED_Web_Server.ino ב-arduino IDE.
לפני העלאת הקוד, אל תשכח להכניס את אישורי הרשת שלך כדי שה-ESP יוכל להתחבר לרשת המקומית שלך.איך הקוד עובד
הסקיצה של ESP32 משתמשת בספריית WiFi.h.השורות הבאות מגדירות משתני מחרוזת שיחזיקו את הפרמטרים R, G ו-B מהבקשה.ארבעת המשתנים הבאים משמשים לפענוח בקשת ה-HTTP בהמשך.צור שלושה משתנים עבור ה-GPIOs שישלטו בפרמטרי הרצועה R, G ו-B. במקרה זה אנו משתמשים ב-GPIO 13, GPIO 12 ו-GPIO 14.GPIOs אלה צריכים להוציא אותות PWM, אז עלינו להגדיר תחילה את מאפייני ה-PWM. הגדר את תדר האות PWM ל-5000 הרץ. לאחר מכן, שייך ערוץ PWM לכל צבעולבסוף, הגדר את הרזולוציה של ערוצי PWM ל-8 סיביותב-setup(), הקצה את מאפייני PWM לערוצי PWMחבר את ערוצי ה-PWM ל-GPIO המתאימיםקטע הקוד הבא מציג את בוחר הצבעים שלך web עמוד ומגיש בקשה על סמך הצבע שבחרת.כאשר אתה בוחר צבע, אתה מקבל בקשה בפורמט הבא.

אז, אנחנו צריכים לפצל את המחרוזת הזו כדי לקבל את הפרמטרים R, G ו-B. הפרמטרים נשמרים במשתנים redString, greenString ו-bluString ויכולים להיות להם ערכים בין 0 ל-255.כדי לשלוט ברצועה עם ה-ESP32, השתמש בפונקציה ledcWrite() כדי ליצור אותות PWM עם הערכים מפוענחים מה-HTTP בַּקָשָׁה.פֶּתֶק: למד עוד על PWM עם ESP32: Project 3 ESP32 PWM (פלט אנלוגי)
כדי לשלוט ברצועה עם ה-ESP8266, אנחנו רק צריכים להשתמש
הפונקציה analogWrite() ליצירת אותות PWM עם הערכים מפוענחים מבקשת ה-HTPP.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
מכיוון שאנו מקבלים את הערכים במשתנה מחרוזת, עלינו להמיר אותם למספרים שלמים באמצעות שיטת toInt() .
הַפגָנָה
לאחר הכנסת אישורי הרשת שלך, בחר את הלוח הנכונים ואת יציאת ה-COM והעלה את הקוד ל-ESP32 שלך. העלאת שלבי התייחסות לקוד.
לאחר ההעלאה, פתח את הצג הטורי בקצב העברת נתונים של 115200 ולחץ על לחצן ESP Enable/Reset. אתה צריך לקבל את כתובת ה-IP של הלוח.פתח את הדפדפן שלך והכנס את כתובת ה-IP של ESP. כעת, השתמש בבורר הצבעים כדי לבחור צבע עבור LED RGB.
לאחר מכן, עליך ללחוץ על כפתור "שנה צבע" כדי שהצבע ייכנס לתוקף.כדי לכבות את LED RGB, בחר את הצבע השחור.
הצבעים החזקים ביותר (בחלק העליון של בורר הצבעים), הם אלו שיניבו תוצאות טובות יותר.

Project 7 ESP32 Relay Web שרת

שימוש בממסר עם ה-ESP32 הוא דרך מצוינת לשלוט במכשירי AC ביתיים מרחוק. מדריך זה מסביר כיצד לשלוט במודול ממסר עם ה-ESP32.
נסתכל כיצד עובד מודול ממסר, כיצד לחבר את הממסר ל-ESP32 ולבנות web שרת לשליטה על ממסר מרחוק.
היכרות עם ממסרים
ממסר הוא מתג הפועל באמצעות חשמל וכמו כל מתג אחר, אותו ניתן להפעיל או לכבות, לתת לזרם לעבור או לא. ניתן לשלוט בו עם ווליום נמוךtages, כמו 3.3V שסופק על ידי ESP32 GPIOs ומאפשר לנו לשלוט בווליום גבוהtagזה כמו 12V, 24V או כרך רשתtage (230V באירופה ו-120V בארה"ב).בצד שמאל, יש שני סטים של שלושה שקעים לחיבור ווליום גבוהtages, והפינים בצד ימין (נמוך כרךtagה) התחבר ל-ESP32 GPIOs.
רשת כרכיםtage חיבוריםלמודול הממסר המוצג בתמונה הקודמת יש שני מחברים, כל אחד עם שלושה שקעים: משותף (COM), סגור רגיל (NC) ופתוח רגיל (NO).

COM: חבר את הזרם שבו ברצונך לשלוט (כח רשת החשמלtagה).
NC (רגיל סגור): התצורה הסגורה בדרך כלל משמשת כאשר אתה רוצה שהממסר ייסגר כברירת מחדל. ה-NC הם פיני COM מחוברים, כלומר הזרם זורם אלא אם כן אתה שולח אות מה-ESP32 למודול הממסר כדי לפתוח את המעגל ולעצור את זרימת הזרם.
NO (פתוח רגיל): התצורה הפתוחה בדרך כלל פועלת הפוך: אין קשר בין הפינים NO ו-COM, כך שהמעגל נשבר אלא אם כן אתה שולח אות מה-ESP32 לסגירת המעגל.

סיכות בקרההווליום הנמוךtagבצד e יש סט של ארבע פינים וסט של שלוש פינים. הסט הראשון מורכב מ-VCC ו-GND כדי להפעיל את המודול, וכניסה 1 (IN1) וקלט 2 (IN2) כדי לשלוט בממסרים התחתונים והעליונים, בהתאמה.
אם למודול הממסר שלך יש רק ערוץ אחד, יהיה לך רק פין IN אחד. אם יש לך ארבעה ערוצים, יהיו לך ארבעה פינים IN, וכן הלאה.
האות שאתה שולח לפינים IN, קובע אם הממסר פעיל או לא. הממסר מופעל כאשר הקלט יורד מתחת ל-2V בערך. זה אומר שיהיו לך את התרחישים הבאים:

תצורה סגורה בדרך כלל (NC):
אות גבוה - זרם זורם
אות נמוך - זרם אינו זורם
תצורה פתוחה בדרך כלל (לא):
אות HIGH - זרם אינו זורם
אות נמוך - זרם זורם

עליך להשתמש בתצורה סגורה בדרך כלל כאשר הזרם אמור לזרום רוב הפעמים, ואתה רוצה להפסיק אותו רק מדי פעם.
השתמש בתצורה פתוחה בדרך כלל כאשר אתה רוצה שהזרם יזרום מדי פעם (לדוגמהampלה, הפעל את אלamp לִפְעָמִים).
בחירת ספק כוחקבוצת הפינים השנייה מורכבת מסיכות GND, VCC ו-JD-VCC.
פין JD-VCC מפעיל את האלקטרומגנט של הממסר. שימו לב שלמודול יש מכסה מגשר המחבר את פיני VCC ו-JD-VCC; זה שמוצג כאן הוא צהוב, אבל שלך עשוי להיות בצבע אחר.
כאשר מכסה המגשר מופעל, פיני VCC ו-JD-VCC מחוברים. זה אומר שהאלקטרומגנט הממסר מופעל ישירות מפין החשמל של ESP32, כך שמודול הממסר ומעגלי ה-ESP32 אינם מבודדים פיזית זה מזה.
ללא מכסה המגשר, עליך לספק מקור כוח עצמאי כדי להפעיל את האלקטרומגנט של הממסר דרך פין JD-VCC. תצורה זו מבודדת פיזית את הממסרים מה-ESP32 עם המצמד האופטו המובנה של המודול, המונע נזק ל-ESP32 במקרה של קוצים חשמליים.
סכימתיאַזהָרָה: שימוש בכרך גבוהtagספקי כוח עלולים לגרום לפציעה חמורה.
לכן, נעשה שימוש ב-LED של 5 מ"מ במקום בנפח אספקה גבוהtagנורות אלקטרוניות בניסוי. אם אינך מכיר את כרך רשת החשמלtagשאל מישהו שיעזור לך. בזמן תכנות ה-ESP או חיווט המעגל שלך, וודא שהכל מנותק ממתח החשמלtage.התקנת הספרייה עבור ESP32
לבנות את זה web שרת, אנו משתמשים ב-ESPAsyncWebספריית שרת וספריית AsyncTCP.
התקנת ה-ESPAsyncWebספריית שרתים
בצע את השלבים הבאים כדי להתקין את ESPAsyncWebשרת סִפְרִיָה:

לחץ כאן כדי להוריד את ה-ESPAsyncWebספריית שרתים. היית צריך
תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את ESPAsyncWebתיקיית שרת-מאסטר
שנה את שם התיקייה שלך מ-ESPAsyncWebשרת-מאסטר ל-ESPAsyncWebשרת
הזז את ה-ESPAsyncWebתיקיית שרת לתיקיית ספריות ההתקנה של Arduino IDE

לחלופין, ב-Arduino IDE שלך, אתה יכול ללכת אל Sketch> Include
ספרייה > הוסף ספריית .ZIP... ובחר את הספרייה שזה עתה הורדת.
התקנת ספריית AsyncTCP עבור ESP32
ה ESPAsyncWebשרת הספרייה דורשת את AsyncTCP הספרייה לעבודה. לַעֲקוֹב
השלבים הבאים להתקנת ספרייה זו:

לחץ כאן כדי להוריד את ספריית AsyncTCP. צריכה להיות לך תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את תיקיית AsyncTCP-master
1. שנה את שם התיקייה שלך מ-AsyncTCP-master ל-AsyncTCP
3. העבר את תיקיית AsyncTCP לתיקיית ספריות ההתקנה של Arduino IDE
4. לבסוף, פתח מחדש את ה-Arduino IDE שלך

לחלופין, ב-Arduino IDE שלך, אתה יכול ללכת אל Sketch> Include
ספרייה > הוסף ספריית .ZIP... ובחר את הספרייה שזה עתה הורדת.
קוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
לאחר התקנת הספריות הנדרשות, פתח את הקוד Project_7_ESP32_Relay_Web_Server.ino ב-arduino IDE.
לפני העלאת הקוד, אל תשכח להכניס את אישורי הרשת שלך כדי שה-ESP יוכל להתחבר לרשת המקומית שלך.הַפגָנָה
לאחר ביצוע השינויים הדרושים, העלה את הקוד ל-ESP32 שלך. העלאת שלבי ההפניה לקוד.
פתח את הצג הטורי בקצב העברת העברת נתונים של 115200 ולחץ על כפתור ESP32 EN כדי לקבל את כתובת ה-IP שלו. לאחר מכן, פתח דפדפן ברשת המקומית שלך והקלד את כתובת ה-IP ESP32 כדי לקבל גישה ל- web שרת.
פתח את הצג הטורי בקצב העברת העברת נתונים של 115200 ולחץ על כפתור ESP32 EN כדי לקבל את כתובת ה-IP שלו. לאחר מכן, פתח דפדפן ברשת המקומית שלך והקלד את כתובת ה-IP ESP32 כדי לקבל גישה ל- web שרת.פֶּתֶק: הדפדפן וה-ESP32 שלך צריכים להיות מחוברים לאותו LAN.
אתה אמור לקבל משהו כדלקמן עם שני כפתורים כמספר הממסרים שהגדרת בקוד שלך.כעת, אתה יכול להשתמש בלחצנים כדי לשלוט בממסרים שלך באמצעות הטלפון החכם שלך.

Project_8_Output_State_Synchronization_ Web_שרת

פרויקט זה מראה כיצד לשלוט ביציאות ESP32 או ESP8266 באמצעות א web שרת וכפתור פיזי בו זמנית. מצב הפלט מתעדכן ב- web עמוד אם הוא משתנה באמצעות כפתור פיזי או web שרת.
הפרויקט הסתייםview
בואו נסתכל במהירות על איך הפרויקט עובד.ה-ESP32 או ESP8266 מארח א web שרת המאפשר לך לשלוט במצב הפלט;

מצב הפלט הנוכחי מוצג ב- web שרת;
ה-ESP מחובר גם ללחצן פיזי השולט על אותו פלט;
אם תשנה את מצב הפלט באמצעות הכפתור הפיזי, המצב הנוכחי שלו מתעדכן גם ב- web שרת.

לסיכום, פרויקט זה מאפשר לך לשלוט באותו פלט באמצעות a web שרת וכפתור לחיצה בו זמנית. בכל פעם שמצב הפלט משתנה, ה web השרת מעודכן.
חלקים נדרשים
הנה רשימה של החלקים שאתה צריך כדי לבנות את המעגל:

לוח ESP32 DEVKIT V1
LED 5 מ"מ
נגד 220 אוהם
לחץ על הכפתור
נגד 10k אוהם
קרש לחם
חוטי מגשר

סכימתיהתקנת הספרייה עבור ESP32
לבנות את זה web שרת, אנו משתמשים ב-ESPAsyncWebספריית שרת וספריית AsyncTCP. (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת ה-ESPAsyncWebספריית שרתים
בצע את השלבים הבאים כדי להתקין את ESPAsyncWebספריית שרתים:

לחץ כאן כדי להוריד את ה-ESPAsyncWebספריית שרתים. היית צריך
תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את ESPAsyncWebתיקיית שרת-מאסטר
שנה את שם התיקייה שלך מ-ESPAsyncWebשרת-מאסטר ל-ESPAsyncWebשרת
הזז את ה-ESPAsyncWebתיקיית שרת לתיקיית ספריות ההתקנה של Arduino IDE
לחלופין, ב-Arduino IDE שלך, אתה יכול ללכת אל Sketch> Include
ספרייה > הוסף ספריית .ZIP... ובחר את הספרייה שזה עתה הורדת.

התקנת ספריית AsyncTCP עבור ESP32
ה-ESPAsyncWebספריית שרת דורשת שספריית AsyncTCP תעבוד. בצע את השלבים הבאים כדי להתקין את הספרייה:

לחץ כאן כדי להוריד את ספריית AsyncTCP. צריכה להיות לך תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את תיקיית AsyncTCP-master
שנה את שם התיקייה שלך מ-AsyncTCP-master ל-AsyncTCP
העבר את תיקיית AsyncTCP לתיקיית ספריות ההתקנה של Arduino IDE
לבסוף, פתח מחדש את ה- Arduino IDE שלך
לחלופין, ב-Arduino IDE שלך, אתה יכול ללכת אל Sketch> Include
ספרייה > הוסף ספריית .ZIP... ובחר את הספרייה שזה עתה הורדת.

איך הקוד עובד

מצב כפתור ומצב פלט
המשתנה ledState מחזיק את מצב פלט LED. כברירת מחדל, כאשר web השרת מתחיל, הוא נמוך.

ה-buttonState ו-lastButtonState משמשים כדי לזהות אם הלחצן נלחץ או לא.כפתור (web שרת)
לא כללנו את ה-HTML כדי ליצור את הכפתור במשתנה index_html.
זה בגלל שאנחנו רוצים להיות מסוגלים לשנות את זה בהתאם למצב LED הנוכחי שניתן לשנות גם עם הכפתור.
אז, יצרנו מציין מיקום עבור הכפתור %BUTTONPLACEHOLDER% שיוחלף בטקסט HTML כדי ליצור את הכפתור מאוחר יותר בקוד (זה נעשה בפונקציה processor()).מעבד()
הפונקציה processor() מחליפה את כל מצייני המיקום בטקסט ה-HTML בערכים בפועל. ראשית, הוא בודק אם טקסטי HTML מכילים כאלה
מצייני מיקום %BUTTONPLACEHOLDER%.לאחר מכן, קרא לפונקציה theoutputState() שמחזירה את מצב הפלט הנוכחי. אנו שומרים אותו במשתנה outputStateValue.לאחר מכן, השתמש בערך זה כדי ליצור את טקסט ה-HTML כדי להציג את הכפתור במצב הנכון:בקשת HTTP GET לשינוי מצב פלט (JavaScript)
כאשר אתה לוחץ על הכפתור, הפונקציה thetoggleCheckbox() נקראת. פונקציה זו תגיש בקשה על שונה URLs כדי להדליק או לכבות את הנורית.כדי להדליק את הנורית, הוא מגיש בקשה ב- /update?state=1 URL:אחרת, הוא מגיש בקשה ב- /update?state=0 URL.
בקשת HTTP GET לעדכון מצב (JavaScript)
כדי לעדכן את מצב הפלט ב- web שרת, אנו קוראים לפונקציה הבאה שמבצעת בקשה חדשה ב-/state URL כל שניה.טיפול בבקשות
לאחר מכן, עלינו לטפל במה שקורה כאשר ה-ESP32 או ESP8266 מקבלים בקשות על אלה URLs.
כאשר מתקבלת בקשה בשורש /URL, אנו שולחים את דף ה-HTML וכן את המעבד.השורות הבאות בודקות אם קיבלת בקשה ב- /update?state=1 או /update?state=0 URL ומשנה את ה-ledState בהתאם.כאשר מתקבלת בקשה ב-/state URL, אנו שולחים את מצב הפלט הנוכחי:לוּלָאָה()
בלולאה(), אנו משחררים את הכפתור ומפעילים או מכבים את ה-LED בהתאם לערך של ledState מִשְׁתַנֶה.הַפגָנָה
העלה את הקוד ללוח ה-ESP32 שלך. העלאת שלבי התייחסות לקוד.
לאחר מכן, פתח את הצג הטורי בקצב העברת העברת נתונים של 115200. לחץ על לחצן EN/RST המובנה כדי לקבל את כתובת ה-IP.פתח דפדפן ברשת המקומית שלך והקלד את כתובת ה-IP של ESP. צריכה להיות לך גישה ל web שרת כפי שמוצג להלן.
פֶּתֶק: הדפדפן וה-ESP32 שלך צריכים להיות מחוברים לאותו LAN.אתה יכול להחליף את הכפתור ב- web שרת כדי להדליק את הנורית.אתה יכול גם לשלוט באותה LED עם הכפתור הפיזי. המצב שלו תמיד יתעדכן אוטומטית ב- web שרת.

פרויקט 9 ESP32 DHT11 Web שרת

בפרויקט זה תלמדו כיצד לבנות ESP32 אסינכרוני web שרת עם DHT11 שמציג טמפרטורה ולחות באמצעות Arduino IDE.
דרישות מוקדמות
ה web שרת שנבנה מעדכן את הקריאות באופן אוטומטי ללא צורך לרענן את web עַמוּד.
עם הפרויקט הזה תלמדו:

כיצד לקרוא טמפרטורה ולחות מחיישני DHT;
בנה אסינכרוני web שרת המשתמש ב- ESPAsyncWebספריית שרתים;
עדכן את קריאות החיישן באופן אוטומטי ללא צורך לרענן את web עַמוּד.

אסינכרוני Web שרת
כדי לבנות את web שרת בו נשתמש ESPAsyncWebספריית שרתים המספק דרך קלה לבנות אסינכרוני web שרת. בניית אסינכרוני web לשרת יש כמה advantages כפי שהוזכר בדף GitHub הספרייה, כגון:

"טפל ביותר מחיבור אחד בו-זמנית";
"כשאתה שולח את התגובה, אתה מוכן מיד לטפל בחיבורים אחרים בזמן שהשרת דואג לשלוח את התגובה ברקע";
"מנוע עיבוד תבניות פשוט לטיפול בתבניות";

חלקים נדרשים
כדי להשלים את המדריך הזה אתה צריך את החלקים הבאים:

לוח פיתוח ESP32
מודול DHT11
קרש לחם
חוטי מגשר

סכימתיהתקנת ספריות
אתה צריך להתקין כמה ספריות עבור הפרויקט הזה:

ה DHT ואת חיישן מאוחד של Adafruit ספריות מנהלי התקנים לקריאה מחיישן DHT.
ESPAsyncWebשרת ו אסינכרון TCP ספריות לבנות את האסינכרוני web שרת.
בצע את ההוראות הבאות להתקנת ספריות אלה:

התקנת ספריית חיישן DHT
כדי לקרוא מחיישן DHT באמצעות Arduino IDE, עליך להתקין את ספריית חיישני DHT. בצע את השלבים הבאים כדי להתקין את הספרייה.

לחץ כאן כדי להוריד את ספריית חיישן DHT. צריכה להיות לך תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את תיקיית DHT-sensor-library-master
שנה את שם התיקייה שלך מ-DHT-sensor-library-master ל-DHT_sensor
העבר את תיקיית DHT_sensor לתיקיית ספריות ההתקנה של Arduino IDE שלך
לבסוף, פתח מחדש את ה- Arduino IDE שלך

התקנת הדרייבר של Adafruit Unified Sensor
אתה גם צריך להתקין את ספריית מנהלי התקנים של חיישן מאוחד של Adafruit לעבוד עם חיישן DHT. בצע את השלבים הבאים כדי להתקין את הספרייה.

לחץ כאן כדי להוריד את ספריית Adafruit Unified Sensor. צריכה להיות לך תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-zip ואתה אמור לקבל את התיקיה Adafruit_sensor-master
שנה את שם התיקייה שלך מ-Adafruit_sensor-master ל-Adafruit_sensor
העבר את תיקיית Adafruit_sensor לתיקיית ספריות ההתקנה של Arduino IDE שלך
לבסוף, פתח מחדש את ה- Arduino IDE שלך

התקנת ה-ESPAsyncWebספריית שרתים

בצע את השלבים הבאים כדי להתקין את ESPAsyncWebשרת סִפְרִיָה:

לחץ כאן כדי להוריד את ה-ESPAsyncWebספריית שרתים. היית צריך
תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-zip ואתה צריך
קבל ESPAsyncWebתיקיית שרת-מאסטר
שנה את שם התיקייה שלך מ-ESPAsyncWebשרת-מאסטר ל-ESPAsyncWebשרת
הזז את ה-ESPAsyncWebתיקיית שרת לתיקיית ספריות ההתקנה של Arduino IDE

התקנת ספריית Async TCP עבור ESP32
ה ESPAsyncWebשרת הספרייה דורשת את AsyncTCP הספרייה לעבודה. בצע את השלבים הבאים כדי להתקין את הספרייה:

לחץ כאן כדי להוריד את ספריית AsyncTCP. צריכה להיות לך תיקיית ‎.zip בתיקיית ההורדות שלך
פתח את תיקיית ה-.zip ואתה אמור לקבל את תיקיית AsyncTCP-master
שנה את שם התיקייה שלך מ-AsyncTCP-master ל-AsyncTCP
העבר את תיקיית AsyncTCP לתיקיית ספריות ההתקנה של Arduino IDE
לבסוף, פתח מחדש את ה- Arduino IDE שלך

קוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDE
לאחר התקנת הספריות הנדרשות, פתח את הקוד
Project_9_ESP32_DHT11_Web_Server.ino ב-arduino IDE.
לפני העלאת הקוד, אל תשכח להכניס את אישורי הרשת שלך כדי שה-ESP יוכל להתחבר לרשת המקומית שלך.איך הקוד עובד
בפסקאות הבאות נסביר כיצד הקוד עובד. המשך לקרוא אם אתה רוצה ללמוד עוד או קפוץ למדור ההדגמה כדי לראות את התוצאה הסופית.
ייבוא ספריות
ראשית, ייבא את הספריות הנדרשות. ה-WiFi, ESPAsyncWebיש צורך בשרת וב-ESPAsyncTCP כדי לבנות את web שרת. יש צורך ב-Adafruit_Sensor וספריות DHT כדי לקרוא מחיישני DHT11 או DHT22.הגדרת משתנים
הגדר את ה-GPIO שאליו מחובר סיכת הנתונים של DHT. במקרה זה, הוא מחובר ל-GPIO 4.לאחר מכן, בחר את סוג חיישן ה-DHT שבו אתה משתמש. באקס שלנוample, אנחנו משתמשים ב-DHT22. אם אתה משתמש בסוג אחר, אתה רק צריך לבטל הערות לחיישן שלך ולהגיב לכל האחרים.

הצג אובייקט DHT עם הסוג והפין שהגדרנו קודם לכן.צור אסינכרוןWebאובייקט שרת ביציאה 80.קרא את פונקציות הטמפרטורה והלחות
יצרנו שתי פונקציות: האחת לקריאת הטמפרטורה יצרנו שתי פונקציות: האחת לקריאת הטמפרטורה (readDHTTemperature()) והשנייה לקריאת לחות (readDHTHumidity()).קבלת קריאות חיישנים היא פשוטה כמו שימוש. קבלת קריאות חיישנים היא פשוטה כמו שימוש בשיטות readTemperature() ו-readHumidity() באובייקט dht.יש לנו גם מצב שמחזיר שני מקפים (–) למקרה שהחיישן לא מצליח לקבל את הקריאות.הקריאות מוחזרות כסוג מחרוזת. כדי להמיר צף למחרוזת, השתמש בפונקציה String()כברירת מחדל, אנו קוראים את הטמפרטורה במעלות צלזיוס. כדי לקבל את הטמפרטורה במעלות פרנהייט, הערה את הטמפרטורה בצלזיוס ובטל את ההערה על הטמפרטורה בפרנהייט, כך שיש לך את הדברים הבאים:העלה את הקוד
כעת, העלה את הקוד ל-ESP32 שלך. ודא שבחרתם את הלוח הנכונים ויציאת ה-COM. העלאת שלבי התייחסות לקוד.
לאחר ההעלאה, פתח את הצג הטורי בקצב העברת נתונים של 115200. לחץ על לחצן האיפוס של ESP32. יש להדפיס את כתובת ה-IP של ESP32 בסידורי לפקח.הַפגָנָה
פתח דפדפן והקלד את כתובת ה-IP ESP32. שֶׁלְךָ web השרת אמור להציג את קריאות החיישנים העדכניות ביותר.
פֶּתֶק: הדפדפן וה-ESP32 שלך צריכים להיות מחוברים לאותו LAN.
שימו לב כי קריאות הטמפרטורה והלחות מתעדכנות אוטומטית ללא צורך לרענן את web עַמוּד.

Project_10_ESP32_OLED_תצוגה

פרויקט זה מראה כיצד להשתמש בצג SSD0.96 OLED בגודל 1306 אינץ' עם ESP32 באמצעות Arduino IDE.
מציגה תצוגת OLED בגודל 0.96 אינץ'
ה תצוגת OLED בו נשתמש במדריך זה הוא דגם SSD1306: צג חד-צבעוני בגודל 0.96 אינץ' עם 128×64 פיקסלים כפי שמוצג באיור הבא.תצוגת ה-OLED אינה דורשת תאורה אחורית, מה שמביא לניגודיות יפה מאוד בסביבות חשוכות. בנוסף, הפיקסלים שלו צורכים אנרגיה רק כשהם דולקים, כך שתצוגת ה-OLED צורכת פחות חשמל בהשוואה לצגים אחרים.
מכיוון שתצוגת ה-OLED משתמשת בפרוטוקול תקשורת I2C, החיווט פשוט מאוד. אתה יכול להשתמש בטבלה הבאה כהתייחסות.

סיכת OLED	ESP32
וין	3.3V
GND	GND
SCL	GPIO 22
SDA	GPIO 21

סכימתיהתקנת ספריית SSD1306 OLED – ESP32
ישנן מספר ספריות זמינות לשליטה בתצוגת ה-OLED עם ה-ESP32.
במדריך זה נשתמש בשתי ספריות Adafruit: ספריית Adafruit_SSD1306 ו ספריית Adafruit_GFX.
בצע את השלבים הבאים כדי להתקין ספריות אלה.

פתח את ה-Arduino IDE שלך ועבור אל Sketch> כלול ספריה> נהל ספריות. מנהל הספרייה אמור להיפתח.
הקלד "SSD1306" בתיבת החיפוש והתקן את ספריית SSD1306 מ-Adafruit.
לאחר התקנת ספריית SSD1306 מ-Adafruit, הקלד "GFX" בתיבת החיפוש והתקן את הספרייה.
לאחר התקנת הספריות, הפעל מחדש את Arduino IDE שלך.

קוד
לאחר התקנת הספריות הנדרשות, פתח את Project_10_ESP32_OLED_Display.ino ב-arduino IDE. קוד
אנו נתכנת את ה-ESP32 באמצעות Arduino IDE, אז ודא שהתוסף ESP32 מותקן לפני שתמשיך: (אם כבר ביצעת את השלב הזה, תוכל לדלג לשלב הבא.)
התקנת תוסף ESP32 ב- Arduino IDEאיך הקוד עובד
ייבוא ספריות
ראשית, עליך לייבא את הספריות הדרושות. ספריית ה-Wire לשימוש ב-I2C וספריות Adafruit כדי לכתוב לתצוגה: Adafruit_GFX ו-Adafruit_SSD1306.אתחל את תצוגת ה-OLED
לאחר מכן, אתה מגדיר את הרוחב והגובה של ה-OLED שלך. באקס זהampאבל, אנחנו משתמשים בתצוגת OLED בגודל 128×64. אם אתה משתמש בגדלים אחרים, תוכל לשנות זאת במשתנים SCREEN_WIDTH ו-SCREEN_HEIGHT.לאחר מכן, אתחול אובייקט תצוגה עם הרוחב והגובה שהוגדרו קודם לכן עם פרוטוקול תקשורת I2C (&Wire).הפרמטר (-1) אומר שלצג ה-OLED שלך אין פין RESET. אם לצג ה-OLED שלך יש פין RESET, יש לחבר אותו ל-GPIO. במקרה כזה, עליך להעביר את מספר ה-GPIO כפרמטר.
ב-setup(), אתחל את ה-Serial Monitor ב-baud rautte של 115200 למטרות ניפוי באגים.אתחל את תצוגת ה-OLED בשיטת begin() באופן הבא:קטע זה גם מדפיס הודעה על הצג הטורי, למקרה שלא נוכל להתחבר לתצוגה.

במקרה שאתה משתמש בתצוגת OLED אחרת, ייתכן שתצטרך לשנות את כתובת ה-OLED. במקרה שלנו, הכתובת היא 0x3C.לאחר אתחול התצוגה, הוסף השהיה של שתי שניות, כך של-OLED יהיה מספיק זמן לאתחל לפני כתיבת טקסט:נקה תצוגה, הגדר גודל גופן, צבע וכתוב טקסט
לאחר אתחול התצוגה, נקה את מאגר התצוגה בשיטת clearDisplay():

לפני כתיבת טקסט, עליך להגדיר את גודל הטקסט, הצבע והיכן יוצג הטקסט ב-OLED.
הגדר את גודל הגופן באמצעות שיטת setTextSize():הגדר את צבע הגופן בשיטת setTextColor():
WHITE מגדיר גופן לבן ורקע שחור.
הגדר את המיקום שבו הטקסט מתחיל באמצעות שיטת setCursor(x,y). במקרה זה, אנו מגדירים את הטקסט להתחיל בקואורדינטות (0,0) - בפינה השמאלית העליונה.לבסוף, אתה יכול לשלוח את הטקסט לתצוגה באמצעות שיטת println() כדלקמןלאחר מכן, עליך לקרוא לשיטת display() כדי להציג בפועל את הטקסט על המסך.

ספריית Adafruit OLED מספקת שיטות שימושיות לגלול טקסט בקלות.

startscrollright(0x00, 0x0F): גלול טקסט משמאל לימין
startscrollleft(0x00, 0x0F): גלול טקסט מימין לשמאל
startscrolldiagright(0x00, 0x07): גלילה טקסט מהפינה השמאלית התחתונה לפינה הימנית העליונה startscrolldiagleft(0x00, 0x07): גלילה של טקסט מהפינה הימנית התחתונה לפינה השמאלית העליונה

העלה את הקוד
כעת, העלה את הקוד ל-ESP32 שלך. שלבי עזר להעלאת קוד.
לאחר העלאת הקוד, ה-OLED יציג טקסט גלילה.

מסמכים / משאבים

ערכת התחלה בסיסית של LAFVIN ESP32 [pdfמדריך הוראות
ESP32 Basic Starter Kit, ESP32, Basic Starter Kit, Starter Kit

הפניות

מדריך למשתמש

רשימת אריזה

ESP32 מבוא

לוחות פיתוח ESP32

העלה קוד בדיקה

פתרון בעיות

Project 1 ESP32 כניסות פלטים

הַפגָנָה

Project 2 ESP32 כניסות אנלוגיות

מסכם

Project 3 ESP32 PWM (פלט אנלוגי)

בודקים את האקסample

Project 4 ESP32 PIR תנועה חיישן

Project 5 ESP32 Switch Web שרת

איך הקוד עובד

סטיילינג את Web עַמוּד

מסכם

פרויקט 6 RGB LED Web שרת

Project 7 ESP32 Relay Web שרת

Project_8_Output_State_Synchronization_ Web_שרת

איך הקוד עובד

פרויקט 9 ESP32 DHT11 Web שרת

Project_10_ESP32_OLED_תצוגה

מסמכים / משאבים

הפניות

השאר תגובה

בטל תשובה