Installation eines MQTT-Brokers auf dem Raspberry Pi

Um verschiedenste Sensordaten zu sammeln und an andere Applikationen, zum Beispiel FHEM weiterzuleiten ist ein kleiner MQTT-Broker die richtige Wahl. Da er auch nicht sehr viel Performance benötigt, eignet sich dafür ein kleiner Raspberry Pi. Vor allem in Verbindung mit Node-Red, aber dazu mehr in einem anderen Beitrag.

 
Raspberry Pi 3 Model B ARM-Cortex-A53 4x 1,2GHz, 1GB RAM, WLAN, Bluetooth, LAN, 4x USB

Auf dem Pi läßt sich unter Raspbian am einfachsten der MQTT-Broker Mosquitto nutzen und installieren.

Dazu müssen nur folgende Schritte durchgeführt werden:

sudo apt-get update
sudo apt-get install -y mosquitto mosquitto-clients

Nach der Installation läuft der Mosquitto bereits. Hier ein kleiner Test:

mosquitto_sub -h localhost -v -t inTopic

Mit diesem Befehl wird ein MQTT-Subscriber gestartet, der auf Nachrichten im “inTopic”-Kanal hört.

Mit einer zweiten Verbindung zum Raspberry Pi und dem MQTT-Publisher kann man nun eine Nachricht absetzen:

mosquitto_pub -h localhost -t inTopic -m "Hi Mosquitto"

Jetzt sollte das MQTT-Subscriber Fenster die Nachricht “Hi Mosquitto” auf dem Bildschirm anzeigen.

Veröffentlicht unter Raspberry Pi | Verschlagwortet mit , , , | Kommentare deaktiviert für Installation eines MQTT-Brokers auf dem Raspberry Pi

Arduino – Wohnwagen Controlpanel

Nachdem wir unseren Wohnwagen mal wieder ein wenig umgebaut haben, musste natürlich auch ein Controlpanel her, über das wir die meisten Daten angezeigt bekommen. Dafür eignet sich, wie ich herausgefunden habe ein Arduino am besten.

Die 12V Bordspannung, die Kühlschranktemperatur und der Wasserstand im Tank werden in dieser Version überwacht.

Was benötigen wir dafür:

1 x Arduino Mega 2560
1 x TFT 3,5″
1 x Arduino Prototype Shield
1 x Widerstand 15 kΩ
1 x Widerstand 3,75 kΩ
1 x Widerstand 4,7 kΩ
2 x Dallas DS18B20 Temperatursensor (OneWire)
1 x DS1307 I2C real-time clock chip
1 x Relaisplatine
2 x Leiterplattenklemmen

 

 

WW03

 

Hier der Code:

//
//
// Anzeigepanel des Wohnwagens
// Auflösung des Displays 320×240 Pixel
//
// Autor: Jörg Zinsius
// Datum: 20.07.2014
// Version: 0.9
//

/* Includes */

#include <UTFT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <UTouch.h>
#include <UTFT_Buttons.h>
#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>

//
// Deklaration der verwendeten Schriften
//
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t DotMatrix_M[];
extern uint8_t arial_normal[];
extern uint8_t Sinclair_S[];
extern uint8_t Inconsola[];
extern uint8_t Ubuntu[];
extern uint8_t UbuntuBold[];

//
// Initialisierung des Displays
//

UTFT myGLCD(ITDB32S,38,39,40,41);
UTouch myTouch(6,5,4,3,2);
UTFT_Buttons myButtons(&myGLCD, &myTouch);

//
// Initialisierung der Variablen
//

#define ONE_WIRE_BUS 10 /* Digitalport Pin 10 als OneWire definieren */

OneWire ourWire(ONE_WIRE_BUS); /* Ini oneWire instance */

DallasTemperature sensors(&ourWire); /* Dallas Temperature Library für Nutzung der oneWire Library vorbereiten */

const int analogInPinVolt = A3; // Setzen des analogen PINs 3 zur Spannungsmessung
const int analogInPinCLC = A5; // Setzen des analogen PINs 5 für den Füllstandssensors
int m_press;
int Stunde;
int Minute;
int Sekunde;
int Relais4 = 13;
int Relais3 = 12;
int Relais2 = 11;
int Relais1 = 9;
float KuehltempDisp = 0;

void setup()
{
myGLCD.InitLCD();
myGLCD.setFont(Sinclair_S);
myGLCD.clrScr(); // Löschen des Bildschirminhals
sensors.begin(); // Inizialisieren der Dallas Temperature library
analogReference(DEFAULT);
pinMode(Relais4, OUTPUT);
pinMode(Relais3, OUTPUT);
pinMode(Relais2, OUTPUT);
pinMode(Relais1, OUTPUT);
digitalWrite(Relais4, LOW);
digitalWrite(Relais3, LOW);
digitalWrite(Relais2, LOW);
digitalWrite(Relais1, LOW);
adresseAusgeben(); // Adresse der oneWire Devices ausgeben

Serial.begin(9600);
}

void loop()
{

// Messung der Spannungen und Ströme
int sensorVoltValue; // Setzen der Variable für die Spannung
sensorVoltValue = analogRead(analogInPinVolt); // Messen der Spannung
float BatSpannung;
BatSpannung = (sensorVoltValue / 1023.0) * 25; // Berechnung der variablen Batteriespannung

sensors.requestTemperatures(); // Temperaturen der Dallas abfragen
KuehltempDisp = sensors.getTempCByIndex(0); // Setzen der Displayvariablen zur Ausrichtung

// Füllstand des Wassertanks ermitteln
int sensorCLCValue; // Setzen der Variablen für den Füllstand
sensorCLCValue = analogRead(analogInPinCLC); // Messen des Füllstands am Port 2
sensorCLCValue = sensorCLCValue + 200;

// Setzen der Defaultfarben

myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(0, 0, 0);

/* Anzeigen der Spannung */
/* Einstellung des Abstands für die Batterie im Display */
int DisplayZehnerStelleVolt;
if (BatSpannung < 10)
DisplayZehnerStelleVolt = 36;
else
DisplayZehnerStelleVolt = 20;

myGLCD.setFont(Sinclair_S);
myGLCD.print(„Batterie“, 40,15);
myGLCD.drawRect(15, 7, 30, 10);
myGLCD.drawRect(110, 7, 125, 10);
myGLCD.drawRect(10,10,130,60);
myGLCD.setFont(DotMatrix_M);
if (BatSpannung > 12.95){ myGLCD.setColor(VGA_LIME);}
if (BatSpannung < 12.74){ myGLCD.setColor(VGA_GREEN);}
if (BatSpannung < 12.54){ myGLCD.setColor(VGA_YELLOW);}
if (BatSpannung < 12.24){ myGLCD.setColor(VGA_RED);}
myGLCD.printNumF(BatSpannung, 2, DisplayZehnerStelleVolt, 35);
myGLCD.print(„V“, 104, 35);

/********************************************************/
/* */
/* Anzeige der Temperaturen */
/* */
/********************************************************/
myGLCD.setColor(255,255,255);
myGLCD.drawRoundRect(10, 80, 130, 200);
myGLCD.setFont(Sinclair_S);
myGLCD.print(„Temperatur“, 33,90);
myGLCD.print(„Kuehlschrank“, 24,100);

myGLCD.setFont(DotMatrix_M);
int DisplayZehnerStelleTemp;
float KTemp;
KTemp = sensors.getTempCByIndex(0);
KTemp = KTemp – 5;
if (KTemp < 10)
DisplayZehnerStelleTemp = 46;
else
DisplayZehnerStelleTemp = 30;
if (KTemp > 5.0){
myGLCD.setColor(VGA_RED);
digitalWrite(Relais1, LOW);
}
if (KTemp < 4.5){
digitalWrite(Relais1, HIGH); }
if (KTemp < 10.0)
{
myGLCD.setColor(VGA_LIME);
}

int AussenTemp;
AussenTemp = sensors.getTempCByIndex(1);
int AussenZehnerStelleDisp;
if (AussenTemp < 10)
AussenZehnerStelleDisp = 46;
else
AussenZehnerStelleDisp = 30;
myGLCD.printNumF(KTemp, 1, DisplayZehnerStelleTemp, 115);
myGLCD.print(„C“, 98, 115);
myGLCD.setFont(Sinclair_S);
myGLCD.setColor(255, 255, 255);
myGLCD.print(„Temperatur“, 33,145);
myGLCD.print(„Aussen“, 40,155);
myGLCD.setFont(DotMatrix_M);
myGLCD.printNumF(sensors.getTempCByIndex(1), 1, AussenZehnerStelleDisp, 165);
myGLCD.print(„C“, 98, 165);

/********************************************************/
/* */
/* Anzeige des Wasserstands */
/* */
/********************************************************/

myGLCD.drawRoundRect(170, 100, 285, 200);
myGLCD.setFont(Sinclair_S);
int FuellstandDisp;
int AktFuellstand;
// Einteilung für die Anzeige

if (sensorCLCValue < 340) {AktFuellstand = 5;}
if (sensorCLCValue > 370) {AktFuellstand = 10;}
if (sensorCLCValue > 401) {AktFuellstand = 25;}
if (sensorCLCValue > 600) {AktFuellstand = 50;}
if (sensorCLCValue > 700) {AktFuellstand = 75;}
if (sensorCLCValue > 780) {AktFuellstand = 100;}
FuellstandDisp = 200 – (int)(AktFuellstand + .5);
/* Änderung der Farben je nach Wasserstand */
if (AktFuellstand < 100) {
myGLCD.setColor(50,205,5);

}
if (AktFuellstand < 50) {
myGLCD.setColor(255,255,0);

}
if (AktFuellstand < 30) {
myGLCD.setColor(255,0,0);
}
myGLCD.fillRoundRect(171,199,284,FuellstandDisp);
myGLCD.setFont(Sinclair_S);
myGLCD.setColor(255, 255, 255);
myGLCD.print(„Wasserstand“, 185,85);
myGLCD.setFont(DotMatrix_M);
myGLCD.setColor(255,255,255);
int DisplayProzentWasser = 0;
if (AktFuellstand < 10) {DisplayProzentWasser = 212;}
if (AktFuellstand >= 10) {DisplayProzentWasser = 196;}
if (AktFuellstand > 100) {DisplayProzentWasser = 180;}
myGLCD.printNumF(AktFuellstand, 0, DisplayProzentWasser, 120);
myGLCD.print(„%“, 260, 120);
// Uhr

tmElements_t tm;
int StundenDisp;
myGLCD.setFont(Sinclair_S);
myGLCD.print(„UHRZEIT“, 205,20);
myGLCD.setFont(DotMatrix_M);
if (RTC.read(tm))
{
Stunde = tm.Hour;
if (Stunde < 10)
{ StundenDisp = 186;
myGLCD.print(„0“, 170,30);
}
if (Stunde >= 10) {StundenDisp = 170;}
myGLCD.printNumI(Stunde, StundenDisp, 30);
myGLCD.printNumI(Stunde, StundenDisp, 30);

myGLCD.print(„:“, 202,30);
int MinutenDisp;
Minute = tm.Minute;
if (Minute < 10)
{ MinutenDisp = 234;
myGLCD.print(„0“, 218, 30);
}
if (Minute >= 10) {MinutenDisp = 218;}
myGLCD.printNumI(Minute, MinutenDisp, 30);
myGLCD.print(„:“, 250,30);
int SekundenDisp;
Sekunde = tm.Second;
if (Sekunde < 10)
{ SekundenDisp = 282;
myGLCD.print(„0“, 266, 30);
}
if (Sekunde >= 10) {SekundenDisp = 266;}
myGLCD.printNumI(Sekunde, SekundenDisp, 30);
}
// delay (10000);
}

void adresseAusgeben(void) {
byte i;
byte present = 0;
byte data[12];
byte addr[8];

Serial.print(„Suche 1-Wire-Devices…\n\r“);// „\n\r“ is NewLine
while(ourWire.search(addr)) {
Serial.print(„\n\r\n\r1-Wire-Device gefunden mit Adresse:\n\r“);
for( i = 0; i < 8; i++) {
Serial.print(„0x“);
if (addr[i] < 16) {
Serial.print(‚0‘);
}
Serial.print(addr[i], HEX);
if (i < 7) {
Serial.print(„, „);
}
}
if ( OneWire::crc8( addr, 7) != addr[7]) {
Serial.print(„CRC is not valid!\n\r“);
return;
}
}
Serial.println();
ourWire.reset_search();
return;
}

Downloads: Wohnwagenboard.ino

Veröffentlicht unter Arduino | Kommentare deaktiviert für Arduino – Wohnwagen Controlpanel