OpenHab - sterowanie za pomocą poleceń głosowych

Aplikacja OpenHab na Androida (habDroid) ma bardzo ciekawą i użyteczną funkcjonalność sterowania głosem. Mając już działającą konfigurację OpenHab należy do naszego pliku *.items dopisać:

String VoiceCommand

dokładnie w takiej postaci.

W momencie rozpoznania głosu habDroid do elementu o nazwie VoiceCommand wysyła rozpoznaną treść.
Przykładowy plik zawierający jeden przełącznik o nazwie salonLed z możliwością sterowania głosem powinien wyglądać następująco:

	Group All
	Group Salon "Salon" (All)
	Switch salonLed "Salon LED" (All, Salon) {mqtt=">[mosquitto:/house:command:ON:salonled1],>[mosquitto:/house:command:OFF:salonled0],<[mosquitto:/houseIn:state:MAP(salonled.map)]"}
	String VoiceCommand

view raw voiceCommand.items hosted with ❤ by GitHub

OpenHab posiada możliwość definiowania tzw. reguł (rules). Reguły muszą znajdować się w katalogu

configurations/rules

w pliku o rozszerzeniu

*.rules

W celu określenia jaka  jaka akcja powinna być wykonana po otrzymaniu zdefiniowanej komendy głosowej należy utworzyć odpowiednią regułę. Załóżmy że chcemy sterować elementem salonLed. Należy wtedy utworzyć plik z regułą, np.

voice.rules 

o następującej treści:

	rule "przelacz sufit"
	when
	Item VoiceCommand received command sufit
	then
	if(salonLed.state==ON) {
	salonLed.sendCommand(OFF)
	}
	else {
	salonLed.sendCommand(ON)
	}
	end

view raw voice.rules hosted with ❤ by GitHub

Jak widać reguły definiowane są w prostym i dość czytelnym języku skryptowym.
Aby sterować kolejnymi urządzeniami trzeba po prostu dodać nowe elementy w pliku *.items oraz nowe reguły dla nich w pliku *.rules

To praktycznie cała konfiguracja, jak widać jest banalnie prosta. Zastosowań można znaleźć wiele, na przykład jedną komendą głosową można otworzyć bramę wjazdową, bramę garażową i zapalić halogen na podjeździe. Można wtedy zapomnieć o pilotach :)
Dla miłośników IPhone'ów mam niestety złą wiadomość. Sterowanie głosowe działa wyłącznie na Androidzie.

Na koniec przykładowy film z działania funkcjonalności:

OpenHab, arduino i mqtt binding

Klon arduino możesz zakupić tanio  na aliexpres. Poniższy link to link afiliacyjny. Skorzystanie z niego Ciebie nic dodatkowo nie kosztuje a ja otrzymam niewielką prowizję która wspomoże rozwój tego bloga. Dzięki!

http://ali.pub/2hk8rp

Jak już pisałem wcześniej komunikacja arduino z OpenHab za pomocą TCP nie sprawdziła się w praktyce. Za to z czystym sumieniem mogę stwierdzić że komunikacja za pomocą MQTT działa znakomicie.

Przy takim rozwiązaniu dochodzi jednak dodatkowa warstwa pośrednia - broker.
W uproszczeniu można powiedzieć że broker zajmuje się rozprowadzaniem komunikatów do zainteresowanych klientów.

Rozwiązanie to działa na zasadzie mechanizmu Publish - subscribe.
Odpowiednie urządzenia mogą publikować (Publish) komunikaty w danym temacie (TOPIC). Klienci podłączają się do brokera informując go że są zainteresowani (subscribe) komunikatami z danego tematu.

Przenosząc to na płaszczyznę automatyki domowej ja zastosowałem następującą architekturę:

Na Raspberry PI zainstalowałem broker MQTT. Najpopularniejszym brokerem obecnie jest chyba Mosquitto.

Aby zainstalować mosquitto należy wykonać następujące polecenie:

sudo apt-get install mosquitto mosquitto-clients

Po instalacji pojawi się katalog:

/etc/mosquitto

w którym znajduje się plik konfiguracyjny brokera

mosquitto.conf

Wystarczy bardzo prosta konfiguracja:

	port 1883
	persistence true
	persistence_location /var/lib/mosquitto/
	log_dest none
	allow_anonymous false
	password_file /etc/mosquitto/password_file

view raw mosquitto.conf hosted with ❤ by GitHub

Jak widać z powodu bezpieczeństwa wyłączyłem anonimowy dostęp do brokera. W tym przypadku należy utworzyć plik

 /etc/mosquitto/password_file

,w którym zapiszemy login i hasło do brokera z którego  będą korzystać Arduino i OpenHab.
Plik powinien zawierać wpis w postaci:

login:hasło

Teraz należy zrestartować broker poleceniem:

/etc/init.d/mosquitto restart

Następnie można przetestować działanie brokera. Dostępne są dwa programy:

mosquitto_sub 

do obsługi subskrypcji oraz

mosquitto_pub 

do obsługi publikowania.

Na początku należy uruchomić polecenie:

mosquitto_sub -h localhost -u login -P hasło -t /house

co oznacza że utworzyliśmy klienta który podłączył się do brokera na serwerze localhost przy użyciu loginu "login" i hasła "hasło" (zdefiniowanych w pliku password_file). Klient subskrybował wszystkie wiadomości w temacie (TOPIC) /house.

Po wykonaniu polecenia klient oczekuje na komunikaty.

W drugiej konsoli należy uruchomić polecenie:

mosquitto_pub -h localhost -u login -P hasło -t /house -m test

Oznacza to że na brokerze pod adresem localhost opublikowaliśmy wiadomość o treści "test" w temacie /house

Jeśli wszystko wykonaliśmy poprawnie na konsoli na której uruchomiliśmy mosquitto_sub powinna pojawić się zawartość wiadomości, czyli "test"

Dla eksperymentu można uruchomić kilka klientów mosquitto_sub nasłuchujących dany "topic". Na wszystkich jednocześnie powinna pojawić się treść opublikowanego komunikatu


Mając działający broker można przystąpić do konfiguracji OpenHab.

W tym celu należy przekopiować plik jar o nazwie

org.openhab.bindings.mqtt-1.5.0.jar (numer wersji może być inny)

 do katalogu addons serwera openhab.
W pliku konfiguracyjnym

configuration/openhab_default.cfg

należy dopisać następujące linie:

	mqtt:mosquitto.url=tcp://localhost:1883
	mqtt:mosquitto.user=login
	mqtt:mosquitto.pwd=hasło
	mqtt:mosquitto.qos=1
	mqtt:mosquitto.retain=true
	mqtt:mosquitto.clientId=ohab1
	mqtt:mosquitto.async=true

view raw openhab_default.cfg hosted with ❤ by GitHub

Załóżmy że chcemy sterować halogenem. W tym przypadku plik

configurations/items/house.items

powinien wyglądać następująco:

	Group All
	Group Salon "Salon" (All)
	/*Lights */
	Switch halogen "Halogen" (All, Salon) {mqtt=">[mosquitto:/house:command:ON:halogen#1],>[mosquitto:/house:command:OFF:halogen#0],<[mosquitto:/houseIn:state:MAP(halogen.map)]"}

view raw house.items hosted with ❤ by GitHub

Oznacza to że w naszej konfiguracji mamy jeden przełącznik odpowiadający za załączanie halogena.
Załączenie przełącznika OPUBLIKUJE wiadomość o treści "halogen#1" na brokerze mqtt w topic'u "/house". Wyłączenie przełącznika OPUBLIKUJE wiadomość o treści "halogen#0" na brokerze mqtt również w topic'u "/house"
Dodatkowo obsługa tego przełącznika SUBSKRYBUJE topic /houseIn na tym samym brokerze.
W pliku

transform/halogen.map 

powinno znaleźć się mapowanie treści otrzymanej wiadomości na stan przełącznika.
Plik powinien mieć następującą zawartość:

halogen#1=ON
halogen#0=OFF

Nasłuchiwanie służy do aktualizacji stanu przełącznika. Pamiętajmy że halogen można zapalić również zwykłym przełącznikiem na ścianie. Wówczas OpenHab powinien się o tym dowiedzieć aby wyświetlić odpowiedni stan przełącznika.

To cała konfiguracja po stronie OpenHab. Należy tylko zrestartować usługę.

Pozostaje jeszcze obsługa po stronie mikrokontrolera.
Bibliotek do obsługi mqtt na arduino jest kilka. Ja wykorzystałem bibliotekę PubSubClient którą znalazłem pod adresem:
http://knolleary.net/arduino-client-for-mqtt/

Poniżej przedstawiam fragmenty kodu które obrazują zasadę działania:

	#include <SPI.h>
	#include <Ethernet.h>
	#include <PubSubClient.h>
	const int HALOGEN_BUTTON_PIN = 28;
	const int HALOGEN_RELAY_PIN = 30;
	String HALOGEN_ON_COMMAND("halogen#1");
	String HALOGEN_OFF_COMMAND("halogen#0");
	const int AFTER_CHANGE_DELAY = 500;
	int halogenButtonState;
	int halogenState = LOW;
	//numer IP komputera na którym jest uruchomiony serwer mqtt
	byte mqtt_server[] = { 192,168, 1, 3 };
	void setup() {
	Serial.begin(9600);
	initializeMqtt();
	initializeHalogen();
	}
	void loop() {
	checkHalogen();
	checkMqtt();
	}
	void callback(char* topic, byte* payload, unsigned int length) {
	payload[length] = '\0';
	String strPayload = String((char*)payload);
	Serial.print("IN: ");
	Serial.println(strPayload);
	executeRemoteCommand(strPayload);
	}
	PubSubClient mqtt_client(mqtt_server, 1883, callback, client);
	void sendMqttState(String state) {
	Serial.print("STATE: ");
	Serial.print(state);
	/*
	konieczna weryfikacja czy mamy aktywne połączenie
	jeśli nie, trzeba je odnowić
	*/
	boolean connected = mqtt_client.connected();
	if (!connected) {
	initializeMqtt();
	}
	char ssid[state.length()+1];
	state.toCharArray(ssid, state.length()+1);
	boolean publishState = mqtt_client.publish("/houseIn", ssid);
	Serial.print(" published: ");
	Serial.println(publishState);
	}
	void initializeMqtt()
	{
	if (mqtt_client.connect("arduinoClient", "login", "hasło")) {
	mqtt_client.subscribe("/house");
	Serial.println("MQTT connect OK");
	} else {
	Serial.println("MQTT connect failed");
	}
	}
	void checkMqtt()
	{
	mqtt_client.loop();
	}
	void executeRemoteCommand(String command) {
	Serial.println(command);
	if (command == HALOGEN_ON_COMMAND) {
	setHalogenState(HIGH);
	}
	if (command == HALOGEN_OFF_COMMAND) {
	setHalogenState(LOW);
	}
	}
	void initializeHalogen() {
	pinMode(HALOGEN_BUTTON_PIN, INPUT);
	pinMode(HALOGEN_RELAY_PIN, OUTPUT);
	setHalogenState(LOW);
	}
	void checkHalogen() {
	halogenButtonState = digitalRead(HALOGEN_BUTTON_PIN);
	if (halogenButtonState == HIGH) {
	toogleHalogen();
	delay(AFTER_CHANGE_DELAY);
	}
	}
	void setHalogenState(int state) {
	digitalWrite(HALOGEN_RELAY_PIN, state);
	halogenState = state;
	if (state == LOW) {
	sendMqttState(HALOGEN_OFF_COMMAND);
	} else {
	sendMqttState(HALOGEN_ON_COMMAND);
	}
	}
	void toogleHalogen() {
	if (halogenState == LOW) {
	setHalogenState(HIGH);
	} else {
	setHalogenState(LOW);
	}
	}

view raw halogen.ino hosted with ❤ by GitHub

Nie jest to kompletny kod, ponieważ całość wraz z obsługą wszystkich przekaźników które mam obecnie jest zbyt duża żeby wklejać je na bloga. Większe fragmenty publikowane były już w poprzednich wpisach. Myślę że osoby obeznane z tematem bez problemu powinny poradzić sobie z wykorzystaniem podanych fragmentów. W przypadku pytań  piszcie w komentarzach.

Jedyny fragment który sprawiał problemy to okolice wiersza 45. Po  pewnym czasie od momentu restartu arduino przy wciskaniu przełączników sprzętowych przestawały dochodzić potwierdzenia do OpenHab. Okazało się że z jakichś nieokreślonych powodów było zrywane połączenie między Arduino a MQTT. Dodanie sprawdzania stanu i ponownego połączenia w przypadku gdy połączenie nie było aktywne rozwiązało problem.

Po tych zmianach cały układ działa bardzo stabilnie i myślę że można stwierdzić że można go z powodzeniem wykorzystywać w warunkach produkcyjnych