Pengurusan rumah hijau atau rumah hijau dari mana saja di dunia (contoh pelaksanaan)

Tujuan pembangunan ini adalah untuk mengumpulkan data dari sensor tempatan, menghantar data ini ke Internet. Pengguna akan dapat melihat data yang datang dari sensor di mana sahaja di dunia dan membuat keputusan jauh mengenai pengaktifan penggerak tertentu yang akan ditempatkan di dalam negara, bersebelahan dengan sensor

Projek ini digunakan Arduino UNO dan modul WiFi ESP8266-01. Data akan dihantar ke cloud melalui perkhidmatan web ThingSpeak.com, dan peranti akan diaktifkan melalui aplikasi android yang dibangunkan menggunakan MIT AppInventor.





Fokus utama projek IoT ini adalah perkhidmatan ThingSpeak.com. Peranti UNO / ESP-01 tempatan menerima data daripada sensor dan data mengenai status penggerak, menghantarnya ke "rakaman" Internet melalui saluran status ThingSpeak.com tertentu (ThingSpeak.com Status Channel), serta peranti tempatan yang sama menerima data, " membaca "mereka dari saluran data lain -" saluran alat eksekutif "(ThanSpeak.com Actuator Channels).



Data akan dikumpulkan menggunakan sensor suhu dan kelembapan relatif, suhu tanah dan kelembapan, dan sensor cahaya ambien. Data ini akan dihantar ke awan perkhidmatan ThingSpeak.

Akan ada dua alat eksekutif - ini adalah pam elektrik air dan lampu. Status ON / OFF mereka juga akan dihantar ke awan. Data dari sensor, sebagai contoh, boleh memaparkan keadaan semasa rumah hijau atau rumah hijau. Pengguna akan mengawal peranti eksekutif menggunakan aplikasi android.




Semua pautan hanya untuk tujuan maklumat sahaja.






2 x LED (merah dan hijau)
1 x
- $3.00
Lampu 220V
2 x 330 ohm perintang (digunakan dengan LED)
2 x 10K ohm perintang (digunakan dengan DHT22 dan LDR)
1 x 4K7 ohm perintang (digunakan dengan DS18B20)
Breadboard
Jumper
Bekalan kuasa luaran untuk geganti 5V DC



Sekarang anda perlu menyambung semua sensor, seperti yang ditunjukkan dalam rajah.



Penyelesaian yang ideal adalah memasang dan menguji projek di bahagian.

Dalam urutan berikut:
1. Pasang dan uji semua sensor
2.Pasang dan sekurang-kurangnya mengkonfigurasi ESP-01
3. Tukar persediaan ESP-01 ke konfigurasi dan ujian akhir
4. Konfigurasi Saluran Status ThingSpeak
5. Pasang kod ThingSpeak pada Arduino dan periksa status sensor di atas awan
6. Buat versi pertama program di android untuk menyemak mesej status dari sensor
7. Pasang penggerak
8. Konfigurasikan saluran Penggerak ThingSpeak
9. Pasang dan uji kod untuk peranti eksekutif pada Arduino
10. Buat versi kedua program pada android untuk pemasangan seluruh peranti.



Projek ini menggunakan beberapa perpustakaan yang termasuk dalam. Ia perlu menyemak ketersediaan mereka. Konfigurasi awal perpustakaan ini adalah seperti berikut:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 pada pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

// DHT
#include "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (Cahaya)
#define ldrPIN 1
int light = 0;

// Kelembapan tanah
#define soilHumPIN 0
int soilHum = 0;

Kini kami memulakan sensor kami dan memaparkannya di terminal:

batal persediaan ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

kekosongan gelung ()
{
  readSensors ();
  paparanSensor ();
  kelewatan (10000);
}

Dan akhirnya, kita akan menulis dua fungsi: satu membaca bacaan dari sensor, dan yang lain memaparkannya pada skrin:

/ ********* Baca nilai Sensor ************* /
tidak sah readSensors (tidak sah)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Sensor 0 akan menangkap Tanah Temp dalam Celcius
  
  soilHum = map (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> cahaya 100%

}

/ ********* Nilai Sensor Paparan ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (soilTemp);
  Serial.print ("soilHum (%):");
  Serial.println (soilHum);
  Serial.print ("light (%):");
  Serial.println (cahaya);
  Serial.println ("");
}

Foto menunjukkan bagaimana data dipaparkan pada skrin.


Kod sumber boleh dimuat turun dari pengarang.



Cara terpantas untuk "bercakap" dengan modul adalah arahan AT. Pemproses sudah mempunyai pemproses perintah AT. Secara lalai, modul ini dilengkapi dengan tetapan kilang 115200 baud, anda perlu menetapkan 9600 baud dalam tetapan.

Pertama, anda perlu menyambung modul, seperti yang ditunjukkan dalam foto



( Ambil perhatian bahawa terminal Tx ESP-01 disambungkan ke terminal Tx UNO, sama seperti terminal Rx disambungkan kepada satu sama lain. Sambungan ini akan diubah kemudian. ).

Kemudian sambungkan UNO ke komputer, buka IDE dan muat turun contoh yang terletak. Ini kod kosong sehingga tiada konflik antara ESP-01 dan UNO. Kod ini telah dimuat naik ke Ardunio sebelum menyambung ESP-01 kepadanya, untuk memastikan bahawa Ardunio tidak akan menggunakan pin Tx dan Rx untuk apa-apa lagi.
Sekarang anda perlu membuka Monitor Serial IDE, tetapkan kadar baud ke 115200 dalam tetapan dan hantar arahan AT ke Monitor Serial IDE. ESP-01 perlu menghantar jawapan OK

Sekarang anda perlu menukar kadar data dalam modul ESP-01. Untuk melakukan ini, dalam IDE, berikan arahan

AT + CIOBAUD = 9600

Ia mungkin berlaku bahawa ESP-01 kembali ke tetapan kilang, maka anda perlu menggunakan perintah lain:

AT + UART_DEF = , , , , 

Contohnya 9600 baud / 8 bit data / 1 bit bit dan tiada pariti dan kawalan aliran

AT + UART_DEF = 9600,8,1,0,0

Sekarang ubah kadar pemindahan data dalam tetapan IDE ke 9600 dan hantar perintah AT, tindak balas OK akan datang.
Seterusnya, anda perlu menukar modul ke mod STA supaya ia boleh menyambung ke pusat akses rangkaian anda.

AT + CWMODE = 1

Untuk modul untuk menyambung ke rangkaian, masukkan arahan AT + CWJAP = "network_name", "network_name_1"di mana network_name Adakah nama rangkaian anda, dan network_name_1 - kata laluan untuk rangkaian anda (kata laluan dan nama rangkaian mestilah dalam tanda petikan)
Sekiranya anda melihat jawapannya WIFI GANTI WIFI GOT IP, maka sambungan itu ditubuhkan. Sahkan alamat IP dengan arahan

AT + CIFSR

.

Alamat yang muncul di monitor anda, anda boleh gunakan pada masa akan datang. Sebaik sahaja anda telah mengkonfigurasi modul, anda boleh menyambungkannya secara kekal, tetapi untuk ini anda perlu menukar litar pensuisannya, seperti yang ditunjukkan dalam rajah tersebut.


• ESP-01 RX (Kuning) -> UNO Pin D7
• ESP-01 TX (Orange) -> UNO Pin D6
• ESP-01 Ch-Pd (Brown) -> Vcc (3.3V)
• ESP-01 Reset (Blue) -> UNO Pin D8
• ESP-01 Vcc (Merah) -> 3.3V
• ESP-01 Gnd (Hitam) -> UNO GND

Ambil perhatian bahawa pustaka Serial Perisian menggunakan pin UNO Pin D7 seperti tx dan ia menyambung kepada output ESP-01 Rxmanakala UNO Pin D6 seperti rxdisambungkan ke ESP-01 TX.

Masukkan kod kecil untuk menyemak sambungan dan konfigurasi yang betul dari modul ESP-01

#include 
SoftwareSerial esp8266 (6.7); // Rx ==> Pin 6; TX ==> Pin7

#define speed8266 9600

batal persediaan ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("Persediaan ujian ESP8266 - gunakan AT coomands");
}

kekosongan gelung ()
{
  sementara (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  sementara (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Sekarang beberapa pasukan AT. Lihat hasil dalam Monitor Serial.



* AT =====> ESP8266 mengembalikan OK
* AT + RST =====> ESP8266 mulakan semula dan kembali OK
* AT + GMR =====> ESP8266 mengembalikan AT Versi; Versi SDK; id; Ok
* AT + CWMODE? => ESP8266 mengembalikan jenis mod
* AT + CWLAP ===> ESP8266 mengembalikan titik akses yang dekat
* AT + CIFSR ===> ESP8266 mengembalikan IP yang dilantik

Kod program boleh dimuat turun di

6 sambungan sensor dan ESP-01

Setelah semua sensor disambungkan dan diperiksa, serta modul ESP-01 diperiksa, perlu menyediakan data untuk dihantar ke Internet.





Salah satu bahagian yang paling penting dalam projek ini adalah platform IoT yang terbuka, yang akan membolehkan anda mengumpulkan data dari sensor, memproses dan menganalisisnya. Untuk melakukan ini, pergi ke dan buat akaun anda. Seterusnya, anda perlu membuat saluran di mana terdapat 2 penggerak, 5 sensor dan satu bidang sandaran.
• Bidang 1: Penggerak 1 (peranti 1)
• Medan 2: Penggerak 2 (peranti 2)
• Medan 3: Suhu Udara di oC (suhu udara dalam darjah Celcius)
• Isi 4: Kelembapan Relatif Udara dalam% (Kelembapan relatif dalam%)
• Medan 5: Suhu Tanah di oC (Suhu tanah dalam gred Celcius)
• Medan 6: Kelembapan Tanah dalam% (kelembapan tanah dalam%)
• Medan 7: Luminositas dalam% (pencahayaan dalam%)
• Bidang 8: Ganti

Bidang 8 dikhaskan untuk pengembangan masa depan atau debugging. Dalam projek ini, ia digunakan sebagai kaunter ralat komunikasi antara Arduino / ESP-01 dan ThingSpeak.com.

Sebaik sahaja anda telah mencipta Saluran Status, anda perlu merakam kekunci seperti yang ditunjukkan dalam foto.



Pada masa ini, kami mempunyai perkhidmatan awan yang dikonfigurasikan dan sensor kami mengumpul data secara tempatan. Kini anda perlu mengambil data ini dan hantar ke awan di ThingSpeak.com.

Untuk menulis data ke saluran ThingSpeak, anda perlu menghantar rentetan GET. Ini akan dilakukan dalam tiga peringkat.
Hantar arahan "Mula cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Panjang rentetan selanjutnya

AT + CIPSEND = 116

Dan akhirnya, rentetan GET yang akan menulis data kami dalam bidang Saluran Status tersimpan.

GET / update_ Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Harap maklum bahawa kita tidak boleh menulis data ke saluran lebih daripada 1 kali dalam 16 saat.

Kod yang dikemukakan akan melakukan semua ini.

// Thingspeak
Status rentetanChWriteKey = "KEBUTUHAN ANDA DI SINI"; // // ID Status: 385184

#include 
EspSerial SoftwareSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 pada pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

// DHT
#include "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (Cahaya)
#define ldrPIN 1
int light = 0;

// Kelembapan tanah
#define soilHumPIN 0
int soilHum = 0;

// Pembolehubah yang akan digunakan dengan pemasa
panjang writeTimingSeconds = 17; // ==> Tentukan masa Contoh dalam beberapa saat untuk menghantar data
startWriteTiming = 0;
panjang elapsedWriteTime = 0;

/ // Pembolehubah yang akan digunakan dengan Penggerak
boolean pump = 0;
lampu boolean = 0;

int ganti = 0;
ralat boolean;

batal persediaan ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, TINGGI);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset modulo WiFi Modulo
  startWriteTiming = millis (); // memulakan "jam program"
}

kekosongan gelung ()
{
  mula: // label
  ralat = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  jika (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  jika (ralat == 1) // Selesaikan jika penghantaran tidak selesai
  {
    Serial.println ("<<<< ERROR >>>>");
    kelewatan (2000);
    goto start; // pergi ke label "mula"
  }
}

/ ********* Baca nilai Sensor ************* /
tidak sah readSensors (tidak sah)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Sensor 0 akan menangkap Tanah Temp dalam Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> cahaya 100%
  soilHum = map (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
tidak sah menulisThingSpeak (tidak sah)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pam);
  getStr + = "& field2 =";
  getStr + = String (lampu);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (soilTemp);
  getStr + = "& field6 =";
  getStr + = String (soilHum);
  getStr + = "& field7 =";
  getStr + = String (cahaya);
  getStr + = "& field8 =";
  getStr + = String (ganti);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Reset ESP ************* /
tidak sah EspHardwareReset (tidak sah)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  kelewatan (500);
  digitalWrite (HARDWARE_RESET, TINGGI);
  kelewatan (8000); // Lihat keperluan untuk datang
  Serial.println ("RESET");
}

/ ********* Memulakan komunikasi dengan ThingSpeak ************* /
tidak sah startThingSpeakCmd (tidak sah)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Mula cmd:");
  Serial.println (cmd);

  jika (EspSerial.find ("Ralat"))
  {
    Serial.println ("ralat AT + CIPSTART");
    kembali
  }
}

/ ********* hantar cmd GET ke ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

  jika (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    kelewatan (500); // tempo para processar o GET, semoga penangguhan ini sibuk tanpa arahan

    Mesej StringBody = "";
    sementara (EspSerial.available ())
    {
      Talian rentetan = EspSerial.readStringUntil ('\ n');
      jika (line.length () == 1)
      {// kandungan sebenar bermula selepas baris kosong (yang mempunyai panjang 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody received:");
    Serial.println (messageBody);
    kembali mesejBody;
  }
  lain
  {
    EspSerial.println ("AT + CIPCLOSE"); // pengguna amaran
    Serial.println ("ESP8266 CIPSEND RALAT: MENINGKATKAN"); // Sambung semula ...
    ganti = ganti + 1;
    ralat = 1;
    kembali "ralat";
  }
}

Anda boleh melihat kemajuan dalam Monitor Serial.

Kod sumber boleh dimuat turun di



Pertama anda perlu membuat antara muka pengguna. Gambar menunjukkan unsur-unsur yang kelihatan dan tidak kelihatan yang utama.



Selepas itu, anda perlu membuat blok. Item menu sesuai dengan nombor tangkapan skrin.

1 Pembolehubah negeri yang perlu diisytiharkan sebagai global

2 Setiap dua saat (bergantung pada Clock1) prosedur dipanggil "readArduino"


Prosedur ini mengembalikan nilai pembolehubah yang sepatutnya dipaparkan pada skrin. Dalam kes ini, nilai negeri (0 dan 1) untuk penggerak ditukar kepada "ON" dan "OFF" untuk persepsi yang lebih baik.

Nilai (Status) ini akan dipaparkan dalam "Pintasan"

3 Rutin readArduino pada dasarnya akan membaca saluran status dalam ThingSpeak. Jadi, anda perlu menentukan URL yang akan dihantar kepada Thingspeak. Untuk melakukan ini, 3 pembolehubah global mesti diisytiharkan dan digabungkan untuk membuat URL yang akan dihantar kepada ThingSpeak. GET perlu dihantar ke komponen web yang dipanggil "ArduFarmBotStatusCh"

4 Teks yang diterima daripada arahan terdahulu akan tiba dalam format JSon. Teks ini perlu diproses supaya setiap bidang dibaca dan disimpan dalam pembolehubah global sepadan.

5 Perkara terakhir yang perlu dilakukan ialah memanggil prosedur "penggera", yang akan menganalisis keadaan dua sensor tanah. Jika suhu terlalu rendah (dalam kes kita 10oC), mesej harus dipaparkan. Sama untuk kelembapan jika di bawah 60%.

Sila ambil perhatian bahawa kami telah menentukan pemasa lain (Clock2), yang diprogramkan untuk menjalankannya setiap saat. Ia hanya diperlukan untuk "menukar" warna teks mesej (dari putih ke merah). Mesej itu akan berkelip.

Kod permohonan boleh dimuat turun di




Perintah dan mematikan pam dan lampu akan diterima dari jauh. Output Ardunio akan mengaktifkan relay dan LED, mengambil arahan ini. Gambar menunjukkan bagaimana penggerak perlu disambungkan. Sila ambil perhatian bahawa output geganti GND TIDAK SAMBUNGAN kepada output GNDUNO. Dengan cara ini akan ada gangguan kuasa yang kurang apabila geganti berjalan.




Semua tindakan mengulangi prosedur untuk mengkonfigurasi saluran Status. Ia adalah perlu untuk membuat dua saluran untuk setiap peranti. Untuk setiap saluran, tulis ID Saluran, Baca dan Tulis kekunci. Kami akan menulis hanya dalam bidang pertama setiap saluran. Sebagai contoh:
ID saluran 375598 ==> LED Red (Pam)
◦ Field1 = 0 ==> PUMP OFF
◦ Field1 = 1 ==> PUMP ON
2. ID Saluran 375599 ==> LED Hijau (Lampu)
◦ Field1 = 0 ==> Lampu OFF
◦ Field1 = 1 ==> Lamp ON



Apabila kami menghantar data ke awan, kami "menulis" data ini kepada ThingSpeak. Saluran status, "menghantar" (memuat naik) data ini. Sekarang kita perlu "membaca" data dari Channel Actuator, "menerima" (memuat turun) data ini.

Untuk melakukan ini, hantar rentetan GET dan prosedur ini terdiri daripada 3 peringkat.
"Mula cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Panjang garis

AT + CIPSEND = 36

Dan tali GET itu sendiri

GET / channels / 375598 / fields / 1 / terakhir

Saluran akan "dibaca" setiap 10 saat

Selepas menghantar GET, kami mesti menerima respons daripada ThingSpeak. Jawapannya mestilah sama ada 0 atau 1, untuk setiap saluran. Sekiranya terdapat sebarang nilai lain, maka kita hanya mengabaikannya.

Perbezaan utama antara bahagian ini dan yang sebelumnya hanya dalam fungsi readThingSpeak (saluran channelID)
Berikut adalah kod yang melakukan tindakan yang dijelaskan.

// Thingspeak
String canalID1 = "999999"; / // Actuator1
String canalID2 = "999999"; / // Actuator2

#include 
EspSerial SoftwareSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// Pembolehubah yang akan digunakan dengan pemasa
readTimingSeconds = 10; // ==> Tentukan masa Sampel dalam beberapa saat untuk menerima data
lama startReadTiming = 0;
panjang elapsedReadTime = 0;

// Relays
#define ACTUATOR1 10 // RED LED ==> Pam
#define ACTUATOR2 12 // LED GREEN ==> Lampu
boolean pump = 0;
lampu boolean = 0;

int ganti = 0;
ralat boolean;

batal persediaan ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

  digitalWrite (ACTUATOR1, TINGGI); // // módulo relé é ativo em LOW
  digitalWrite (ACTUATOR2, TINGGI); // // módulo relé é ativo em LOW
  digitalWrite (HARDWARE_RESET, TINGGI);

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset modulo WiFi Modulo
  startReadTiming = millis (); // memulakan "jam program"
}

kekosongan gelung ()
{
  mula: // label
  ralat = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  jika (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int command = readThingSpeak (canalID1);
    jika (perintah! = 9) pam = arahan;
    kelewatan (5000);
    command = readThingSpeak (canalID2);
    jika (perintah! = 9) lampu = arahan;
    takeActions ();
    startReadTiming = millis ();
  }
  
  jika (ralat == 1) // Selesaikan jika penghantaran tidak selesai
  {
    Serial.println ("<<<< ERROR >>>>");
    kelewatan (2000);
    goto start; // pergi ke label "mula"
  }
}

/ ********* Ambil tindakan berdasarkan ThingSpeak Commands ************* /
void takeActions (void)
{
  Serial.print ("Pam:");
  Serial.println (pam);
  Serial.print ("Lamp:");
  Serial.println (lampu);
  jika (pam == 1) digitalWrite (ACTUATOR1, LOW);
  lain digitalWrite (ACTUATOR1, HIGH);
  jika (lamp == 1) digitalWrite (ACTUATOR2, LOW);
  lain digitalWrite (ACTUATOR2, TINGGI);
}

/ ********* Baca perintah penggerak dari ThingSpeak ************* /
int readThingSpeak (saluran saluranID)
{
  startThingSpeakCmd ();
  perintah int;
  // preparacao da string GET
  String getStr = "GET / channels /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  Mesej StringDown = sendThingSpeakGetCmd (getStr);
  jika (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Perintah yang diterima:");
    Serial.println (perintah);
  }
  lain perintah = 9;
  mengembalikan arahan;
}

/ ********* Reset ESP ************* /
tidak sah EspHardwareReset (tidak sah)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  kelewatan (500);
  digitalWrite (HARDWARE_RESET, TINGGI);
  kelewatan (8000); // Lihat keperluan untuk datang
  Serial.println ("RESET");
}

/ ********* Memulakan komunikasi dengan ThingSpeak ************* /
tidak sah startThingSpeakCmd (tidak sah)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Mula cmd:");
  Serial.println (cmd);

  jika (EspSerial.find ("Ralat"))
  {
    Serial.println ("ralat AT + CIPSTART");
    kembali
  }
}

/ ********* hantar cmd GET ke ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

  jika (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    kelewatan (500); // tempo para processar o GET, semoga penangguhan ini sibuk tanpa arahan

    Mesej StringBody = "";
    sementara (EspSerial.available ())
    {
      Talian rentetan = EspSerial.readStringUntil ('\ n');
      jika (line.length () == 1)
      {// kandungan sebenar bermula selepas baris kosong (yang mempunyai panjang 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody received:");
    Serial.println (messageBody);
    kembali mesejBody;
  }
  lain
  {
    EspSerial.println ("AT + CIPCLOSE"); // pengguna amaran
    Serial.println ("ESP8266 CIPSEND RALAT: MENINGKATKAN"); // Sambung semula ...
    ganti = ganti + 1;
    ralat = 1;
    kembali "ralat";
  }
}

Anda boleh memuat turunnya di



Pada peringkat ini, kami mempunyai saluran penggerak yang dikonfigurasi yang menukar nilai medan 1 untuk setiap peranti. Kita mesti mengesahkan bahawa peranti berfungsi dengan baik dengan betul. Pada akhir projek, aplikasi android akan digunakan untuk ini, tetapi ia juga boleh dilakukan melalui penyemak imbas.

Hidupkan pam (lampu LED merah)

https://api.thingspeak.com/update?api_key=Saved_channel_key_1&field1=1

Pam (merah LED)

https://api.thingspeak.com/update?api_key=Saved Channel_key_1 & field1 = 0

Hidupkan lampu (LED hijau hidup)

https://api.thingspeak.com/update?api_key=Saved Channel_key_2 & field1 = 1

Matikan lampu (hijau dipadamkan)

https://api.thingspeak.com/update?api_key=Saved Channel_key_2 & field1 = 0

Di bahagian sebelumnya, terdapat program mudah yang "membaca" data dari saluran dan dipaparkan pada skrin. Kini kita perlu membuat program "menulis" arahan di Actuator Channal, supaya arahan ini boleh dibaca oleh pengawal dan lampu dengan pam itu berfungsi dengan sewajarnya.

Supaya pengguna boleh menghantar arahan, aplikasi itu akan mempunyai dua butang untuk setiap peranti. Jika dihidupkan, biru, jika dimatikan, merah.

Dengan mengklik butang dalam aplikasi, anda boleh melihat keputusan dalam Monitor Serial.

Kod boleh dimuat turun di



Pada peringkat ini, terdapat aplikasi Android yang lengkap, sebahagian besar "besi" dipasang, tetapi tidak ada kod dalam pengawal yang akan sentiasa membaca data dan menghantar arahan ke awan. Anda hanya perlu menggabungkan semua serpihan kod yang ditulis lebih awal. Sudah tentu, kod tersebut mempunyai pilihan pengesahan tambahan (contohnya, jika ESP-01 membeku). Untuk melakukan ini, secara berkala, sebelum setiap arahan membaca atau menulis, arahan AT dihantar.Dan jika jawapannya OK tidak datang dari modul, maka modul itu telah reboot perisian secara paksa.

Kod projek penuh boleh dimuat turun di

Di alamat, anda boleh mendapatkan kemas kini untuk fail program.

Anda juga boleh membaca komen pada pautan ke sumber, jika sesuatu tidak jelas.