IOT Made Simple: Bermain Dengan ESP32 pada Arduino IDE

Mari kita terokai dalam tutorial ini, ESP32, Lembaga Kit Pembangunan baru yang hebat untuk penggunaan IoT. Papan ini, yang dibangunkan oleh Espressif, harus menjadi pengganti NodeMCU, kerana harga yang rendah dan ciri-ciri hebatnya.

Tetapi juga penting untuk menunjukkan bahawa TIDAK SEMUA perpustakaan atau fungsi yang anda gunakan untuk bekerja dengan ESP8266 dan / atau Arduino belum berfungsi pada papan baru ini. Mungkin ini akan berlaku tidak lama lagi, jadi periksa dengan teratur pada ESP 32 Forum WebPage.

Di sini kita akan belajar cara memprogram ESP32 pada Arduino IDE, meneroka fungsi dan perpustakaan yang paling umum, menunjukkan beberapa perbezaan penting dan ciri baru yang diperkenalkan dengan cip hebat ini.

Pendek kata, kami akan meneroka:

  • Output Digital: Berkedip LED
  • Input Digital: Membaca Sensor Sentuh
  • Input analog: Membaca voltan berubah dari potensiometer
  • Output Analog: Mengawal kecerahan LED
  • Output Analog: Mengawal Kedudukan Servo
  • Bacaan Suhu / Data Kelembapan dengan sensor Digital
  • Menyambung ke Internet dan mendapat masa setempat
  • Menerima data dari halaman web setempat yang mudah, menghidupkan / mematikan LED
  • Menghantar data ke webPage tempatan yang mudah

Langkah 1: Ciri Utama ESP32

ESP32 adalah di bawah $ 10 papan dengan kelebihan yang besar berbanding papan IoT yang sama di pasaran.

Papan ini mempunyai mikropemproses berproses ganda yang membantu banyak, kerana apabila satu pemproses mengendalikan komunikasi, yang satu lagi bertanggungjawab terhadap kawalan I / O, contohnya. Ciri ini akan menghalang beberapa masalah yang berlaku dengan ESP8266, di mana CPU tunggal perlu berhenti mengawal I / Os apabila mengendalikan dengan Comm. Selain itu, ESP32 telah menggabungkan WIFI, BLUETOOTH, DAC, beberapa ADC (bukan sahaja sebagai ESP8266), sensor sentuhan kapasitif, dan lain-lain (lihat di atas gambarajah blok). Dan kabar baiknya ialah Penggunaan Kuasa hampir sama dengan ESP8266.

Bawah carta yang dapat menunjukkan kepada kita ciri-ciri utamanya, dan perbezaan apabila dibandingkan dengan ESP8266:

Mari kita tunjukkan sifat utamanya dalam lebih banyak maklumat:

Ciri-ciri utama:

  • 240 MHz mikropengawal dua teras Tensilica LX6 dengan 600 DMIPS
  • Bersepadu 520 KB SRAM
  • Transceiver Wi-Fi 802.11 b / g / n Bersepadu, baseband, timbunan dan LwIP
  • Mod dwi bersepadu Bluetooth (klasik dan BLE)
  • 16 MB kilat, memetakan memori ke ruang kod CPU
  • 2.3V ke voltan operasi 3.6V
  • -40 ° C hingga suhu operasi + 125 ° C
  • Penyambung antena / IPEX PCB untuk antena luaran

Sensor:

  • Penguat analog bising ultra-rendah
  • Sensor Dewan
  • Antara muka sentuh kapasitif 10x
  • Osilator kristal 32 kHz

34 x GPIO:

  • 3 x UARTs, termasuk kawalan aliran perkakasan
  • 3 x SPI
  • 2 x I2S
  • 18 x saluran masukan ADC
  • 2 x DAC
  • 2 x I2C
  • Input / output PWM / pemasa yang terdapat pada setiap pin GPIO
  • Antara muka debug OpenOCD dengan penampan TRAX 32 kB
  • Master / hamba SDIO 50 MHz
  • Menyokong flash SPI luaran sehingga 16 MB
  • Sokongan antara muka SD-kad

Berkaitan Keselamatan:

  • WEP, WPA / WPA2 PSK / Enterprise
  • Perkakasan dipercepatkan penyulitan: AES / SHA2 / Kriptografi Kurva Elliptical / RSA-4096

Prestasi:

  • Menyokong mod sniffer, Stesen, SoftAP dan Wi-Fi langsung
  • Kadar data maksimum 150 HT40, 72 HT20, 54, dan 11
  • Kuasa penghantaran maksimum 19.5, 16.5, 15.5
  • Sensitiviti penerima minima -97 dBm
  • 135 Mbps UDP terus menerus
  • Penggunaan kuasa 5 μA dalam tidur mendalam

Langkah 2: BoM - Bill of Material

  • ESP32 Dev Kit: Lembaga Pembangunan ESP32 (US $ 8.52)
  • Servo Mikro: TowerPro SG90 9G Mini Servo (US $ 3.80)
  • Temp / Hum Sensor DHT22 / AM2302 Sensor Suhu dan Kelembapan Digital (US $ 9.99)
  • LED
  • 2 x Resistor: 330 ohm dan 10K ohm
  • Potentiometer: 10K ohm
  • Pelindung

Langkah 3: ESP32 Arduino IDE Installation

Kami akan menggunakan Arduino IDE untuk memprogram ESP32 kami, sama seperti yang kita lakukan dengan keluarga ESP8266.

Memasang Pemandu:

Adalah penting bahawa anda telah memasang pada komputer anda, USB CP210x yang dikemas kini kepada Pemandu UART. Masukkan dalam pautan ini: usb-to-uart-bridge-vcp-drivers dan pasang pemacu yang sesuai untuk OS anda.

Pasang Perpustakaan:

Kebaharuan di sini ialah Expressif sendiri dalam GitHubnya, akan memberikan arahan yang tepat untuk pemasangan perpustakaan: arduino-esp32. Ikut arahan untuk OS anda. Dalam kes saya (MacOS), pemasangannya sangat mudah:

Buka Terminal dan jalankan arahan berikut (copy-> paste dan tekan enter):

 mkdir -p ~ / Documents / Arduino / hardware / espressif && \ cd ~ / Documents / Arduino / hardware / espressif && \ git clone //github.com/espressif/arduino-esp32.git esp32 && \ cd esp32 / tools / & & \ python get.py 

Selepas itu, mulakan semula IDE Arduino dan sudah selesai! Anda mesti melihat beberapa papan pada Menu "TOOLS". Pilih yang sesuai untuk anda. Umumnya, "generik" ESP32 DEV MODUL berfungsi dengan baik.

Apabila anda membuka IDE Arduino buat kali pertama, anda akan perhatikan bahawa kelajuan muat naik lalai ialah 921, 600 baud. Ini boleh menimbulkan ketidakstabilan. Tukar ke 115, 200 bauds !

Langkah 4: Hello World! Berkedip LED

Seperti biasa, perkara pertama yang perlu dilakukan apabila kita mula meneroka HW baru adalah untuk mengedipkan LED.

Pergi ke Contoh Menu dalam IDE dan buka lakaran Blink.

ESP32 DevKit, mempunyai LED terbina dalam yang disambungkan ke GPIO 02. Ia adalah penting untuk memeriksa sama ada " LED_BUILTIN " secara automatik diiktiraf oleh IDE. Sekiranya tidak, anda harus menambah kod kod:

 int LED_BUILTIN = 2; 
Setiap papan ESP32 mempunyai LED dalaman yang disambungkan ke GPIO yang berbeza
 / * ESP 32 Blink Menghidupkan LED selama satu saat, kemudian dimatikan selama satu saat, berkali-kali. ESP32 mempunyai LED biru dalaman di D2 (GPIO 02) * / int LED_BUILTIN = 2; void setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, TINGGI); / / putar LED pada (TINGGI adalah tahap voltan) kelewatan (1000); // tunggu untuk digitalWrite kedua (LED_BUILTIN, LOW); // Matikan lampu LED dengan membuat kelewatan LOW voltan (1000); / tunggu sebentar} 

Di bawah LED berkelip dalaman (ambil perhatian cahaya biru) bersama dengan luaran yang disambungkan ke GPIO 2:

Terdapat beberapa papan yang berlainan dengan peta pin yang berlainan di pasaran. Rajah di atas menunjukkan papan yang saya gunakan. Anda boleh menemuinya di sini: / ESP32-Development-Board

Sempurna! Oleh itu, DigitalWrite () berfungsi dengan sempurna, sama dengan ESP8266 dan Arduino. BTW, DigitalRead () juga berfungsi dengan cara yang sama untuk membaca input digital, seperti butang tekan misalnya.

Langkah 5: Sensor Sentuh

Mari melompat ke ciri baru yang sejuk, Sensor Sentuh !

ESP32 mempunyai 10 sensor sentuhan kapasitif dalaman. Anda boleh menggunakannya sebagai butang sebagai contoh.

Sensor tersebut dihubungkan dengan beberapa 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

Untuk membacanya, anda mesti menggunakan fungsi: touchRead (Touch Pin #);

Sebagai contoh, untuk membaca Sensor Sentuh 0 (T0), anda mesti melakukan sesuatu seperti:

 int value = touchRead (4); 

Mari buat kod, di mana jika kita menyentuh sensor T0 (GPIO4), LED akan dihidupkan.

Gunakan monitor siri untuk memeriksa nilai yang dibaca oleh sensor dan menyesuaikan kod dengan betul.

Di bawah kod lengkap:

 / ************************************************* **** * Ujian Sentuhan ESP32 dan Ctrl LED * Touch pin ==> Touch0 adalah T0 yang berada di GPIO 4 (D4). * PIN LED ==> D2 * * MJRoBot.org 6Sept17 ************************************* **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; void setup () {Serial.begin (115200); kelewatan (1000); // berikan saya masa untuk memaparkan monitor siri Serial.println ("Ujian Sentuhan ESP32"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // mendapatkan nilai menggunakan T0 jika (touch_value <50) {digitalWrite (LED_PIN, TINGGI); } else {digitalWrite (LED_PIN, LOW); } kelewatan (1000); } 

Dan di bawah kerja ESP32:

Langkah 6: Input Analog

Sekarang mari kita uji bagaimana Isyarat nilai analog input.

Terdapat sejumlah 18 x 12 bit saluran input ADC, berbanding hanya 1 X 10 bit ADC pada NodeMCU.

Saluran ADC GPIO

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

Untuk membaca input analog, anda akan sama seperti yang dilakukan dengan Arduino dan ESP8266:

 int analog_value = analogRead (36); 

Sangat penting untuk diperhatikan bahawa, ESP32 ADCs mempunyai resolusi 12bits (versus 10bits pada ESP8266 dan Arduino), sehingga jumlah bacaan ADC mencapai 4, 095 (sebaliknya 1, 027 pada Arduinos dan ESP8266) apabila maksimum 3.3V digunakan untuk inputnya.

Untuk input, mari kita gunakan potensiometer 10K ohm, sambungkannya dari 3.3V dan GND. Mari kita gunakan output pembolehubahnya untuk menjadi input untuk pin ESP32 ADC. Diagram di atas menunjukkan potensiometer yang disambungkan ke GPIO 36 iaitu ADC1 Channel 0. Cobalah juga input lain di papan anda.

Jalankan kod mudah di bawah:

 / ************************************************* ***** * Ujian Input ESP32 * Input Analog: ADC_1_0 pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ******************************************** ********* // // Input analog #define ANALOG_PIN_0 36 int analog_value = 0; void setup () {Serial.begin (115200); kelewatan (1000); / / Berikan saya masa untuk memaparkan monitor siri Serial.println ("ESP32 Analog IN Test"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); kelewatan (500); } 

Hidupkan potensiometer anda dan perhatikan pada IDE Serial Monitor ukuran pengukuran dari sifar hingga 4, 095.

Langkah 7: Mematikan LED: Output Analog Menggunakan PWM

Jika kita mahu "Dimmer a LED" pada ESP8266 atau Arduino, kita boleh menggunakan arahan seperti analogWrite (), yang akan mengubah nilai PWM outputnya, menyimulasikan nilai analog. Malangnya, kami masih tidak mempunyai arahan seperti yang dibangunkan untuk ESP32 pada Arduino IDE. tetapi berita yang sangat baik adalah bahawa semua 36 GPIO ESP32 mempunyai keupayaan PWM, yang bagus! Hanya kita mesti menggunakan kod yang lebih kompleks untuk mencapai hasil yang sama.

Jadi, mari kita program salah satu GPIOs dengan isyarat output PWM.

Anda boleh menemui tutorial yang sangat baik tentang bagaimana PWM berfungsi di pautan ini: esp32-arduino-led-pwm-fading.

Perkara pertama untuk memikirkan isyarat PWM yang dijana adalah kekerapannya. Kami akan menggunakan nilai 5000 Hz, yang berfungsi dengan baik dengan LED. Kita mesti juga menentukan saluran PWM LED dan resolusi kitaran tugas PWM, dalam bit. Kita boleh memilih saluran dari 0 hingga 15 dan resolusi antara 1 dan 16 bit. Kami akan menggunakan saluran 0 dan resolusi 8 bit.

 int freq = 5000; int ledChannel = 0; ketetapan int = 8; 

Mari kita gunakan GPIO2, di mana kita mempunyai LED luaran yang dilampirkan (dan yang dalaman).

 #define LED_PIN 2 

Parameter tersebut mesti ditentukan semasa fasa persediaan (), menggunakan fungsi di bawah:

 void setup () {ledcSetup (ledChannel, freq, resolusi); ledcAttachPin (LED_PIN, ledChannel); } 

Untuk menghidupkan LED dengan kecerahan tertentu, kita mesti menentukan "kitaran tugas".

Sebagai contoh, untuk mematikan LED, kitaran tugas mesti sifar dan fungsi ledcWrite (ledChannel, dutyCycle) digunakan untuk menghantar nilai melalui saluran PWM tertentu:

 int dutyCycle = 0; ledcWrite (ledChannel, dutyCycle); 

Nilai yang berbeza daripada pemboleh ubah Duti kuliah akan menghidupkan LED dengan kecerahan yang berbeza. pembolehubah ini, Kitaran duti, akan berubah dari 0 hingga 255, sebaik sahaja resolusi yang digunakan adalah 8 bit.

Kita boleh menggunakan Potentiometer (disambungkan kepada pembolehubah analog_value ) untuk menyediakan pembolehubah dutyCycle secara manual, tetapi sebaik sahaja julat nilainya berbeza, mari kita gunakan fungsi peta untuk memadankan input dan output:

 dutyCycle = peta (analog_value, 0, 4095, 0, 255); 

Di bawah kod lengkap:

 ************************************************** *** * ESP32 Input / Output Ujian Analog * Input Analog: ADC_1_0 pin ==> GPIO36 (VP). * Pin LED PWM ==> GPIO 02 * * MJRoBot.org 6Sept17 *********************************** ****************** // // Input analog #define ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; ketetapan int = 8; int dutyCycle = 0; void setup () {Serial.begin (115200); kelewatan (1000); / / Berikan saya masa untuk memaparkan monitor siri Serial.println ("ESP32 Analog IN / OUT Test"); ledcSetup (ledChannel, freq, resolusi); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); dutyCycle = peta (analog_value, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); kelewatan (500); } 

Itu sahaja!

Langkah 8: Kawalan Servo

Mari kita mengawal Servo Motor menggunakan keupayaan PWM ESP32 kami. Kod ini pada asasnya sama dengan yang digunakan untuk mengawal kecerahan LED.

Pertama, penting untuk diingat bahawa kekerapan untuk bekerja dengan Servo Mikro adalah 50Hz, jadi kita mesti menukar parameter frekuensi kepada 50 (bukannya 5, 000 yang digunakan dengan LED). Kita mesti juga menentukan saluran PWM LED dan resolusi kitaran tugas PWM, dalam bit. Kami akan menggunakan lagi saluran 0 dan resolusi 8 bit.

 int freq = 50; int channel = 0; ketetapan int = 8; 

Servo akan disambungkan ke GPIO 5 (lihat rajah elektrik di atas).

 #define SERVO_PIN 5 

Sama seperti LED, parameter tersebut mesti ditakrifkan semasa fasa persediaan (), menggunakan fungsi di bawah:

 void setup () {ledcSetup (saluran, freq, resolusi); ledcAttachPin (SERVO_PIN, saluran); } 

Untuk memposisikan servo pada sudut tertentu, kita mesti menentukan "kitaran tugas" (sila lihat gambarajah di atas).

Sebagai contoh, untuk meletakkan servo sekitar 90 darjah, kitaran tugas mesti sekitar 21 dan fungsi ledcWrite (ledChannel, dutyCycle) sepatutnya digunakan untuk menghantar nilai melalui saluran PWM:

 int dutyCycle = 21; ledcWrite (saluran, dutyCycle); 

Nilai yang berlainan dari pemboleh ubah Duti kuliah akan meletakkan servo dengan sudut yang berbeza. Pembolehubah, dutyCycle ini, perlu berbeza dari 10 hingga 32 (julat ini diperoleh secara manual).

Sama seperti yang kita lakukan dengan LED, Potentiometer (disambungkan kepada pembolehubah analog_value ) boleh digunakan untuk menyediakan pembolehubah dutyCycle secara manual dan mengubah kedudukan servo. Setelah julat nilai mereka berbeza, mari kita gunakan fungsi peta untuk memadankan input dan output:

 dutyCycle = peta (analog_value, 0, 4095, 10, 33); 

Di bawah kod lengkap:

 / ************************************************* **** * Kawalan Servis ESP32 * Input Analog: ADC_1_0 pin ==> GPIO36 (VP). * PWM SERVO pin ==> GPIO 05 * * MJRoBot.org 6Sept17 *********************************** ****************** // // Input analog #define ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; int channel = 0; ketetapan int = 8; int dutyCycle = 21; void setup () {Serial.begin (115200); kelewatan (1000); / / Berikan saya masa untuk memaparkan monitor siri Serial.println ("Kawalan Servis ESP32"); ledcSetup (saluran, freq, resolusi); ledcAttachPin (SERVO_PIN, saluran); ledcWrite (saluran, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Kitaran Duti ==>"); Serial.println (dutyCycle); dutyCycle = peta (analog_value, 0, 4095, 10, 33); ledcWrite (saluran, dutyCycle); kelewatan (50); } 

Sekarang kita boleh bekerja dengan Sensor Ultrasonik di atas servo dan membina Radar IoT !. Tetapi ini akan menjadi tutorial lain! ;-)

Langkah 9: Menyambung ke Internet: Setem Masa Tempatan

Selepas menguji beberapa keupayaan digital digital / analog dan input / output, mari kita sambungkan ESP32 kami di internet!

Dengan keluarga ESP8266 kami menggunakan pustaka esp8266wifi.h untuk itu. Dengan ESP32, perpustakaan yang digunakan adalah:

Satu contoh yang sangat mudah akan menjadi pengaturcaraan lembaga kami untuk menangkap dari internet masa tempatan. Ini adalah ciri yang sangat baik untuk mempunyai projek. Kod di bawah akan melakukannya untuk kami:

 / ************************************************* ************* * Setem Masa Tempatan dengan ESP32 * Dibangunkan oleh Marcelo Rovai - 8 September 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // Dalam saat #define NTP_INTERVAL 60 * 1000 // Dalam miliseconds #define NTP_ADDRESS "europe.pool.ntp.org" WiFiUDP ntpUDP; NTPClient timeClient (ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); void setup () {Serial.begin (115200); timeClient.begin (); } 

Anda boleh melihat di Serial memantau masa setempat yang dicap.

Langkah 10: Pelayan WiFi Mudah

Sekarang mari kita uji ESP32 kami sebagai pelayan WiFi mudah.

  • Buka menu EXAMPLES pada Arduino IDE anda dan dapatkan lakaran ESP32 WiFi / SimpleWiFiServer.ino:

Mengenai program ini:

Wifi Web Server LED Blink

  • Dibuat untuk arduino 25 Nov 2012 oleh Tom Igoe
  • Diambil untuk sparkfun esp32 31.01.2017 oleh Jan Hendrik Berlin

Pelayan web mudah yang membolehkan anda mengedipkan LED menerusi web. Lakaran ini akan mencetak alamat IP rangkaian ESP32 WiFi anda ke monitor Serial. Dari sana, anda boleh membuka alamat itu dalam pelayar web untuk menghidupkan dan mematikan LED pada pin 5.

Jika alamat IP lembaga anda sebagai contoh 10.0.1.40 :

  • //10.0.1.40/H menghidupkan LED
  • //10.0.1.40/L

    mematikan lampu LED

Contoh ini ditulis untuk rangkaian menggunakan penyulitan WPA. Untuk WEP atau WPA, tukar panggilan Wifi.begin () dengan sewajarnya.

Litar: LED dipasang pada pin 5

Jadi, mari gunakan program ini tanpa pengubahsuaian yang ketara. Tukar Pin LED Luaran ke GPIO5

Sudah tentu, jika anda lebih suka mengubah kod GPIO2 dengan menukar HW.

Pertama, masukkan kelayakan rangkaian anda:

 const char * ssid = "yourssid"; const char * password = "yourpasswd"; 

Dan muat naik pada ESP32 anda.

Perkara pertama yang akan anda lihat pada Monitor bersiri anda adalah maklumat yang ESP32 anda disambungkan dan apakah Alamat Ip:

 Sambungan WiFi. Alamat IP: 10.0.1.40 

Buka penyemak imbas kegemaran anda, taip alamat IP ini. Anda akan mendapat WebPage seperti yang di atas. Di sana anda boleh Hidupkan atau matikan LED dari jauh.

Langkah 11: DHT 22 - Suhu Membaca dan Kelembapan

Sensor yang sangat berguna untuk digunakan pada projek IoT ialah DHT 11 atau 22. Mereka sangat murah dan mudah disertakan dalam projek anda.

Pertama, anda perlu memasang Perpustakaan Adafrut pada IDE anda. Pergi ke GitHub mereka dan muat turun versi perpustakaan ini yang dikemaskini: DHT-sensor-library

Unzip fail tersebut, namakan namanya kepada DHT dan pindahkan folder lengkap ke direktori Perpustakaan Arduino anda

Apabila saya menggunakan untuk kali pertama saya mendapat mesej:

ralat maut: Adafruit_Sensor.h: Tiada fail atau direktori sedemikian

Selepas beberapa menggali, saya mendapati bahawa ia juga perlu mempunyai Perpustakaan Adaptasi Bersepadu Adafruit juga dipasang. Jadi, saya melakukannya dari Pengurus Perpustakaan IDE Arduino (lihat gambar di atas). Selepas itu, semuanya berfungsi dengan baik, sama seperti yang kita gunakan dengan Arduino dan NodeMCU.

Mari buat beberapa ujian dengan sensor ini. Ikuti rajah elektrik di atas dan pasang DHT22 seperti yang ditunjukkan (melihat sensor dengan muka "grid" anda, hitungkan 4 kaki dari kiri ke kanan):

  1. Pin VCC ==> 3.3V
  2. Pin Data ==> GPIO 23
  3. N / C
  4. PIN GND ==> GND

Juga, sambungkan perintang 10K ohm antara VCC dan Data.

Itu sahaja!

Anda boleh menggunakan lakaran contoh "DHT tester.ino" yang dimasukkan dalam pustaka, atau buat sendiri.

Saya menulis kod ringkas untuk menguji sensor seperti yang ditunjukkan di bawah:

 / ************************************************* **** * ESP32 DHT Reading * Input DHT: ==> GPIO23. * * MJRoBot.org 9Sept17 ******************************************** ********* / / * DHT * / #include "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); kelewatan (1000); / / Berikan saya masa untuk memaparkan monitor bersiri Serial.println (""); Serial.println ("ESP32 DHT Suhu dan Kelembapan"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); kelewatan (2000); } / ************************************************ *** * Dapatkan data Temp / Hum dalam ruangan **************************************** ************ / void getDHT () {float tempIni = localTemp; float humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); jika (isnan (localHum) || isnan (localTemp)) // Periksa jika ada fail yang gagal dan keluar awal (untuk mencuba lagi). {localTemp = tempIni; localHum = humIni; kembali; }} 

Anda boleh melihat hasilnya di atas PrintScreen Monitor Serial.

Langkah 12: Menghantar dan Menerima Data Dari Laman Web Tempatan

Mengkaji semula apa yang kita tutup sejauh ini dalam tutorial ini:

  • Output Digital: Berkedip LED
  • Input Digital: Membaca Sensor Sentuh
  • Input analog: Membaca voltan berubah dari potensiometer
  • Output Analog: Mengawal kecerahan LED
  • Output Analog: Mengawal Kedudukan Servo
  • Bacaan Suhu / Data Kelembapan dengan sensor Digital
  • Menyambung ke Internet dan mendapat masa setempat
  • Mewujudkan laman web mudah untuk menghidupkan / mematikan LED (menerima data)

Kami menyedari bahawa kami masih harus cuba menghantar data ke laman web. Jadi, mari kita lakukan!

Kami akan mengambil data yang dihasilkan daripada sensor DHT kami dan nilai analog yang disediakan oleh potensiometer dan menghantarnya ke laman web yang dibuat untuk mengawal LED.

Saya bermula dari kod SimpleWiFiServer yang digunakan dalam langkah 10 dan menambah baris kod yang berkaitan untuk mendapatkan data potensiometer dan DHT.

Perhatikan bahawa saya mengalihkan LED ke GPIO 2 seperti yang anda lihat pada gambar rajah elektrik.

Muat turun kod lengkap dari GitHub saya: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Perhatikan bahawa saya mengatur kod yang lebih baik dan sekarang, gelung () hanya:

 kekosongan gelung () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

Kebaharuan di sini ialah fungsi "WiFiLocalWebPageCtrl ()". Tetapi, inilah persediaan asal () yang digunakan pada SimpleWebServer. Apa yang saya termasuk di dalam fungsi ini, adalah apa yang sepatutnya muncul di laman web (lihat skrin cetak di atas untuk halaman web).

 // kandungan respons HTTP mengikuti pengepala: // WiFiLocalWebPageCtrl (); client.print ("Suhu sekarang adalah:"); client.print (localTemp); client.print ("oC 
"); client.print (" Kelembapan sekarang ialah: "); client.print (localHum); client.print ("%
"); client.print ("
"); client.print (" Data Analog: "); client.print (analog_value); client.print ("
"); client.print ("
"); client.print (" Klik di sini untuk menghidupkan LED.
"); client.print (" Klik di sini untuk mematikan LED.
");
Perhatikan bahawa suhu, kelembapan dan nilai analog, akan dikemas kini setiap kali anda klik pada pautan yang digunakan untuk mengawal LED atau apabila anda memuat semula halaman.

Langkah 13: Kesimpulan

Kita boleh pergi dan terus ke sini, tetapi kita tidak akan pernah menutup semua fungsi atau potensi ESP32. Terdapat banyak yang tersisa untuk diterokai dengan peranti IoT yang hebat ini dan pada tutorial saya yang akan datang, anda akan belajar bagaimana untuk menambah paparan OLED pada ESP32 anda:

Paparan ESP32 dan OLED: Jam Internet - DHT22

Kami akan kembali dengan tutorial ESP32 yang baru!

Seperti biasa, saya berharap projek ini dapat membantu orang lain mencari jalan mereka dalam dunia elektronik, robotika dan IOT yang menarik!

Sila lawati GitHub saya untuk fail yang dikemaskini: Bermain dengan ESP32 dan Arduino IDE

Untuk lebih banyak projek, sila lawati blog saya: MJRoBot.org

Saludos dari selatan dunia!

Lihat awak di temuduga saya yang seterusnya!

Terima kasih,

Marcelo

Artikel Berkaitan