Kursy • Poradniki • Inspirujące DIY • Forum
Poprzednio przetestowaliśmy możliwości zbierania danych oraz analizowania odczytów w chmurze. W tej części zobaczymy jak zdalnie sterować modułem Intel Edison.
W ramach przykładu postaramy się rozbudować projekt zamka cyfrowego, który tworzyliśmy na początku kursu. Tym razem możliwa będzie jego zdalna kontrola przez Internet.
W nazewnictwie przyjętym przez Intela w Cloud Analytics do sterowania modułem służą aktuatory, czyli urządzenia wykonawcze. Są one definiowane z wykorzystaniem komponentów, podobnie jak w przypadku czujników.
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Elementy konieczne do wykonania ćwiczeń zebrane zostały w gotowe zestawy, które można nabyć w Botlandzie. W kuferku znajdziecie ponad 180 elementów w tym moduł Intel Edison!
Zamów w Botland.com.pl »Domyślnie w systemie znajdziemy komponent będący aktuatorem o nazwie Powerswitch. Z bocznego menu wybieramy opcję Account, a następnie zakładkę Catalog (poznaliśmy ją w poprzedniej części kursu).
Na liście dostępnych komponentów odnajdujemy Powerswitch oraz jego aktualną wersję, czyli powerswitch.v1.0. Po kliknięciu na nim zobaczymy opcje konfiguracyjne:
Ustawienia komponentu PowerSwitch.
Najważniejsza różnica w porównaniu z poprzednio poznanymi komponentami, to pole Type - tym razem wskazuje na element wykonawczy, czyli właśnie Actuator. Komponent działa w trybie włącz/wyłącz, więc jako typ danych został wybrany Boolean.
Warto jeszcze spojrzeć na pole Values - są w nim wartości jakie można przypisać do naszego aktuatora, czyli 0 lub 1.
Czas zarejestrować aktuator w systemie. Musimy nadać mu nazwę, podobnie jak wcześniej czujnikowi oraz wskazać typ, czyli powerswitch.v1.0. Niech jako przykład nazwą będzie "dioda". Z poziomu konsoli modułu Edison wydajemy polecenia poznane poprzednio:
|
1 2 |
iotkit-admin register dioda powerswitch.v1.0 systemctl restart iotkit-agent |
Warto upewnić się, czy wybrany został protokół komunikacji MQTT. Ustawiamy go poleceniem:
|
1 |
iotkit-admin protocol mqtt |
Teraz możemy wrócić do Analytics Cloud i sprawdzić, czy nowy komponent został dodany do naszego urządzenia.
Oczywiście komponent, to nie wszystko. Potrzebujemy jeszcze podłączyć układ oraz napisać program. Zacznijmy od podłączenia układu identycznie jak w części omawiającej Arduino IDE:
Podłączenie diody święcącej do Intel Edisona.
Program zaczyna się podobnie jak poprzednio od utworzenia obiektu klasy IoTkit:
|
1 2 3 4 5 6 |
#include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> // create an object of the IoTkit class IoTkit iotkit; |
Teraz napiszemy program kod inicjalizujący połączenie z chmurą oraz konfigurujący wyjście sterujące diodą świecącą:
|
1 2 3 4 5 6 7 8 |
const int LED_PIN = 2; void setup() { pinMode(LED_PIN, OUTPUT); digitalWrite(LED_PIN, LOW); iotkit.begin(); } |
Jak na razie nie pojawiło się właściwie nic nowego. Pierwsza nowość, to zmiana w pętli główna programu. W niej będziemy sprawdzać, czy nie przyszły polecenia z chmury:
|
1 2 3 4 |
void loop() { iotkit.receive(callback); delay(500); } |
Jako parametr metody iotkit.receive() podajemy adres funkcji, która zostanie wywołana po otrzymaniu danych z serwera. Musimy napisać tę funkcję i to właśnie w niej będzie zawarta obsługa odebranych poleceń:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL) && (strcmp(component->valuestring, "dioda")) == 0) { if (strcmp(value->valuestring, "0") == 0) digitalWrite(LED_PIN, LOW); else digitalWrite(LED_PIN, HIGH); } } |
Dane z serwera otrzymujemy jako napis w formacie JSON. Aby zrozumieć powyższy kod najlepiej najpierw zobaczyć otrzymane dane (np. wysyłając je przez port szeregowy):
|
1 2 3 4 5 6 7 8 9 10 |
{ "component": "dioda", "command": "LED.v1.0", "argv": [ { "name": "LED", "value": "1" } ] } |
Jak widzimy do klucza component jest przypisana nazwa naszego komponentu, czyli dioda. Funkcją strcmp sprawdzamy, skąd pochodzi komunikat:
|
1 |
if ((strcmp(component->valuestring, "dioda")) == 0) |
Przekazywane parametry znajdziemy w tablicy argv, do której odwołujemy się pisząc:
|
1 |
aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); |
Ponieważ spodziewamy się tylko jednego parametru, po prostu wybieramy pierwszy za pomocą argv->child. Następnie odszukujemy właściwość value, która przechowuje wybraną wartość, czyli jedynkę, aby zapalić diodę lub zero, aby ją zgasić:
|
1 |
aJsonObject* value = aJson.getObjectItem(argv->child, "value"); |
Wiemy już jak działa program, możemy spokojnie przeanalizować cały kod:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> // create an object of the IoTkit class IoTkit iotkit; const int LED_PIN = 2; void setup() { pinMode(LED_PIN, OUTPUT); digitalWrite(LED_PIN, LOW); iotkit.begin(); } void loop() { iotkit.receive(callback); delay(500); } void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL) && (strcmp(component->valuestring, "dioda")) == 0) { if (strcmp(value->valuestring, "0") == 0) digitalWrite(LED_PIN, LOW); else digitalWrite(LED_PIN, HIGH); } } |
Program powinien skompilować się bez problemu, możemy więc zaprogramować układ i przejść do zdalnego sterowania z poziomu chmury.
Układ mamy gotowy, czas wrócić do Cloud Analytics i przystąpić do zdalnego sterowania, czyli do celu naszej dzisiejszej pracy. Z menu wybieramy opcję Control. Zobaczymy ekran wyboru nieco podobny do znanego nam z przygotowywania wykresów.
Najpierw musimy wybrać nasze urządzenie,
następnie zaznaczamy komponent, który chcemy wybrać.
Po wybraniu komponentu musimy wybrać parametr z listy Add action. Mamy tylko jeden parametr o nazwie LED. W środkowej kolumnie pojawią się przyciski sterujące naszym układem - 0 do gaszenia diody oraz 1 do jej włączania. Ostatnią opcją którą musimy zaznaczyć jest protokół, czyli mqtt. Opcje powinny wyglądać następująco:
Odpowiednie ustawienia komponentu do zdalnego sterowania.
Teraz możemy nacisnąć przycisk Add action i dodać instrukcję sterującą do listy:
Dodawanie instrukcji sterującej do listy.
Polecenie nie jest automatycznie wysyłane, ale trafia do planu działania, gdzie jak widzimy ma status Ready to send. Możemy przygotować bardziej skomplikowane plany i wysyłać wiele komend, jednocześnie.
W naszym przypadku nie potrzebujemy takich funkcji,
więc po prostu klikamy na Send lub Send all valid actions.
Po chwili dioda powinna się zapalić. Mamy więc pierwszy zdalnie sterowany komponent!
Niejako na zakończenie opisu Analytics Cloud omówimy jeszcze nieco bardziej rozbudowany przykład. W części kursu poświęconej Arduino IDE skonstruowaliśmy elektroniczny zamek (albo jego namiastkę). Teraz przygotujemy zamek, który będzie współpracował z Internetem.
Pewnie zastanawiacie się do czego można wykorzystać internet w zamku do drzwi? Oczywiście możliwości jest bardzo wiele, my skonstruujemy dość prosty układ, który pozwoli na:
Oczywiście jest to przykładowy zestaw funkcji.
Każdy może zaimplementować później zupełnie inną funkcjonalność.
Zaczynamy od powrotu do wcześniej omówionego układu. Podłączamy wyświetlacz, klawiaturę oraz diodę, która będzie symulowała elektryczny rygiel:
Ponownie podłączamy model zamka cyfrowego.
Teraz możemy wgrać program, który napisaliśmy wcześniej. Dla przypomnienia zamieszczam go poniżej. Jeśli podłączenia zostały wykonane poprawnie, to wszystko powinno od razu działać.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <Keypad.h> const int PASS_MAXLEN = 8; // maksymalna dlugosc hasla const char PASSWORD[] = { "1234#" }; // tajne haslo char pass[PASS_MAXLEN + 1]; // wprowadzone haslo const int LOCK_PIN = 3; const byte ROWS = 4; //four rows const byte COLS = 3; //three columns char keys[ROWS][COLS] = { {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'} }; byte rowPins[ROWS] = {4, 5, 6, 7}; //connect to the row pinouts of the keypad byte colPins[COLS] = {8, 9, 10}; //connect to the column pinouts of the keypad Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); LiquidCrystal_I2C lcd(0x27, 16, 2); static void clear_pass(void) { memset(pass, 0, sizeof(pass)); // zerowanie hasla } void setup(){ lcd.init(); lcd.backlight(); pinMode(LOCK_PIN, OUTPUT); digitalWrite(LOCK_PIN, LOW); clear_pass(); } static void print_pass(void) { int pass_len = strlen(pass); lcd.clear(); for (int i = 0; i < pass_len; i++) lcd.print('*'); } static void open_door(void) { lcd.clear(); lcd.print("!!! OTWARTE !!!"); digitalWrite(LOCK_PIN, HIGH); delay(5000); digitalWrite(LOCK_PIN, LOW); } void loop(){ char key = keypad.getKey(); if (key != NO_KEY) { int pass_len = strlen(pass); // obliczamy dlugosc hasla if (key == '*') { clear_pass(); } else if (pass_len < PASS_MAXLEN) { // jesli jest miejsce w buforze pass[pass_len] = key; if (strcmp(pass, PASSWORD) == 0) { // poprawne haslo open_door(); clear_pass(); } } print_pass(); } delay(50); } |
Do programu dodajmy kod, który poprzednio wykorzystaliśmy do sterowania diodą. Tym razem, zamiast zapalać diodę, będziemy blokować dostęp do zamka. Na początek wykorzystamy sprawdzony wcześniej komponent. Nazywa się on dioda, ale uznajmy, że do testu wystarczy.
Zmiany w programie są niewielkie. Po pierwsze dodajemy flagę (czyli zmienną), która będzie przechowywała informację o zablokowaniu dostępu:
|
1 2 3 4 5 6 |
#include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> IoTkit iotkit; bool locked = false; |
W funkcji setup dodajemy inicjalizację IoTkit-a:
|
1 2 |
void setup(){ iotkit.begin(); |
Natomiast w pętli głównej obsługujemy odbiór danych z chmury oraz wykonujemy odczyt klawiatury tylko, jeśli zamek nie został zablokowany:
|
1 2 3 |
void loop() { iotkit.receive(callback); if (!locked) { |
Tak jak w przykładzie ze sterowaniem diodą,
cała obsługa komunikatów z chmury znajduje się w funkcji callback.
Kod podobny do poprzedniego, ale tym razem zamiast zapalać lub gasić diodę ustawiamy wartość flagi locked oraz wypisujemy lub kasujemy komunikat o zablokowaniu dostępu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL) && (strcmp(component->valuestring, "dioda")) == 0) { if (strcmp(value->valuestring, "0") == 0) { if (locked) { locked = false; lcd.clear(); } } else { if (!locked) { locked = true; lcd.clear(); lcd.print("Zablokowane!"); } } } } |
To są już wszystkie zamiany niezbędne do dodania funkcji zdalnego blokowania dostępu.
Od teraz możemy nasz pokój zamknąć będąc nawet na dalekich wakacjach.
Kompletny kod programu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <Keypad.h> #include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> IoTkit iotkit; bool locked = false; const int PASS_MAXLEN = 8; // maksymalna dlugosc hasla const char PASSWORD[] = { "1234#" }; // tajne haslo char pass[PASS_MAXLEN + 1]; // wprowadzone haslo const int LOCK_PIN = 3; const byte ROWS = 4; //four rows const byte COLS = 3; //three columns char keys[ROWS][COLS] = { {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'} }; byte rowPins[ROWS] = {4, 5, 6, 7}; //connect to the row pinouts of the keypad byte colPins[COLS] = {8, 9, 10}; //connect to the column pinouts of the keypad Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); LiquidCrystal_I2C lcd(0x27, 16, 2); static void clear_pass(void) { memset(pass, 0, sizeof(pass)); // zerowanie hasla } void setup(){ iotkit.begin(); lcd.init(); lcd.backlight(); pinMode(LOCK_PIN, OUTPUT); digitalWrite(LOCK_PIN, LOW); clear_pass(); } static void print_pass(void) { int pass_len = strlen(pass); lcd.clear(); for (int i = 0; i < pass_len; i++) lcd.print('*'); } static void open_door(void) { lcd.clear(); lcd.print("!!! OTWARTE !!!"); digitalWrite(LOCK_PIN, HIGH); delay(5000); digitalWrite(LOCK_PIN, LOW); } void loop() { iotkit.receive(callback); if (!locked) { char key = keypad.getKey(); if (key != NO_KEY) { int pass_len = strlen(pass); // obliczamy dlugosc hasla if (key == '*') { clear_pass(); } else if (pass_len < PASS_MAXLEN) { // jesli jest miejsce w buforze pass[pass_len] = key; if (strcmp(pass, PASSWORD) == 0) { // poprawne haslo open_door(); clear_pass(); } } print_pass(); } } delay(50); } void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL) && (strcmp(component->valuestring, "dioda")) == 0) { if (strcmp(value->valuestring, "0") == 0) { if (locked) { locked = false; lcd.clear(); } } else { if (!locked) { locked = true; lcd.clear(); lcd.print("Zablokowane!"); } } } } |
Utwórz własny komponent do blokowania dostępu. Powinien mieć takie same właściwości jak dioda, ale nazwę lepiej dopasowaną do tego projektu, np.: zamek lub blokada.
Dotychczasowe programy miały kod dostępu ustawiony na stałe. Takie rozwiązanie nie jest ani wygodne, ani bezpieczne - powinniśmy przecież zmieniać kod od czasu do czasu. Teraz użyjemy Cloud Analytics do zdalnej zmiany kodu dostępu.
Na początek musimy utworzyć własny typ komponentu. Logujemy się do chmury i z menu wybieramy opcję Account oraz zakładkę Catalog. Na dole zobaczymy przycisk Add a New Catalog Item. Klikamy na nim i wypełniamy odpowiednie dane:
Następnie klikamy na Add parameter i wprowadzamy:
Wybór zatwierdzamy przyciskiem Save:
Definiowanie nowego komponentu w chmurze.
Po zapisaniu, nasz komponent automatycznie zmieni nazwę na pincode.v1.0. Teraz logujemy się do konsoli systemu Linux na module Edison i rejestrujemy nowy komponent:
|
1 2 |
iotkit-admin register pincode pincode.v1.0 systemctl restart iotkit-agent |
Zmiany w programie są kosmetyczne. Najpierw musimy zmienić miejsce przechowywania hasła. Dotychczas była to stała PASSWORD, ponieważ będziemy chcieli zmieniać hasło, musimy zastąpić ją zwykłą tablicą.
Dla zachowania standardu, zmienimy też nazwę - zwyczajowo stałe pisze się dużymi literami, a zmienne małymi.
Nowy kod będzie wyglądał następująco:
|
1 |
char password[PASS_MAXLEN + 1] = { "1234#" }; // tajne haslo |
Samo sprawdzanie hasła pozostaje bez zmian (poza oczywiście zmianą dużych liter na małe). Musimy tylko dodać trochę kodu do funkcji callback, tak aby obsługiwać komunikaty wysłane z komponentu pincode:
|
1 2 3 |
if (strcmp(component->valuestring, "pincode") == 0) { sprintf(password, "%s#", value->valuestring); } |
Wykorzystaliśmy standardową funkcję biblioteki C - sprintf. Pozwala ona na sformatowanie komunikatu i wstawienie go do zmiennej. W naszym przypadku chcemy po prostu dodać znak # na końcu, sam kod PIN i tak dostajemy jako napis.
Pełny kod wygląda więc następująco:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <Keypad.h> #include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> IoTkit iotkit; bool locked = false; const int PASS_MAXLEN = 8; // maksymalna dlugosc hasla char password[PASS_MAXLEN + 1] = { "1234#" }; // tajne haslo char pass[PASS_MAXLEN + 1]; // wprowadzone haslo const int LOCK_PIN = 3; const byte ROWS = 4; //four rows const byte COLS = 3; //three columns char keys[ROWS][COLS] = { {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'} }; byte rowPins[ROWS] = {4, 5, 6, 7}; //connect to the row pinouts of the keypad byte colPins[COLS] = {8, 9, 10}; //connect to the column pinouts of the keypad Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); LiquidCrystal_I2C lcd(0x27, 16, 2); static void clear_pass(void) { memset(pass, 0, sizeof(pass)); // zerowanie hasla } void setup(){ iotkit.begin(); lcd.init(); lcd.backlight(); pinMode(LOCK_PIN, OUTPUT); digitalWrite(LOCK_PIN, LOW); clear_pass(); } static void print_pass(void) { int pass_len = strlen(pass); lcd.clear(); for (int i = 0; i < pass_len; i++) lcd.print('*'); } static void open_door(void) { lcd.clear(); lcd.print("!!! OTWARTE !!!"); digitalWrite(LOCK_PIN, HIGH); delay(5000); digitalWrite(LOCK_PIN, LOW); } void loop() { iotkit.receive(callback); if (!locked) { char key = keypad.getKey(); if (key != NO_KEY) { int pass_len = strlen(pass); // obliczamy dlugosc hasla if (key == '*') { clear_pass(); } else if (pass_len < PASS_MAXLEN) { // jesli jest miejsce w buforze pass[pass_len] = key; if (strcmp(pass, password) == 0) { // poprawne haslo open_door(); clear_pass(); } } print_pass(); } } delay(50); } void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL)) { if (strcmp(component->valuestring, "dioda") == 0) { if (strcmp(value->valuestring, "0") == 0) { if (locked) { locked = false; lcd.clear(); } } else { if (!locked) { locked = true; lcd.clear(); lcd.print("Zablokowane!"); } } } else if (strcmp(component->valuestring, "pincode") == 0) { sprintf(password, "%s#", value->valuestring); } } } |
W poprzednich częściach kursu poznaliśmy sposób na podłączenie czujników do naszej płytki. Teraz możemy wykorzystać jednocześnie akuatory oraz sensory. Podłączamy poznane wcześniej elementy według schematu:
Podłączenie wszystkich peryferiów do zestawu.
Mamy już skonfigurowany obiekt klasy IoTkit, więc wysyłanie danych do chmury jest właściwie trywialne. Jedyny problem to ograniczenie częstotliwości transmisji - na potrzeby obsługi klawiatury opóźnienie w pętli głównej zostało zmniejszone.
Jednak wysyłanie danych, co 50 ms, to stanowczo zbyt często. Możemy więc wprowadzić dodatkowy licznik (zmienną), który będzie zwiększany przy każdym przebiegu pętli, a dane będą wysyłane dopiero po osiągnięciu przez czujnik odpowiednio dużej wartości.
Pełny program wygląda następująco:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 |
#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <Keypad.h> #include <IoTkit.h> // include IoTkit.h to use the Intel IoT Kit #include <Ethernet.h> // must be included to use IoTkit #include <aJSON.h> #include <Adafruit_HDC1000.h> const int PASS_MAXLEN = 8; // maksymalna dlugosc hasla const int LOCK_PIN = 3; const int DOOR_PIN = 12; const int MOVE_PIN = 13; Adafruit_HDC1000 hdc; IoTkit iotkit; bool locked = false; char password[PASS_MAXLEN + 1] = { "1234#" }; // tajne haslo char pass[PASS_MAXLEN + 1]; // wprowadzone haslo int send_counter = 0; const byte ROWS = 4; //four rows const byte COLS = 3; //three columns char keys[ROWS][COLS] = { {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'} }; byte rowPins[ROWS] = {4, 5, 6, 7}; //connect to the row pinouts of the keypad byte colPins[COLS] = {8, 9, 10}; //connect to the column pinouts of the keypad Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); LiquidCrystal_I2C lcd(0x27, 16, 2); static void clear_pass(void) { memset(pass, 0, sizeof(pass)); // zerowanie hasla } void setup(){ Serial.begin(9600); iotkit.begin(); lcd.init(); lcd.backlight(); pinMode(LOCK_PIN, OUTPUT); digitalWrite(LOCK_PIN, LOW); clear_pass(); if (!hdc.begin()) { lcd.print("Brak HDC1008"); while (1); } } static void print_pass(void) { int pass_len = strlen(pass); lcd.clear(); for (int i = 0; i < pass_len; i++) lcd.print('*'); } static void open_door(void) { lcd.clear(); lcd.print("!!! OTWARTE !!!"); digitalWrite(LOCK_PIN, HIGH); delay(5000); digitalWrite(LOCK_PIN, LOW); } void loop() { iotkit.receive(callback); if (!locked) { char key = keypad.getKey(); if (key != NO_KEY) { int pass_len = strlen(pass); // obliczamy dlugosc hasla if (key == '*') { clear_pass(); } else if (pass_len < PASS_MAXLEN) { // jesli jest miejsce w buforze pass[pass_len] = key; if (strcmp(pass, password) == 0) { // poprawne haslo open_door(); clear_pass(); } } print_pass(); } } if (++send_counter >= 20) { //Jeśli licznik doliczył do 20, to wysyłamy informację iotkit.send("temp", hdc.readTemperature()); iotkit.send("humidity", hdc.readHumidity()); iotkit.send("light1", (int)analogRead(0)); iotkit.send("light2", (int)analogRead(1)); iotkit.send("opendoor", (int)!digitalRead(DOOR_PIN)); iotkit.send("pirmove", (int)digitalRead(MOVE_PIN)); send_counter = 0; } delay(100); } void callback(char* json) { aJsonObject* parsed = aJson.parse(json); if (parsed == NULL) return; aJsonObject* component = aJson.getObjectItem(parsed, "component"); aJsonObject* argv = aJson.getObjectItem(parsed, "argv"); aJsonObject* value = aJson.getObjectItem(argv->child, "value"); if ((component != NULL) && (value != NULL)) { if (strcmp(component->valuestring, "dioda") == 0) { if (strcmp(value->valuestring, "0") == 0) { if (locked) { locked = false; lcd.clear(); } } else { if (!locked) { locked = true; lcd.clear(); lcd.print("Zablokowane!"); } } } else if (strcmp(component->valuestring, "pincode") == 0) { sprintf(password, "%s#", value->valuestring); } } } |
W tej części kursu poznaliśmy możliwości zdalnego sterowania pracą modułu Intel Edison za pomocą akuatorów. Zobaczyliśmy jak utworzyć własny komponent wykonawczy oraz jak pobierać dane oraz sterować układami zewnętrznymi.
Dzięki temu możliwe było utworzenie w pełni sprawnego modelu centralki monitorującej stan Twojego pokoju, która miała nawet możliwość zdalnego sterowania zamkiem! W kolejnej części omówimy kwestię modułu Bluetooth dostępnego w Intel Edisonie.
Nie chcesz przeoczyć kolejnych części kursu? Skorzystaj z poniższego formularza i zapisz się na powiadomienia o nowych artykułach!
Autor kursu: Piotr (Elvis) Bugalski
Redakcja: Damian (Treker) Szymański
Edison, internet, IoT, kurs, kursEdison, sterowanie, zamek
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY z Arduino i RPi.
Trwa ładowanie komentarzy...