Basitleştirildi: Arduino IDE'de ESP32 ile Oynama

IoT kullanımı için harika yeni Geliştirme Kiti panosu ESP32'yi bu eğitimde keşfedelim. Espressif tarafından geliştirilen bu kart, düşük fiyatı ve mükemmel özellikleri nedeniyle NodeMCU'nun halefi olmalıdır.

Ancak, ESP8266 ve / veya Arduino ile çalışmaya alışkın DEĞİL TÜM kütüphanelerin veya işlevlerin bu yeni kartta henüz işlevsel olmadığını belirtmek de önemlidir. Muhtemelen bu yakında olacak, bu yüzden ESP 32 Forum WebPage'de düzenli olarak kontrol edin.

Burada ESP32'yi Arduino IDE'de nasıl programlayacağımızı, en yaygın işlevlerini ve kitaplıklarını nasıl keşfedeceğinizi, bu büyük çip ile sunulan önemli farklılıkların ve yeni özelliklerin bazılarını göstereceğiz.

Kısacası, keşfedeceğiz:

  • Dijital Çıkış: Bir LED'i yanıp sönüyor
  • Dijital Giriş: Dokunmatik Sensörü Okuma
  • Analog Giriş: Bir potansiyometreden değişken bir voltaj okuma
  • Analog Çıkış: LED parlaklığını kontrol etme
  • Analog Çıkış: Servo Konumunu Kontrol Etme
  • Dijital sensör ile Sıcaklık / Nem Verilerini Okuma
  • İnternete bağlanma ve yerel saati alma
  • Basit bir yerel web sayfasından veri alma, bir LED'i açma / kapatma
  • Verileri basit bir yerel web sayfasına aktarma

Adım 1: ESP32 Ana Özellikleri

ESP32, piyasadaki benzer IoT kartlarına göre büyük avantajlara sahip 10 ABD dolarının altında bir karttır.

Bu kartta çok yardımcı olan çift işlenmiş bir mikroişlemci vardır, çünkü bir işlemci iletişim işlediğinde, diğeri G / Ç kontrolünden sorumludur. Bu özellik, tek CPU'nun Comm ile çalışırken I / O'ları kontrol etmeyi bırakması gereken ESP8266 ile ilgili bazı sorunları önleyecektir. Ayrıca, ESP32 entegre WIFI, BLUETOOTH, DAC, birkaç ADC (sadece ESP8266 olarak değil), kapasitif dokunmatik sensörler, vb. (Yukarıdaki blok şemasına bir göz atın) entegre edilmiştir. İyi haber şu ki, Güç Tüketimi ESP8266 ile neredeyse aynı.

ESP8266 ile karşılaştırıldığında bize ana özelliklerini ve farklılıklarını gösterebilen bir grafik aşağıdadır:

Ana özelliklerini daha ayrıntılı olarak ele alalım:

Ana Özellikler:

  • 600 DMIPS ile 240 MHz çift çekirdekli Tensilica LX6 mikrodenetleyici
  • Tümleşik 520 KB SRAM
  • Entegre 802.11 b / g / n HT40 Wi-Fi alıcı-verici, temel bant, yığın ve LwIP
  • Entegre çift modlu Bluetooth (klasik ve BLE)
  • CPU kod alanına bellek eşlemeli 16 MB flash
  • 2.3V - 3.6V çalışma gerilimi
  • -40 ° C ila + 125 ° C çalışma sıcaklığı
  • Harici anten için yerleşik PCB anteni / IPEX konektörü

Sensörler:

  • Ultra düşük gürültülü analog amplifikatör
  • Salon sensörü
  • 10x kapasitif dokunmatik arayüz
  • 32 kHz kristal osilatör

34 x GPIO:

  • Donanım akış kontrolü dahil 3 x UART
  • 3 x SPI
  • 2 x I2S
  • 18 x ADC giriş kanalı
  • 2 x DAC
  • 2 x I2C
  • Her GPIO piminde PWM / zamanlayıcı girişi / çıkışı mevcuttur
  • 32 kB TRAX tamponlu OpenOCD hata ayıklama arayüzü
  • SDIO master / slave 50 MHz
  • 16 MB'a kadar harici SPI flaşı destekler
  • SD kart arayüz desteği

Güvenlikle İlgili:

  • WEP, WPA / WPA2 PSK / Kurumsal
  • Donanım hızlandırmalı şifreleme: AES / SHA2 / Eliptik Eğri Şifrelemesi / RSA-4096

Verim:

  • Sniffer, Station, SoftAP ve Wi-Fi direct modunu destekler
  • Maksimum veri hızı 150 HT40, 72 HT20, 54 ve 11
  • Maksimum iletim gücü 19, 5, 16, 5, 15, 5
  • Minimum alıcı duyarlılığı -97 dBm
  • 135 Mbps UDP sürekli üretim
  • Derin uykuda 5 μA güç tüketimi

Adım 2: BoM - Malzeme Listesi

  • ESP32 Geliştirme Kiti: ESP32 Geliştirme Kartı (8, 52 ABD Doları)
  • Mikro Servo: TowerPro SG90 9G Mini Servo (US $ 3.80)
  • Sıcaklık / Hum Sensörü DHT22 / AM2302 Dijital Sıcaklık ve Nem Sensörü (US $ 9.99)
  • LED
  • 2 x Direnç: 330 ohm ve 10K ohm
  • Potansiyometre: 10K ohm
  • Protoboards

Adım 3: ESP32 Arduino IDE Kurulumu

ESP8266 ailesi ile yaptığımız gibi ESP32 programlamak için Arduino IDE'yi kullanacağız.

Sürücüleri Yükle:

Bilgisayarınıza, CP210x USB'den UART Sürücüsüne güncellenmiş olması önemlidir. Bu bağlantıya girin: usb-uart-bridge-vcp-drivers ve işletim sisteminiz için uygun sürücüyü yükleyin.

Kitaplığı Yükle:

Buradaki yenilik, Expressif'in GitHub'daki kendisinin bize kütüphane kurulumu için uygun yönleri vermesi: arduino-esp32. İşletim sisteminiz için talimatları izleyin. Benim durumumda (MacOS) kurulum çok basit:

Terminal'i açın ve aşağıdaki komutu yürütün (copy-> paste ve enter tuşuna basın):

 mkdir -p ~ / Belgeler / Arduino / donanım / espressif && \ cd ~ / Belgeler / Arduino / donanım / espressif && \ git clone //github.com/espressif/arduino-esp32.git esp32 && \ cd esp32 / tools / && \ python get.py 

Bundan sonra, Arduino IDE'yi yeniden başlatın ve bitti! "ARAÇLAR" Menüsünde birkaç pano görmelisiniz. Size uygun olanı seçin. Genel olarak, "genel" ESP32 DEV MODÜLÜ iyi çalışır.

Arduino IDE'yi ilk kez açtığınızda, varsayılan yükleme hızının 921.600 baud olduğunu göreceksiniz. Bu, dengesizliği provoke edebilir. 115.200 baud ile değiştirin !

Adım 4: Merhaba Dünya! Bir LED yanıp sönüyor

Her zamanki gibi, yeni bir HW keşfetmeye başladığımızda yapılacak ilk şey bir LED'i yanıp sönmektir.

IDE'deki Örnekler Menüsüne gidin ve Göz Kırpma çizimini açın.

ESP32 DevKit, GPIO 02'ye bağlı yerleşik bir LED'e sahiptir. " LED_BUILTIN " öğesinin IDE tarafından otomatik olarak tanınıp tanınmadığını kontrol etmek önemlidir. Değilse, satırı kodlamak için eklemeniz gerekir:

 int LED_BUILTIN = 2; 
Her ESP32 kartında farklı bir GPIO'ya bağlı dahili bir LED bulunur
 / * ESP 32 Yanıp Sönüyor Bir LED'i bir saniye boyunca yanar, ardından bir saniye boyunca sürekli yanar. ESP32'de D2 (GPIO 02) * / int LED_BUILTIN = 2'de dahili bir mavi LED bulunur; void setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, YÜKSEK); // LED'i açın (YÜKSEK voltaj seviyesidir) gecikme (1000); // ikinci bir digitalWrite bekleyin (LED_BUILTIN, LOW); // gerilimi DÜŞÜK gecikme (1000) yaparak LED'i kapatın; // bir saniye bekle } 

GPIO 2'ye bağlı harici bir LED ile birlikte dahili LED'in yanıp sönmesinin (mavi ışığı not edin) altında:

Piyasada farklı pin haritalarına sahip birkaç farklı pano vardır. Yukarıdaki şemada kullandığım kart gösterilmektedir. Burada bulabilirsiniz: / ESP32-Development-Board

Mükemmel! Yani, DigitalWrite () ESP8266 ve Arduino ile aynı şekilde mükemmel çalışıyor. BTW, DigitalRead (), örneğin bir düğme gibi bir dijital girişi okumak için de aynı şekilde çalışır.

Adım 5: Dokunmatik Sensör

Yeni bir harika özelliğe, Dokunmatik Sensöre geçelim!

ESP32, 10 dahili kapasitif dokunmatik sensöre sahiptir. Örneğin düğmeler olarak kullanabilirsiniz.

Bu sensörler birkaç GPIO ile bağlanır:

  • 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

Bunları okumak için şu işlevi kullanmalısınız: touchRead (Touch Pin #);

Örneğin, Dokunmatik Sensör 0'ı (T0) okumak için aşağıdakine benzer bir şey yapmanız gerekir:

 int değeri = touchRead (4); 

Bir kod oluşturalım, burada T0 sensörüne (GPIO4) dokunursak, LED yanar.

Sensör tarafından okunan değerleri kontrol etmek ve kodu uygun şekilde ayarlamak için seri monitörü kullanın.

Tam kodun altında:

 / ************************************************* **** * ESP32 Dokunmatik Test ve LED Ctrl * Dokunmatik pim ==> Touch0, GPIO 4'te (D4) bulunan T0'dır. * LED pin ==> D2 * * MJRoBot.org 6Sept17 ************************************* **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; void setup () {Serial.begin (115200); Gecikme (1000); // seri monitörü açmak için bana zaman verin Serial.println ("ESP32 Touch Test"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, DÜŞÜK); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // if (touch_value <50) {digitalWrite (LED_PIN, HIGH) ile T0 kullanarak değer alın; } başka {digitalWrite (LED_PIN, LOW); } gecikme (1000); } 

Ve ESP32'nin altında çalışıyor:

Adım 6: Analog Giriş

Şimdi analog değer sinyallerinin nasıl girileceğini test edelim.

NodeMCU'da sadece 1 X 10 bit ADC'ye karşı toplam 18 x 12 bit ADC giriş kanalı vardır.

GPIO ADC Kanalı

  • 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

Analog girişi okumak için Arduino ve ESP8266 ile yaptığınız gibi olacaksınız:

 int analog_value = analogOkuma (36); 

ESP32 ADC'lerin 12 bit çözünürlüğe (ESP8266 ve Arduino'da 10 bit'e) sahip olduğunu, bu nedenle maksimum 3.3V uygulandığında toplam ADC aralıklarının 4.095'e (Arduinos ve ESP8266'da 1.027) gittiğine dikkat etmek çok önemlidir. girdileri.

Giriş için, 3.3V ve GND'den bağlayan 10K ohm potansiyometre kullanalım. Değişken çıkışını ESP32 ADC pinleri için giriş olarak kullanalım. Yukarıdaki şemada ADC1 Kanal 0 olan GPIO 36'ya bağlı potansiyometre gösterilmektedir. Ayrıca kartınızdaki diğer girişleri de deneyin.

Aşağıdaki basit kodu çalıştırın:

 / ************************************************* ***** * ESP32 Analog Giriş Testi * Analog Giriş: ADC_1_0 pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ******************************************** ********* / // Analog Giriş #define ANALOG_PIN_0 36 int analog_value = 0; void setup () {Serial.begin (115200); Gecikme (1000); // seri monitörü Serial.println ("ESP32 Analog IN Testi") getirmek için bana zaman verin; } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); gecikmesi (500); } 

Potansiyometrenizi çevirin ve sıfırdan 4, 095'e kadar olan ölçümleri IDE Seri Monitör'de izleyin.

Adım 7: Bir LED'i Karartma: PWM Kullanarak Analog Çıkış

ESP8266 veya Arduino'da "Bir LED'i Sönükleştirmek" istiyorsak, çıkışının PWM değerini değiştirerek analog bir değeri simüle eden analogWrite () gibi bir komut kullanabiliriz. Ne yazık ki, Arduino IDE'deki ESP32 için hala böyle bir komut geliştirmedik. ama çok iyi haber şu ki, ESP32 GPIO'ların 36'sında PWM özelliği var, ne harika! Aynı sonuca ulaşmak için yalnızca daha karmaşık kodlar kullanmalıyız.

Bu GPIO'lardan birini PWM çıkış sinyaliyle programlayalım.

PWM'nin bu bağlantıda nasıl çalıştığı hakkında ayrıntılı olarak çok iyi bir öğretici bulabilirsiniz: esp32-arduino-led-pwm-fading.

Üretilecek bir PWM sinyali hakkında düşünülmesi gereken ilk şey frekansıdır. LED ile iyi çalışan 5000 Hz'lik bir değer kullanacağız. Ayrıca LED PWM kanalını ve PWM görev döngüsünün çözünürlüğünü bit cinsinden belirtmeliyiz. 0 ila 15 arasında bir kanal ve 1 ila 16 bit arasında bir çözünürlük seçebiliriz. Kanal 0 ve 8 bit çözünürlük kullanacağız.

 int frekans = 5000; int ledChannel = 0; int çözünürlük = 8; 

Harici LED'imizin (ve dahili LED'in) takılı olduğu GPIO2'yi kullanalım.

 #define LED_PIN 2 

Bu parametreler, setup () aşamasında aşağıdaki işlevler kullanılarak tanımlanmalıdır:

 void setup () {ledcSetup (ledChannel, frekans, çözünürlük); ledcAttachPin (LED_PIN, ledChannel); } 

LED'i belirli bir parlaklıkla açmak için "görev döngüsü" nü tanımlamamız gerekir.

Örneğin, LED'i kapatmak için görev döngüsü sıfır olmalı ve değeri belirli bir PWM kanalı üzerinden göndermek için ledcWrite (ledChannel, dutyCycle) işlevi kullanılmalıdır:

 int görev Döngüsü = 0; ledcWrite (ledChannel, dutyCycle); 

DutyCycle değişkeninin farklı değerleri, farklı parlaklıktaki LED'i açar. Bu değişken, dutyCycle, kullanılan çözünürlük 8 bit olduğunda 0 ila 255 arasında değişecektir.

DutyCycle değişkenini manuel olarak ayarlamak için Potansiyometreyi ( analog_value değişkenine bağlı) kullanabiliriz, ancak değer aralıkları farklı olduğunda, giriş ve çıkışı eşleştirmek için bir harita işlevi kullanalım:

 dutyCycle = harita (analog_değer, 0, 4095, 0, 255); 

Tam kodun altında:

 ************************************************** *** * ESP32 Analog Giriş / Çıkış Testi * Analog Giriş: ADC_1_0 pin ==> GPIO36 (VP). * PWM LED pin ==> GPIO 02 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Analog Input #define ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int frekans = 5000; int ledChannel = 0; int çözünürlük = 8; int görev Döngüsü = 0; void setup () {Serial.begin (115200); Gecikme (1000); // seri monitörü Serial.println ("ESP32 Analog GİRİŞ / ÇIKIŞ Testi") açmak için bana zaman verin; ledcSetup (ledChannel, frekans, çözünürlük); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); dutyCycle = harita (analog_değer, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); gecikmesi (500); } 

Bu kadar!

Adım 8: Servo Kontrol

ESP32'nin PWM özelliğini kullanarak bir Servo Motoru kontrol edelim. Kod, temel olarak LED parlaklığını kontrol etmek için kullanılan kodla aynı olacaktır.

İlk olarak, bir Micro Servo ile çalışma frekansının 50Hz olduğunu hatırlamak önemlidir, bu nedenle frekans parametresini 50 olarak değiştirmeliyiz (LED ile kullanılan 5.000 yerine). Ayrıca LED PWM kanalını ve PWM görev döngüsünün çözünürlüğünü bit cinsinden belirtmeliyiz. Kanal 0'ı ve 8 bit çözünürlüğü tekrar kullanacağız.

 int frekans = 50; int kanalı = 0; int çözünürlük = 8; 

Servo GPIO 5'e bağlanacaktır (yukarıdaki elektrik şemasına bakın).

 #define SERVO_PIN 5 

LED ile aynı şekilde, bu parametreler setup () aşamasında aşağıdaki işlevler kullanılarak tanımlanmalıdır:

 void setup () {ledcSetup (kanal, frekans, çözünürlük); ledcAttachPin (SERVO_PIN, kanal); } 

Servoyu belirli bir açıda konumlandırmak için "görev döngüsü" nü tanımlamalıyız (lütfen yukarıdaki şemaya bakın).

Örneğin, servoyu 90 derece civarında konumlandırmak için görev döngüsü 21 civarında olmalıdır ve değeri PWM kanalı üzerinden göndermek için ledcWrite (ledChannel, dutyCycle) işlevi kullanılmalıdır:

 int görev Döngüsü = 21; ledcWrite (kanal, görev Döngüsü); 

DutyCycle değişkeninin farklı değerleri, servoyu farklı açılarla konumlandıracaktır. Bu dutyCycle değişkeni 10'dan 32'ye değişmelidir (bu aralık manuel olarak alınmıştır).

LED ile yaptığımız gibi, Potansiyometre ( analog_value değişkenine bağlı) dutyCycle değişkenini manuel olarak ayarlamak ve böylece servo konumunu değiştirmek için kullanılabilir. Değer aralıkları farklı olduğunda, girdi ve çıktıyı eşleştirmek için bir harita işlevi kullanalım:

 dutyCycle = harita (analog_değer, 0, 4095, 10, 33); 

Tam kodun altında:

 / ************************************************* **** * ESP32 Servo Kontrol * Analog Giriş: ADC_1_0 pin ==> GPIO36 (VP). * PWM SERVO pin ==> GPIO 05 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Analog Input #define ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int frekans = 50; int kanalı = 0; int çözünürlük = 8; int görev Döngüsü = 21; void setup () {Serial.begin (115200); Gecikme (1000); // seri monitörü açmak için bana zaman verin Serial.println ("ESP32 Servo Control"); ledcSetup (kanal, frekans, çözünürlük); ledcAttachPin (SERVO_PIN, kanal); ledcWrite (kanal, görev Döngüsü); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Görev Döngüsü ==>"); Serial.println (dutyCycle); dutyCycle = harita (analog_değer, 0, 4095, 10, 33); ledcWrite (kanal, görev Döngüsü); gecikmesi (50); } 

Şimdi servo üstünde Ultrasonik Sensör ile çalışabilir ve bir IoT Radarı oluşturabiliriz. Ama bu başka bir öğretici olacak! ;-)

Adım 9: İnternete Bağlanma: Yerel Zaman Damgası

Bazı GPIO dijital / analog ve giriş / çıkış özelliklerini test ettikten sonra, ESP32'yi internete bağlayalım!

ESP8266 ailesi ile bunun için esp8266wifi.h kütüphanesini kullanıyorduk. ESP32 ile kullanılacak kütüphane şöyle olacaktır:

Çok basit bir örnek, yerel saatte internetten çekim yapmak için kartımızı programlamak olacaktır. Bu, projelere hazır olmak için çok iyi bir özellik. Aşağıdaki kod bizim için yapacak:

 / ************************************************* ************* * ESP32 ile Yerel Zaman Damgası * Marcelo Rovai tarafından geliştirilmiştir - 8 Eylül 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // Saniyeler içinde #define NTP_INTERVAL 60 * 1000 // Milisaniye #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 (); } 

Seri monitörde damgalanan yerel saati görebilirsiniz.

10.Adım: Basit WiFi Sunucusu

Şimdi ESP32'yi basit bir WiFi Sunucusu olarak test edelim.

  • Arduino IDE'nizdeki ÖRNEKLER menüsünü açın ve ESP32 WiFi / SimpleWiFiServer.ino taslağını edinin:

Bu program hakkında:

WiFi Web Sunucusu LED Yanıp Sönüyor

  • Oluşturan arduino 25 Kas 2012 tarafından Tom Igoe
  • Taşınan kıvılcım esp32 31.01.2017 Jan Hendrik Berlin

Web üzerinden bir LED'in yanıp sönmesini sağlayan basit bir web sunucusu. Bu çizim ESP32 WiFi ağınızın IP adresini Seri monitöre yazdıracaktır. Buradan, pim 5'teki LED'i açmak ve kapatmak için bu adresi bir web tarayıcısında açabilirsiniz.

Anakartınızın IP adresi örneğin 10.0.1.40 ise :

  • //10.0.1.40/H LED'i açar
  • //10.0.1.40/L

    LED'i kapatır

Bu örnek, WPA şifrelemesi kullanan bir ağ için yazılmıştır. WEP veya WPA için Wifi.begin () çağrısını uygun şekilde değiştirin.

Devre: pime 5 bağlı LED

Bu yüzden programı önemli değişiklikler yapmadan kullanalım. Harici LED Pimini GPIO5 olarak değiştirin

Elbette, HW'yi değiştirmeden GPIO2 kodunu değiştirmeyi tercih ederseniz.

İlk olarak, ağ kimlik bilgilerinizi girin:

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

Ve ESP32'nize yükleyin.

Seri Monitörünüzde göreceğiniz ilk şey ESP32'nizin bağlı olduğu ve IP Adresinin ne olduğu olacaktır:

 WiFi bağlı. IP adresi: 10.0.1.40 

Bu IP adresini yazarak favori tarayıcınızı açın. Yukarıdaki gibi bir Web Sayfası alacaksınız. Orada LED'i uzaktan açabilir veya kapatabilirsiniz.

Adım 11: DHT 22 - Okuma Sıcaklığı ve Nem

IoT projelerinde kullanılacak çok kullanışlı bir sensör DHT 11 veya 22'dir. Çok ucuzdur ve projelerinize dahil edilmesi kolaydır.

İlk olarak, IDE'nizde Adafrut Kütüphanesi kurulu olmalıdır. GitHub'larına gidin ve bu kütüphanenin güncellenmiş sürümünü indirin: DHT-sensor-library

Dosyayı açın, DHT olarak yeniden adlandırın ve tüm klasörü Arduino Library dizininize taşıyın

İlk kez kullandığımda bir mesaj aldım:

ölümcül hata: Adafruit_Sensor.h: Böyle bir dosya veya dizin yok

Bazı kazmalardan sonra Adafruit Birleşik Sensör Kitaplığı'nın da kurulu olması gerektiğini buldum. Bu yüzden bunu Arduino IDE Kütüphane Yöneticisi'nden yaptım (yukarıdaki resme bakın). Bundan sonra, Arduino ve NodeMCU ile yaptığımız gibi her şey iyi çalıştı.

Bu sensörle bazı testler yapalım. Yukarıdaki elektrik şemasını takip edin ve DHT22'yi gösterildiği gibi takın (sensörü "ızgara" ile yüzünüze bakarak, soldan sağa 4 bacağı sayın):

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

Ayrıca, VCC ve Veri arasında 10K ohm direnç bağlayın.

Bu kadar!

Kütüphanede yer alan "DHT tester.ino" örnek çizimini kullanabilir veya kendinizinkini yapabilirsiniz.

Aşağıda gösterildiği gibi sensörü test etmek için basit bir kod yazdım:

 / ************************************************* **** * ESP32 DHT Okuma * DHT Girişi: ==> GPIO23. * * MJRoBot.org 9Sept17 ******************************************** ********* / / * DHT * / # "DHT.h" #define ekleyin DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); Gecikme (1000); // seri monitörü açmam için bana zaman ver Serial.println (""); Serial.println ("ESP32 DHT Sıcaklık ve Nem"); Serial.println ( ""); dht.begin (); } void loop () {getDHT (); Serial.print ("Sıcaklık: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); gecikmesi (2000); } / ************************************************ *** * İç mekan Sıcaklık / Uğultu verilerini alın **************************************** ************ / void getDHT () {float tempIni = localTemp; şamandıra humnini = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Okumaların başarısız olup olmadığını kontrol edin ve erken çıkın (tekrar denemek için). {localTemp = tempIni; localHum = humIni; dönüş; }} 

Sonucu Seri Monitörün PrintScreen'inde görebilirsiniz.

Adım 12: Yerel Bir Web Sayfasından Veri Gönderme ve Alma

Bu derste şimdiye kadar neler yaptığımızı gözden geçirmek:

  • Dijital Çıkış: Bir LED'i yanıp sönüyor
  • Dijital Giriş: Dokunmatik Sensörü Okuma
  • Analog Giriş: Bir potansiyometreden değişken bir voltaj okuma
  • Analog Çıkış: LED parlaklığını kontrol etme
  • Analog Çıkış: Servo Konumunu Kontrol Etme
  • Dijital sensör ile Sıcaklık / Nem Verilerini Okuma
  • İnternete bağlanma ve yerel saati alma
  • Bir LED'i açmak / kapatmak için basit bir web sayfası oluşturma (veri alma)

Yine de bir web sayfasına veri göndermeye çalışmamız gerektiğini biliyoruz. Öyleyse hadi yapalım!

DHT sensörümüzden üretilen verileri ve potansiyometre tarafından sağlanan analog değeri alacağız ve LED'leri kontrol etmek için oluşturulan web sayfasına göndereceğiz.

Adım 10'da kullanılan SimpleWiFiServer kodundan başladım ve potansiyometre ve DHT verilerini almak için ilgili kod satırlarını ekledim.

Elektrik şemasında görebileceğiniz gibi LED'i GPIO 2'ye geri taşıdığımı unutmayın.

Kodun tamamını GitHub'ımdan indir: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Ben kodu daha iyi organize ve şimdi, döngü () sadece:

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

Buradaki yenilik "WiFiLocalWebPageCtrl ()" işlevidir. Ancak bu, SimpleWebServer'da kullanılan orijinal setup () işlevidir. Bu işlevin içine dahil ettiğim şey, web sayfasında görünmesi gereken şeydir (web sayfası için yukarıdaki yazdırma ekranına bakın).

 // HTTP yanıtının içeriği şu başlığı izler: // WiFiLocalWebPageCtrl (); client.print ("Şimdi sıcaklık:"); client.print (localTemp); client.print ("oC 
"); client.print (" Şimdi nem: "); client.print (localHum); client.print ("%
"); client.print ("
"); client.print (" Analog Veri: "); client.print (analog_value); client.print ("
"); client.print ("
"); client.print (" LED'i açmak için burayı tıklayın.
"); client.print (" LED'i kapatmak için burayı tıklayın.
");
Sıcaklık, nem ve analog değerlerin, LED kontrolü için kullanılan bağlantılara her tıkladığınızda veya sayfayı yenilediğinizde güncelleneceğini unutmayın.

Adım 13: Sonuç

Burada devam edebiliriz, ama asla tüm ESP32 fonksiyonlarını veya potansiyelini kapsamazdık. Bu harika IoT cihazı ile keşfedilecek çok şey var ve bir sonraki eğitimde ESP32'nize nasıl OLED ekran ekleyeceğinizi öğreneceksiniz:

ESP32 ve OLED Ekran: İnternet Saati - DHT22

Yakında yeni ESP32 eğiticileriyle geri döneceğiz!

Her zaman olduğu gibi, bu projenin diğerlerinin heyecan verici elektronik, robotik ve IoT dünyasında yollarını bulmalarına yardımcı olabileceğini umuyorum!

Güncellenmiş dosyalar için lütfen GitHub'umu ziyaret edin: ESP32 ve Arduino IDE ile oynama

Daha fazla proje için lütfen blogumu ziyaret edin: MJRoBot.org

Dünyanın güneyinden Saludos!

Bir sonraki talimatımda görüşmek üzere!

Teşekkür ederim,

Marcelo

İlgi̇li̇ Makaleler