[096] Budujemy termostat - cz. 4

Ze względu na ewoluujące środowisko chmury Arduino, czeka nas ponownie skrócony przewodnik wpleciony między rozważania nad naszym projektem termostatu. Pominę rzeczy oczywiste jak choćby potrzebę stworzenia konta – najlepiej przez mail Google, ponieważ w ten sposób łatwiej połączymy chmurę z telefonem. I jak to było już wiele razy – znów nie zrobimy wszystkiego naraz, a etapami. Pierwszym będzie nawiązanie współpracy chmury, Arduino i smartfona. A jak wiadomo, najlepiej do tego celu użyć nieśmiertelnego programu Blink, teraz z dopiskiem Cloud.

W tym celu musimy wejść do zakładki z przykładami. Przybyło ich sporo, ale nas interesuje pierwszy. Trzeba go zaimportować, klikając w USE TEMPLATE.

Tajemniczy chmurowy byt będzie się teraz starał przygarnąć naszą płytkę do siebie, co będzie wymagało między innymi instalacji Agenta – aplikacji siedzącej w naszym komputerze. Jeśli oczywiście dotąd jeszcze z niej nie korzystaliśmy. Pozostaje jej zaufać i zgodzić się na współpracę. Po zainstalowaniu, agent ów rozpozna naszą płytkę Arduino R4 i wyśle informację o niej do chmury. Oczywiście płytkę tę należy mieć podłączoną i sprawdzoną, choćby naszym projektem offline’owym.

Zaraz potem nastąpi aktualizacja oprogramowania systemowego płytki, o której nie będę nic pisał, bo prawdę powiedziawszy, na tym etapie o szczegółach nie mam już pojęcia. Najważniejsze, by proces zakończył się sukcesem. Na końcu prawdopodobnie trzeba wykonać słynny manewr informatyków: wyciągnąć wtyczkę i włożyć ją z powrotem.

Czas na chrzest, czyli nadanie płytce jakiejś przyjaznej nazwy, która będzie się potem pojawiać w projektach Trzeba też podać namiary na lokalną sieć WiFi. Dodam, że sieć musi pracować na częstotliwości 2,4 GHz. Po nieco przydługiej chwili w końcu Arduino wstąpi do chmury.

Program Cloud Blink jest niezwykle mało ciekawy, ale działa. Klikanie na ekranie mruga diodką, nie tylko tą ekranową, ale też prawdziwą. Ostatnią próbą będzie odpalenie apki na telefonie. Oczywiście tę należy sobie wcześniej zainstalować z apkowego sklepu. Jeśli system będzie zalogowany na to samo konto, nie trzeba będzie niczego konfigurować. W panelu znajdziemy bliźniaczy projekt z przełącznikiem i diodą – klikamy paluchem i dioda włącza się albo wyłącza – zarówno na płytce Arduino jak i na ekranie komputera. Połączenie więc jest, wszystko pracuje jak należy. Można się zabrać za ożenek naszego termostatu z chmurą i telefonem.

Przypomnieć jednak muszę pokrótce zasady chmurowego portalu. A więc nasz panel – odpowiednik tego, który znajdziemy w smartfonie, siedzi w zakładce Dashboards. W Sketches znajdziemy dokładnie to, co robiliśmy dotąd offline, za pomocą aplikacji Arduino IDE. W zakładce Devices zaś siedzi sobie nasza płytka Arduino, a w Things – spis aktywnych elementów i zmiennych powiązanych z nimi, które znajdziemy na ekranie smartfona, które to będziemy potem łączyć z elementami szkicu. Bierzmy się więc za nasz termostat.

Aby czuć się swobodnie w obcym – dla początkujących środowisku, nie zbuduję projektu od początku, a wykorzystam ten, który właśnie przed chwilą skompilowałem. Skoro pracuje zarówno z panelu witryny jak i smartfona, łatwiej będzie utrzymać nad nim kontrolę. Na początek zmieńmy mu nazwę Z Cloud Blink na Thermostat. Tym razem będę używał nazw angielskich, ponieważ witryna pracuje w tym języku i byłoby nienaturalne używać polskich znaczeń poza komentarzami.

#include "thingProperties.h"                                           // Biblioteka współpracy z chmurą.
#include <Wire.h>                                                      // Biblioteka obsługująca magistralę I2C
#include <hd44780.h>                                                   // Biblioteka obsługująca wyświetlacze 44780
#include <hd44780ioClass/hd44780_I2Cexp.h>                             // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH);  // Konfiguracja połączeń wyświetlacza LCD

const byte thermometer = A2;  // Adres czujnika temperatury.
float realTemperature;        // Temperatura w jednostkach rzeczywistych - stopniach Celsiusza.
const byte plus = 3;          // Adres przycisku zwiększającego wartość oczekiwanej temperatury.
const byte minus = 2;         // Adres przycisku zmniejszającego wartość oczekiwanej temperatury.
float thermTemperature = 20;  // Temperatura w jednostkach rzeczywistych - stopniach Celsiusza.
const byte relay = 4;         // Adres przekaźnika.

void setup() {
  initProperties();                                   // Inicjuj pracę z chmurą.
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);  // Podłącz Arduino do chmury.
  lcd.begin(16, 2);                                   // Inicjuj wyświetlacz: 16 kolumn, 2 wiersze
  pinMode(plus, INPUT_PULLUP);                        // Deklaruj pin plus jako wejście.
  pinMode(minus, INPUT_PULLUP);                       // Deklaruj pin minus jako wejście.
  pinMode(relay, OUTPUT);                             // Deklaruj pin przekaźnika jako wyjście.
  showThermostat();                                   // Wyświetl wartość termostatu.
}

void loop() {
  ArduinoCloud.update();  // Sprawdź stan elementów zdalnych

  realTemperature = (analogRead(thermometer) * 0.125 - 22.0);  // Zmierz temperaturę i przenieś ją do zmiennej realTemperature.
  lcd.setCursor(0, 0);                                         // Ustaw kursor na początku wyświetlacza.
  lcd.print("Temp: ");                                         // Wyświetl napis "Temp: "
  lcd.print(realTemperature, 1);                               // Wyświetl temperaturę z dokładnością do jednego miejsca po przecinku.
  showDegree();                                                // Wyświetl znak stopnia.
// thermometerCloud = round(realTemperature);                  // Aktualizuj informację o temperaturze dla smartfona, zaokrąglając ją do wartości całkowitej.

  if (digitalRead(plus) == HIGH && thermTemperature < 30) {  // Jeśli wciśnięto plus i temperatura nastawiona jest niższa od 30 stopni...
    thermTemperature += 0.5;                                 // Zwiększ temperaturę termostatu o pół stopnia.
    showThermostat();                                        // Wyświetl temperaturę termostatu.
    while (digitalRead(plus) == HIGH) {}                     // Czekaj na zwolnienie przycisku.
  }
  if (digitalRead(minus) == HIGH && thermTemperature > 10) {  // Jeśli wciśnięto minus i temperatura nastawiona jest wyższa od 10 stopni...
    thermTemperature -= 0.5;                                  // Zwiększ temperaturę termostatu o pół stopnia.
    showThermostat();                                         // Wyświetl temperaturę termostatu.
    while (digitalRead(minus) == HIGH) {}                     // Czekaj na zwolnienie przycisku.
  }
  if (realTemperature < (thermTemperature - 0.5)) {  // Jeśli temperatura zmierzona jest mniejsza o pół stopnia od nastawionej, to...
    digitalWrite(relay, HIGH);                       // Włącz przekaźnik.
    lcd.setCursor(15, 0);                            // Ustaw kursor na końcu wyświetlacza.
    lcd.print("*");                                  // Wyświetl gwiazdkę.
//  statusCloud = HIGH;                              // Aktualizuj informację o statusie przekaźnika dla smartfona.
  }
  if (realTemperature > (thermTemperature + 0.5)) {  // Jeśli temperatura zmierzona jest większa o pół stopnia od nastawionej, to...
    digitalWrite(relay, LOW);                        // Wyłącz przekaźnik.
    lcd.setCursor(15, 0);                            // Ustaw kursor na końcu wyświetlacza.
    lcd.print(" ");                                  // Wygaś gwiazdkę.
//  statusCloud = LOW;                               // Aktualizuj informację o statusie przekaźnika dla smartfona.
  }
  delay(100);  // Pętla opóźniająca.
}
void showThermostat() {                // Obsługa wyświetlenia informacji o termostacie.
  lcd.setCursor(0, 1);                 // Ustaw kursor na początku wyświetlacza.
  lcd.print("Ther: ");                 // Wyświetl napis "Ther: "
  lcd.print(thermTemperature, 1);      // Wyświetl temperaturę termostatu z dokładnością do jednego miejsca po przecinku.
  showDegree();                        // Wyświetl znak stopnia.
// thermostatCloud = thermTemperature; // Aktualizuj informację o temperaturze termostatu dla smartfona.
}
void showDegree() {  // Obsługa wyświetlenia stopni Celsiusza.
  lcd.print(" ");    // Wyświetl spację.
  lcd.write(223);    // Wyświetl znak stopnia.
  lcd.print("C  ");  // Wyświetl literę C i dwie spacje.
}

Ożenienie obu projektów nie będzie trudne, ponieważ w BlinkCloud prawie niczego nie było. Zaczniemy od pozostawienia istotnej tutaj biblioteki współpracy z chmurą: thingProperties.h Kolejne ważne elementy znajdziemy w pętli setup: inicjację tej biblioteki oraz podłączenie do chmury naszej płytki.

initProperties();                                   // Inicjuj pracę z chmurą.
ArduinoCloud.begin(ArduinoIoTPreferredConnection);  // Podłącz Arduino do chmury.

Pętla główna zacznie się od sprawdzenia stanu elementów znajdujących się poza płytką, czyli tego, co za chwilę zobaczymy na ekranie smartfona:

ArduinoCloud.update();  // Sprawdź stan elementów zdalnych

Później już nie znajdziemy niczego innego poza – na razie – „zakomentowanymi” elementami. Przy okazji, wprowadziłem skróty += oraz -= dodające lub odejmujące od zmiennej stałą, których nie było w wersji offline. Próba kompilacji zakończy się błędem, ponieważ projekt nie ma dostępu do biblioteki związanej z wyświetlaczem. Nie jest to jednak żaden problem, będziemy musieli ją podłączyć, jak to robiliśmy w wersji edytora lokalnego, a znajdziemy ją w zakładce z bibliotekami.

Przejdźmy teraz do zakładki Dashboards i dodajmy trzy elementy: Stepper, Gauge i Status.

Element pierwszy pozwala zwiększać bądź zmniejszać zmienną wraz z jej prezentacją. Wymaga podania minimum i maksimum oraz przyrostu. Wybierzemy te elementy dokładnie tak samo jak w wersji offline, a więc 10 stopni, 30 stopni i pół stopnia przyrostu. Tym elementem będziemy zmieniać temperaturę termostatu.

Drugi element to wskaźnik, który nie posiada już żadnych nastaw. Pozwala wyświetlać wartości zmiennej przysłanej z Arduino. W naszym przypadku będzie to temperatura zmierzona.

W końcu trzeci element to odpowiednik naszej gwiazdki. Będzie przyjmował dwa stany: przekaźnik wyłączony bądź włączony.

Teraz trzeba przejść do zakładki Things. Znajdziemy tu wszystkie trzy nowo osadzone elementy. W każdym przypadku należy ustalić dla nich nazwę zmiennej, którą potem wpleciemy do szkicu. Do odpowiedników z wersji offline dopisałem po prostu Cloud. Typ zmiennej jest tożsamy z tymi, które już pracują offline.

Teraz znowu trzeba powrócić do zakładki Dashboards i uzupełnić powiązania elementów z właśnie dopiero co ponazywanymi zmiennymi. Wróćmy do szkicu.

void onThermostatCloudChange() {       // Obsługa zmiany temperatury termostatu za pomocą panelu smartfona.
  thermTemperature = thermostatCloud;  // Aktualizuj temperaturę termostatu.
  showThermostat();                    // Wyświetl zaktualizowaną temperaturę termostatu na wyświetlaczu.
}
void onThermometerCloudChange() {  // Obsługa wyświeltenia temperatury na ekranie smartfona.
}
void onStatusCloudChange() {  // Obsługa wyświeltenia stanu przekaźnika na ekranie smartfona.
}

Na jego końcu w cudowny sposób coś nam dopisało trzy podprogramy z nazwami kojarzonymi z elementami, które przed chwilą edytowaliśmy. Zajmijmy się najpierw regulatorem termostatu. Gdy na ekranie smartfona wciśniemy któryś z przycisków, program wyląduje w miejscu onThermostatCloudChange() z wartością w zmiennej thermostatCloud. Załadujemy ją więc do naszej lokalnej zmiennej thermTemperature i wyświetlimy na wyświetlaczu. W ten sposób majstrowanie na ekranie smartfona da nam prawie natychmiastową aktualizację na wyświetlaczu przy Arduino.

Ale to nie wszystko. A co będzie, jeśli ktoś zmieni temperaturę za pomocą lokalnej klawiaturki? I to jest właśnie piękne: ta zmieni się jak w wersji offline, ale dodatkowo w linii dotąd zakomentowanej thermostatCloud = thermTemperature; nastąpi aktualizacja zmiennej dla wyświetlacza w smartfonie. Po otrzymaniu zmienionej wartości program, już poza naszą świadomością wyśle dane na telefon i tam ujrzymy temperaturę zaktualizowaną lokalnie.

Pozostałe elementy są prostsze, bo pracują tylko w jedną stronę: z Arduino do smartfona. I tak: grafika z temperaturą zmierzoną jest aktualizowana w linii: thermometerCloud = round(realTemperature); i przy okazji zaokrąglana, ponieważ tak jest ładniej. W końcu wskaźnik stanu przekaźnika jest aktualizowany zaraz po aktualizacji gwiazdki na wyświetlaczu, czyli tutaj: statusCloud = HIGH; (albo LOW, gdy przekaźnik będziemy wyłączać).

I to już wszystko. Należy tylko poukładać elementy interfejsu tak, by na ekranie smartfona wyglądały dobrze i były wygodne w obsłudze. Po kompilacji, która siłą rzeczy musi trwać teraz dłużej, otrzymamy program już nam znany, ale po włączeniu apki – obsługiwany nawet z drugiego końca świata. To dopiero początek. Brakuje tu watchdoga i kolejnych usprawnień, a trzy przekaźniki na płytce shield marnują się, nic nie robiąc. Ale to pozostawiam już szanownym czytelnikom.