Eelco: /* Bemonsteren van sensoren, aansturen van actuatoren */

2016-11-04T18:50:41Z

Bemonsteren van sensoren, aansturen van actuatoren

← Oudere versie		Versie van 4 nov 2016 18:50
Regel 257:		Regel 257:

	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	~~function~~ loop() {		void loop() {
	...		...
	if (digitalRead(button0) == HIGH) {		if (digitalRead(button0) == HIGH) {

Eelco: /* ESP8266-versie */

2016-11-02T08:25:42Z

ESP8266-versie

← Oudere versie		Versie van 2 nov 2016 08:25
Regel 33:		Regel 33:

	De ESP8266 heeft een klein voordeel: het mac-adres kan opgevraagd worden, dit betekent dat je de software niet voor elke node afzonderlijk hoeft aan te passen.		De ESP8266 heeft een klein voordeel: het mac-adres kan opgevraagd worden, dit betekent dat je de software niet voor elke node afzonderlijk hoeft aan te passen.

			=== Raspberry Pi versie ===

			Omdat we op de Raspberry Pi Python (en een compleet O.S.) tot onze beschikking hebben, heeft de software daarvoor een iets andere opzet.

			P.M.

	== Gebruikte externe Arduino-bibliotheken (libraries) ==		== Gebruikte externe Arduino-bibliotheken (libraries) ==

Eelco op 2 nov 2016 om 08:13

2016-11-02T08:13:30Z

← Oudere versie		Versie van 2 nov 2016 08:13
Regel 1:		Regel 1:
			{{Zijbalk Internet of Things}}
	== Structuur van de node-software ==		== Structuur van de node-software ==

Eelco: /* ESP8266-versie */

2016-11-02T08:08:15Z

ESP8266-versie

← Oudere versie		Versie van 2 nov 2016 08:08
Regel 29:		Regel 29:
	* netwerk: WiFi in plaats van Ethernet (met netwerknaam/wachtwoord)		* netwerk: WiFi in plaats van Ethernet (met netwerknaam/wachtwoord)
	* sensoren, actuatoren: gebruik van andere pinnen		* sensoren, actuatoren: gebruik van andere pinnen
	*		* (in setup): andere snelheid van de seriële host-verbinding

	De ESP8266 heeft een klein voordeel: het mac-adres kan opgevraagd worden, dit betekent dat je de software niet voor elke node afzonderlijk hoeft aan te passen.		De ESP8266 heeft een klein voordeel: het mac-adres kan opgevraagd worden, dit betekent dat je de software niet voor elke node afzonderlijk hoeft aan te passen.

Eelco: /* Structuur van de node-software */

2016-11-02T08:05:50Z

Structuur van de node-software

@@ Regel 8: / Regel 8: @@
 * coderen (JSON) van uitgaande MQTT-berichten;
 * opzetten van IP-verbinding (voor MQTT);
 == Gebruikte externe Arduino-bibliotheken (libraries) ==

Eelco: Nieuwe pagina aangemaakt met '== Structuur van de node-software == We beschrijven hier de structuur van de node-software. Dit is een voorbeeld; er zijn alternatieve oplossingen denkbaar. Dit vo...'

2016-11-02T07:56:56Z

Nieuwe pagina aangemaakt met '== Structuur van de node-software == We beschrijven hier de structuur van de node-software. Dit is een voorbeeld; er zijn alternatieve oplossingen denkbaar. Dit vo...'

Nieuwe pagina

== Structuur van de node-software ==

We beschrijven hier de structuur van de node-software. Dit is een voorbeeld; er zijn alternatieve oplossingen denkbaar. Dit voorbeeld kan uitgebreid worden met andere sensoren en actuatoren. In een node moeten we de volgende taken uitvoeren:
* bemonsteren van sensoren, met een vaste regelmaat;
* aansturen van actuatoren;
* communiceren met de MQTT-broker: node als MQTT-client;
* decoderen (JSON) en interpreteren van de binnenkomende MQTT-berichten;
* coderen (JSON) van uitgaande MQTT-berichten;
* opzetten van IP-verbinding (voor MQTT);

== Gebruikte externe Arduino-bibliotheken (libraries) ==

Voor de communicatie met de MQTT-broker gebruiken we de Arduino-bibliotheek <code>PubSubClient</code> (van Nick O'Leary). Informatie over deze library is te vinden via:
* http://pubsubclient.knolleary.net
* https://github.com/knolleary/pubsubclient

Voor de MQTT-berichten gebruiken we het JSON-formaat. Dit maakt het gemakkelijker om deze berichten te verwerken, in de verschillende onderdelen van de IoT-keten. Voor het coderen en decoderen van JSON-berichten gebruiken we de bibliotheek <code>ArduinoJson</code> (van Benoît Blanchon). Informatie over deze library is te vinden via:
* https://github.com/bblanchon/ArduinoJson

=== Installeren van deze libraries in de Arduino IDE (eenmalig)===
* selecteer Schets->Bibliotheek gebruiken->Bibliotheken beheren
* zoek de MQTT-bibliotheek PubSubClient (van Nick O'Leary)
* klik op "more info"
* installeer de library
* zoek de JSON-bibliotheek ArduinoJson (van Benoît Blanchon)
* klik op "more info"
* installeer de library

=== Importeren van deze libraries in het Arduino-programma ===

Voordat we de functies en andere elementen uit deze libraries in ons Arduino-programma kunnen gebruiken, moeten we eerst deze libraries importeren. Dit doen we aan het begin van het programma, als volgt:

<syntaxhighlight lang="cpp">
#include <Ethernet.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
</syntaxhighlight>

De Ethernet-library is een Arduino-library voor het aansturen van het Ethernet-shield. Deze library maakt de internet-communicatie mogelijk die de basis is voor de MQTT-communicatie.

== Communicatie met MQTT-broker ==

=== Internet-verbinding ===

MQTT maakt gebruik van de internet-verbinding, in dit geval via het Arduino Ethernet-shield:

<syntaxhighlight lang="cpp">
// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x4D, 0x60};

EthernetClient ethClient;
</syntaxhighlight>

* het MAC-adres van het Ethernet-shield moet je voor elk shield afzonderlijk invullen. Je kunt dan niet hetzelfde programma op verschillende nodes laten werken. We proberen de code zo op te zetten dat je dit maar op één plaats hoeft aan te passen.
* voor de ESP8266-systemen kun je het MAC-adres opvragen, dan kun je wel eenzelfde programma op verschillende nodes uitvoeren.
* de internet-communicatie verloopt via <code>ethClient</code>.

De internet-verbinding zetten we als volgt op:
<syntaxhighlight lang="cpp">
void networkSetup() {
if (Ethernet.begin(mac) == 0) {
Serial.println("Failed to configure Ethernet using DHCP");
// no point in carrying on, so do nothing forevermore:
for (;;)
;
}
// print your local IP address:
Serial.print("My IP address: ");
Serial.println(Ethernet.localIP());
}
</syntaxhighlight>

=== Node-identificatie ===

Voor de identificatie van een node in MQTT gebruiken we de laatste 2 bytes van het MAC-adres.

<syntaxhighlight lang="cpp">
String nodeID;

void setup() {
//...
networkSetup();
nodeID = String(mac[4] * 256 + mac[5], HEX));
//...
}
</syntaxhighlight>

=== Opzetten en instandhouden van de MQTT-communicatie ===

<syntaxhighlight lang="cpp">
const char* mqttServer = "mqttbroker";
// alternative: IPAddress mqttServer(172, 16, 0, 2);
const int mqttPort = 1883;

PubSubClient client(ethClient);

void setup() {
// ...
client.setServer(mqttServer, mqttPort);
client.setCallback(callback);
}
</syntaxhighlight>

Het <code>client</code>-object biedt het interface voor de interactie met de MQTT-broker. We moeten dit eerst koppelen aan het internet-interface (<code>ethClient</code>), en daarna aan de server en de callback-functie.

De callback-functie wordt vanuit dit client-object aangeroepen als er een MQTT-bericht binnenkomt voor een topic waarop deze client geabonneerd is. We beschrijven deze functie verderop.

<syntaxhighlight lang="cpp>
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");
String clientID = "IoTClient-" + nodeID;
if (client.connect(clientID.c_str())) {
Serial.println("connected");

client.subscribe(actuatorTopic.c_str());
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}

</syntaxhighlight>

=== Verzenden van MQTT-berichten ===

Voor het versturen van een MQTT-bericht gebruiken we de functie (method) <code>client.publish(<topic>, <message>);</code>. Voor een voorbeeld zie het versturen van sensor-data in JSON-formaat.

=== Ontvangen van MQTT berichten ===

Als er een MQTT-bericht ontvangen wordt, van een topic waarop deze client geabonneerd is, dan wordt de functie aangeroepen die we opgegeven hebben als callback-functie.

<syntaxhighlight lang="cpp">
void mqttCallback(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();

if (strcmp(topic, actuatorTopic.c_str())==0) {
Serial.println("actuator message received");
StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.parseObject((char*) payload);
if (root.success()) {
if (root.containsKey("led0")) {
digitalWrite(led0, root["led0"]);
}
}
}
}
</syntaxhighlight>

== JSON coderen en decoderen ==

We gebruiken het JSON-formaat voor de MQTT-berichten. Bij het versturen moeten we de sensorgegevens in deze vorm gieten. Bij het ontvangen moeten we het bericht interpreteren, en de juiste actie(s) ondernemen.

Voor de manier waarop je de JSON-library gebruikt, zie de documentatie:

=== Coderen en versturen ===

Als voorbeeld geven we hier het inpakken en versturen van de gegevens van sensor1: een analoge sensor (bijv. een LDR-lichtsensor). Als onderdeel van een bericht geven we ook de ID van de node mee, en de lokale tijd (in msec sinds het opstarten).

<syntaxhighlight lang ="cpp">
void publish_sensor1() {
StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.createObject();
String msg;
root["id"] = nodeID;
root["sensor1"] = analogRead(A0);;
root["localtime"] = millis();
root.printTo(msg);
Serial.println(msg);
client.publish(sensorTopic.c_str(), msg.c_str());
}
</syntaxhighlight>

=== Ontvangen en decoderen ===

Bij het ontvangen moet je eerst uitzoeken welk MQTT-topic het betreft. Als het om het actuators-topic gaat, moet je het bericht verder ontleden (via de JSON-library). In het onderstaande voorbeeld hebben we maar met één actuator te maken. Je controleert of het MQTT bericht data voor een actuator bevat, door de test: <code>if (root.containsKey(<actuatorname>)) {...} </code>. In principe kan een bericht data voor meerdere actuatoren bevatten. Het formaat van de data hangt af van het soort actuator dat je gebruikt.

<syntaxhighlight lang="cpp">

if (strcmp(topic, actuatorTopic.c_str())==0) {
Serial.println("actuator message received");
StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.parseObject((char*) payload);
if (root.success()) {
if (root.containsKey("led0")) {
digitalWrite(led0, root["led0"]);
}
}
}
</syntaxhighlight>

== Bemonsteren van sensoren, aansturen van actuatoren ==

* pin-definitie van sensoren, timer-definitie
<syntaxhighlight lang="cpp">
// i/o pin map
const int led0 = 5;
const int button0 = 2;
// analog sensor on A0

long sensor1Timer = 0;
long sensor1Period = 50000; // in millisecs
</syntaxhighlight>
* setup van relevante pins (in setup-functie)
<syntaxhighlight lang="cpp">
void setup() {
pinMode(led0, OUTPUT);
pinMode(button0, INPUT);
analogReference(INTERNAL); //1.1V
...
}
</syntaxhighlight>
* uitlezen van sensoren (in loop-functie; sommige sensoren gebruiken een timer).

<syntaxhighlight lang="cpp">
function loop() {
...
if (digitalRead(button0) == HIGH) {
sensor0Publish();
delay(200); // limit button repetition rate
}

if (millis() >= sensor1Timer) {
sensor1Publish();
sensor1Timer = sensor1Timer + sensor1Period;
}
}
</syntaxhighlight>

* aansturen van actuatoren: zie <code>mqttCallback</code>

Internet of Things/Node-software - Bewerkingsoverzicht

Eelco: /* Bemonsteren van sensoren, aansturen van actuatoren */

Eelco: /* ESP8266-versie */

Eelco op 2 nov 2016 om 08:13

Eelco: /* ESP8266-versie */

Eelco: /* Structuur van de node-software */

Eelco: Nieuwe pagina aangemaakt met '== Structuur van de node-software == We beschrijven hier de structuur van de node-software. Dit is een voorbeeld; er zijn alternatieve oplossingen denkbaar. Dit vo...'