IOT Made Simple: Bermain Dengan ESP32 di Arduino IDE

Mari kita jelajahi dalam tutorial ini, ESP32, papan Kit Pengembangan baru yang fantastis untuk penggunaan IOT. Papan ini, yang dikembangkan oleh Espressif, harus menjadi penerus NodeMCU, karena harganya yang murah dan fitur-fitur hebat.

Tetapi juga penting untuk menunjukkan bahwa TIDAK SEMUA perpustakaan atau fungsi yang Anda gunakan untuk bekerja dengan ESP8266 dan / atau Arduino belum berfungsi pada papan baru ini. Mungkin ini akan segera, jadi periksa secara teratur di ESP 32 Forum WebPage.

Di sini kita akan belajar bagaimana memprogram ESP32 pada Arduino IDE, mengeksplorasi fungsi dan pustaka yang paling umum, menunjukkan beberapa perbedaan penting dan fitur baru yang diperkenalkan dengan chip hebat ini.

Singkatnya, kita akan mengeksplorasi:

  • Output Digital: Berkedip LED
  • Input Digital: Membaca Sensor Sentuh
  • Input Analog: Membaca tegangan variabel dari potensiometer
  • Output Analog: Mengontrol kecerahan LED
  • Output Analog: Mengontrol Posisi Servo
  • Membaca Data Suhu / Kelembaban dengan sensor Digital
  • Menghubungkan ke Internet dan mendapatkan waktu setempat
  • Menerima data dari halaman web lokal sederhana, menyalakan / mematikan LED
  • Mengirim data ke halaman web lokal sederhana

Langkah 1: Karakteristik Utama ESP32

ESP32 adalah papan di bawah US $ 10 dengan keuntungan besar dibandingkan papan IOT serupa di pasar.

Papan ini memiliki mikroprosesor ganda yang banyak membantu, karena ketika satu prosesor menangani komunikasi, yang lain bertanggung jawab atas kontrol I / O, misalnya. Fitur ini akan mencegah beberapa masalah yang terjadi dengan ESP8266, di mana satu-satunya CPU perlu berhenti mengendalikan I / Os ketika menangani dengan Comm. Selain itu, ESP32 memiliki WIFI terintegrasi, BLUETOOTH, DAC, beberapa ADC (tidak hanya satu seperti ESP8266), sensor sentuh kapasitif, dll (lihat diagram blok di atas). Dan kabar baiknya adalah Konsumsi Daya hampir sama dengan ESP8266.

Di bawah bagan yang dapat menunjukkan kepada kita karakteristik utamanya, dan perbedaan jika dibandingkan dengan ESP8266:

Mari kita tunjukkan properti utamanya secara lebih rinci:

Fitur Utama:

  • Mikrokontroler Tensilica LX6 dual core 240 MHz dengan 600 DMIPS
  • SRAM 520 KB terintegrasi
  • Transceiver Wi-Fi 802.11 b / g / n HT40 terintegrasi, baseband, stack, dan LwIP
  • Bluetooth mode ganda terintegrasi (klasik dan BLE)
  • 16 MB flash, dipetakan ke ruang kode CPU
  • 2.3V ke 3.6V tegangan operasi
  • -40 ° C hingga + 125 ° C suhu pengoperasian
  • Antena PCB onboard / konektor IPEX untuk antena eksternal

Sensor:

  • Penguat analog noise ultra-rendah
  • Sensor hall
  • 10x antarmuka sentuh kapasitif
  • Osilator kristal 32 kHz

34 x GPIO:

  • 3 x UART, termasuk kontrol aliran perangkat keras
  • 3 x SPI
  • 2 x I2S
  • 18 x saluran input ADC
  • 2 x DAC
  • 2 x I2C
  • Input / output PWM / timer tersedia pada setiap pin GPIO
  • Antarmuka debug OpenOCD dengan buffer TRAX 32 kB
  • SDIO master / slave 50 MHz
  • Mendukung flash SPI eksternal hingga 16 MB
  • Dukungan antarmuka SD-card

Keamanan terkait:

  • WEP, WPA / WPA2 PSK / Enterprise
  • Enkripsi yang dipercepat perangkat keras: AES / SHA2 / Elliptical Curve Cryptography / RSA-4096

Kinerja:

  • Mendukung sniffer, Station, SoftAP dan mode langsung Wi-Fi
  • Kecepatan data maks 150 HT40, 72 HT20, 54, dan 11
  • Daya pancar maksimum 19, 5, 16, 5, 15, 5
  • Sensitivitas penerima minimum -97 dBm
  • 135 Mbps throughput berkelanjutan UDP
  • Konsumsi daya 5 μA dalam Tidur nyenyak

Langkah 2: BoM - Bill of Material

  • ESP32 Dev Kit: ESP32 Development Board (US $ 8.52)
  • Micro Servo: TowerPro SG90 9G Mini Servo (US $ 3, 80)
  • Temp / Hum Sensor DHT22 / AM2302 Digital Suhu dan Kelembaban Sensor (US $ 9.99)
  • LED
  • 2 x Resistor: 330 ohm dan 10K ohm
  • Potensiometer: 10K ohm
  • Protoboards

Langkah 3: Instalasi IDE Arduino ESP32

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

Instal Driver:

Penting bahwa Anda telah menginstal pada komputer Anda, USB CP210x yang diperbarui untuk Driver UART. Masukkan tautan ini: driver usb-to-uart-bridge-vcp dan instal driver yang sesuai untuk OS Anda.

Instal Perpustakaan:

Kebaruan di sini adalah bahwa Expressif sendiri di GitHub-nya, akan memberi kita petunjuk yang tepat untuk instalasi perpustakaan: arduino-esp32. Ikuti instruksi untuk OS Anda. Dalam kasus saya (MacOS), instalasi sangat sederhana:

Buka Terminal dan jalankan perintah 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 

Setelah itu, restart Arduino IDE dan selesai! Anda harus melihat beberapa papan di Menu "TOOLS". Pilih yang sesuai untuk Anda. Secara umum, MODULE ESP32 DEV "generik" berfungsi dengan baik.

Ketika Anda membuka Arduino IDE untuk pertama kalinya, Anda akan mencatat bahwa kecepatan unggah default adalah 921.600 baud. Ini bisa memicu ketidakstabilan. Ubah ke 115.200 baud !

Langkah 4: Hello World! Berkedip LED

Seperti biasa, hal pertama yang harus dilakukan ketika kita mulai menjelajahi HW baru adalah mengedipkan LED.

Buka Menu Contoh di IDE dan buka sketsa Blink.

ESP32 DevKit, memiliki LED bawaan yang terhubung ke GPIO 02-nya. Penting untuk memeriksa apakah " LED_BUILTIN " secara otomatis dikenali oleh IDE. Jika tidak, Anda harus menambahkan kode ke baris:

 int LED_BUILTIN = 2; 
Setiap papan ESP32 memiliki LED internal yang terhubung ke GPIO yang berbeda
 / * ESP 32 Blink Menyalakan LED menyala selama satu detik, lalu mati selama satu detik, berulang kali. ESP32 memiliki LED biru internal pada D2 (GPIO 02) * / int LED_BUILTIN = 2; void setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, HIGH); // nyalakan LED (TINGGI adalah level voltase) penundaan (1000); // tunggu digitalWrite kedua (LED_BUILTIN, LOW); // matikan LED dengan membuat penundaan RENDAH voltase (1000); // tunggu sebentar} 

Di bawah LED internal berkedip (perhatikan lampu biru) bersama dengan yang eksternal terhubung ke GPIO 2:

Ada beberapa papan berbeda dengan pin map berbeda di pasaran. Diagram di atas menunjukkan papan yang saya gunakan. Anda dapat menemukannya di sini: / ESP32-Development-Board

Sempurna! Jadi, DigitalWrite () bekerja dengan sempurna, dengan cara yang sama dengan ESP8266 dan Arduino. BTW, DigitalRead () juga bekerja dengan cara yang sama untuk membaca input digital, seperti tombol-tekan misalnya.

Langkah 5: Sensor Sentuh

Mari beralih ke fitur keren baru, Sensor Sentuh !

ESP32 memiliki 10 sensor sentuh kapasitif internal. Anda dapat menggunakannya sebagai tombol misalnya.

Sensor-sensor tersebut terhubung dengan beberapa GPIO:

  • 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 harus menggunakan fungsi: touchRead (Sentuh Pin #);

Misalnya, untuk membaca Sensor Sentuh 0 (T0), Anda harus melakukan sesuatu seperti:

 int value = touchRead (4); 

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

Gunakan monitor serial untuk memeriksa nilai yang dibaca oleh sensor dan sesuaikan kode dengan benar.

Di bawah kode lengkap:

 / ************************************************* **** * Tes Sentuh ESP32 dan LED Ctrl * Pin sentuh ==> Touch0 adalah T0 yang ada 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); keterlambatan (1000); // beri saya waktu untuk memunculkan monitor serial Serial.println ("ESP32 Touch Test"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // dapatkan nilai menggunakan T0 if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } else {digitalWrite (LED_PIN, LOW); } delay (1000); } 

Dan di bawah ESP32 berfungsi:

Langkah 6: Input Analog

Sekarang mari kita menguji bagaimana cara memasukkan sinyal nilai analog.

Total ada 18 x 12 bit saluran input ADC, versus hanya 1 X 10 bit ADC di NodeMCU.

Saluran GPIO ADC

  • 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 dicatat bahwa, ADC ESP32 memiliki resolusi 12 bit (dibandingkan 10 bit pada ESP8266 dan Arduino), sehingga total rentang bacaan ADC mencapai 4.095 (alih-alih 1.027 pada Arduinos dan ESP8266) ketika maksimum 3.3V diterapkan untuk inputnya.

Untuk input, mari gunakan potensiometer 10K ohm, yang menghubungkannya dari 3.3V dan GND. Mari kita gunakan keluaran variabelnya untuk menjadi input untuk pin ADC ESP32. Diagram Di atas menunjukkan potensiometer yang terhubung ke GPIO 36 yang merupakan Saluran ADC1 0. Coba juga input lain di papan Anda.

Jalankan kode sederhana di bawah ini:

 / ************************************************* ***** * Tes Input Analog ESP32 * Input Analog: pin ADC_1_0 ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ****************************************** ********* / // Input Analog #define ANALOG_PIN_0 36 int analog_value = 0; void setup () {Serial.begin (115200); keterlambatan (1000); // beri saya waktu untuk memunculkan monitor serial Serial.println ("ESP32 Analog IN Test"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); keterlambatan (500); } 

Putar potensiometer Anda dan amati pada IDE Serial Monitor pengukuran dari nol menjadi 4.095.

Langkah 7: Peredupan LED: Output Analog Menggunakan PWM

Jika kita ingin "Dimmer LED" pada ESP8266 atau Arduino, kita cukup menggunakan perintah seperti analogWrite (), yang akan memvariasikan nilai PWM dari outputnya, mensimulasikan nilai analog. Sayangnya, kami masih belum memiliki jenis perintah yang dikembangkan untuk ESP32 pada Arduino IDE. tapi kabar baiknya adalah bahwa semua 36 GPIO ESP32 memiliki kemampuan PWM, bagus sekali! Hanya kita harus menggunakan kode yang lebih kompleks untuk mencapai hasil yang sama.

Jadi, mari kita programkan salah satu GPIO itu dengan sinyal output PWM.

Anda dapat menemukan tutorial yang sangat bagus dalam detail tentang cara kerja PWM di tautan ini: esp32-arduino-led-pwm-fading.

Hal pertama yang harus dipikirkan tentang sinyal PWM yang akan dihasilkan adalah frekuensinya. Kami akan menggunakan nilai 5000 Hz, yang berfungsi baik dengan LED. Kita juga harus menentukan saluran PWM LED dan resolusi siklus tugas PWM, dalam bit. Kita dapat 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; resolusi int = 8; 

Mari kita gunakan GPIO2, di mana kita memiliki LED eksternal kita (dan yang internal).

 #define LED_PIN 2 

Parameter tersebut harus ditentukan selama fase pengaturan (), menggunakan fungsi di bawah ini:

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

Untuk menyalakan LED dengan kecerahan tertentu, kita harus mendefinisikan "siklus tugas".

Misalnya, untuk mematikan LED, siklus tugas harus nol dan fungsi ledcWrite (ledChannel, dutyCycle) yang digunakan untuk mengirim nilai melalui saluran PWM tertentu:

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

Nilai yang berbeda dari variabel dutyCycle akan menyalakan LED dengan kecerahan yang berbeda. variabel ini, dutyCycle, akan bervariasi dari 0 hingga 255, setelah resolusi yang digunakan adalah 8 bit.

Kita dapat menggunakan Potensiometer (terhubung ke variabel analog_value ) untuk secara manual mengatur variabel dutyCycle, tetapi begitu rentang nilainya berbeda, mari gunakan fungsi peta untuk mencocokkan input dan output:

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

Di bawah kode lengkap:

 ************************************************ *** * ESP32 Analog Input / Output Test * Input Analog: pin ADC_1_0 ==> 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; resolusi int = 8; int dutyCycle = 0; void setup () {Serial.begin (115200); keterlambatan (1000); // beri saya waktu untuk memunculkan monitor serial 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); keterlambatan (500); } 

Itu dia!

Langkah 8: Kontrol Servo

Mari kita mengendalikan Servo Motor menggunakan kemampuan PWM dari ESP32 kami. Kode ini pada dasarnya akan sama dengan yang digunakan untuk mengontrol kecerahan LED.

Pertama, penting untuk diingat bahwa frekuensi untuk bekerja dengan Micro Servo adalah 50Hz, jadi kita harus mengubah parameter frekuensi menjadi 50 (daripada 5.000 digunakan dengan LED). Kita juga harus menentukan saluran PWM LED dan resolusi siklus tugas PWM, dalam bit. Kami akan menggunakan lagi saluran 0 dan resolusi 8 bit.

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

Servo akan terhubung ke GPIO 5 (lihat diagram listrik di atas).

 #define SERVO_PIN 5 

Sama seperti dengan LED, parameter-parameter itu harus ditentukan selama fase setup (), menggunakan fungsi di bawah ini:

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

Untuk memposisikan servo pada sudut tertentu, kita harus mendefinisikan "duty cycle" (tolong, lihat diagram di atas).

Misalnya, untuk memposisikan servo sekitar 90 derajat, siklus tugas harus sekitar 21 dan fungsi ledcWrite (ledChannel, dutyCycle) harus digunakan untuk mengirim nilai melalui saluran PWM:

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

Nilai yang berbeda dari variabel dutyCycle akan memposisikan servo dengan sudut yang berbeda. Variabel ini, dutyCycle, harus bervariasi dari 10 hingga 32 (kisaran ini didapat secara manual).

Sama seperti yang kami lakukan dengan LED, Potensiometer (terhubung ke variabel analog_value ) dapat digunakan untuk secara manual mengatur variabel dutyCycle dan dengan demikian, mengubah posisi servo. Setelah rentang nilainya berbeda, mari gunakan fungsi peta untuk mencocokkan input dan output:

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

Di bawah kode lengkap:

 / ************************************************* **** * Kontrol Servo ESP32 * Input Analog: pin ADC_1_0 ==> GPIO36 (VP). * Pin PWM SERVO ==> 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; resolusi int = 8; int dutyCycle = 21; void setup () {Serial.begin (115200); keterlambatan (1000); // beri saya waktu untuk membuka monitor serial Serial.println ("ESP32 Servo Control"); 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 ("Siklus Tugas ==>"); Serial.println (dutyCycle); dutyCycle = peta (analog_value, 0, 4095, 10, 33); ledcWrite (saluran, dutyCycle); keterlambatan (50); } 

Sekarang kita dapat bekerja dengan Sensor Ultrasonik di atas servo dan membangun Radar IoT !. Tapi ini akan menjadi tutorial lain! ;-)

Langkah 9: Menghubungkan ke Internet: Cap Waktu Lokal

Setelah menguji beberapa kemampuan digital / analog dan input / output GPIO, mari sambungkan ESP32 kami di internet!

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

Contoh yang sangat sederhana adalah memprogram papan kami untuk menangkap dari internet waktu setempat. Ini adalah fitur yang sangat bagus untuk dimiliki di proyek. Kode di bawah ini akan melakukannya untuk kita:

 / ************************************************* ************* * Perangko Waktu Lokal dengan ESP32 * Dikembangkan oleh Marcelo Rovai - 8 September 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // Dalam detik #define NTP_INTERVAL 60 * 1000 // Dalam milidetik #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 dapat melihat di Serial monitor waktu setempat dicap.

Langkah 10: Server WiFi Sederhana

Sekarang mari kita uji ESP32 kami sebagai Server WiFi sederhana.

  • Buka menu CONTOH pada Arduino IDE Anda dan dapatkan sketsa ESP32 WiFi / SimpleWiFiServer.ino:

Tentang program ini:

WiFi LED Server Web Blink

  • Dibuat untuk Arduino 25 Nov 2012 oleh Tom Igoe
  • Porting untuk sparkfun esp32 31.01.2017 oleh Jan Hendrik Berlin

Server web sederhana yang memungkinkan Anda mengedipkan LED melalui web. Sketsa ini akan mencetak alamat IP jaringan WiFi ESP32 Anda ke monitor Serial. Dari sana, Anda dapat membuka alamat itu di browser web untuk menghidupkan dan mematikan LED pada pin 5.

Jika alamat IP papan Anda misalnya 10.0.1.40 :

  • //10.0.1.40/H menyalakan LED
  • //10.0.1.40/L

    mematikan LED

Contoh ini ditulis untuk jaringan yang menggunakan enkripsi WPA. Untuk WEP atau WPA, ubah panggilan Wifi.begin () yang sesuai.

Sirkuit: LED terpasang ke pin 5

Jadi, mari kita gunakan program ini tanpa modifikasi yang signifikan. Ubah Pin LED Eksternal ke GPIO5

Tentu saja, jika Anda lebih suka mengubah kode untuk GPIO2 tanpa mengubah HW.

Pertama, masukkan kredensial jaringan Anda:

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

Dan unggah di ESP32 Anda.

Hal pertama yang akan Anda lihat di Monitor serial Anda adalah informasi bahwa ESP32 Anda terhubung dan apa alamat IP-nya:

 WiFi terhubung. Alamat IP: 10.0.1.40 

Buka browser favorit Anda, ketikkan alamat IP ini. Anda akan mendapatkan WebPage seperti di atas. Di sana Anda dapat Menghidupkan atau mematikan LED dari jarak jauh.

Langkah 11: DHT 22 - Membaca Suhu dan Kelembaban

Sensor yang sangat berguna untuk digunakan pada proyek IoT adalah DHT 11 atau 22. Sensor ini sangat murah dan mudah dimasukkan dalam proyek Anda.

Pertama, Anda harus memiliki Perpustakaan Adafrut diinstal pada IDE Anda. Buka GitHub mereka dan unduh versi terbaru dari perpustakaan ini: DHT-sensor-library

Buka zip file, ganti namanya menjadi DHT dan pindahkan folder lengkap ke direktori Arduino Library Anda

Ketika saya menggunakan untuk pertama kalinya saya mendapat pesan:

kesalahan fatal: Adafruit_Sensor.h: Tidak ada file atau direktori tersebut

Setelah beberapa penggalian, saya menemukan bahwa juga perlu memiliki Adafruit Unified Sensor Library juga diinstal. Jadi, saya melakukannya dari Arduino IDE Library Manager (lihat gambar di atas). Setelah itu, semuanya bekerja dengan baik, sama seperti yang kita gunakan dengan Arduino dan NodeMCU.

Mari kita lakukan beberapa tes dengan sensor ini. Ikuti diagram listrik di atas dan instal DHT22 seperti yang ditunjukkan (lihat sensor dengan "grid" menghadap Anda, hitung 4 kaki dari kiri ke kanan):

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

Juga, hubungkan resistor 10K ohm antara VCC dan Data.

Itu dia!

Anda dapat menggunakan sketsa contoh "DHT tester.ino" yang disertakan dalam perpustakaan, atau melakukannya sendiri.

Saya menulis kode sederhana untuk menguji sensor seperti yang ditunjukkan di bawah ini:

 / ************************************************* **** * ESP32 DHT Membaca * Input DHT: ==> GPIO23. * * MJRoBot.org 9Sept17 ****************************************** ********* / / * DHT * / # sertakan "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); keterlambatan (1000); // beri saya waktu untuk membuka monitor serial Serial.println (""); Serial.println ("ESP32 DHT Temperatur dan Kelembaban"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); delay (2000); } / ********************************************** *** * Dapatkan data Temp / Hum dalam ruangan ************************************** ************ / batal getDHT () {float tempIni = localTemp; float humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Periksa jika ada bacaan yang gagal dan keluar lebih awal (untuk mencoba lagi). {localTemp = tempIni; localHum = humIni; kembali; }} 

Anda dapat melihat hasilnya di PrintScreen dari Serial Monitor di atas.

Langkah 12: Mengirim dan Menerima Data Dari Halaman Web Lokal

Meninjau apa yang kami bahas sejauh ini dalam tutorial ini:

  • Output Digital: Berkedip LED
  • Input Digital: Membaca Sensor Sentuh
  • Input Analog: Membaca tegangan variabel dari potensiometer
  • Output Analog: Mengontrol kecerahan LED
  • Output Analog: Mengontrol Posisi Servo
  • Membaca Data Suhu / Kelembaban dengan sensor Digital
  • Menghubungkan ke Internet dan mendapatkan waktu setempat
  • Membuat halaman web sederhana untuk menghidupkan / mematikan LED (menerima data)

Kami menyadari bahwa kami masih harus mencoba mengirim data ke halaman web. Jadi, mari kita lakukan!

Kami akan mengambil data yang dihasilkan dari sensor DHT kami dan nilai analog yang diberikan oleh potensiometer dan mengirimkannya ke halaman web yang dibuat untuk mengontrol LED.

Saya mulai dari kode SimpleWiFiServer yang digunakan pada langkah 10 dan menambahkan baris kode terkait untuk mendapatkan data potensiometer dan DHT.

Perhatikan bahwa saya memindahkan kembali LED ke GPIO 2 seperti yang dapat Anda lihat pada diagram listrik.

Unduh kode lengkap dari GitHub saya: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Perhatikan bahwa saya mengatur kode dengan lebih baik dan sekarang, loop () hanya:

 void loop () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

Kebaruan di sini adalah fungsi "WiFiLocalWebPageCtrl ()". Tapi, ini persis fungsi setup () asli yang digunakan pada SimpleWebServer. Apa yang saya sertakan di dalam fungsi ini, adalah apa yang seharusnya muncul di halaman web (lihat layar cetak di atas untuk halaman web).

 // konten respons HTTP mengikuti tajuk: // WiFiLocalWebPageCtrl (); client.print ("Temperatur sekarang adalah:"); client.print (localTemp); client.print ("oC 
"); client.print (" Kelembaban sekarang adalah: "); 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 menyalakan LED.
"); client.print (" Klik di sini untuk mematikan LED.
");
Perhatikan bahwa suhu, kelembaban, dan nilai analog, akan diperbarui setiap kali Anda mengklik tautan yang digunakan untuk kontrol LED atau saat Anda menyegarkan halaman.

Langkah 13: Kesimpulan

Kita dapat terus dan terus di sini, tetapi kita tidak akan pernah membahas semua fungsi atau potensi ESP32. Ada banyak yang tersisa untuk dijelajahi dengan perangkat IoT yang hebat ini dan pada tutorial saya berikutnya, Anda akan belajar cara menambahkan tampilan OLED pada ESP32 Anda:

Tampilan ESP32 dan OLED: Jam Internet - DHT22

Kami akan segera kembali dengan tutorial ESP32 baru!

Seperti biasa, saya berharap proyek ini dapat membantu orang lain menemukan jalan mereka di dunia elektronik, robot, dan IoT yang menarik!

Silakan kunjungi GitHub saya untuk file yang diperbarui: Bermain dengan ESP32 dan Arduino IDE

Untuk proyek lainnya, silakan kunjungi blog saya: MJRoBot.org

Saludos dari selatan dunia!

Sampai jumpa di instruksiku berikutnya!

Terima kasih,

Marcelo

Artikel Terkait