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.
Gotowe zestawy do kursów Forbota
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!
Masz już zestaw? Zarejestruj go wykorzystując dołączony do niego kod. Szczegóły »
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.
Rejestrowanie aktuatora
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:
Shell
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:
Shell
1
iotkit-admin protocol mqtt
Teraz możemy wrócić do Analytics Cloud i sprawdzić, czy nowy komponent został dodany do naszego urządzenia.
Podłączenie układu i program
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:
C++
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ą:
C++
1
2
3
4
5
6
7
8
constintLED_PIN=2;
voidsetup(){
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:
C++
1
2
3
4
voidloop(){
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ń:
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):
JavaScript
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:
C
1
if((strcmp(component->valuestring,"dioda"))==0)
Przekazywane parametry znajdziemy w tablicy argv, do której odwołujemy się pisząc:
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ć:
Program powinien skompilować się bez problemu, możemy więc zaprogramować układ i przejść do zdalnego sterowania z poziomu chmury.
Zdalne sterowanie z Intel Cloud Analytics
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!
Internetowy zamek elektroniczny
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:
zdalne zablokowanie dostępu,
zdalne ustalanie kodu PIN,
monitorowanie czasu otwarcia drzwi,
wykrywanie ruchu w pomieszczeniu,
monitorowanie warunków panujących w pomieszczeniu.
Oczywiście jest to przykładowy zestaw funkcji.
Każdy może zaimplementować później zupełnie inną funkcjonalność.
Prosty zamek elektroniczny na Intel Edisonie
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ć.
C++
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>
constintPASS_MAXLEN=8;// maksymalna dlugosc hasla
constcharPASSWORD[]={"1234#"};// tajne haslo
charpass[PASS_MAXLEN+1];// wprowadzone haslo
constintLOCK_PIN=3;
constbyteROWS=4;//four rows
constbyteCOLS=3;//three columns
charkeys[ROWS][COLS]={
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
byterowPins[ROWS]={4,5,6,7};//connect to the row pinouts of the keypad
bytecolPins[COLS]={8,9,10};//connect to the column pinouts of the keypad
}elseif(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);
}
Zdalne blokowanie zamka
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:
C++
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;
boollocked=false;
W funkcji setup dodajemy inicjalizację IoTkit-a:
C
1
2
voidsetup(){
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:
C++
1
2
3
voidloop(){
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:
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.
Zmiana kodu dostępu
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:
Name: PINCode,
Type: Actuator,
Data type: Number,
Format: Integer,
Unit of measure: x (cokolwiek, ale nie może zostać puste),
Display: Time series.
Następnie klikamy na Add parameter i wprowadzamy:
Name: code,
Values: 0-9999.
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:
Shell
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.
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:
C
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:
C++
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
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:
C++
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
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.
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 na bazie Arduino i Raspberry Pi.
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...