Een Ultrasoon water sensor en MagicMirror

Met een beetje creativiteit kun je soms echt verbazingwekkende dingen maken. Onlangs heb ik een ultrasone watersensor gemaakt voor de water tanks in de achtertuin die communiceerde met een MagicMirror module via het MQTT-protocol. Het project begon met het bouwen van een eenvoudig Arduino-circuit dat bestond uit een ultrasoon sensorelement, een microcontroller (ESP8266 node MCU), een MQTT-broker en een draadloze WiFi verbinding.

Ik gebruikte Arduino IDE om de code te schrijven waarmee de sensor de waterstand in de tuin kon detecteren. Vervolgens verbond ik de circuit met het lokale WiFi-netwerk. Dit stond me toe om het MQTT-bericht te verzenden naar de MagicMirror module, die ik eerder had geïnstalleerd. De MagicMirror module detecteerde het MQTT-bericht en laat een icoon zien aan de hand van de waterstand in de tuin.

Nu heb ik altijd een real-time update over de waterstand in de tanks in mijn tuin. Het maken van de ultrasoon watersensor was een leuke uitdaging. Niet alleen heb ik wat elektronica-kennis en programmerervaring opgedaan, maar ik heb ook een praktisch apparaat gebouwd dat dagelijks van pas komt.

Als je ook een leuke technische uitdaging zoekt, dan is het bouwen van een ultrasone watersensor een leuke manier om je technische vaardigheden te verbeteren. Ik hoop dat dit artikel je geïnspireerd heeft om je eigen ultrasone watersensor te bouwen! Als dit zo is lees dan vooral verder hoe ik dit gedaan heb.

Wat heb je nodig

1x ESP8266 Node MCU

1x (of meer) HC-SR04 ultrasoon sensor

1x Een RPI of ander apparaat met Magic Mirror

1x Een pc om de code op te schrijven voor Arduino en MagicMirror

Stap 1: Instaleer de MQTT Broker

Eerst moeten we een MQTT- Broker installeren op de pi. De broker is een soort kiosk iedereen kan zijn krant(Topic) bij hem aanbieden en hij verspreid dan die informatie naar iedereen met een abonnement op die krant (Topic).

log in op je RaspberryPi via SSH of open een terminal op de Pi en typ het volgende command om Mosquitto te instaleren onze MQTT-Broker.

sudo apt install mosquitto mosquitto-clients

Vervolgens moeten we de MQTT-Broker opstarten met het volgende command.

sudo systemctl enable mosquitto

De broker zou nu moeten draaien je kunt dit checken met het volgende command.

sudo systemctl status mosquitto

Daar zou het volgende uit moeten komen:

● mosquitto.service - LSB: mosquitto MQTT v3.1 message broker
   Loaded: loaded (/etc/init.d/mosquitto; generated; vendor preset: enabled)
   Active: active (running) since Sat 2018-12-29 16:27:56 GMT; 22h ago
     Docs: man:systemd-sysv-generator(8)
   CGroup: /system.slice/mosquitto.service
           └─1685 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

Dec 29 16:27:56 raspberrypi systemd[1]: Starting LSB: mosquitto MQTT v3.1 message broker...
Dec 29 16:27:56 raspberrypi mosquitto[1679]: Starting network daemon:: mosquitto.
Dec 29 16:27:56 raspberrypi systemd[1]: Started LSB: mosquitto MQTT v3.1 message broker.

Vervolgens kun je je abonneren op een Topic door middel van het volgende command waar in “ip” word vervangen voor het IP-adres van je RaspberryPi.

mosquitto_sub -h "ip" -t TestTopic

Open nu een tweede terminal en typ daar het volgende command waar in wederom “ip” word vervangen door je RaspberryPi’s IP-adres.

mosquitto_pub -h 'localhost'ip' -t TestTopic -m "Hello, world"

Je zou nu op je 1e terminal het volgende moeten zien.

Hello, world

Gefeliciteerd je hebt je eerste bericht via MQTT verstuurd! 🎉

Stap 2: Installeer de MagicMirror Modules

Eerst gaan we de MMM-MQTT module instaleren.

Navigeer in de therminal naar MagicMirror/modules met het volgende command.

cd MagicMirror/modules

Download en installeer nu de module met de volgende Commands.

git clone https://github.com/ottopaulsen/MMM-MQTT
cd MMM-MQTT
npm install

Nu gaan we mijn eigen module toevoegen MMM-IconDisplayer hiermee gaan wij notificaties van de MMM-MQTT module lezen en aan de hand van die informatie Iconen laten zien.

Navigeer terug naar MagicMirror/modules.

cd ..

En typ de volgende commands.

git clone https://github.com/wiedsee/MMM-IconDisplayer.git
cd MMM-IconDisplayer
npm install

Nu we beide modules hebben geïnstalleerd moeten we ze nog configureren.

Open het config.js bestand en plak daar de volgende code in. let op dat je bij “ip” weer het IP-adres van de pi invoert.

{	module: "MMM-IconDisplayer",
	header: 'Water levels',
	position: "top_right",
	config: {
		preferences: [
			{	topic: "Tank_1", // topic name for the MQTT message
				icon: "10", // icon name to display
				max: 10, // maximum value to display icon
				min: 0, // minimum value to display icon
			},
			{	topic: "Tank_2", // topic name for the MQTT message
				icon: "20", // icon name to display
				max: 20, // maximum value to display icon
				min: 11, // minimum value to display icon
			},
		],
	},
},
{	module: 'MMM-MQTT',
	position: 'bottom_left',
	header: 'MQTT',
	config: {
		logging: false,
		useWildcards: false,
		mqttServers: [
			{
				address: 'ip',	// Server address or IP address
				port: '1883',		// Port number if other than default
				subscriptions: [	
					{
						topic: 'Tank_1',
						suffix: '%',
						decimals: 0,
						broadcast: true,	// Broadcast messages to other modules
					},
{
						topic: 'Tank_2',
						suffix: '%',
						decimals: 0,
						broadcast: true,	// Broadcast messages to other modules
					},

				]
			}
		],
	}
}

Zoals je ziet zitten in beide modules de waarde topic: als deze overeen komen dan werkt de module,

Let op dat bij de MMM-MQTT module Broadcast op true staat.

Nu moeten we nog 1 kleine aanpassing doen aan MMM-MQTT.js in de map MagicMirror/modules/MMM-MQTT rond regel 84 zou je het volgende moeten zien.

this.sendNotification("MQTT_MESSAGE_RECEIVED", payload);

En vervang deze met.

this.sendNotification( payload.topic , payload.value);

Nu zou alles bij de RaspberryPi klaar zijn samen met MagicMirror en is het tijd om de sensor te maken.

Stap 3: De ESP programmeren en verbinden

Sluit de ESP en de Ultrasoon sensoren aan volgens het schema hieronder.

Let Op op de ESP8266 zitten de verbindingen ergens anders!

verbindingds schema:

• HC-SR04(1) VCC > ESP 5V/VCC
• HC-SR04(1) TRIG > ESP D2
• HC-SR04(1) ECHO > ESP D1
• HC-SR04(1) GND > ESP GND
• HC-SR04(2) VCC > ESP 5V/VCC
• HC-SR04(2) TRIG > ESP D4
• HC-SR04(2) ECHO > ESP D3
• HC-SR04(2) GND > ESP GND

Upload de volgende sketch via Arduino IDE. let op vul in bij “Wifi” je eigen WiFi netwerk naam en bij “Password” je WiFi wachtwoord en bij “Local” het Ip-adres van je RaspberryPi.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
// WiFi
const char *ssid = "Wifi"; // Enter your WiFi name
const char *password = "Password";  // Enter WiFi password
// MQTT Broker
const char *mqtt_broker = "Local"; // Enter your WiFi or Ethernet IP
const char *Tank_1 = "Tank_1"; // topic naam van de 1e sensor
const char *Tank_2 = "Tank_2"; // topic naam van de 2e sensor
const int mqtt_port = 1883;
WiFiClient espClient;
PubSubClient client(espClient);
const int echoPin = D1;
const int trigPin = D2;
const int echoPin2 = D3;
const int trigPin2 = D4;
int gemiddelde;
int gemiddelde2;
int tank1;
int tank2;
float duration, distance, count;
float duration2, distance2;

float ultrasoon;
float meter = 100;
float oppervlakte;
float inhoud;
int inhoudL;
float P;
float A;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(trigPin2, OUTPUT);
  pinMode(echoPin2, INPUT);
  Serial.begin(9600);
 
 // connecting to a WiFi network
 WiFi.begin(ssid, password);
   while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.println("Connecting to WiFi..");
 }
 
 Serial.println("Connected to the WiFi network");
 
 //connecting to a mqtt broker
 client.setServer(mqtt_broker, mqtt_port);

 
 while (!client.connected()) {
 String client_id = "esp8266-client-";
 client_id += String(WiFi.macAddress());
 
 Serial.printf("The client %s connects to mosquitto mqtt broker\n", client_id.c_str());
 
 if (client.connect(client_id.c_str())) {
  Serial.println("Public emqx mqtt broker connected");
 } else {
  Serial.print("failed with state ");
  Serial.print(client.state());
  delay(2000);
 }
}
}

void loop() {
  client.loop();
  gemiddelde = 0;
  gemiddelde2 = 0;
  count = 10;
  while(count > 0){
    digitalWrite(trigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
    duration = pulseIn(echoPin, HIGH);
    distance = (duration*.034435)/2;
    gemiddelde = (gemiddelde + distance);
    Serial.println(distance);
    
    digitalWrite(trigPin2, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin2, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin2, LOW);
    duration2 = pulseIn(echoPin2, HIGH);
    distance2 = (duration2*.034435)/2;
    gemiddelde2 = (gemiddelde2 + distance2);
    Serial.println(distance2);
    count = count -1;
  }
  
  gemiddelde = gemiddelde / 10;
  gemiddelde2 = gemiddelde2 / 10;
  if (gemiddelde == 0){
    client.publish(Tank_1, "unavailable");
  }
    else if (gemiddelde > 200){
    client.publish(Tank_1, "unavailable");
  }
  else {
    ultrasoon = gemiddelde;
    ultrasoon = ultrasoon / meter;
    P = 2 - ultrasoon;
    A = acos(1 - P) * 2;
    oppervlakte = 0.5 * (A - sin(A));
    inhoud = oppervlakte / 12.566;
    inhoud = inhoud * 400;
    inhoud = round(inhoud);
    inhoudL = inhoud * 100;
    Serial.print("tank1 ");
    Serial.print(inhoudL);
    Serial.println(" liter");
    client.publish(Tank_1, String(inhoudL).c_str(), true);
  }
  if (gemiddelde2 == 0){
    client.publish(Tank_2, "unavailable");
  }
  else if (gemiddelde2 > 200){
    client.publish(Tank_2, "unavailable");
  }
  else {
    ultrasoon = gemiddelde2;
    ultrasoon = ultrasoon / meter;
    P = 2 - ultrasoon;
    A = acos(1 - P) * 2;
    oppervlakte = 0.5 * (A - sin(A));
    inhoud = oppervlakte / 12.566;
    inhoud = inhoud * 400;
    inhoud = round(inhoud);
    inhoudL = inhoud * 100;
    Serial.print("tank2 ");
    Serial.print(inhoudL);
    Serial.println(" liter");
    client.publish(Tank_2, String(inhoud).c_str(), true);
  }
}

Stap 4: Alles werkt nu als het goed is

Als alles goed is gegaan dan zou er nu iedere seconde een MQTT bericht verstuurt worden naar de RaspberryPi. De RaspberryPi zou deze berichten moeten ontvangen en de juiste iconen moeten laten zien op de MagicMirror. Als dit werkt dan is je Ultrasoon watersensor klaar! 🎉 Gefeliciteerd je hebt zojuist je eigen ultrasone watersensor gemaakt met behulp van een ESP8266, twee ultrasone sensoren en een RaspberryPi met MagicMirror. Ik hoop dat je het leuk vond om deze eenvoudige project te maken en dat het je geïnspireerd heeft om meer projecten te maken met Arduino en andere technologieën.