Vodnický blog

Co je Mosquitto? Je to MQTT message broker. To znamená, že umožňuje komunikaci mezi hromadou zařízení pomocí MQTT protokolu. Zařízení může být v jednom ze dvou režimů. To první je Publisher, to druhe Subscriber. Publisher data generuje a sype do nějaké fronty, Subscriber (odběratel) je pak načítá. Odběratelů může být neomezeně, stejně tak Publisherů (vydavatelů?).

Celé se to dá krásně využít k tomu, že všechny IoT čidla postavené na Arduinu generují data a jednotně je sypo do MQTT. Z MQTT se to pak jednotně načítá, ať už napřímo přes Loxone, nebo třeba do NodeRED, kde se nastaví co se s datama má dít a až pak se data pošlu dál.

Díky tomu se do čidel nemusí dávat žádná složitá logika na publikování dat, posílání jích do Loxone atd. Ale jen se to nasype do MQTT brokera a další logika se postaví až o stupeň dál.

Instalace Mosquitto serveru.

Já jsem využil toho, že mi doma běží server na pracovní věci, a tak jsem si udělal novou virtualizovanou instanci Ubuntu ;-). Ale jinak se dá mosquitto rozběhat i na Windows, Raspberry, Turrisu a dalších.

Instalace byla v mém pomocí apt-get. Kromě balíku mosquitto sem bral i mosquitto-clients, které přidají příkazy na simulaci subscribera/publishera, takže lze otestovat, že vše běží jak má. Po nainstalování jsem pak pro účely ladění zapl komplet logování, které v ostrém provozu později vypnu.

sudo apt-get install mosquitto mosquitto-clients
sudo /etc/init.d/mosquitto stop
sudo nano /etc/mosquitto/mosquitto.conf
sudo /etc/init.d/mosquitto start

Do konfigurační soubor mosquitta jsem přidal:

log_type error
log_type warning
log_type notice
log_type information

connection_messages true
log_timestamp true

A nahodil jsem zpět mosquitto. Pro otestování, že vše funuje jak má, jsou právě ty mosquitto-clients.

Pro otestování subscribera je příkaz mosquitto_sub. Parametr -d zapíná debug zprávy, -t nastavuje název kanálu, nad kterým subscriber poslouchá.

mosquitto_sub -d -t hello/world

Když máme posluchače, je potřeba vygenerovat nějakou zprávu. To se dělá pomocí publishera mosquitto_pub. Parametry opět stejné, akorat místo naslouchání na -t se do kanálu -t data pošlou, -m pak definuje zprávu na poslání.

mosquitto_pub -d -t hello/world -m "test"

Jakmile vygenerujete publisherem zprávu, na subscriberovi se zobrazí

Client mosqsub/7136-home-serve received PUBLISH (d0, q0, r0, m0, 'hello/world', ... (4 bytes))
test

To znamená, že nám MQTT broker funguje jak má. Pokud by něco zlobilo, logy jsou dostupně v souboru  /var/log/mosquitto/mosquitto.log

Komunikace s Mosquitto serverem z Arduina

A teď ta druhá část, poslání/naslouchání MQTT s Arduina. Zkusíme poslat zprávu, kterou necháme zobrazit pomocí již nahozeného subscribera v konzoli a pak přijímat zprávy a při přijmutí bliknout diodou.

Krok první, nainstalujeme si nějakou předpřipravenou MQTT knihovnu do Arduina. V menu VMICRO -> Visual Micro Explorer -> Manage Libraries.

Zkusil jsem PubSubClient, tvrdí že je lightweight a takové mám rád ;-).

Jako další krok vložíme knihovnu do projektu. Pokud člověk ví co dělá, stačí obyčejný #include<PubSubClient.h>, pokud ne, může si to vybrat takto z wizarda. Napoprvé je to fajn, že není potřeba lovit, jak se soubor přesně jmenuje.

Zkusíme zkompilovat a zdá se, že je vše ok. Tak pojďme poslat nějaká data. Výhoda Arduina je, že celý ekosystém už je opravdu pěkně rozrostlý a na všechno existují připravené knihovny.

Na druhou stranu nevýhoda Arduina je, že celý ekosystém dělají lidé, co jsou zřejme opravdu borci na elektrotechniku, ale dost slabí na programování. Takže ačkoli je Arduino postavené nad c++,  jeho knihovny, ukázky a vše ostatní vypadá jako programy psané v čistém C kódu kdysi v minulém století.

Naštěstí to není až takový problém a všechno jde postupně zabalit do vlastních objektů a udělat si nad tím čistý kód.

Inicializace Wifi, Debugu, Mqtt a Diody

Aby měl návod trochu spád, spojím všechny tyto věci dohromady. Jak už jsem psal, kód pro Arduino je bohužel takový c-like spaghetti bastl. Ačkoli využívá objektový zápis, tak instance objektů existují kdesi globálně a jen se používají. To je supr pro nováčky, co netuší která bije, ale pro pokročilé vyvíjení je to imho škoda, protože to maskuje hromadu věcí a cokoli globálního je prostě blbě.

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <PubSubClient.h>

const char* ssid = "wifi";
const char* password = "password";
const char* mqtt_server = "192.168.0.102";

WiFiClient espClient;
PubSubClient mqttClient(espClient);

void setupDebug()
{
	Serial.begin(9600);
	Serial.println("WeMos MQTT test");
	Serial.println("");
}

void setupWifi()
{
	// Connect to your WiFi network
	WiFi.begin(ssid, password);
	Serial.print("Connecting");

	// Wait for successful connection
	while ( WiFi.status() != WL_CONNECTED )
	{
		delay(500);
		Serial.print(".");
	}
	Serial.println("");
	Serial.print("Connected to: ");
	Serial.println(ssid);
	Serial.print("IP address: ");
	Serial.println(WiFi.localIP());
	Serial.println("");
}

void setupMqtt()
{
	mqttClient.setServer(mqtt_server, 1883);
	mqttClient.setCallback(MQTT_callback);
}

void setupDiode()
{
	pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output 
}

void Blink(int nDelayOn, int nDelayOff)
{
	digitalWrite(LED_BUILTIN, HIGH);  // Turn the LED off by making the voltage HIGH
	delay(nDelayOn);                      // Wait for two seconds (to demonstrate the active low LED)
	digitalWrite(LED_BUILTIN, LOW);   // Turn the LED on (Note that LOW is the voltage level  
	delay(nDelayOff);                      // Wait for two seconds (to demonstrate the active low LED)
}

void setup() 
{ 
  setupDebug(); 
  setupWifi(); 
  setupMqtt(); 
  setupDiode(); 
}

Takhle nějak vypadá inicializace pro WeMos D1.

• hromada “println” posílá po seriovém portu zpět do IDE stavy a zprávy
• setupDebug inicializuje seriovou linku právě pro tyto přenosy.
• setupWifi připojí wifi adaptér k zadané síti a vypíše kam se připojila.
• setupMqtt nastaví parametry připojení pro MQTT clienta
• setupDiode jakýmsi způsobem propojuje PIN LED_BUILTIN na OUTPUT diodu, toto zatím beru jako fakt a moc to nechápu
• Blink slouží k bliknutí diody
• A setup spustí všechny výše uvedené nastavení.

Spoustu nastavení, ale jinak nic objevného. Toto nastavení použijeme jak pro zapisování dat do MQTT, tak pro čtení.

Komunikace s MQTT brokerem

Po tom, co máme vše inicializováno, zbývá se jen připojit k MQTT brokerovi a posílat a přijímat data. Připojení se provede pomocí

if ( mqttClient.connected() == false )
  mqttClient.connect("ESP8266Client");

kdy řetězec “ESP8266Client” je pro mne velkou záhadou, ale mám to z examplu. Moc nerozumím tomu, proč je to jako string “ESP8266Client” místo objektu WiFi nebo espClient, ale je to jen další z divných věcí v Arduinu, která má zřejmě sloužit dobru, ale imho jen škodí.

Odeslání dat se provádí pomocí metody publish, která má jako první parametr název kanálu, jako druhý parametr data k odeslání.

mqttClient.publish("hello/world", "hello world");

Příjem dat se provádí pomocí zaregistrování callbacku metodou setCallback a pak přihlášení ke konkrétnímu kanálu metodou subscribe. Tady by mi přišlo logičtější mít co kanál možnost jiný callback, ale opět asi zjednodušení.

void MQTT_callback(char* topic, byte* payload, unsigned int length) {}
mqttClient.setCallback(MQTT_callback);
mqttClient.subscribe("hello/world/2");
 

Celý kód pak vypadá třeba takto. V MQTT_callback se zobrazí obdržená data a blikneme diodou. V metodě reconnect se provádí testování platného připojení a jeho případně znovupřipojení, v metodě loop pak dokola testujeme platnost připojení, voláme interní loop MQTT clienta (kvůli přijmu dat) a každé 2sec posíláme zprávy do MQTT brokera “Hello world” spolu s pořadovým číslem zprávy.

void MQTT_callback(char* topic, byte* payload, unsigned int length) {
	Serial.print("Message arrived [");
	Serial.print(topic);
	Serial.print("] ");
	for ( int i = 0; i < length; i++ )
	{
		Serial.print((char)payload[i]);
	}
	Serial.println();

	Blink(100, 100);
}

void MQTT_reconnect() 
{
	// Loop until we're reconnected
	while ( !mqttClient.connected() )
	{
		Serial.print("Attempting MQTT connection...");
		// Attempt to connect
		if ( mqttClient.connect("ESP8266Client") )
		{
			Serial.println("connected");
			// Once connected, publish an announcement...
			mqttClient.publish("hello/world", "hello world");
			// ... and resubscribe
			mqttClient.subscribe("hello/world/2");
		}
		else
		{
			Serial.print("failed, rc=");
			Serial.print(mqttClient.state());
			Serial.println(" try again in 5 seconds");
			// Wait 5 seconds before retrying
			delay(5000);
		}
	}
}



void loop()
{
	if ( !mqttClient.connected() )
		MQTT_reconnect();
	mqttClient.loop();

	static long lastTime = 0;
	static int lastValue = 0;
	if ( millis() - lastTime > 2000 )
	{
		char msg[50];
		snprintf(msg, 75, "hello world #%ld", lastValue++);
		Serial.print("Publish message: ");
		Serial.println(msg);
		mqttClient.publish("hello/world", msg);
		lastTime = millis();
	}
}

Na celém kódu není nic složitého a díky předpřipravenému MQTT clientu a hotovým ukázkám jde kód narychlo polepit dohromady.

Co je nevýhoda, tak kód je prostě ošklivý a nepřehledý. Na vlastní finální řešení to bude chtít obalit vše svými objekty, ideálně napsat i nějaké mock objekty kvůli testování a celkově nad tím udělat robustnější testování, aby člověk neprogramoval stylem zkompilovat-nahrát-zkusit-znovu. Takhle se programovalo v dobách Atari, ale ne dneska.

A to je vše, máme funční Arduino MQTT publisher i subscriber. Příště až bude čas, tak zkusím rozchodit onen Node-Red. A až dorazí věci z Aliny, tak na Wemos napom čidla a zkusim posílat nějaká smysluplnější data.

Ostatní linky

• https://mosquitto.org/
• http://www.switchdoc.com/2016/02/tutorial-installing-and-testing-mosquitto-mqtt-on-raspberry-pi/
• http://pubsubclient.knolleary.net/
• https://www.baldengineer.com/mqtt-tutorial.html
• https://www.digitalocean.com/community/questions/how-to-setup-a-mosquitto-mqtt-server-and-receive-data-from-owntracks
• https://www.arduino.cc/en/Reference/WiFiClient
• http://www.iot-hub.org/2015/09/mqtt-with-mosquitto-beginners-tutorial.html

Link na diskuzní fórum o Arduino vývoji