ESP32 Basic Starter
קיט
פּאַקינג רשימה
ESP32 הקדמה
נייַ צו ESP32? אָנהייב דאָ! די ESP32 איז אַ סעריע פון נידעריק-פּרייַז און נידעריק-מאַכט סיסטעם אויף אַ טשיפּ (SoC) מיקראָקאָנטראָללערס דעוועלאָפּעד דורך Espressif וואָס אַרייַננעמען ווי-פי און בלועטאָאָטה וויירליס קייפּאַבילאַטיז און צווייענדיק-האַרץ פּראַסעסער. אויב איר זענט באַקאַנט מיט די ESP8266, די ESP32 איז זיין סאַקסעסער, לאָודיד מיט אַ פּלאַץ פון נייַע פֿעיִקייטן.
ESP32 ספּעסאַפאַקיישאַנז
אויב איר ווילן צו באַקומען אַ ביסל מער טעכניש און ספּעציפיש, איר קענען נעמען אַ קוק אין די פאלגענדע דיטיילד ספּעסאַפאַקיישאַנז פון די ESP32 (מקור: http://esp32.net/) — פֿאַר מער פּרטים, טשעק די דאַטן בלאַט):
- ווירעלעסס קאַנעקטיוויטי WiFi: 150.0 Mbps דאַטן קורס מיט HT40
- בלועטאָאָטה: BLE (בלועטאָאָטה נידעריק ענערגיע) און בלועטאָאָטה קלאַסיק
- פּראַסעסער: Tensilica Xtensa Dual Core 32-bit LX6 מייקראָופּראַסעסער, פליסנדיק ביי 160 אָדער 240 מהז
- זכּרון:
- ראַם: 448 קב (פֿאַר בוטינג און האַרץ פאַנגקשאַנז)
- SRAM: 520 קב (פֿאַר דאַטן און ינסטראַקשאַנז)
- RTC fas SRAM: 8 קב (פֿאַר דאַטן סטאָרידזש און הויפּט קפּו בעשאַס RTC שטיוול פֿון די טיף שלאָפן מאָדע)
- RTC פּאַמעלעך SRAM: 8KB (פֿאַר קאָ-פּראַסעסער אַקסעסינג בעשאַס טיף שלאָפן מאָדע) eFuse: 1 Kbit (פון וואָס 256 ביץ זענען געניצט פֿאַר די סיסטעם (מאַק אַדרעס און שפּאָן קאַנפיגיעריישאַן) און די רוען 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 (ESP32-PICO-D4 SiP מאָדולע)
נידעריק מאַכט: ינשורז אַז איר קענען נאָך נוצן ADC קאַנווערזשאַנז, למשלample, בעשאַס טיף שלאָפן.
פּעריפעראַל אַרייַנשרייַב / רעזולטאַט:
- פּעריפעראַל צובינד מיט DMA וואָס כולל קאַפּאַסיטיווע פאַרבינדן
- ADCs (אַנאַלאָג-צו-דיגיטאַל קאָנווערטער)
- דאַקס (דיגיטאַל-צו-אַנאַלאָג קאָנווערטער)
- I²C (ינטער-ינאַגרייטיד קרייַז)
- UART (וניווערסאַל אַסינטשראָנאָוס ופנעמער / טראַנסמיטער)
- SPI (סיריאַל פּעריפעראַל צובינד)
- I²S (ינאַגרייטיד ינטערטשיפּ סאָונד)
- RMII (רעדוסעד מעדיע ינדעפּענדענט צובינד)
- PWM (Pulse-Width Modulation)
זיכערהייט: ייַזנוואַרג אַקסעלערייטערז פֿאַר 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 (צווייענדיק האַרץ) |
| ווי-פי | 2.4 גהז אַרויף צו 150 מביט / s |
| בלועטאָאָטה | BLE (בלועטאָאָטה נידעריק ענערגיע) און לעגאַט בלועטאָאָטה |
| אַרטשיטעקטורע | 32 ביץ |
| זייגער אָפטקייַט | אַרויף צו 240 MHz |
| באַראַן | 512 קב |
| פּינס | 30 (דיפּענדינג אויף די מאָדעל) |
| פּעריפעראַלס | קאַפּאַסיטיווע פאַרבינדן, ADC (אַנאַלאָג צו דיגיטאַל קאַנווערטער), DAC (דיגיטאַל צו אַנאַלאָג קאַנווערטער), 12C (ינטער-ינאַגרייטיד קרייַז), UART (וניווערסאַל ייסינגקראַנאַס ופנעמער / טראַנסמיטער), CAN 2.0 (קאָנטראָללער שטח נעטוואָקר), SPI (סיריאַל פּעריפעראַל צובינד) , 12S (ינאַגרייטיד ינטער-יק סאָונד), RMII (רעדוסעד מעדיע ינדעפּענדענט צובינד), PWM (פּאָלס ברייט מאַדזשאַליישאַן) און מער. |
| געבויט-אין קנעפּלעך | באַשטעטיק און שטיוול קנעפּלעך |
| געבויט-אין לעדס | געבויט-אין בלוי געפירט פארבונדן צו GPIO2; געבויט-אין רויט געפירט וואָס ווייזט אַז די ברעט איז פּאַוערד |
| וסב צו UART בריק |
CP2102 |
עס קומט מיט אַ מיקראָוסב צובינד אַז איר קענען נוצן צו פאַרבינדן די ברעט צו דיין קאָמפּיוטער צו צופֿעליקער קאָד אָדער צולייגן מאַכט.
עס ניצט די CP2102 שפּאָן (וסב צו UART) צו יבערגעבן מיט דיין קאָמפּיוטער דורך אַ קאַם פּאָרט ניצן אַ סיריאַל צובינד. אן אנדער פאָלקס שפּאָן איז די CH340. קוק וואָס איז די וסב צו UART שפּאָן קאַנווערטער אויף דיין ברעט ווייַל איר דאַרפֿן צו ינסטאַלירן די פארלאנגט דריווערס אַזוי אַז דיין קאָמפּיוטער קענען יבערגעבן מיט די ברעט (מער אינפֿאָרמאַציע וועגן דעם שפּעטער אין דעם פירער).
דער ברעט אויך קומט מיט אַ RESET קנעפּל (קען זיין מיטן נאָמען EN) צו ריסטאַרט די ברעט און אַ שטיוול קנעפּל צו שטעלן די ברעט אין פלאַשינג מאָדע (בנימצא צו באַקומען קאָד). באַמערקונג אַז עטלעכע באָרדז קען נישט האָבן אַ BOOT קנעפּל.
עס אויך קומט מיט אַ געבויט-אין בלוי געפירט וואָס איז ינעווייניק פארבונדן צו GPIO 2. דעם געפירט איז נוציק פֿאַר דיבאַגינג צו געבן עטלעכע סאָרט פון וויזשאַוואַל פיזיש רעזולטאַט. עס איז אויך אַ רויט געפירט וואָס לייץ ווען איר צושטעלן מאַכט צו די ברעט.
ESP32 Pinout
די ESP32 פּעריפעראַלס אַרייַננעמען:
- 18 אַנאַלאָג-צו-דיגיטאַל קאָנווערטער (ADC) טשאַנאַלז
- 3 SPI ינטערפייסיז
- 3 UART ינטערפייסיז
- 2 I2C ינטערפייסיז
- 16 פּוום רעזולטאַט טשאַנאַלז
- 2 דיגיטאַל-צו-אַנאַלאָג קאָנווערטערס (דאַק)
- 2 I2S ינטערפייסיז
- 10 קאַפּאַסיטיווע סענסינג GPIOs
די ADC (אַנאַלאָג צו דיגיטאַל קאַנווערטער) און DAC (דיגיטאַל צו אַנאַלאָג קאַנווערטער) פֿעיִקייטן זענען אַסיינד צו ספּעציפיש סטאַטיק פּינס. אָבער, איר קענען באַשליסן וואָס פּינס זענען UART, I2C, SPI, PWM, עטק - איר נאָר דאַרפֿן צו באַשטימען זיי אין די קאָד. דאָס איז מעגלעך רעכט צו דער מולטיפּלעקסינג שטריך פון די ESP32 שפּאָן.
כאָטש איר קענען דעפינירן די פּינס פּראָפּערטיעס אויף די ווייכווארג, עס זענען פּינס אַסיינד דורך פעליקייַט ווי געוויזן אין די פאלגענדע פיגור
דערצו, עס זענען פּינס מיט ספּעציפיש פֿעיִקייטן וואָס מאַכן זיי פּאַסיק אָדער נישט פֿאַר אַ באַזונדער פּרויעקט. די פאלגענדע טיש ווייזט וואָס פּינס זענען בעסטער צו נוצן ווי ינפּוץ, אַוטפּוץ און וואָס איר דאַרפֿן צו זיין אָפּגעהיט.
די פּינס כיילייטיד אין גרין זענען גוט צו נוצן. די וואָס זענען כיילייטיד אין געל זענען גוט צו נוצן, אָבער איר דאַרפֿן צו באַצאָלן ופמערקזאַמקייט ווייַל זיי קען האָבן אַ אומגעריכט נאַטור דער הויפּט ביי שטיוול. די פּינס כיילייטיד אין רויט זענען נישט רעקאַמענדיד צו נוצן ווי ינפּוץ אָדער אַוטפּוץ.
| GP IO | אַרייַנשרייַב | רעזולטאַט | הערות |
| 0 | ארויפגעצויגן | OK | אַוטפּוץ PWM סיגנאַל ביי שטיוול, מוזן זיין נידעריק צו אַרייַן פלאַשינג מאָדע |
| 1 | טקס שטיפט | OK | דיבאַג רעזולטאַט ביי שטיוול |
| 2 | OK | OK | קאָננעקטעד צו אויף-ברעט געפירט, מוזן זיין לינקס פלאָוטינג אָדער נידעריק צו אַרייַן פלאַשינג מאָדע |
| 3 | OK | RX שפּילקע | הויך ביי שטיוול |
| 4 | OK | OK | |
| 5 | OK | OK | אַוטפּוץ פּוום סיגנאַל ביי שטיוול, סטראַפּינג שטיפט |
| 12 | OK | OK | שטיוול פיילז אויב פּולד הויך, סטראַפּינג שטיפט |
| 13 | OK | OK | |
| 14 | OK | OK | אַוטפּוץ פּוום סיגנאַל ביי שטיוול |
| 15 | OK | OK | אַוטפּוץ פּוום סיגנאַל ביי שטיוול, סטראַפּינג שטיפט |
| 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 און זייַן פאַנגקשאַנז.
אַרייַנשרייַב בלויז פּינס
גפּיאָס 34 צו 39 זענען גפּי - פּינס בלויז אַרייַנשרייַב. די פּינס טאָן ניט האָבן ינערלעך ציען-אַרויף אָדער ציען-אַראָפּ רעסיסטאָרס. זיי קענען ניט זיין געוויינט ווי אַוטפּוץ, אַזוי נוצן די פּינס בלויז ווי ינפּוץ:
- 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 קס 12 ביץ ADC אַרייַנשרייַב טשאַנאַלז (בשעת די ESP8266 בלויז 1 קס 10 ביץ ADC). דאָס זענען די GPIOs וואָס קענען זיין געוויינט ווי אַדק און ריספּעקטיוו טשאַנאַלז:
- 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 קאָראַספּאַנדז צו 0 וו און 4095 צו 3.3 וו. איר קענט אויך שטעלן די האַכלאָטע פון דיין טשאַנאַלז אויף די קאָד און די ADC קייט.
די ESP32 ADC פּינס טאָן ניט האָבן אַ לינעאַר נאַטור. איר וועט מיסטאָמע נישט קענען צו ויסטיילן צווישן 0 און 0.1 וו, אָדער צווישן 3.2 און 3.3 וו. איר דאַרפֿן צו האַלטן דאָס אין זינען ווען איר נוצן די ADC פּינס. איר וועט באַקומען אַ נאַטור ענלעך צו די וואָס איז געוויזן אין די פאלגענדע פיגור.
דיגיטאַל צו אַנאַלאָג קאָנווערטער (DAC)
עס זענען 2 X 8 ביץ דאַק טשאַנאַלז אויף די ESP32 צו גער דיגיטאַל סיגנאַלז אין אַנאַלאָג וואַלtagE סיגנאַל אַוטפּוץ. דאָס זענען די DAC טשאַנאַלז:
- DAC1 (GPIO25)
- DAC2 (GPIO26)
RTC GPIOs
עס איז RTC GPIO שטיצן אויף די ESP32. די GPIOs ראַוטיד צו די RTC נידעריק-מאַכט סאַבסיסטאַם קענען זיין געוויינט ווען די ESP32 איז אין טיף שלאָפן. די RTC GPIOs קענען ווערן גענוצט צו וועקן די ESP32 פון טיף שלאָפן ווען די הינטער נידעריק
מאַכט (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 פּינס (GPIOs 34-39 קענען נישט דזשענערייט PWM).
צו שטעלן אַ PWM סיגנאַל, איר דאַרפֿן צו דעפינירן די פּאַראַמעטערס אין דעם קאָד:
- סיגנאַל ס אָפטקייַט;
- פליכט ציקל;
- פּוום קאַנאַל;
- GPIO ווו איר ווילן צו רעזולטאַט די סיגנאַל.
I2C
די ESP32 האט צוויי I2C טשאַנאַלז און קיין שטיפט קענען זיין שטעלן ווי SDA אָדער SCL. ווען איר נוצן די ESP32 מיט די Arduino IDE, די פעליקייַט I2C פּינס זענען:
- GPIO 21 (SDA)
- GPIO 22 (SCL)
אויב איר ווילן צו נוצן אנדערע פּינס ווען איר נוצן די דראָט ביבליאָטעק, איר נאָר דאַרפֿן צו רופן:
Wire.begin(SDA, SCL);
ספּי
דורך פעליקייַט, די שפּילקע מאַפּינג פֿאַר SPI איז:
| ספּי | MOSI | MISO | CLK | CS |
| VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO 5 |
| הספּי | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
ינטעראַפּץ
כל GPIOs קענען זיין קאַנפיגיערד ווי ינטעראַפּץ.
סטראַפּינג פּינס
די ESP32 שפּאָן האט די פאלגענדע סטראַפּינג פּינס:
- GPIO 0 (מוזן זיין נידעריק צו אַרייַן שטיוול מאָדע)
- GPIO 2 (מוזן זיין פלאָוטינג אָדער נידעריק בעשאַס שטיוול)
- GPIO 4
- GPIO 5 (מוזן זיין הויך בעשאַס שטיוול)
- GPIO 12 (מוזן זיין נידעריק בעשאַס שטיוול)
- GPIO 15 (מוזן זיין הויך בעשאַס שטיוול)
די זענען געניצט צו שטעלן די ESP32 אין באָאָטלאָאַדער אָדער פלאַשינג מאָדע. אויף רובֿ אַנטוויקלונג באָרדז מיט אַ געבויט-אין וסב / סיריאַל, איר טאָן ניט דאַרפֿן צו זאָרג וועגן די שטאַט פון די פּינס. די ברעט לייגט די פּינס אין די רעכט שטאַט פֿאַר פלאַשינג אָדער שטיוול מאָדע. מער אינפֿאָרמאַציע וועגן די סעלעקציע פון די ESP32 שטיוול מאָדע קענען זיין געפֿונען דאָ.
אָבער, אויב איר האָבן פּעריפעראַלס קאָננעקטעד צו די פּינס, איר קען האָבן קאָנפליקט צו צופֿעליקער נייַ קאָד, פלאַשינג די ESP32 מיט נייַ פירמוואַרע אָדער באַשטעטיק די ברעט. אויב איר האָבן עטלעכע פּעריפעראַלס קאָננעקטעד צו די סטראַפּינג פּינס און איר באַקומען קאָנפליקט צו ופּלאָאַדינג קאָד אָדער פלאַשינג די ESP32, דאָס קען זיין ווייַל די פּעריפעראַלס פאַרהיטן די ESP32 פון אַרייַן די רעכט מאָדע. לייענען די באָאָט מאָדע סעלעקציע דאַקיומענטיישאַן צו פירן איר אין די רעכט ריכטונג. נאָך באַשטעטיק, פלאַשינג אָדער בוטינג, די פּינס אַרבעט ווי דערוואַרט.
פּינס הויך אין שטיוול
עטלעכע GPIOs טוישן זייער שטאַט צו HIGH אָדער רעזולטאַט PWM סיגנאַלז ביי שטיוול אָדער באַשטעטיק.
דעם מיטל אַז אויב איר האָבן אַוטפּוץ פארבונדן צו די GPIOs, איר קען באַקומען אומגעריכט רעזולטאַטן ווען די ESP32 ריסעץ אָדער שיך.
- GPIO 1
- GPIO 3
- GPIO 5
- GPIO 6 צו GPIO 11 (פארבונדן צו די ESP32 ינאַגרייטיד SPI בליץ זכּרון - ניט רעקאַמענדיד צו נוצן).
- GPIO 14
- GPIO 15
געבן (ען)
געבן (EN) איז די 3.3 וו רעגולאַטאָר ס געבן שטיפט. עס איז פּולד אַרויף, אַזוי פאַרבינדן צו ערד צו דיסייבאַל די 3.3 וו רעגולאַטאָר. דעם מיטל אַז איר קענען נוצן דעם שטיפט פארבונדן צו אַ פּושקנעפּל צו ריסטאַרט דיין ESP32, למשלample.
GPIO קראַנט ציען
די אַבסאָלוט מאַקסימום קראַנט ציען פּער GPIO איז 40 מאַ לויט די "רעקאַמענדיד אָפּערייטינג טנאָים" אָפּטיילונג אין די 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 Fileסיסטעם ופּלאָאַדער פּלוגין) וואָס זענען נישט נאָך געשטיצט אויף Arduino 2. אַזוי, אויב איר בדעה צו נוצן די SPIFFS פּלוגין אין דער צוקונפֿט, מיר רעקאָמענדירן צו ינסטאַלירן די לעגאַט ווערסיע 1.8.X. איר נאָר דאַרפֿן צו מעגילע אַראָפּ אויף די Arduino ווייכווארג בלאַט צו געפֿינען עס.
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
צו ינסטאַלירן די ESP32 ברעט אין דיין Arduino IDE, נאָכגיין די פאלגענדע ינסטראַקשאַנז:
- אין דיין Arduino IDE, גיין צו File> פּרעפֿערענצן
- אַרייַן די פאלגענדע אין די "נאָך באָרד מאַנאַגער URLs" פעלד:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
דערנאָך גיט די "OK" קנעפּל:
באַמערקונג: אויב איר שוין האָבן די 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 דריווערס):
- עפענען די פאלגענדע עקסample אונטער 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 זאָל האָבן די נייַע סקיצע פליסנדיק. דריקן די "ענאַבלע" קנעפּל צו ריסטאַרט די ESP32 און לויפן די נייַ ופּלאָאַדעד סקיצע.
איר וועט אויך האָבן צו איבערחזרן דעם קנעפּל סיקוואַנס יעדער מאָל איר ווילן צו צופֿעליקער אַ נייַע סקיצע.
פּראָיעקט 1 ESP32 ינפּוץ אַוטפּוץ
אין דעם אָנהייב גייד איר וועט לערנען ווי צו לייענען דיגיטאַל ינפּוץ ווי אַ קנעפּל באַשטימען און קאָנטראָלירן דיגיטאַל אַוטפּוץ ווי אַ געפירט מיט די ESP32 מיט Arduino IDE.
פּרירעקוואַזאַץ
מיר פּראָגראַם די ESP32 מיט Arduino IDE. אַזוי, מאַכן זיכער אַז איר האָבן די ESP32 באָרדז אַדישאַן אינסטאַלירן איידער איר פאָרזעצן:
- ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
ESP32 קאָנטראָל דיגיטאַל אַוטפּוץ
ערשטער, איר דאַרפֿן צו שטעלן די GPIO איר ווילן צו קאָנטראָלירן ווי אַ רעזולטאַט. ניצן די pinMode () פֿונקציע ווי גייט:
פּינמאָדע (גפּיאָ, רעזולטאַט);
צו קאָנטראָלירן אַ דיגיטאַל רעזולטאַט, איר נאָר דאַרפֿן צו נוצן די דיגיטאַלWrite () פֿונקציע, וואָס אַקסעפּץ ווי אַרגומענטן, די GPIO (ינט נומער) איר ריפערד צו, און די שטאַט, אָדער הויך אָדער נידעריק.
דיגיטאַלWrite (GPIO, STATE);
אַלע גפּיאָס קענען ווערן גענוצט ווי אַוטפּוץ אַחוץ גפּיאָס 6 צו 11 (פארבונדן צו די ינאַגרייטיד ספּי בליץ) און גפּיאָס 34, 35, 36 און 39 (אַרויסגעבן בלויז גפּיאָס);
לערן מער וועגן די ESP32 GPIOs: ESP32 GPIO רעפערענץ גייד
ESP32 לייענען דיגיטאַל ינפּוץ
ערשטער, שטעלן די GPIO איר ווילן צו לייענען ווי ינפּוט, ניצן די pinMode () פֿונקציע ווי גייט:
פּינמאָדע (גפּיאָ, ינפּוט);
צו לייענען אַ דיגיטאַל אַרייַנשרייַב, ווי אַ קנעפּל, איר נוצן די digitalRead () פֿונקציע, וואָס אַקסעפּץ ווי אַרגומענט, די GPIO (ינט נומער) איר ריפערד צו.
digitalRead (GPIO);
אַלע ESP32 GPIOs קענען זיין געוויינט ווי ינפּוץ, אַחוץ GPIOs 6 צו 11 (פארבונדן צו די ינאַגרייטיד SPI בליץ).
לערן מער וועגן די ESP32 GPIOs: ESP32 GPIO רעפערענץ גייד
פּראָיעקט עקסample
צו ווייַזן איר ווי צו נוצן דיגיטאַל ינפּוץ און דיגיטאַל אַוטפּוץ, מיר בויען אַ פּשוט פּרויעקט עקסampמיט אַ פּושקנעפּל און אַ געפירט. מיר וועלן לייענען די שטאַט פון די פּושקנעפּל און אָנצינדן די געפירט אַקאָרדינגלי ווי ילאַסטרייטיד אין די פאלגענדע פיגור.
פּאַרץ פארלאנגט
דאָ איז אַ רשימה פון די פּאַרץ איר דאַרפֿן צו בויען דעם קרייַז:
- ESP32 DEVKIT V1
- 5 מם געפירט
- 220 אָום רעסיסטאָר
- פּושבוטטאָן
- 10 ק אָום קעגנשטעל
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש דיאַגראַמע
איידער פּראַסידינג, איר דאַרפֿן צו אַסעמבאַל אַ קרייַז מיט אַ געפירט און אַ פּושקנעפּל.
מיר פאַרבינדן די געפירט צו GPIO 5 און די פּושקנעפּל צו GPIO 4.
קאָד
עפֿענען דעם קאָד Project_1_ESP32_Inputs_Outputs.ino אין Arduino IDE
ווי די קאָד אַרבעט
אין די פאלגענדע צוויי שורות, איר מאַכן וועריאַבאַלז צו באַשטימען פּינס:
דער קנעפּל איז קאָננעקטעד צו GPIO 4 און די געפירט איז קאָננעקטעד צו GPIO 5. ווען איר נוצן די Arduino IDE מיט די ESP32, 4 קאָראַספּאַנדז צו GPIO 4 און 5 קאָראַספּאַנדז צו GPIO 5.
ווייַטער, איר מאַכן אַ בייַטעוודיק צו האַלטן די קנעפּל שטאַט. דורך פעליקייַט, עס איז 0 (ניט געדריקט).
int buttonState = 0;
אין די סעטאַפּ (), איר ינישאַלייז די קנעפּל ווי אַ ינפּוט, און די געפירט ווי אַ רעזולטאַט.
פֿאַר דעם, איר נוצן די pinMode () פֿונקציע וואָס אַקסעפּץ די שטיפט איר ריפערד צו, און די מאָדע: INPUT אָדער OUTPUT.
pinMode (קנעפּל פּין, ינפּוט);
pinMode (ledPin, OUTPUT);
אין די שלייף () איז ווו איר לייענען די קנעפּל שטאַט און שטעלן די געפירט אַקאָרדינגלי.
אין דער ווייַטער שורה, איר לייענען דעם קנעפּל שטאַט און ראַטעווען עס אין די קנעפּל שטאַט בייַטעוודיק.
ווי מיר האָבן געזען פריער, איר נוצן די digitalRead () פֿונקציע.
buttonState = digitalRead (קנעפּל פּין);
די פאלגענדע אויב סטאַטעמענט, טשעקס צי די קנעפּל שטאַט איז הויך. אויב דאָס איז, עס טורנס די געפירט מיט די דיגיטאַלWrite () פֿונקציע וואָס אַקסעפּץ ווי אַרגומענט די ledPin און די שטאַט HIGH.
אויב (קנעפּל שטאַט == הויך)
אויב די קנעפּל שטאַט איז נישט הויך, איר שטעלן די געפירט אַוועק. נאָר שטעלן LOW ווי אַ צווייט אַרגומענט אין די digitalWrite () פֿונקציע.
ופּלאָאַדינג די קאָד
איידער איר קליקט אויף די ופּלאָאַד קנעפּל, גיין צו מכשירים > ברעט, און סעלעקטירן דעם ברעט: DOIT ESP32 DEVKIT V1 ברעט.
גיין צו מכשירים > פּאָרט און סעלעקטירן דעם COM פּאָרט צו וואָס די ESP32 איז קאָננעקטעד. דערנאָך, דריקן די ופּלאָאַד קנעפּל און וואַרטן פֿאַר די "געטאן ופּלאָאַדינג" אָנזאָג.
באַמערקונג: אויב איר זען אַ פּלאַץ פון דאַץ (קאַנעקטינג ... __ ...__) אין די דיבאַגינג פֿענצטער און די אָנזאָג "ניט אַנדערש צו פאַרבינדן צו ESP32: טיימד אויס ווארטן פֿאַר פּאַקאַט כעדער", דאָס מיטל איר דאַרפֿן צו דריקן די ESP32 אויף-באָרד שטיוול קנעפּל נאָך די דאַץ
אָנהייב אַפּירינג.טראָובלעשאָאָטינג
דעמאַנסטריישאַן
נאָך ופּלאָאַדינג די קאָד, פּרובירן דיין קרייַז. דיין געפירט זאָל ליכט אַרויף ווען איר דריקן די פּושקנעפּל:
און קער אַוועק ווען איר מעלדונג עס:
פּראָיעקט 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 V פון 3.2 V.
איר וועט באַקומען די זעלבע ווערט פֿאַר ביידע וואָלtagעס: 4095.
דער זעלביקער כאַפּאַנז פֿאַר זייער נידעריק וואָלtagE וואַלועס: פֿאַר 0 V און 0.1 V איר וועט באַקומען די זעלבע ווערט: 0. איר דאַרפֿן צו האַלטן דעם אין זינען ווען איר נוצן די ESP32 ADC פּינס.
analogRead() פֿונקציע
לייענען אַן אַנאַלאָג אַרייַנשרייַב מיט די ESP32 ניצן די Arduino IDE איז ווי פּשוט ווי ניצן די AnalogRead () פונקציע. עס אַקסעפּץ ווי אַרגומענט, די GPIO איר ווילן צו לייענען:
analogRead (GPIO);
בלויז 15 זענען בנימצא אין די DEVKIT V1board (ווערסיע מיט 30 GPIOs).
כאַפּן דיין ESP32 ברעט פּינאָוט און געפֿינען די ADC פּינס. די זענען כיילייטיד מיט אַ רויט גרענעץ אין די פיגור אונטן.
די אַנאַלאָג אַרייַנשרייַב פּינס האָבן 12-ביסל האַכלאָטע. דעם מיטל אַז ווען איר לייענען אַן אַנאַלאָג אַרייַנשרייַב, די קייט קען בייַטן פון 0 צו 4095.
באַמערקונג: ADC2 פּינס קענען ניט זיין געוויינט ווען Wi-Fi איז געניצט. אַזוי, אויב איר נוצן Wi-Fi און איר האָבן קאָנפליקט צו באַקומען די ווערט פון אַ ADC2 GPIO, איר קען באַטראַכטן ניצן אַ ADC1 GPIO אַנשטאָט, וואָס זאָל סאָלווע דיין פּראָבלעם.
צו זען ווי אַלץ טייז צוזאַמען, מיר מאַכן אַ פּשוט עקסample צו לייענען אַן אַנאַלאָג ווערט פון אַ פּאָטענטיאָמעטער.
פּאַרץ פארלאנגט
פֿאַר דעם עקסampליי, איר דאַרפֿן די פאלגענדע פּאַרץ:
- ESP32 DEVKIT V1 באָרד
- פּאָטענטיאָמעטער
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש
דראָט אַ פּאָטענטיאָמעטער צו דיין ESP32. די פּאָטענטיאָמעטער מיטל שטיפט זאָל זיין קאָננעקטעד צו GPIO 4. איר קענען נוצן די פאלגענדע סכעמאַטיש דיאַגראַמע ווי אַ רעפֿערענץ.
קאָד
מיר וועלן פּראָגראַם די ESP32 ניצן Arduino IDE, אַזוי מאַכן זיכער אַז איר האָבן די ESP32 אַדישאַן אינסטאַלירן איידער איר פאָרזעצן: (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
עפֿענען דעם קאָד Project_2_ESP32_Inputs_Outputs.ino אין Arduino IDE
דער קאָד פשוט לייענט די וואַלועס פון די פּאָטענטיאָמעטער און פּרינץ די וואַלועס אין די סיריאַל מאָניטאָר.
אין דעם קאָד, איר אָנהייבן מיט דיפיינינג די GPIO מיט וואָס די פּאָטענטיאָמעטער איז קאָננעקטעד. אין דעם עקסampלע, GPIO 4.
אין די סעטאַפּ (), ינישאַלייז אַ סיריאַל קאָמוניקאַציע מיט אַ באַוד קורס פון 115200.
אין די שלייף (), נוצן די AnalogRead () פֿונקציע צו לייענען די אַנאַלאָג אַרייַנשרייַב פֿון די פּאָטפּין.
צום סוף, דרוקן די וואַלועס לייענען פֿון די פּאָטענטיאָמעטער אין די סיריאַל מאָניטאָר.
צופֿעליקער די קאָד צוגעשטעלט צו דיין ESP32. מאַכן זיכער איר האָבן די רעכט ברעט און COM פּאָרט אויסגעקליבן אין די מכשירים מעניו.
טעסטינג די עקסample
נאָך ופּלאָאַדינג די קאָד און דרינגלעך די ESP32 באַשטעטיק קנעפּל, עפענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200. דרייען די פּאָטענטיאָמעטער און זען די וואַלועס טשאַנגינג.
די מאַקסימום ווערט איר וועט באַקומען איז 4095 און די מינימום ווערט איז 0.
ראַפּינג אַרויף
אין דעם אַרטיקל איר האָט געלערנט ווי צו לייענען אַנאַלאָג ינפּוץ ניצן די ESP32 מיט די Arduino IDE. בקיצור:
- די ESP32 DEVKIT V1 DOIT ברעט (ווערסיע מיט 30 פּינס) האט 15 אַדק פּינס איר קענען נוצן צו לייענען אַנאַלאָג ינפּוץ.
- די פּינס האָבן אַ האַכלאָטע פון 12 ביץ, וואָס מיטל איר קענען באַקומען וואַלועס פון 0 צו 4095.
- צו לייענען אַ ווערט אין די Arduino IDE, איר פשוט נוצן די AnalogRead () פֿונקציע.
- די ESP32 ADC פּינס טאָן ניט האָבן אַ לינעאַר נאַטור. איר וועט מיסטאָמע נישט קענען צו ויסטיילן צווישן 0 און 0.1 וו, אָדער צווישן 3.2 און 3.3 וו. איר דאַרפֿן צו האַלטן דאָס אין זינען ווען איר נוצן די ADC פּינס.
Project 3 ESP32 PWM (אַנאַלאָג רעזולטאַט)
אין דעם טוטאָריאַל מיר וועט ווייַזן איר ווי צו דזשענערייט PWM סיגנאַלז מיט די ESP32 ניצן Arduino IDE. ווי אַן עקסampמיר וועלן בויען אַ פּשוט קרייַז וואָס דימז אַ געפירט מיט די LED PWM קאָנטראָללער פון די ESP32.
ESP32 געפירט פּוום קאָנטראָללער
די ESP32 האט אַ געפירט פּוום קאָנטראָללער מיט 16 פרייַ טשאַנאַלז וואָס קענען זיין קאַנפיגיערד צו דזשענערייט פּוום סיגנאַלז מיט פאַרשידענע פּראָפּערטיעס.
דאָ זענען די סטעפּס איר וועט האָבן צו נאָכפאָלגן צו טונקען אַ געפירט מיט PWM ניצן די Arduino IDE:
- ערשטער, איר דאַרפֿן צו קלייַבן אַ PWM קאַנאַל. עס זענען 16 טשאַנאַלז פון 0 צו 15.
- דערנאָך איר דאַרפֿן צו שטעלן די PWM סיגנאַל אָפטקייַט. פֿאַר אַ געפירט, אַ אָפטקייַט פון 5000 הז איז פייַן צו נוצן.
- איר אויך דאַרפֿן צו שטעלן די האַכלאָטע פון דעם סיגנאַל: איר האָבן רעזאַלושאַנז פון 1 צו 16 ביטן. מיר וועלן נוצן 8-ביסל האַכלאָטע, וואָס מיטל איר קענען קאָנטראָלירן די געפירט ברייטנאַס מיט אַ ווערט פון 0 צו 255.
- דערנאָך, איר דאַרפֿן צו ספּעציפיצירן אויף וואָס GPIO אָדער GPIO ס דער סיגנאַל וועט דערשייַנען. פֿאַר דעם איר וועט נוצן די פאלגענדע פֿונקציע:
ledcAttachPin (GPIO, קאַנאַל)
די פֿונקציע אַקסעפּץ צוויי אַרגומענטן. דער ערשטער איז די GPIO וואָס וועט רעזולטאַט די סיגנאַל, און די רגע איז דער קאַנאַל וואָס וועט דזשענערייט דעם סיגנאַל. - צום סוף, צו קאָנטראָלירן די געפירט ברייטנאַס ניצן PWM, איר נוצן די פאלגענדע פונקציע:
ledcWrite (קאַנאַל, פליכט)
די פֿונקציע אַקסעפּץ ווי אַרגומענטן די קאַנאַל וואָס איז דזשענערייטינג די PWM סיגנאַל און די פליכט ציקל.
פּאַרץ פארלאנגט
צו נאָכפאָלגן דעם טוטאָריאַל איר דאַרפֿן די פּאַרץ:
- ESP32 DEVKIT V1 באָרד
- 5 מם געפירט
- 220 אָום רעסיסטאָר
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש
דראָט אַ געפירט צו דיין ESP32 ווי אין די פאלגענדע סכעמאַטיש דיאַגראַמע. די געפירט זאָל זיין קאָננעקטעד צו GPIO 4.
באַמערקונג: איר קענען נוצן קיין שטיפט איר ווילן, ווי לאַנג ווי עס קענען שפּילן ווי אַ רעזולטאַט. אַלע פּינס וואָס קענען שפּילן ווי אַוטפּוץ קענען זיין געוויינט ווי PWM פּינס. פֿאַר מער אינפֿאָרמאַציע וועגן די ESP32 GPIOs, לייענען: ESP32 Pinout רעפערענץ: וואָס GPIO פּינס זאָל איר נוצן?
קאָד
מיר וועלן פּראָגראַם די ESP32 ניצן Arduino IDE, אַזוי מאַכן זיכער אַז איר האָבן די ESP32 אַדישאַן אינסטאַלירן איידער איר פאָרזעצן: (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
עפֿענען דעם קאָד Project_3_ESP32_PWM.ino אין Arduino IDE
איר אָנהייב דורך דיפיינינג די שטיפט די געפירט איז אַטאַטשט צו. אין דעם פאַל, די געפירט איז אַטאַטשט צו GPIO 4.
דערנאָך איר שטעלן די PWM סיגנאַל פּראָפּערטיעס. איר דעפינירן אַ אָפטקייַט פון 5000 הז, קלייַבן קאַנאַל 0 צו דזשענערייט דעם סיגנאַל און שטעלן אַ האַכלאָטע פון 8 ביטן. איר קענען קלייַבן אנדערע פּראָפּערטיעס, אַנדערש ווי די, צו דזשענערייט פאַרשידענע PWM סיגנאַלז.
אין די סעטאַפּ (), איר דאַרפֿן צו קאַנפיגיער LED PWM מיט די פּראָפּערטיעס וואָס איר האָט דיפיינד פריער דורך ניצן די ledcSetup () פֿונקציע וואָס אַקסעפּץ ווי אַרגומענטן, די ledChannel, די אָפטקייַט און די האַכלאָטע, ווי גייט:
דערנאָך איר דאַרפֿן צו קלייַבן די GPIO פון וואָס איר וועט באַקומען די סיגנאַל. פֿאַר דעם נוצן די ledcAttachPin() פֿונקציע וואָס אַקסעפּץ ווי אַרגומענטן די GPIO וווּ איר ווילט באַקומען דעם סיגנאַל און דער קאַנאַל וואָס דזשענערייץ די סיגנאַל. אין דעם עקסampמיר וועלן באַקומען די סיגנאַל אין די ledPin GPIO, וואָס קאָראַספּאַנדז צו GPIO 4. דער קאַנאַל וואָס דזשענערייץ די סיגנאַל איז די ledChannel, וואָס קאָראַספּאַנדז צו קאַנאַל 0.
אין די שלייף, איר וועט בייַטן די פליכט ציקל צווישן 0 און 255 צו פאַרגרעסערן די געפירט ברייטנאַס.
און דעמאָלט, צווישן 255 און 0 צו פאַרמינערן די ברייטנאַס.
צו שטעלן די ברייטנאַס פון די געפירט, איר נאָר דאַרפֿן צו נוצן די ledcWrite () פֿונקציע וואָס אַקסעפּץ ווי אַרגומענטן די קאַנאַל וואָס איז דזשענערייטינג די סיגנאַל און די פליכט ציקל.
ווי מיר נוצן 8-ביסל האַכלאָטע, די פליכט ציקל וועט זיין קאַנטראָולד מיט אַ ווערט פון 0 צו 255. באַמערקונג אַז אין די ledcWrite() פֿונקציע מיר נוצן דעם קאַנאַל וואָס איז דזשענערייטינג די סיגנאַל, און נישט די GPIO.
טעסטינג די עקסample
צופֿעליקער די קאָד צו דיין ESP32. מאַכט זיכער אַז איר האָט אויסגעקליבן די רעכט ברעט און COM פּאָרט. קוק אין דיין קרייַז. איר זאָל האָבן אַ דיממער געפירט וואָס ינקריסיז און דיקריסאַז ברייטנאַס.
Project 4 ESP32 PIR מאָטיאָן סענסאָר
דער פּרויעקט ווייזט ווי צו דעטעקט באַוועגונג מיט די ESP32 ניצן אַ PIR באַוועגונג סענסער. דער בוזזער וועט געזונט אַ שרעק ווען באַוועגונג איז דיטעקטאַד, און האַלטן די שרעק ווען קיין באַוועגונג איז דיטעקטאַד פֿאַר אַ פּריסעט צייט (אַזאַ ווי 4 סעקונדעס)
ווי HC-SR501 באַוועגונג סענסער אַרבעט
.
דער אַרבעט פּרינציפּ פון HC-SR501 סענסער איז באזירט אויף די ענדערונג פון די ינפרערעד ראַדיאַציע אויף די מאָווינג כייפעץ. צו זיין דיטעקטאַד דורך די HC-SR501 סענסער, דער כייפעץ מוזן טרעפן צוויי רעקווירעמענץ:
- דער כייפעץ איז ימיטינג די ינפרערעד וועג.
- דער כייפעץ איז מאָווינג אָדער שאַקינג
אַזוי:
אויב אַ כייפעץ עמיטינג די ינפרערעד שטראַל אָבער ניט מאָווינג (למשל, אַ מענטש שטייט נאָך אָן מאָווינג), עס איז נישט דיטעקטאַד דורך די סענסער.
אויב אַ כייפעץ איז מאָווינג אָבער נישט ימיטינג די ינפרערעד שטראַל (למשל, ראָבאָט אָדער פאָרמיטל), עס איז נישט דיטעקטאַד דורך די סענסער.
ינטראָודוסינג טיימערז
אין דעם עקסampמיר וועלן אויך פאָרשטעלן טיימערז. מיר ווילן די געפירט צו בלייַבן אויף פֿאַר אַ פּרידיטערמינד נומער פון סעקונדעס נאָך באַוועגונג איז דיטעקטאַד. אַנשטאָט ניצן אַ פאַרהאַלטן () פֿונקציע וואָס בלאַקס דיין קאָד און טוט נישט לאָזן איר צו טאָן עפּעס אַנדערש פֿאַר אַ באשלאסן נומער פון סעקונדעס, מיר זאָל נוצן אַ טייַמער.
די פאַרהאַלטן () פֿונקציע
איר זאָל זיין באַקאַנט מיט די פאַרהאַלטן () פונקציע ווייַל עס איז וויידלי געניצט. דעם פֿונקציע איז גאַנץ פּשוט צו נוצן. עס אַקסעפּץ אַ איין ינט נומער ווי אַן אַרגומענט.
דער נומער רעפּראַזענץ די צייט אין מיליסעקאַנדז וואָס די פּראָגראַם דאַרף וואַרטן ביז איר מאַך אויף צו דער ווייַטער שורה פון קאָד.
ווען איר פאַרהאַלטן (1000) דיין פּראָגראַם סטאַפּס אויף די שורה פֿאַר 1 רגע.
פאַרהאַלטן () איז אַ בלאַקינג פֿונקציע. בלאַקינג פאַנגקשאַנז פאַרמייַדן אַ פּראָגראַם פון טאן עפּעס אַנדערש ביז אַז באַזונדער אַרבעט איז געענדיקט. אויב איר דאַרפֿן קייפל טאַסקס צו פאַלן אין דער זעלביקער צייט, איר קענען נישט נוצן פאַרהאַלטן ().
פֿאַר רובֿ פּראַדזשעקס, איר זאָל ויסמיידן דילייז און נוצן טיימערז אַנשטאָט.
די מיליס () פֿונקציע
ניצן אַ פֿונקציע גערופֿן מיליס () איר קענען צוריקקומען די נומער פון מיליסעקאַנדז וואָס זענען דורכגעגאנגען זינט די פּראָגראַם ערשטער סטאַרטעד.
פארוואס איז די פונקציע נוציק? ווייַל דורך ניצן עטלעכע מאַט, איר קענען לייכט באַשטעטיקן ווי פיל צייט איז דורכגעגאנגען אָן בלאַקינג דיין קאָד.
פּאַרץ פארלאנגט
צו נאָכפאָלגן דעם טוטאָריאַל איר דאַרפֿן די פאלגענדע פּאַרץ
- ESP32 DEVKIT V1 באָרד
- PIR באַוועגונג סענסער (HC-SR501)
- אַקטיוו באַזער
- דזשאַמפּער ווירעס
- ברעאַדבאָאַרד
סכעמאַטיש
באַמערקונג: די אַרבעט וואָלtagE פון HC-SR501 איז 5 וו. ניצן די Vin שטיפט צו מאַכט עס.
קאָד
איידער איר פאָרזעצן מיט דעם טוטאָריאַל, איר זאָל האָבן די ESP32 אַדישאַן אינסטאַלירן אין דיין Arduino IDE. גיי איינער פון די פאלגענדע טוטאָריאַלז צו ינסטאַלירן די ESP32 אויף די Arduino IDE, אויב איר האָט נישט שוין. (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
עפֿענען דעם קאָד Project_4_ESP32_PIR_Motion_Sensor.ino אין Arduino IDE.
דעמאַנסטריישאַן
צופֿעליקער די קאָד צו דיין ESP32 ברעט. מאַכן זיכער איר האָבן די רעכט ברעט און קאַם פּאָרט אויסגעקליבן. ופּלאָאַד קאָד דערמאָנען טריט.
עפֿענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200.
מאַך דיין האַנט אין פראָנט פון די PIR סענסער. דער בוזזער זאָל קער אויף, און דער אָנזאָג איז געדרוקט אין די סיריאַל מאָניטאָר געזאגט "מאָטיאָן דיטעקטיד! בוזזער שרעק".
נאָך 4 סעקונדעס די זשומען זאָל קער אַוועק.
פּראָיעקט 5 ESP32 סוויטש Web סערווירער
אין דעם פּרויעקט איר וועט מאַכן אַ סטאַנדאַלאָנע web סערווער מיט אַן ESP32 וואָס קאָנטראָלס אַוטפּוץ (צוויי לעדס) ניצן די Arduino IDE פּראָגראַממינג סוויווע. די web סערווער איז רירעוודיק אָפּרופיק און קענען זיין אַקסעסט מיט קיין מיטל ווי אַ בלעטערער אויף די היגע נעץ. מיר וועט ווייַזן איר ווי צו מאַכן די web סערווער און ווי דער קאָד אַרבעט שריט-דורך-שריט.
פּראָיעקט איבערview
איידער איר גיין גלייך צו די פּרויעקט, עס איז וויכטיק צו דערקלערן וואָס אונדזער web די סערווער וועט זיין געטאן, אַזוי עס איז גרינגער צו נאָכפאָלגן די סטעפּס שפּעטער.
- די web די סערווער איר וועט בויען קאָנטראָלס צוויי לעדס פארבונדן צו די ESP32 GPIO 26 און GPIO 27;
- איר קענט אַקסעס די ESP32 web סערווער דורך טייפּינג די ESP32 IP אַדרעס אויף אַ בלעטערער אין די היגע נעץ;
- דורך געבן אַ קליק אויף דיין קנעפּל web סערווער איר קענען טייקעף טוישן די שטאַט פון יעדער געפירט.
פּאַרץ פארלאנגט
פֿאַר דעם טוטאָריאַל איר וועט דאַרפֿן די פאלגענדע פּאַרץ:
- ESP32 DEVKIT V1 באָרד
- 2x 5mm געפירט
- 2 קס 200 אָהם רעסיסטאָר
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש
אָנהייב דורך בויען דעם קרייַז. פאַרבינדן צוויי לעדס צו די ESP32 ווי געוויזן אין די פאלגענדע סכעמאַטיש דיאַגראַמע - איינער געפירט פארבונדן צו GPIO 26, און די אנדערע צו GPIO 27.
באַמערקונג: מיר נוצן די ESP32 DEVKIT DOIT ברעט מיט 36 פּינס. איידער איר אַסעמבאַל די קרייַז, מאַכן זיכער איר קאָנטראָלירן די פּינאָוט פֿאַר די ברעט איר נוצן.
קאָד
דאָ מיר צושטעלן די קאָד וואָס קריייץ די 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 און וואַרטן אַ ביסל סעקונדעס בשעת די קאָד קאַמפּיילז און ופּלאָאַדס צו דיין ברעט.
- וואַרטן פֿאַר די אָנזאָג "געטאן ופּלאָאַדינג".
געפֿינען די ESP IP אַדרעס
נאָך ופּלאָאַדינג די קאָד, עפענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200.
דריקן די ESP32 EN קנעפּל (באַשטעטיק). די ESP32 קאַנעקץ צו Wi-Fi און אַוטפּוץ די ESP IP אַדרעס אויף די סיריאַל מאָניטאָר. נאָכמאַכן די IP אַדרעס, ווייַל איר דאַרפֿן עס צו אַקסעס די ESP32 web סערווער.
אַקסעס די Web סערווירער
צו אַקסעס די web סערווער, עפֿענען דיין בלעטערער, פּאַפּ די ESP32 IP אַדרעס, און איר וועט זען די פאלגענדע בלאַט.
באַמערקונג: דיין בלעטערער און ESP32 זאָל זיין קאָננעקטעד צו דער זעלביקער לאַן.
אויב איר נעמען אַ קוק אין די סיריאַל מאָניטאָר, איר קענען זען וואָס איז געשעעניש אויף דער הינטערגרונט. די ESP באקומט אַ הטטפּ בעטן פון אַ נייַע קליענט (אין דעם פאַל, דיין בלעטערער).
איר קענט אויך זען אנדערע אינפֿאָרמאַציע וועגן די HTTP בעטן.
דעמאַנסטריישאַן
איצט איר קענען פּרובירן אויב דיין web סערווער איז ארבעטן רעכט. דריקט אויף די קנעפּלעך צו קאָנטראָלירן די לעדס.
אין דער זעלביקער צייט, איר קענען נעמען אַ קוק אין די סיריאַל מאָניטאָר צו זען וואָס איז געשעעניש אין דער הינטערגרונט. פֿאַר עקסampאויב איר גיט די קנעפּל צו קער GPIO 26 אויף, ESP32 באקומט אַ בקשה אויף די /26/on URL.
ווען די ESP32 באקומט די בעטן, עס טורנס די געפירט אַטאַטשט צו GPIO 26 ON און דערהייַנטיקט זיין שטאַט אויף די web בלאַט.
דער קנעפּל פֿאַר GPIO 27 אַרבעט אויף אַ ענלעך וועג. פּרובירן אַז עס אַרבעט רעכט.
ווי די קאָד אַרבעט
אין דעם אָפּטיילונג וועט נעמען אַ נעענטער קוק אין די קאָד צו זען ווי עס אַרבעט.
דער ערשטער זאַך איר דאַרפֿן צו טאָן איז צו אַרייַננעמען די וויפי ביבליאָטעק.
ווי דערמאנט פריער, איר דאַרפֿן צו אַרייַנלייגן דיין ssid און פּאַראָל אין די פאלגענדע שורות אין די טאָפּל קוואָטעס.
דערנאָך, איר שטעלן דיין web סערווער צו פּאָרט 80.
די פאלגענדע שורה קריייץ אַ בייַטעוודיק צו קראָם די כעדער פון די HTTP בעטן:
דערנאָך איר שאַפֿן אַגזיליערי וועריאַבאַלז צו קראָם די קראַנט שטאַט פון דיין אַוטפּוץ. אויב איר ווילן צו לייגן מער אַוטפּוץ און ראַטעווען זייַן שטאַט, איר דאַרפֿן צו שאַפֿן מער וועריאַבאַלז.
איר אויך דאַרפֿן צו באַשטימען אַ GPIO צו יעדער פון דיין אַוטפּוץ. דאָ מיר זענען ניצן GPIO 26 און GPIO 27. איר קענען נוצן קיין אנדערע פּאַסיק GPIOs.
סעטאַפּ ()
איצט, לאָזן אונדז גיין אין די סעטאַפּ (). ערשטער, מיר אָנהייבן אַ סיריאַל קאָמוניקאַציע מיט אַ באַוד קורס פון 115200 פֿאַר דיבאַגינג צוועקן.
איר אויך דעפינירן דיין GPIOs ווי אַוטפּוץ און שטעלן זיי צו נידעריק.
די פאלגענדע שורות אָנהייבן די ווי-פי קשר מיט WiFi.begin(ssid, פּאַראָל), וואַרטן פֿאַר אַ געראָטן קשר און דרוקן די ESP IP אַדרעס אין די סיריאַל מאָניטאָר.
שלייף ()
אין די שלייף () מיר פּראָגראַם וואָס כאַפּאַנז ווען אַ נייַע קליענט יסטאַבלישיז אַ קשר מיט די web סערווער.
די ESP32 איז שטענדיק צוגעהערט פֿאַר ינקאַמינג קלייאַנץ מיט די פאלגענדע שורה:
ווען אַ בקשה איז באקומען פון אַ קליענט, מיר ראַטעווען די ינקאַמינג דאַטן. דער בשעת שלייף וואָס גייט וועט זיין פליסנדיק אַזוי לאַנג ווי דער קליענט סטייז קאָננעקטעד. מיר רעקאָמענדירן נישט צו טוישן די פאלגענדע טייל פון די קאָד אויב איר וויסן פּונקט וואָס איר טאָן.
דער ווייַטער אָפּטיילונג פון אויב און אַנדערש סטייטמאַנץ טשעקס וואָס קנעפּל איז געדריקט אין דיין web בלאַט, און קאָנטראָלס די אַוטפּוץ אַקאָרדינגלי. ווי מיר האָבן געזען פריער, מיר מאַכן אַ בקשה אויף פאַרשידענע URLס דיפּענדינג אויף דעם קנעפּל געדריקט.
פֿאַר עקסampאויב איר האָט דריקן די GPIO 26 ON קנעפּל, די ESP32 נעמט אַ בקשה אויף די /26/ON URL (מיר קענען זען אַז די אינפֿאָרמאַציע אויף די הטטפּ כעדער אויף די סיריאַל מאָניטאָר). אַזוי, מיר קענען קאָנטראָלירן אויב די כעדער כּולל די אויסדרוק GET /26/on. אויב עס כּולל, מיר טוישן די רעזולטאַט 26 שטאַט בייַטעוודיק צו ON, און די ESP32 טורנס די געפירט אויף.
דאָס אַרבעט סימילאַרלי פֿאַר די אנדערע קנעפּלעך. אַזוי, אויב איר ווילן צו לייגן מער אַוטפּוץ, איר זאָל מאָדיפיצירן דעם טייל פון די קאָד צו אַרייַננעמען זיי.
ווייַזנדיק HTML web בלאַט
דער ווייַטער זאַך איר דאַרפֿן צו טאָן איז קריייטינג די web בלאַט. די ESP32 וועט שיקן אַ ענטפער צו דיין בלעטערער מיט עטלעכע HTML קאָד צו בויען די web בלאַט.
די web בלאַט איז געשיקט צו דעם קליענט ניצן דעם יקספּרעסינג client.println(). איר זאָל אַרייַן וואָס איר ווילן צו שיקן צו דעם קליענט ווי אַ אַרגומענט.
דער ערשטער זאַך מיר זאָל שיקן איז שטענדיק די פאלגענדע שורה, וואָס ינדיקייץ אַז מיר שיקן HTML.
דערנאָך, די פאלגענדע שורה מאכט די web בלאַט אָפּרופיק אין קיין web בלעטערער.
און די פאלגענדע איז געניצט צו פאַרמייַדן ריקוועס אויף די פאַוויקאָן. – איר טאָן ניט דאַרפֿן צו זאָרג וועגן דעם שורה.
סטילינג די Web בלאַט
ווייַטער, מיר האָבן עטלעכע CSS טעקסט צו סטיל די קנעפּלעך און די web בלאַט אויסזען.
מיר קלייַבן די Helvetica שריפֿט, דעפינירן די אינהאַלט צו זיין געוויזן ווי אַ בלאָק און אַליינד אין דעם צענטער.
מיר סטיל אונדזער קנעפּלעך מיט די #4CAF50 קאָליר, אָן גרענעץ, טעקסט אין ווייַס קאָליר, און מיט דעם וואַטן: 16px 40px. מיר אויך שטעלן די טעקסט באַפּוצונג צו גאָרניט, דעפינירן די שריפֿט גרייס, די גרענעץ און די לויפֿער צו אַ טייַטל.
מיר דעפינירן אויך דעם נוסח פאר א צווייטן קנעפל, מיט אלע אייגנשאפטן פונעם קנעפל וואס מיר האבן פריער דעפינירט, אבער מיט אן אנדער קאליר. דאָס וועט זיין דער נוסח פֿאַר די אַוועק קנעפּל.
באַשטעטיקן די Web Page First Heading
אין דער ווייַטער שורה איר קענען שטעלן די ערשטער כעדינג פון דיין web בלאַט. דאָ מיר האָבן "ESP32 Web סערווירער", אָבער איר קענען טוישן דעם טעקסט צו וועלכער איר ווילט.
ווייַזנדיק די קנעפּלעך און קאָראַספּאַנדינג שטאַט
דערנאָך, איר שרייַבן אַ פּאַראַגראַף צו ווייַזן די GPIO 26 קראַנט שטאַט. ווי איר קענען זען, מיר נוצן די output26State בייַטעוודיק, אַזוי אַז די שטאַט דערהייַנטיקונגען טייקעף ווען די בייַטעוודיק ענדערונגען.
דערנאָך, מיר ווייַזן די אויף אָדער די אַוועק קנעפּל, דיפּענדינג אויף די קראַנט שטאַט פון די GPIO. אויב די קראַנט שטאַט פון די GPIO איז אַוועק, מיר ווייַזן די ON קנעפּל, אויב נישט, מיר ווייַזן די OFF קנעפּל.
מיר נוצן די זעלבע פּראָצעדור פֿאַר GPIO 27.
קלאָוזינג די קשר
צום סוף, ווען דער ענטפער ענדס, מיר ויסמעקן די כעדער בייַטעוודיק, און האַלטן די קשר מיט דעם קליענט מיט client.stop().
ראַפּינג אַרויף
אין דעם טוטאָריאַל מיר האָבן געוויזן איר ווי צו בויען אַ web סערווער מיט די ESP32. מיר האָבן געוויזן איר אַ פּשוט עקסampדי וואָס קאָנטראָלס צוויי לעדס, אָבער דער געדאַנק איז צו פאַרבייַטן די לעדס מיט אַ רעלע אָדער קיין אנדערע רעזולטאַט איר ווילן צו קאָנטראָלירן.
Project 6 RGB LED Web סערווירער
אין דעם פּרויעקט מיר וועט ווייַזן איר ווי צו רימאָוטלי קאָנטראָל אַ RGB געפירט מיט אַן ESP32 ברעט מיט אַ web סערווער מיט אַ קאָליר פּיקער.
פּראָיעקט איבערview
איידער איר אָנהייבן, לאָמיר זען ווי די פּרויעקט אַרבעט:
- די ESP32 web סערווער דיספּלייז אַ קאָליר פּיקער.
- ווען איר האָט אויסדערוויילט אַ קאָליר, דיין בלעטערער מאכט אַ בקשה אויף אַ URL וואָס כּולל די R, G און B פּאַראַמעטערס פון די אויסגעקליבן קאָליר.
- דיין ESP32 נעמט די בקשה און ספּליץ די ווערט פֿאַר יעדער קאָליר פּאַראַמעטער.
- דערנאָך, עס סענדז אַ PWM סיגנאַל מיט די קאָראַספּאַנדינג ווערט צו די GPIOs וואָס קאָנטראָלירן די RGB געפירט.
ווי טאָן RGB לעדס אַרבעט?
אין אַ פּראָסט קאַטאָוד רגב געפירט, אַלע דרייַ לעדס טיילן אַ נעגאַטיוו קשר (קאַטאָוד). אַלע אַרייַנגערעכנט אין די קיט זענען פּראָסט-קאַטאָוד רגב.
ווי צו מאַכן פאַרשידענע פארבן?
מיט אַ RGB געפירט איר קענען, פון קורס, פּראָדוצירן רויט, גרין און בלוי ליכט, און דורך קאַנפיגיערינג די ינטענסיטי פון יעדער געפירט, איר קענען פּראָדוצירן אנדערע פארבן.
פֿאַר עקסampליי, צו פּראָדוצירן ריין בלוי ליכט, איר'ד שטעלן די בלוי געפירט צו די העכסטן ינטענסיטי און די גרין און רויט לעדס צו די לאָואַסט ינטענסיטי. פֿאַר אַ ווייַס ליכט, איר'ד שטעלן אַלע דריי לעדס צו די העכסטן ינטענסיטי.
מיקסינג פארבן
צו פּראָדוצירן אנדערע פארבן, איר קענען פאַרבינדן די דריי פארבן אין פאַרשידענע ינטענסיטיז. צו סטרויערן די ינטענסיטי פון יעדער געפירט איר קענען נוצן אַ PWM סיגנאַל.
ווייַל די לעדס זענען זייער נאָענט צו יעדער אנדערער, אונדזער אויגן זען די רעזולטאַט פון די קאָמבינאַציע פון פארבן, אלא ווי די דריי פארבן ינדיווידזשואַלי.
צו האָבן אַ געדאַנק ווי צו פאַרבינדן די פארבן, קוק אין די פאלגענדע טשאַרט.
דאָס איז די סימפּלאַסט קאָליר מיקסינג טשאַרט, אָבער גיט איר אַ געדאַנק ווי עס אַרבעט און ווי צו פּראָדוצירן פאַרשידענע פארבן.
פּאַרץ פארלאנגט
פֿאַר דעם פּרויעקט איר דאַרפֿן די פאלגענדע טיילן:
- ESP32 DEVKIT V1 באָרד
- RGB געפירט
- 3 קס 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-ביסל
אין די סעטאַפּ (), באַשטימען די PWM פּראָפּערטיעס צו די PWM טשאַנאַלז
צוטשעפּען די PWM טשאַנאַלז צו די קאָראַספּאַנדינג GPIOs
די פאלגענדע קאָד אָפּטיילונג דיספּלייז די קאָליר פּיקער אין דיין web בלאַט און מאכט אַ בקשה באזירט אויף די קאָליר איר האָט פּיקט.
ווען איר קלייַבן אַ קאָליר, איר באַקומען אַ בקשה מיט די פאלגענדע פֿאָרמאַט.
אַזוי, מיר דאַרפֿן צו שפּאַלטן דעם שטריקל צו באַקומען די R, G, און B פּאַראַמעטערס. די פּאַראַמעטערס זענען געראטעוועט אין רעדסטרינג, גריןסטרינג און בלועסטרינג וועריאַבאַלז און קענען האָבן וואַלועס צווישן 0 און 255.
צו קאָנטראָלירן דעם פּאַס מיט די ESP32, נוצן די ledcWrite () פֿונקציע צו דזשענערייט פּוום סיגנאַלז מיט די וואַלועס דיקאָודאַד פֿון די הטטפּ. בעטן.
באַמערקונג: לערנען מער וועגן PWM מיט ESP32: Project 3 ESP32 PWM (אַנאַלאָג רעזולטאַט)
צו קאָנטראָלירן די פּאַס מיט די ESP8266, מיר נאָר דאַרפֿן צו נוצן
די אַנאַלאָגווריטע () פֿונקציע צו דזשענערייט פּוום סיגנאַלז מיט די וואַלועס דעקאָדעד פֿון די HTPP בעטן.
אַנאַלאָגווריטע (רעדפּין, רעדסטרינג.טאָינט ());
אַנאַלאָגווריטע (גרין פּין, גריןסטרינג.טאָינט ());
analogWrite(בלועפּין, בלוסטרינג.טאָינט ())
ווייַל מיר באַקומען די וואַלועס אין אַ שטריקל בייַטעוודיק, מיר דאַרפֿן צו גער זיי צו ינטאַדזשערז מיט די toInt () אופֿן.
דעמאַנסטריישאַן
נאָך ינסערטינג דיין נעץ קראַדענטשאַלז, אויסקלייַבן די רעכט ברעט און קאַם פּאָרט און ופּלאָאַד די קאָד צו דיין ESP32.Upload קאָד רעפֿערענץ סטעפּס.
נאָך ופּלאָאַדינג, עפֿענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200 און דריקן די ESP געבן / באַשטעטיק קנעפּל. איר זאָל באַקומען די ברעט IP אַדרעס.
עפֿענען דיין בלעטערער און אַרייַן די ESP IP אַדרעס. איצט, נוצן די קאָליר פּיקער צו קלייַבן אַ קאָליר פֿאַר די RGB געפירט.
דערנאָך, איר דאַרפֿן צו דריקן די "טוישן קאָליר" קנעפּל פֿאַר די קאָליר צו נעמען ווירקונג.
צו קער אַוועק די RGB LED, אויסקלייַבן די שוואַרץ קאָליר.
די סטראָנגעסט פארבן (אין די שפּיץ פון די קאָליר פּיקער), זענען די וואָס וועט פּראָדוצירן בעסער רעזולטאַטן.
פּראָיעקט 7 ESP32 רעלע Web סערווירער
ניצן אַ רעלע מיט די ESP32 איז אַ גרויס וועג צו קאָנטראָלירן אַק הויזגעזינד אַפּפּליאַנסעס רימאָוטלי. דער טוטאָריאַל דערקלערט ווי צו קאָנטראָלירן אַ רעלע מאָדולע מיט די ESP32.
מיר וועלן נעמען אַ קוק אין ווי אַ רעלע מאָדולע אַרבעט, ווי צו פאַרבינדן די רעלע צו די ESP32 און בויען אַ web סערווער צו קאָנטראָלירן אַ רעלע רימאָוטלי.
ינטראָודוסינג רילייז
א רעלע איז אן עלעקטריק אפערירטע סוויטש און ווי יעדע אנדערע סוויטש, קען מען אים אומקערן אדער אפשטעלן, לאזן דעם שטראם דורכגיין אדער נישט. עס קענען זיין קאַנטראָולד מיט נידעריק וואָלtagעס, ווי די 3.3 וו צוגעשטעלט דורך די ESP32 GPIOs און אַלאַוז אונדז צו קאָנטראָלירן הויך וואָקtagעס איז ווי 12 וו, 24 וו אָדער מיינזtagE (230 וו אין אייראָפּע און 120 וו אין די יו. עס.).
אויף די לינקס זייַט, עס זענען צוויי שטעלט פון דריי סאַקאַץ צו פאַרבינדן הויך וואָלtagעס, און די פּינס אויף די רעכט זייַט (נידעריק-באַנדtage) פאַרבינדן צו די ESP32 GPIOs.
מאַינס וואָלtage קאַנעקשאַנז
די רעלע מאָדולע געוויזן אין די פריערדיקע פאָטאָ האט צוויי קאַנעקטערז, יעדער מיט דריי סאַקאַץ: פּראָסט (COM), נאָרמאַללי פארמאכט (NC) און נאָרמאַלי עפֿן (קיין).
- COM: פאַרבינדן די קראַנט איר ווילן צו קאָנטראָלירן (מיינז voltagאון).
- NC (נאָרמאַלי קלאָוזד): די נאָרמאַללי פֿאַרמאַכט קאַנפיגיעריישאַן איז געניצט ווען איר ווילן צו זיין פארמאכט דורך פעליקייַט די רעלע. די NC זענען COM פּינס קאָננעקטעד, טייַטש אַז דער קראַנט איז פלאָוינג סייַדן איר שיקן אַ סיגנאַל פון די ESP32 צו די רעלע מאָדולע צו עפֿענען דעם קרייַז און האַלטן די קראַנט לויפן.
- NO (נאָרמאַלי עפֿן): די נאָרמאַללי אָפֿן קאַנפיגיעריישאַן אַרבעט די אנדערע וועג אַרום: עס איז קיין קשר צווישן די NO און COM פּינס, אַזוי דער קרייַז איז צעבראכן סייַדן איר שיקן אַ סיגנאַל פון די ESP32 צו פאַרמאַכן דעם קרייַז.
קאָנטראָל פּינס
די נידעריק-וואָלtagדי זייַט האט אַ גאַנג פון פיר פּינס און אַ גאַנג פון דריי פּינס. דער ערשטער גאַנג באשטייט פון VCC און GND צו מאַכט די מאָדולע, און אַרייַנשרייַב 1 (IN1) און אַרייַנשרייַב 2 (IN2) צו קאָנטראָלירן די דנאָ און שפּיץ רילייז ריספּעקטיוולי.
אויב דיין רעלע מאָדולע האט בלויז איין קאַנאַל, איר וועט האָבן בלויז איין IN שטיפט. אויב איר האָט פיר טשאַנאַלז, איר וועט האָבן פיר IN פּינס, און אַזוי אויף.
דער סיגנאַל איר שיקן צו די IN פּינס, דיטערמאַנז צי די רעלע איז אַקטיוו אָדער נישט. דער רעלע איז טריגערד ווען די אַרייַנשרייַב גייט אונטער וועגן 2 וו. דעם מיטל אַז איר וועט האָבן די פאלגענדע סינעריאָוז:
- נאָרמאַללי פֿאַרמאַכט קאַנפיגיעריישאַן (NC):
- הויך סיגנאַל - קראַנט איז פלאָוינג
- נידעריק סיגנאַל - די קראַנט איז נישט פלאָוינג
- נאָרמאַללי עפֿן קאַנפיגיעריישאַן (ניין):
- הויך סיגנאַל - די קראַנט איז נישט פלאָוינג
- נידעריק סיגנאַל - קראַנט אין פלאָוינג
איר זאָל נוצן אַ נאָרמאַלי פארמאכט קאַנפיגיעריישאַן ווען די קראַנט זאָל לויפן רובֿ פון די צייט, און איר נאָר ווילן צו האַלטן עס טייל מאָל.
ניצן אַ נאָרמאַללי אָפֿן קאַנפיגיעריישאַן ווען איר ווילן די קראַנט לויפן טייל מאָל (למשלampל, קער אויף עלamp טייל מאָל).
מאַכט צושטעלן סעלעקציע
די רגע גאַנג פון פּינס באשטייט פון GND, VCC און JD-VCC פּינס.
די JD-VCC שטיפט מאַכט די ילעקטראָומאַגנעט פון די רעלע. באַמערקונג אַז דער מאָדולע האט אַ דזשאַמפּער היטל קאַנעקטינג די VCC און JD-VCC פּינס; דער איינער געוויזן דאָ איז געל, אָבער דיין קען זיין אַ אַנדערש קאָליר.
מיט די דזשאַמפּער היטל אויף, די VCC און JD-VCC פּינס זענען פארבונדן. אַז מיטל די רעלע ילעקטראָומאַגנעט איז גלייך Powered פֿון די ESP32 מאַכט שפּילקע, אַזוי די רעלע מאָדולע און די ESP32 סערקאַץ זענען נישט פיזיקלי אפגעזונדערט פון יעדער אנדערער.
אָן די דזשאַמפּער היטל, איר דאַרפֿן צו צושטעלן אַ פרייַ מאַכט מקור צו מאַכט די ילעקטראָומאַגנעט פון די רעלע דורך די JD-VCC שטיפט. די קאַנפיגיעריישאַן יזאָלייץ פיזיקלי די רילייז פון די ESP32 מיט די געבויט-אין אָפּטאָקאָופּלער פון די מאָדולע, וואָס פּריווענץ שעדיקן צו די ESP32 אין פאַל פון עלעקטריקאַל ספּייקס.
סכעמאַטיש
ווארענונג: נוצן פון הויך וואָלtagמאַכט סופּפּליעס קען פאַרשאַפן ערנסט שאָדן.
דעריבער, 5 מם לעדס זענען געניצט אַנשטאָט פון הויך צושטעלן וואָלtagE באַלבז אין דער עקספּערימענט. אויב איר זענט נישט באַקאַנט מיט מאַינס וואָלtagפרעגן עמעצער וואס איז צו העלפן איר. בשעת פּראָגראַממינג די ESP אָדער וויירינג דיין קרייַז, מאַכן זיכער אַז אַלץ איז דיסקאַנעקטיד פון די מעינסtage.
ינסטאָלינג די ביבליאָטעק פֿאַר ESP32
צו בויען דעם web סערווער, מיר נוצן די ESPAsyncWebסערווירער ביבליאָטעק און אַסינקטקפּ ביבליאָטעק.
ינסטאָלינג די ESPAsyncWebסערווירער ביבליאָטעק
גיי די ווייַטער סטעפּס צו ינסטאַלירן די ESPAsyncWebסערווירער ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די ESPAsyncWebסערווירער ביבליאָטעק. איר זאָל האָבן
אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע - אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען ESPAsyncWebסערווירער-בעל טעקע
- רענאַמע דיין טעקע פֿון ESPAsyncWebסערווירער-בעל צו ESPAsyncWebסערווירער
- מאַך די ESPAsyncWebסערווירער טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
אַלטערנאַטיוועלי, אין דיין Arduino IDE, איר קענען גיין צו סקיצע> אַרייַננעמען
ביבליאָטעק> לייג .זיפּ ביבליאָטעק ... און אויסקלייַבן די ביבליאָטעק וואָס איר האָט פּונקט דאַונלאָודיד.
ינסטאָלינג די AsyncTCP ביבליאָטעק פֿאַר ESP32
די ESPAsyncWebסערווירער ביבליאָטעק ריקווייערז די AsyncTCP ביבליאָטעק צו אַרבעטן. גיי
די ווייַטער סטעפּס צו ינסטאַלירן די ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די AsyncTCP ביבליאָטעק. איר זאָל האָבן אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע
- אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען AsyncTCP-master טעקע
1. רענאַמע דיין טעקע פֿון AsyncTCP-master צו AsyncTCP
3. מאַך די AsyncTCP טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
4. סוף, שייַעך-עפענען דיין Arduino IDE
אַלטערנאַטיוועלי, אין דיין Arduino IDE, איר קענען גיין צו סקיצע> אַרייַננעמען
ביבליאָטעק> לייג .זיפּ ביבליאָטעק ... און אויסקלייַבן די ביבליאָטעק וואָס איר האָט פּונקט דאַונלאָודיד.
קאָד
מיר וועלן פּראָגראַם די ESP32 ניצן Arduino IDE, אַזוי מאַכן זיכער אַז איר האָבן די ESP32 אַדישאַן אינסטאַלירן איידער איר פאָרזעצן: (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
נאָך ינסטאָלינג די פארלאנגט לייברעריז, עפֿענען די קאָד Project_7_ESP32_Relay_Web_Server.ino אין Arduino IDE.
איידער איר ופּלאָאַדינג די קאָד, טאָן ניט פאַרגעסן צו אַרייַנלייגן דיין נעץ קראַדענטשאַלז אַזוי אַז די ESP קענען פאַרבינדן צו דיין היגע נעץ.
דעמאַנסטריישאַן
נאָך מאַכן די נייטיק ענדערונגען, צופֿעליקער די קאָד צו דיין ESP32.Upload קאָד רעפֿערענץ סטעפּס.
עפֿענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200 און דריקן די ESP32 EN קנעפּל צו באַקומען זיין IP אַדרעס. דערנאָך, עפֿענען אַ בלעטערער אין דיין היגע נעץ און אַרייַן די ESP32 IP אַדרעס צו באַקומען אַקסעס צו די IP אַדרעס. web סערווער.
עפֿענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200 און דריקן די ESP32 EN קנעפּל צו באַקומען זיין IP אַדרעס. דערנאָך, עפֿענען אַ בלעטערער אין דיין היגע נעץ און אַרייַן די ESP32 IP אַדרעס צו באַקומען אַקסעס צו די IP אַדרעס. web סערווער.
באַמערקונג: דיין בלעטערער און ESP32 זאָל זיין קאָננעקטעד צו דער זעלביקער לאַן.
איר זאָל באַקומען עפּעס ווי גייט מיט ווי צוויי קנעפּלעך ווי די נומער פון רילייז איר האָבן דיפיינד אין דיין קאָד.
איצט איר קענען נוצן די קנעפּלעך צו קאָנטראָלירן דיין רילייז מיט דיין סמאַרטפאָנע.
Project_8_Output_State_Synchronization_ Web_סערווירער
דער פּראָיעקט ווייזט ווי צו קאָנטראָלירן די ESP32 אָדער ESP8266 אַוטפּוץ מיט אַ web סערווער און אַ גשמיות קנעפּל סיימאַלטייניאַסלי. דער רעזולטאַט שטאַט איז דערהייַנטיקט אויף די web בלאַט צי עס איז פארענדערט דורך גשמיות קנעפּל אָדער web סערווער.
פּראָיעקט איבערview
זאל ס נעמען אַ שנעל קוק ווי די פּרויעקט אַרבעט.
די ESP32 אָדער ESP8266 האָסץ אַ web סערווער וואָס אַלאַוז איר צו קאָנטראָלירן די פּראָדוקציע שטאַט;
- די קראַנט רעזולטאַט שטאַט איז געוויזן אויף די web סערווער;
- די ESP איז אויך קאָננעקטעד צו אַ גשמיות פּושקנעפּל וואָס קאָנטראָלס די זעלבע רעזולטאַט;
- אויב איר טוישן די רעזולטאַט שטאַט מיט די גשמיות דרוק קנעפּל, די קראַנט שטאַט איז אויך דערהייַנטיקט אויף די web סערווער.
אין קיצער, דעם פּרויעקט אַלאַוז איר צו קאָנטראָלירן די זעלבע רעזולטאַט מיט אַ web סערווער און אַ שטופּן קנעפּל סיימאַלטייניאַסלי. ווען דער רעזולטאַט שטאַט ענדערונגען, די web סערווער איז דערהייַנטיקט.
פּאַרץ פארלאנגט
דאָ איז אַ רשימה פון די פּאַרץ איר דאַרפֿן צו בויען דעם קרייַז:
- ESP32 DEVKIT V1 באָרד
- 5 מם געפירט
- 220 אָום קעגנשטעל
- פּושבוטטאָן
- 10 ק אָום קעגנשטעל
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש
ינסטאָלינג די ביבליאָטעק פֿאַר ESP32
צו בויען דעם web סערווער, מיר נוצן די ESPAsyncWebסערווירער ביבליאָטעק און AsyncTCP ביבליאָטעק. (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג די ESPAsyncWebסערווירער ביבליאָטעק
גיי די ווייַטער סטעפּס צו ינסטאַלירן די ESPAsyncWebסערווירער ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די ESPAsyncWebסערווירער ביבליאָטעק. איר זאָל האָבן
אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע - אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען ESPAsyncWebסערווירער-בעל טעקע
- רענאַמע דיין טעקע פֿון ESPAsyncWebסערווירער-בעל צו ESPAsyncWebסערווירער
- מאַך די ESPAsyncWebסערווירער טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
אַלטערנאַטיוועלי, אין דיין Arduino IDE, איר קענען גיין צו סקיצע> אַרייַננעמען
ביבליאָטעק> לייג .זיפּ ביבליאָטעק ... און אויסקלייַבן די ביבליאָטעק וואָס איר האָט פּונקט דאַונלאָודיד.
ינסטאָלינג די AsyncTCP ביבליאָטעק פֿאַר ESP32
די ESPAsyncWebסערווירער ביבליאָטעק ריקווייערז די AsyncTCP ביבליאָטעק צו אַרבעטן. גיי די ווייַטער סטעפּס צו ינסטאַלירן די ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די AsyncTCP ביבליאָטעק. איר זאָל האָבן אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע
- אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען AsyncTCP-master טעקע
- רענאַמע דיין טעקע פֿון AsyncTCP-master צו AsyncTCP
- מאַך די AsyncTCP טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
- צום סוף, עפֿענען דיין Arduino IDE ווידער
אַלטערנאַטיוועלי, אין דיין Arduino IDE, איר קענען גיין צו סקיצע> אַרייַננעמען
ביבליאָטעק> לייג .זיפּ ביבליאָטעק ... און אויסקלייַבן די ביבליאָטעק וואָס איר האָט פּונקט דאַונלאָודיד.
קאָד
מיר וועלן פּראָגראַם די ESP32 ניצן Arduino IDE, אַזוי מאַכן זיכער אַז איר האָבן די ESP32 אַדישאַן אינסטאַלירן איידער איר פאָרזעצן: (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
נאָך ינסטאָלינג די פארלאנגט לייברעריז, עפֿן די קאָד
Project_8_Output_State_Synchronization_Web_Server.ino אין Arduino IDE.
איידער איר ופּלאָאַדינג די קאָד, טאָן ניט פאַרגעסן צו אַרייַנלייגן דיין נעץ קראַדענטשאַלז אַזוי אַז די ESP קענען פאַרבינדן צו דיין היגע נעץ.
ווי די קאָד אַרבעט
קנעפּל שטאַט און רעזולטאַט שטאַט
די LedState בייַטעוודיק האלט די LED רעזולטאַט שטאַט. פֿאַר פעליקייַט, ווען די web סערווער סטאַרץ, עס איז נידעריק.
די קנעפּל שטאַט און lastButtonState זענען געניצט צו דעטעקט צי די פּושקנעפּל איז געדריקט אָדער נישט.
קנעפּל (web סערווירער)
מיר האָבן נישט אַרייַנגערעכנט די HTML צו שאַפֿן דעם קנעפּל אויף די index_html בייַטעוודיק.
דאָס איז ווייַל מיר וועלן קענען צו טוישן עס דיפּענדינג אויף די קראַנט געפירט שטאַט וואָס קענען אויך זיין טשיינדזשד מיט די פּושקנעפּל.
אַזוי, מיר האָבן שאַפֿן אַ אָרטהאָלדער פֿאַר די קנעפּל % BUTTONPLACEHOLDER% וואָס וועט זיין ריפּלייסט מיט HTML טעקסט צו שאַפֿן דעם קנעפּל שפּעטער אויף די קאָד (דאָס איז געטאן אין די פּראַסעסער () פֿונקציע).
פּראַסעסער()
די פּראַסעסער () פֿונקציע ריפּלייסיז קיין אָרטהאָלדערס אויף די HTML טעקסט מיט פאַקטיש וואַלועס. ערשטער, עס טשעקס צי די HTML טעקסץ כּולל קיין
אָרטהאָלדערס %BUTTONPLACEHOLDER%.
דערנאָך, רופן די רעזולטאַט שטאַט () פֿונקציע וואָס קערט די קראַנט רעזולטאַט שטאַט. מיר ראַטעווען עס אין די outputStateValue בייַטעוודיק.
נאָך דעם, נוצן דעם ווערט צו שאַפֿן דעם HTML טעקסט צו ווייַזן דעם קנעפּל מיט די רעכט שטאַט:
הטטפּ באַקומען בעטן צו טוישן רעזולטאַט שטאַט (דזשאַוואַסקריפּט)
ווען איר דריקן דעם קנעפּל, thetoggleCheckbox() פֿונקציע איז גערופן. דעם פֿונקציע וועט מאַכן אַ בקשה אויף פאַרשידענע URLs צו קער די געפירט אויף אָדער אַוועק.
צו קער אויף די געפירט, עס מאכט אַ בקשה אויף די / דערהייַנטיקן? שטאַט = 1 URL:
אַנדערש, עס מאכט אַ בקשה אויף די / דערהייַנטיקן? שטאַט = 0 URL.
הטטפּ באַקומען בעטן צו דערהייַנטיקן שטאַט (דזשאַוואַסקריפּט)
צו האַלטן די פּראָדוקציע שטאַט דערהייַנטיקט אויף די web סערווער, מיר רופן די פאלגענדע פֿונקציע וואָס מאכט אַ נייַע בקשה אויף די / שטאַט URL יעדע רגע.
שעפּן ריקוועס
דערנאָך, מיר דאַרפֿן צו שעפּן וואָס כאַפּאַנז ווען די ESP32 אָדער ESP8266 נעמט ריקוועס אויף די URLs.
ווען אַ בקשה איז באקומען אויף דער וואָרצל /URL, מיר שיקן די HTML בלאַט ווי געזונט ווי די פּראַסעסער.
די פאלגענדע שורות קאָנטראָלירן צי איר האָט באקומען אַ בקשה אויף די /update?state=1 אָדער /update?state=0 URL און ענדערונגען די לעד שטאַט אַקאָרדינגלי.
ווען אַ בקשה איז באקומען אויף די / שטאַט URL, מיר שיקן די קראַנט רעזולטאַט שטאַט:
שלייף ()
אין די שלייף (), מיר דיבאַונס די פּושקנעפּל און קער די געפירט אויף אָדער אַוועק דיפּענדינג אויף די ווערט פון די ledState בייַטעוודיק.
דעמאַנסטריישאַן
ופּלאָאַד די קאָד צו דיין ESP32 באָרד. ופּלאָאַד קאָד רעפֿערענץ סטעפּס.
דערנאָך, עפֿענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200. דריקן די אויף-ברעט ען / רסט קנעפּל צו באַקומען די IP אַדרעס.
עפֿענען אַ בלעטערער אויף דיין היגע נעץ און אַרייַן די ESP IP אַדרעס. איר זאָל האָבן צוטריט צו די web סערווער ווי געוויזן אונטן.
באַמערקונג: דיין בלעטערער און ESP32 זאָל זיין קאָננעקטעד צו דער זעלביקער לאַן.
איר קענען באַשטימען דעם קנעפּל אויף די web סערווער צו ווענדן די געפירט אויף.
איר קענען אויך קאָנטראָלירן די זעלבע געפירט מיט די גשמיות פּושקנעפּל. זיין שטאַט וועט שטענדיק זיין דערהייַנטיקט אויטאָמאַטיש אויף די web סערווער.
פּראָיעקט 9 ESP32 DHT11 Web סערווירער
אין דעם פּרויעקט, איר וועט לערנען ווי צו בויען אַן ייסינגקראַנאַס ESP32 web סערווער מיט די DHT11 וואָס דיספּלייז טעמפּעראַטור און הומידיטי ניצן Arduino IDE.
פּרירעקוואַזאַץ
די web סערווער מיר וועט בויען דערהייַנטיקונגען די רידינגז אויטאָמאַטיש אָן די נויט צו דערפרישן די web בלאַט.
מיט דעם פּרויעקט איר וועט לערנען:
- ווי צו לייענען טעמפּעראַטור און הומידיטי פון DHT סענסאָרס;
- בויען אַ ייסינגקראַנאַס web סערווער ניצן די ESPAsyncWebסערווירער ביבליאָטעק;
- דערהייַנטיקן די סענסער רידינגז אויטאָמאַטיש אָן די נויט צו דערפרישן די web בלאַט.
אַסינטשראָנאָוס Web סערווירער
צו בויען די web סערווער מיר וועלן נוצן די ESPAsyncWebסערווירער ביבליאָטעק וואָס גיט אַן גרינג וועג צו בויען אַ ייסינגקראַנאַס web סערווער. בנין אַ ייסינגקראַנאַס web סערווער האט עטלעכע אַדוואַנטידזשיזtagווי דערמאנט אין דער ביבליאָטעק GitHub בלאַט, אַזאַ ווי:
- "האַנדלען מער ווי איין קשר אין דער זעלביקער צייט";
- "ווען איר שיקן דעם ענטפער, איר זענט גלייך גרייט צו שעפּן אנדערע קאַנעקשאַנז בשעת די סערווער איז זאָרגן פון שיקן דעם ענטפער אין דער הינטערגרונט";
- "פּשוט מוסטער פּראַסעסינג מאָטאָר צו שעפּן טעמפּלאַטעס";
פּאַרץ פארלאנגט
צו פאַרענדיקן דעם טוטאָריאַל איר דאַרפֿן די פאלגענדע פּאַרץ:
- ESP32 אַנטוויקלונג ברעט
- DHT11 מאָדולע
- ברעאַדבאָאַרד
- דזשאַמפּער ווירעס
סכעמאַטיש
ינסטאָלינג ליבראַריעס
איר דאַרפֿן צו ינסטאַלירן אַ פּאָר פון לייברעריז פֿאַר דעם פּרויעקט:
- די DHT און די אַדפרויט וניפיעד סענסאָר דרייווער לייברעריז צו לייענען פֿון די DHT סענסער.
- ESPAsyncWebסערווירער און אַסינק טקפּ לייברעריז צו בויען די ייסינגקראַנאַס web סערווער.
גיי די ווייַטער ינסטראַקשאַנז צו ינסטאַלירן די לייברעריז:
ינסטאָלינג די DHT סענסאָר ביבליאָטעק
צו לייענען פֿון די DHT סענסער מיט Arduino IDE, איר דאַרפֿן צו ינסטאַלירן די דהט סענסער ביבליאָטעק. גיי די ווייַטער סטעפּס צו ינסטאַלירן די ביבליאָטעק.
- דריקט דאָ צו אָפּלאָדירן די DHT סענסאָר ביבליאָטעק. איר זאָל האָבן אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע
- אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען DHT-sensor-library-master טעקע
- רענאַמע דיין טעקע פֿון DHT-sensor-library-master צו DHT_sensor
- מאַך די DHT_sensor טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
- צום סוף, עפֿענען דיין Arduino IDE ווידער
ינסטאָלינג די Adafruit וניפיעד סענסאָר דרייווער
איר אויך דאַרפֿן צו ינסטאַלירן די Adafruit וניפיעד סענסאָר דרייווער ביבליאָטעק צו אַרבעטן מיט די DHT סענסער. גיי די ווייַטער סטעפּס צו ינסטאַלירן די ביבליאָטעק.
- דריקט דאָ צו אָפּלאָדירן די Adafruit Unified סענסאָר ביבליאָטעק. איר זאָל האָבן אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע
- אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען Adafruit_sensor-master טעקע
- רענאַמע דיין טעקע פֿון Adafruit_sensor-master צו Adafruit_sensor
- מאַך די Adafruit_sensor טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
- צום סוף, עפֿענען דיין Arduino IDE ווידער
ינסטאָלינג די ESPAsyncWebסערווירער ביבליאָטעק
גיי די ווייַטער סטעפּס צו ינסטאַלירן די ESPAsyncWebסערווירער ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די ESPAsyncWebסערווירער ביבליאָטעק. איר זאָל האָבן
אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע - אַנזיפּ די .זיפּ טעקע און איר זאָל
באַקומען ESPAsyncWebסערווירער-בעל טעקע - רענאַמע דיין טעקע פֿון ESPAsyncWebסערווירער-בעל צו ESPAsyncWebסערווירער
- מאַך די ESPAsyncWebסערווירער טעקע צו דיין Arduino IDE ינסטאַלירונג לייברעריז טעקע
ינסטאָלינג די Async TCP ביבליאָטעק פֿאַר ESP32
די ESPAsyncWebסערווירער ביבליאָטעק ריקווייערז די AsyncTCP ביבליאָטעק צו אַרבעטן. גיי די ווייַטער סטעפּס צו ינסטאַלירן די ביבליאָטעק:
- דריקט דאָ צו אָפּלאָדירן די AsyncTCP ביבליאָטעק. איר זאָל האָבן אַ .זיפּ טעקע אין דיין דאַונלאָודז טעקע
- אַנזיפּ די .זיפּ טעקע און איר זאָל באַקומען 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 סענסער טיפּ איר נוצן. אין אונדזער עקסampמיר נוצן די DHT22. אויב איר נוצן אן אנדער טיפּ, איר נאָר דאַרפֿן צו ומקערן דיין סענסער און באַמערקן אַלע די אנדערע.
ינסטאַנטייט אַ DHT כייפעץ מיט דעם טיפּ און שטיפט וואָס מיר האָבן דיפיינד פריער.
שאַפֿן אַ אַסינקWebסערווירער כייפעץ אויף פּאָרט 80.
לייענען טעמפּעראַטור און הומידיטי פאַנגקשאַנז
מיר האָבן באשאפן צוויי פאַנגקשאַנז: איינער צו לייענען די טעמפּעראַטור מיר האָבן באשאפן צוויי פאַנגקשאַנז: איינער צו לייענען די טעמפּעראַטור (readDHTTemperature()) און די אנדערע צו לייענען הומידיטי (readDHTHumidity()).
באַקומען סענסער רידינגז איז ווי פּשוט ווי צו באַקומען סענסער רידינגז איז ווי פּשוט ווי ניצן די רעאַדטעמפּעראַטור () און רעאַדהומידיטי () מעטהאָדס אויף די דht כייפעץ.
מיר אויך האָבן אַ צושטאַנד אַז קערט צוויי דאַשעס (-) אין פאַל די סענסער פיילז צו באַקומען די רידינגז.
די רידינגז זענען אומגעקערט ווי שטריקל טיפּ. צו גער אַ לאָזנ שווימען צו אַ שטריקל, נוצן די סטרינג () פֿונקציע
דורך פעליקייַט, מיר לייענען די טעמפּעראַטור אין סעלסיוס דיגריז. צו באַקומען די טעמפּעראַטור אין פאַהרענהעיט דיגריז, באַמערקונג די טעמפּעראַטור אין סעלסיוס און נעם אַוועק די טעמפּעראַטור אין פאַהרענהעיט, אַזוי איר האָבן די פאלגענדע:
צופֿעליקער די קאָד
איצט, ופּלאָאַד די קאָד צו דיין ESP32. מאַכן זיכער איר האָבן די רעכט ברעט און קאַם פּאָרט אויסגעקליבן. ופּלאָאַד קאָד דערמאָנען טריט.
נאָך ופּלאָאַדינג, עפענען די סיריאַל מאָניטאָר מיט אַ באַוד קורס פון 115200. דריקן די ESP32 באַשטעטיק קנעפּל. די ESP32 IP אַדרעס זאָל זיין געדרוקט אין די סיריאַל מאָניטאָר.
דעמאַנסטריישאַן
עפֿענען אַ בלעטערער און אַרייַן די ESP32 IP אַדרעס. דיין web סערווער זאָל ווייַזן די לעצטע סענסער רידינגז.
באַמערקונג: דיין בלעטערער און ESP32 זאָל זיין קאָננעקטעד צו דער זעלביקער לאַן.
באַמערקונג אַז די טעמפּעראַטור און הומידיטי רידינגז זענען דערהייַנטיקט אויטאָמאַטיש אָן די נויט צו דערפרישן די web בלאַט.
Project_10_ESP32_OLED_Display
דער פּרויעקט ווייזט ווי צו נוצן די 0.96 אינטש SSD1306 OLED אַרויסווייַזן מיט ESP32 ניצן Arduino IDE.
ינטראָודוסינג 0.96 אינטש OLED ווייַז
די 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 און גיין צו סקיצע> אַרייַננעמען ביבליאָטעק> פירן ליבראַריעס. דער ביבליאָטעק מאַנאַגער זאָל עפענען.
- טיפּ "SSD1306" אין די זוכן קעסטל און ינסטאַלירן די SSD1306 ביבליאָטעק פֿון Adafruit.
- נאָך ינסטאָלינג די SSD1306 ביבליאָטעק פֿון Adafruit, טיפּ "GFX" אין די זוכן קעסטל און ינסטאַלירן די ביבליאָטעק.
- נאָך ינסטאָלינג די לייברעריז, ריסטאַרט דיין Arduino IDE.
קאָד
נאָך ינסטאָלינג די פארלאנגט לייברעריז, עפֿן די Project_10_ESP32_OLED_Display.ino אין arduino IDE. קאָד
מיר וועלן פּראָגראַם די ESP32 ניצן Arduino IDE, אַזוי מאַכן זיכער אַז איר האָבן די ESP32 אַדישאַן אינסטאַלירן איידער איר פאָרזעצן: (אויב איר האָט שוין דורכגעקאָכט דעם שריט, איר קענען האָפּקען צו דער ווייַטער שריט.)
ינסטאָלינג ESP32 לייג-אָן אין Arduino IDE
ווי די קאָד אַרבעט
ימפּאָרטינג ביבליאָטעק
ערשטער, איר דאַרפֿן צו אַרייַנפיר די נייטיק לייברעריז. די ווירע ביבליאָטעק צו נוצן I2C און די Adafruit לייברעריז צו שרייַבן צו די אַרויסווייַזן: Adafruit_GFX און Adafruit_SSD1306.
ינישאַליזע די OLED אַרויסווייַזן
דערנאָך איר דעפינירן דיין OLED ברייט און הייך. אין דעם עקסampאָבער, מיר נוצן אַ 128 × 64 אָלעד אַרויסווייַזן. אויב איר נוצן אנדערע סיזעס, איר קענען טוישן די וועריאַבאַלז SCREEN_WIDTH און SCREEN_HEIGHT.
דערנאָך, ינישאַלייז אַ אַרויסווייַזן כייפעץ מיט די ברייט און הייך דיפיינד פריער מיט I2C קאָמוניקאַציע פּראָטאָקאָל (&דראָט).
דער (-1) פּאַראַמעטער מיטל אַז דיין OLED אַרויסווייַזן האט נישט אַ באַשטעטיק שטיפט. אויב דיין OLED אַרויסווייַזן האט אַ RESET שטיפט, עס זאָל זיין קאָננעקטעד צו אַ GPIO. אין דעם פאַל, איר זאָל פאָרן די GPIO נומער ווי אַ פּאַראַמעטער.
אין די סעטאַפּ (), ינישאַלייז די סיריאַל מאָניטאָר מיט אַ ראַוטע פון 115200 פֿאַר דיבאַגינג צוועקן.
ייטיאַליזע די OLED אַרויסווייַזן מיט די אָנהייב () אופֿן ווי גייט:
דער סניפּאַט אויך פּרינץ אַ אָנזאָג אויף די סיריאַל מאָניטאָר, אין פאַל מיר קענען נישט פאַרבינדן צו די אַרויסווייַזן.
אויב איר נוצן אַ אַנדערש OLED אַרויסווייַזן, איר קען דאַרפֿן צו טוישן די OLED אַדרעס. אין אונדזער פאַל, די אַדרעס איז 0x3C.
נאָך ינישאַליזינג די אַרויסווייַזן, לייגן אַ צוויי רגע פאַרהאַלטן, אַזוי אַז די OLED האט גענוג צייט צו ינישאַלייז איידער שרייבן טעקסט:
קלאָר אַרויסווייַזן, שטעלן שריפֿט גרייס, קאָליר און שרייַבן טעקסט
נאָך יניטיאַליזינג די אַרויסווייַזן, ויסמעקן די אַרויסווייַזן באַפער מיט די ClearDisplay () אופֿן:
איידער שרייבן טעקסט, איר דאַרפֿן צו שטעלן די טעקסט גרייס, קאָליר און ווו דער טעקסט וועט זיין געוויזן אין די OLED.
באַשטעטיק די שריפֿט גרייס מיט די setTextSize () אופֿן:
שטעלן די שריפֿט קאָליר מיט די setTextColor () אופֿן:
WHITE שטעלט ווייַס שריפֿט און שוואַרץ הינטערגרונט.
דעפינירן די שטעלע ווו דער טעקסט סטאַרץ מיט די setCursor (x, y) אופֿן. אין דעם פאַל, מיר שטעלן דעם טעקסט צו אָנהייבן אין די (0,0) קאָואָרדאַנאַץ - אין די שפּיץ לינקס ווינקל.
צום סוף, איר קענען שיקן דעם טעקסט צו די אַרויסווייַזן מיט די println () אופֿן, ווי גייט
דערנאָך, איר דאַרפֿן צו רופן די אַרויסווייַזן () אופֿן צו אַקטשאַוואַלי אַרויסווייַזן די טעקסט אויף דעם עקראַן.
די Adafruit OLED ביבליאָטעק גיט נוציק מעטהאָדס צו לייכט מעגילע טעקסט.
- startscrollright(0x00, 0x0F): מעגילע טעקסט פון לינקס צו רעכט
- startscrollleft(0x00, 0x0F): מעגילע טעקסט פון רעכט צו לינקס
- startscrolldiagright (0x00, 0x07): מעגילע טעקסט פון לינקס דנאָ ווינקל צו רעכט אויבערשטער ווינקל startscrolldiagleft (0x00, 0x07): מעגילע טעקסט פון רעכט דנאָ ווינקל צו לינקס אויבערשטער ווינקל
צופֿעליקער די קאָד
איצט, ופּלאָאַד די קאָד צו דיין ESP32.Upload קאָד רעפֿערענץ סטעפּס.
נאָך ופּלאָאַדינג די קאָד, די OLED וועט אַרויסווייַזן סקראָללינג טעקסט.
דאָקומענטן / רעסאָורסעס
 |
LAFVIN ESP32 באַסיק סטאַרטער קיט [pdf] אינסטרוקציע מאַנואַל ESP32 Basic Starter Kit, ESP32, Basic Starter Kit, Starter Kit |