Zarządzanie szklarnią lub szklarnią z dowolnego miejsca na świecie (przykład wdrożenia)

Celem tego opracowania jest zebranie danych z lokalnych czujników, przesłanie tych danych do Internetu. Użytkownik będzie mógł przeglądać dane pochodzące z czujników w dowolnym miejscu na świecie i podjąć zdalną decyzję o aktywacji niektórych siłowników, które będą zlokalizowane lokalnie, obok czujników

Projekt wykorzystuje Arduino Moduł UNO i WiFi ESP8266-01. Dane zostaną przesłane do chmury za pośrednictwem usługi internetowej ThingSpeak.com, a urządzenia zostaną aktywowane za pośrednictwem aplikacji na Androida opracowanej przy użyciu MIT AppInventor.





Głównym celem tego projektu IoT będzie usługa ThingSpeak.com. Lokalne urządzenie UNO / ESP-01 odbiera dane z czujników i dane o stanie siłowników, przesyła je do Internetu „rejestrując” poprzez określony kanał stanu ThingSpeak.com (kanał statusu ThingSpeak.com), a także to samo urządzenie lokalne odbiera dane, „ odczytywanie ”ich z innego kanału danych -„ kanału urządzeń wykonawczych ”(ThingSpeak.com Actuator Channels).



Dane będą gromadzone za pomocą czujnika temperatury i wilgotności względnej, temperatury i wilgotności gleby oraz czujnika światła otoczenia. Dane te zostaną przesłane do chmury usług ThingSpeak.

Będą dwa urządzenia wykonawcze - jest to elektryczna pompa wodna i lampa. Ich status WŁ. / WYŁ. Zostanie również wysłany do chmury. Na przykład dane z czujników mogą wyświetlać aktualny stan szklarni lub szklarni. Użytkownik będzie kontrolował urządzenia wykonawcze za pomocą aplikacji na Androida.




Wszystkie linki mają wyłącznie charakter informacyjny.






2 x diody LED (czerwona i zielona)
1 x
- $3.00
Lampa 220 V.
Rezystor 2 x 330 omów (stosowany z diodami LED)
Rezystor 2 x 10 K omów (stosowany z DHT22 i LDR)
1 x rezystor 4K7 Ohm (używany z DS18B20)
Breadboard
Swetry
Zewnętrzne źródło zasilania dla przekaźnika 5 V DC



Teraz musisz podłączyć wszystkie czujniki, jak pokazano na schemacie.



Idealnym rozwiązaniem byłoby złożenie i przetestowanie projektu w częściach.

W następującej kolejności:
1. Zainstaluj i przetestuj wszystkie czujniki
2)Zainstaluj i skonfiguruj minimalnie ESP-01
3. Zmień ustawienia ESP-01 na ostateczną konfigurację i przetestuj
4. Skonfiguruj kanał statusu ThingSpeak
5. Zainstaluj kod ThingSpeak na Arduino i sprawdź stan czujników w chmurze
6. Opracuj pierwszą wersję programu na Androida, aby sprawdzać komunikaty o stanie z czujników
7. Zainstaluj siłowniki
8. Skonfiguruj kanały siłowników ThingSpeak
9. Zainstaluj i przetestuj kod dla urządzeń wykonawczych na Arduino
10. Wykonaj drugą wersję programu na Androida dla całego zestawu urządzeń.



Projekt wykorzystuje niektóre biblioteki, które są zawarte w. Konieczne jest sprawdzenie ich dostępności. Początkowa konfiguracja tych bibliotek jest następująca:

// DS18B20
#include 
#include 
# zdefiniować ONE_WIRE_BUS 5 // DS18B20 na pinie D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (i 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 (lekki)
# zdefiniować ldrPIN 1
int light = 0;

// Wilgotność gleby
# zdefiniować glebę HumPIN 0
int glebaHum = 0;

Teraz inicjalizujemy nasze czujniki i wyświetlamy je w terminalu:

void setup ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

void loop ()
{
  readSensors ();
  displaySensors ();
  opóźnienie (10000);
}

Na koniec napiszemy dwie funkcje: jedna odczytuje odczyty z czujników, a druga wyświetla je na ekranie:

/ ********* Odczyt wartości czujników ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Czujnik 0 przechwyci Temperatura Gleby w Celsjuszu
  
  soilHum = mapa (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  światło = mapa (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lekki 100%

}

/ ********* Wyświetlanie wartości czujników *************** /
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 (lekki);
  Serial.println ("");
}

Zdjęcie pokazuje, jak dane są wyświetlane na ekranie.


Kod źródłowy można pobrać od autora.



Najszybszym sposobem na „rozmowę” z modułem jest polecenie AT. Procesor ma już procesor poleceń AT. Domyślnie moduł ma fabryczne ustawienia 115200 bodów, musisz ustawić 9600 bodów w ustawieniach.

Najpierw musisz podłączyć moduł, jak pokazano na zdjęciu



( Zauważ, że terminal Tx ESP-01 jest podłączony do terminala Tx UNO, podobnie jak terminale Rx są ze sobą połączone. To połączenie zostanie później zmienione. ).

Następnie podłącz UNO do komputera, otwórz IDE i pobierz znajdujący się przykład. Jest to pusty kod, aby nie było konfliktów między ESP-01 a UNO. Ten kod został przesłany do Ardunio przed podłączeniem do niego ESP-01, aby mieć pewność, że Ardunio nie użyje pinów Tx i Rx do niczego innego.
Teraz musisz otworzyć Monitor szeregowy IDE, ustawić prędkość transmisji na 115200 w ustawieniach i wysłać polecenie AT do Monitor szeregowy IDE. ESP-01 powinien wysłać odpowiedź OK

Teraz musisz zmienić szybkość transmisji danych w module ESP-01. Aby to zrobić, w IDE wydaj polecenie

AT + CIOBAUD = 9600

Może się zdarzyć, że ESP-01 powróci do ustawień fabrycznych, wtedy będziesz musiał użyć innego polecenia:

AT + UART_DEF = , , , , 

Na przykład 9600 bodów / 8 bitów danych / 1 bit stopu i brak kontroli parzystości i przepływu

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

Teraz zmień szybkość przesyłania danych w ustawieniach IDE na 9600 i wyślij polecenie AT, odpowiedź OK powinna nadejść.
Następnie należy przełączyć moduł w tryb STA, aby mógł połączyć się z punktem dostępu do sieci.

AT + CWMODE = 1

Aby połączyć moduł z siecią, wprowadź polecenie AT + CWJAP = „nazwa sieci”, „nazwa sieci_1”gdzie nazwa_sieci To nazwa twojej sieci i nazwa_sieci_1 - hasło do twojej sieci (hasło i nazwa sieci muszą być w cudzysłowie)
Jeśli zobaczysz odpowiedź WIFI POŁĄCZONE WIFI GOT IP, następnie połączenie zostanie nawiązane. Zweryfikuj adres IP za pomocą polecenia

AT + CIFSR

.

Adres wyświetlany na monitorze, którego możesz użyć w przyszłości. Po skonfigurowaniu modułu możesz go podłączyć na stałe, ale w tym celu musisz zmienić jego obwód przełączający, jak pokazano na rysunku.


• ESP-01 RX (żółty) -> Pin D7 UNO
• ESP-01 TX (pomarańczowy) -> UNO Pin D6
• ESP-01 Ch-Pd (brązowy) -> Vcc (3.3V)
• Reset ESP-01 (niebieski) -> Pin D8 UNO
• ESP-01 Vcc (czerwony) -> 3,3 V.
• ESP-01 Gnd (czarny) -> UNO GND

Zauważ, że biblioteka Software Serial wykorzystuje pin UNO Pin D7 jak tx i łączy się z wyjściem ESP-01 Rxpodczas gdy UNO Pin D6 jak rxpodłączony do ESP-01 TX.

Wprowadź mały kod, aby sprawdzić prawidłowe połączenie i konfigurację modułu ESP-01

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

# zdefiniować prędkość 8266 9600

void setup ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println („Test konfiguracji ESP8266 - użyj kooperantów AT”);
}

void loop ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Teraz kilka drużyn AT. Zobacz wyniki w monitorze szeregowym.



* AT =====> ESP8266 zwraca OK
* AT + RST =====> ESP8266 restartuje się i zwraca OK
* AT + GMR =====> ESP8266 zwraca wersję AT; Wersja SDK; id; Okej
* AT + CWMODE? => ESP8266 zwraca typ trybu
* AT + CWLAP ===> ESP8266 zwraca bliskie punkty dostępu
* AT + CIFSR ===> ESP8266 zwraca oznaczony adres IP

Kod programu można pobrać ze strony

6 połączenie czujników i ESP-01

Po podłączeniu wszystkich czujników i sprawdzeniu modułu ESP-01 konieczne jest przygotowanie danych do wysłania do Internetu.





Jedną z najważniejszych części projektu jest otwarta platforma IoT, która pozwoli Ci gromadzić dane z czujników, przetwarzać je i analizować. Aby to zrobić, przejdź do i utwórz konto. Następnie musisz utworzyć kanał, w którym będą 2 siłowniki, 5 czujników i jedno pole rezerwowe.
• Pole 1: siłownik 1 (urządzenie 1)
• Pole 2: siłownik 2 (urządzenie 2)
• Pole 3: Temperatura powietrza w oC (temperatura powietrza w stopniach Celsjusza)
• Zapisano 4: Wilgotność względna powietrza w% (wilgotność względna w%)
• Pole 5: Temperatura gleby w oC (temperatura gleby w gr. Celsjusza)
• Pole 6: Wilgotność gleby w% (wilgotność gleby w%)
• Pole 7: Jasność w% (oświetlenie w%)
• Pole 8: zapasowe

Pole 8 jest zarezerwowane do przyszłej rozbudowy lub debugowania. W tym projekcie jest on używany jako licznik błędów komunikacji między Arduino / ESP-01 a ThingSpeak.com.

Po utworzeniu kanału stanu należy zarejestrować klucze, jak pokazano na zdjęciu.



W tej chwili mamy skonfigurowaną usługę w chmurze, a nasze czujniki zbierają dane lokalnie. Teraz musisz wziąć te dane i wysłać je do chmury na ThingSpeak.com.

Aby zapisać dane do kanału ThingSpeak, musisz wysłać ciąg GET. Odbędzie się to w trzech etapach.
Wyślij polecenie „Start cmd”

AT + CIPSTART = „TCP”, „184.106.153.149”, 80

Dalsza długość sznurka

AT + CIPSEND = 116

I na koniec ciąg GET, który zapisze nasze dane w zarezerwowanych polach kanału statusu.

GET / update?

Pamiętaj, że nie powinniśmy zapisywać danych na kanale więcej niż 1 raz w ciągu 16 sekund.

Przesłany kod to wszystko.

// Thingspeak
Status stringChWriteKey = "TWÓJ NAPISZ KLUCZ TUTAJ"; // Status Channel ID: 385184

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

// DS18B20
#include 
#include 
# zdefiniować ONE_WIRE_BUS 5 // DS18B20 na pinie D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (i 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 (lekki)
# zdefiniować ldrPIN 1
int light = 0;

// Wilgotność gleby
# zdefiniować glebę HumPIN 0
int glebaHum = 0;

// Zmienne do użycia z zegarami
long writeTimingSeconds = 17; // ==> Określ czas próbkowania w sekundach na wysłanie danych
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Zmienne do użycia z siłownikami
pompa logiczna = 0;
lampka logiczna = 0;

int spare = 0;
błąd boolowski;

void setup ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Zresetuj do Modulo WiFi
  startWriteTiming = millis (); // uruchomienie „zegara programu”
}

void loop ()
{
  start: // etykieta
  błąd = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (błąd == 1) // Wyślij ponownie, jeśli transmisja nie zostanie zakończona
  {
    Serial.println („<<<< BŁĄD >>>>”);
    opóźnienie (2000);
    muszę zacząć; // przejdź do etykiety „start”
  }
}

/ ********* Odczyt wartości czujników ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Czujnik 0 przechwyci Temperatura Gleby w Celsjuszu
             
  światło = mapa (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lekki 100%
  soilHum = mapa (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (void)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  Ciąg getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pump);
  getStr + = "& field2 =";
  getStr + = String (lamp);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (soilTemp);
  getStr + = "& field6 =";
  getStr + = String (soilHum);
  getStr + = "& field7 =";
  getStr + = String (light);
  getStr + = "& field8 =";
  getStr + = String (spare);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Zresetuj ESP ************* /
void EspHardwareReset (void)
{
  Serial.println („Reseting .......”);
  digitalWrite (HARDWARE_RESET, LOW);
  opóźnienie (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  opóźnienie (8000); // Tempo Konieczna para começar a ler
  Serial.println („RESET”);
}

/ ********* Rozpocznij komunikację z ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o bufor antes de começar a gravar
  
  Ciąg cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = „184.106.153.149”; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find („Błąd”))
  {
    Serial.println („Błąd AT + CIPSTART”);
    powrót
  }
}

/ ********* wyślij GET cmd do ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Ciąg cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) „>”))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    opóźnienie (500); // tempo przetwarzania lub GET, najbardziej opóźnione jest zajęte bez komendy próximo

    String messageBody = "";
    while (EspSerial.available ())
    {
      Ciąg znaków = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// rzeczywista treść zaczyna się po pustej linii (która ma długość 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody otrzymano:”);
    Serial.println (messageBody);
    return messageBody;
  }
  jeszcze
  {
    EspSerial.println („AT + CIPCLOSE”); // alert użytkownika
    Serial.println („BŁĄD CIPSEND ESP8266: RESENDING”); // Wyślij ponownie ...
    zapasowy = zapasowy + 1;
    błąd = 1;
    zwróć „błąd”;
  }
}

Postęp można zobaczyć w Monitorze szeregowym.

Kod źródłowy można pobrać pod adresem



Najpierw musisz utworzyć interfejs użytkownika. Zdjęcie pokazuje główne widoczne i niewidoczne elementy.



Następnie musisz utworzyć bloki. Pozycje menu odpowiadają numerom zrzutu ekranu.

1 Zmienne stanu, które powinny być zadeklarowane jako globalne

2 Co dwie sekundy (w zależności od Zegara1) wywoływana jest procedura „readArduino”


Procedura zwraca wartość zmiennych, które powinny być wyświetlane na ekranie. W takim przypadku wartość stanu (0 i 1) dla siłowników jest konwertowana na „ON” i „OFF” dla lepszego postrzegania.

Te wartości (Status) zostaną wyświetlone w odpowiednich „Skrótach”

3 Procedura readArduino w zasadzie odczyta kanał statusu w ThingSpeak. Musisz określić adres URL, który zostanie wysłany do Thingspeak. W tym celu należy zadeklarować i połączyć 3 zmienne globalne, aby utworzyć adres URL, który zostanie wysłany do ThingSpeak. GET należy wysłać do komponentu WWW o nazwie „ArduFarmBotStatusCh”

4 Tekst otrzymany z poprzedniego polecenia pojawi się w formacie JSon. Ten tekst musi zostać przetworzony, aby każde pole zostało odczytane i zapisane w odpowiedniej zmiennej globalnej.

5 Ostatnią rzeczą do zrobienia jest wywołanie procedury „Alarm”, która analizuje stan dwóch czujników gruntu. Jeśli temperatura jest zbyt niska (w naszym przypadku 10oC), powinien zostać wyświetlony komunikat. To samo dotyczy wilgoci, jeśli wynosi poniżej 60%.

Pamiętaj, że zdefiniowaliśmy inny zegar (Zegar2), zaprogramowany tak, aby działał co sekundę. Wystarczy tylko „przełączyć” kolor tekstu wiadomości (z białego na czerwony). Wiadomość zacznie migać.

Kod aplikacji można pobrać ze strony




Polecenia włączania i wyłączania pompy i lampy będą odbierane zdalnie. Wyjście Ardunio aktywuje przekaźnik i diodę LED, przyjmując te polecenia. Zdjęcie pokazuje, jak należy podłączyć siłowniki. Należy pamiętać, że wyjście przekaźnikowe GND NIE PODŁĄCZONY do wyjścia GNDUNO. W ten sposób podczas pracy przekaźnika będzie mniej zakłóceń mocy.




Wszystkie działania powtarzają procedurę konfiguracji kanału stanu. Konieczne jest utworzenie dwóch kanałów dla każdego z urządzeń. Dla każdego kanału wpisz identyfikator kanału, klucze odczytu i zapisu. Napiszemy tylko w pierwszym polu każdego kanału. Na przykład:
ID kanału 375598 ==> Czerwona dioda LED (pompa)
◦ Pole 1 = 0 ==> Pompa wyłączona
◦ Pole 1 = 1 ==> Pompa włączona
2. ID kanału 375599 ==> Dioda LED zielona (lampa)
◦ Pole 1 = 0 ==> Lampa wyłączona
◦ Pole 1 = 1 ==> Lampa włączona



Kiedy wysyłaliśmy dane do chmury, „zapisywaliśmy” te dane do kanału ThingSpeak Stan kanału, „przesyłaliśmy” (przesyłaliśmy) te dane. Teraz musimy „odczytać” dane z kanału siłownika, „przyjmując” (pobierając) te dane.

Aby to zrobić, wyślij ciąg GET, a procedura ta składa się z 3 etapów.
„Uruchom cmd”

AT + CIPSTART = „TCP”, „184.106.153.149”, 80

Długość linii

AT + CIPSEND = 36

I sam łańcuch GET

GET / Channels / 375598 / fields / 1 / last

Kanały będą „czytane” co 10 sekund

Po wysłaniu GET musimy zaakceptować odpowiedź ThingSpeak. Odpowiedź musi wynosić 0 lub 1 dla każdego kanału. Jeśli są jakieś inne wartości, po prostu je ignorujemy.

Główną różnicą między tą częścią a poprzednią jest tylko funkcja readThingSpeak (String channelID)
Poniżej znajduje się kod, który wykonuje opisane czynności.

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

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

// Zmienne do użycia z zegarami
long readTimingSeconds = 10; // ==> Zdefiniuj czas próbkowania w sekundach, aby otrzymać dane
long startReadTiming = 0;
long elapsedReadTime = 0;

// Przekaźniki
# zdefiniować ACTUATOR1 10 // CZERWONA DIODA ==> Pompa
# zdefiniować ACTUATOR2 12 // ZIELONA DIODA ==> Lampa
pompa logiczna = 0;
lampka logiczna = 0;

int spare = 0;
błąd boolowski;

void setup ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, WYJŚCIE);
  pinMode (ACTUATOR2, WYJŚCIE);
  pinMode (HARDWARE_RESET, OUTPUT);

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Zresetuj do Modulo WiFi
  startReadTiming = millis (); // uruchomienie „zegara programu”
}

void loop ()
{
  start: // etykieta
  błąd = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int polecenie = readThingSpeak (canalID1);
    if (polecenie! = 9) pump = polecenie;
    opóźnienie (5000);
    polecenie = readThingSpeak (canalID2);
    if (polecenie! = 9) lamp = polecenie;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (błąd == 1) // Wyślij ponownie, jeśli transmisja nie zostanie zakończona
  {
    Serial.println („<<<< BŁĄD >>>>”);
    opóźnienie (2000);
    muszę zacząć; // przejdź do etykiety „start”
  }
}

/ ********* Podejmuj działania na podstawie poleceń ThingSpeak ************* /
void takeActions (void)
{
  Serial.print („Pump:”);
  Serial.println (pompa);
  Numer seryjny („Lampa:”);
  Serial.println (lampa);
  if (pompa == 1) digitalWrite (ACTUATOR1, LOW);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lampa == 1) digitalWrite (ACTUATOR2, LOW);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Przeczytaj polecenie siłowników z ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int polecenie;
  // preparacao da string GET
  Ciąg getStr = "GET / channels /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    polecenie = komunikatDown [7] -48;
    Serial.print („Otrzymano polecenie:”);
    Serial.println (polecenie);
  }
  else polecenie = 9;
  polecenie powrotu;
}

/ ********* Zresetuj ESP ************* /
void EspHardwareReset (void)
{
  Serial.println („Reseting .......”);
  digitalWrite (HARDWARE_RESET, LOW);
  opóźnienie (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  opóźnienie (8000); // Tempo Konieczna para começar a ler
  Serial.println („RESET”);
}

/ ********* Rozpocznij komunikację z ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o bufor antes de começar a gravar
  
  Ciąg cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = „184.106.153.149”; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find („Błąd”))
  {
    Serial.println („Błąd AT + CIPSTART”);
    powrót
  }
}

/ ********* wyślij GET cmd do ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Ciąg cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) „>”))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    opóźnienie (500); // tempo przetwarzania lub GET, najbardziej opóźnione jest zajęte bez komendy próximo

    String messageBody = "";
    while (EspSerial.available ())
    {
      Ciąg znaków = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// rzeczywista treść zaczyna się po pustej linii (która ma długość 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody otrzymano:”);
    Serial.println (messageBody);
    return messageBody;
  }
  jeszcze
  {
    EspSerial.println („AT + CIPCLOSE”); // alert użytkownika
    Serial.println („BŁĄD CIPSEND ESP8266: RESENDING”); // Wyślij ponownie ...
    zapasowy = zapasowy + 1;
    błąd = 1;
    zwróć „błąd”;
  }
}

Możesz pobrać go na



Na tym etapie mamy skonfigurowany kanał siłownika zmieniający wartość pola 1 dla każdego urządzenia. Musimy sprawdzić, czy urządzenia poprawnie wykonują polecenia. Pod koniec projektu będzie do tego używana aplikacja na Androida, ale można to również zrobić za pomocą przeglądarki.

Włącz pompę (czerwona dioda LED włączona)

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

Pump off (czerwona dioda wyłączona)

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

Włącz lampę (świeci zielona dioda LED)

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

Wyłącz lampę (zielona dioda zgaśnie)

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

W poprzedniej części był prosty program, który „odczytał” dane z kanału i wyświetlił je na ekranie. Teraz musimy sprawić, aby program „zapisał” polecenia w siłowniku kanałowym, aby polecenia te mogły być odczytane przez kontroler i lampa z pompą działała odpowiednio.

Aby użytkownik mógł wysyłać polecenia, aplikacja będzie miała dwa przyciski dla każdego urządzenia. Jeśli jest włączony, niebieski; jeśli jest wyłączony, czerwony.

Klikając przyciski w aplikacji, możesz zobaczyć wynik w monitorze szeregowym.

Kod można pobrać pod adresem



Na tym etapie jest w pełni ukończona aplikacja na Androida, w pełni zmontowana „żelazna” część, ale w kontrolerze nie ma kodu, który stale czytałby dane i wysyłał polecenia do chmury. Wystarczy połączyć wszystkie fragmenty wcześniej napisanego kodu. Oczywiście kod ma dodatkowe opcje weryfikacji (na przykład, jeśli ESP-01 zawiesza się). Aby to zrobić, okresowo, przed każdą komendą odczytu lub zapisu wysyłana jest komenda AT.A jeśli odpowiedź OK nie pochodzi z modułu, wówczas moduł jest programowo uruchamiany ponownie.

Pełny kod projektu można pobrać ze strony

Pod adresem można uzyskać aktualizacje plików programu.

Możesz również przeczytać komentarze do linku do źródła, jeśli coś nie jest jasne.