Added some posts, Readme update

.vscode/settings.json

@@ -20,6 +20,7 @@
     "markdown",
   ],
   "cSpell.words": [
+    "Adminoberfläche",
     "Antippen",
     "Arduinos",
     "giscus",
@@ -35,6 +36,7 @@
     "sysinfo",
     "Tachosignal",
     "Traco",
+    "Umschlüsselung",
     "webp"
   ],
 }

README.md

@@ -305,6 +305,7 @@ Als weitere Argumente kann ein Titel für das Bild angegeben werden.
 
 Zusätzliche optionale Argumente sind mit einem Prefix versehen:
 
+* `thumb:...` - Thumbnail Bild, welches direkt im Beitrag eingebunden wird. Bei Angabe von `thumb:` ohne Dateiname wird dem Dateinamen des originalen Bildes vor der Endung `-thumb` hinzugefügt.
 * `group:abc` - Gruppenname/Gruppen-ID zur Gruppierung mehrere Bilder in einem Beitrag. (Standardmäßig der Slug des Beitrags.)
 * `type:video` - Typ der einzubindenden Medien, wenn es kein Bild ist. (`video`, `iframe`, `ajax`)
 * `maxwidth:300px` - Maximale Breite in der Lightbox-Ansicht.

posts/homepi-einbindung-von-mqtt-in-iobroker.md

@@ -0,0 +1,74 @@
+---
+title: Projekt HomePi – Einbindung von MQTT in ioBroker
+author:
+  name: Peter Müller
+  link: https://crycode.de
+banner: banner.webp
+date: 2019-09-22 12:00:00
+updated: 2024-04-18 16:10:00
+categories:
+  - [HomePi]
+  - [ioBroker]
+tags:
+  - ioBroker
+  - HomePi
+  - MQTT
+abbr:
+  MQTT: Message Queuing Telemetry Transport
+  IoT: Internet of Things
+---
+
+MQTT (Message Queuing Telemetry Transport) ist ein recht einfaches und gerade im {% abbr IoT %} Bereich verbreitetes Protokoll für die Übermittlung von Nachrichten zwischen verschiedenen Endgeräten.
+
+Dieser Beitrag beschreibt die Einbindung von MQTT in ioBroker zum Senden und Empfangen von Nachrichten.
+
+<!-- more -->
+
+Die [Installation des MQTT Brokers Mosca](/homepi-mqtt-broker-mosca) habe ich bereits in einem anderen Beitrag beschrieben.
+
+## Installation des MQTT Adapters
+
+Als erstes installieren wir den Adapter [MQTT Broker/Client](https://github.com/ioBroker/ioBroker.mqtt) über die Administrationsoberfläche von ioBroker. Auch wenn wir nur den Client benötigen empfehle ich trotzdem diesen Adapter, da er deutlich aktueller ist als der ebenfalls verfügbare Adapter MQTT Client.
+
+{% grid 2 %}
+{% img mqtt-adapter-suche.webp thumb: Suche nach dem MQTT Adapter in ioBroker %}
+{% img mqtt-adapter-install.webp thumb: Installation vom MQTT Adapter in ioBroker %}
+{% endgrid %}
+
+Nach der Installation öffnet sich wie gewohnt direkt wieder die Konfigurationsseite der Adapterinstanz.
+
+Hier wählen wir im Reiter *Verbindung* als Typ *Client/subscriber* aus und tragen die IP-Adresse und den Port unseres MQTT Brokers, sowie den Benutzernamen und das Passwort für die Verbindung ein.
+
+Im Reiter *Client Settings* sollte bei *Subscribe patterns* eine Liste der zu empfangenden Topics eingetragen werden. Die *Client ID* ist in den meisten Fällen gleich dem Benutzernamen für den Login.
+
+Unter *MQTT Einstellungen* empfehle ich zudem die *Maske zum Bekanntgeben eigener States* so anzupassen, dass nur die States gesendet werden, die man auch wirklich senden möchte. Zumindest sollte dies auf `mqtt.0.*` beschränkt werden, da sonst alle ioBroker States bei Veränderungen gesendet werden.
+
+{% grid 3 %}
+{% img mqtt-adapter-einstellungen-1.webp thumb: Adaptereinstellungen Reiter Verbindung %}
+{% img mqtt-adapter-einstellungen-2.webp thumb: Adaptereinstellungen Reiter Client Settings %}
+{% img mqtt-adapter-einstellungen-3.webp thumb: Adaptereinstellungen Reiter MQTT Einstellungen %}
+{% endgrid %}
+
+Diese Einstellungen bestätigen wir mit *Speichern und Schließen*.
+
+Anschließend kann die Adapterinstanz mit einem Klick auf den noch roten Start-Button gestartet werden. Kurz darauf sollte der Punkt vor der Instanz grün werden, was eine erfolgreiche Verbindung zum MQTT Broker anzeigt.
+
+{% grid 2 %}
+{% img mqtt-adapter-start-1.webp thumb: Adapter starten %}
+{% img mqtt-adapter-start-2.webp thumb: Adapter gestartet und verbunden %}
+{% endgrid %}
+
+## MQTT Objekte in ioBroker
+
+Für alle empfangenen Topics legt der MQTT Adapter automatisch Objekte innerhalb der Adapterinstanz an.
+
+**Beispiel:** Für die Topic `esp-stall/sensor/0/value` wird das Objekt `mqtt.0.esp-stall.sensor.0.value` angelegt und der empfangene Wert wird in den aktuellen State dieses Objektes geschrieben.
+
+{% img mqtt-adapter-states.webp thumb: ioBroker States vom MQTT Adapter %}
+
+Beim Senden eines geänderten States erfolgt diese Umschlüsselung genau entgegengesetzt. Aus dem State für `mqtt.0.esp-stall.switch.light.set` wird die Topic `esp-stall/switch/light/set` mit dem entsprechenden Wert aus dem State.
+
+Zusätzlich zu den automatisch angelegten Objekten können auch eigene Objekte manuell erstellt werden. Ebenso ist es möglich die automatisch erzeugten Objekte nachträglich nach den eigenen Bedürfnissen anzupassen.
+
+> [!NOTE]
+> Zum Erstellen und Anpassen der States unter `mqtt.0.*` muss gegebenenfalls der Expertenmodus in der Adminoberfläche aktiviert werden.

posts/homepi-iobroker-gpios.md

@@ -0,0 +1,65 @@
+---
+title: Projekt HomePi – ioBroker GPIOs
+author:
+  name: Peter Müller
+  link: https://crycode.de
+banner: banner.webp
+date: 2019-09-20 12:00:00
+updated: 2024-04-18 17:30:00
+categories:
+  - [HomePi]
+  - [ioBroker]
+tags:
+  - GPIO
+  - Raspberry Pi
+  - HomePi
+  - ioBroker
+abbr:
+  GPIO: General Purpose Input Output
+---
+
+Betreibt man ioBroker auf einem Raspberry Pi, dann möchte man sicherlich auch die {% abbr GPIO %}s nutzen.
+
+Dieser Beitrag beschreibt die Installation und Einrichtung des RPI-Monitor Adapters, welcher den Zugriff auf einzelne (oder alle) {% abbr GPIO %}s des Raspberry Pi ermöglicht.
+
+## Installation des RPI-Monitor Adapters
+
+Die Installation des Adapters [RPI-Monitor (rpi2)](https://github.com/iobroker-community-adapters/ioBroker.rpi2) erfolgt wie gewohnt über die Administrationsoberfläche von ioBroker.
+
+{% grid 2 %}
+{% img rpi2-adapter-suche.webp thumb: Suche nach dem RPI-Monitor Adapter in ioBroker %}
+{% img rpi2-adapter-install.webp thumb: Installation vom RPI-Monitor Adapter in ioBroker %}
+{% endgrid %}
+
+Nach der Installation öffnet sich die Adapterkonfiguration, in der wir die gewünschten Funktionen einzeln aktivieren und deaktivieren können.
+
+{% img rpi2-adapter-haupteinstellungen.webp thumb: Haupteinstellungen vom RPI-Monitor Adapter %}
+
+> [!NOTE]
+> Nicht benötigte Funktionen sollten hier deaktiviert werden, um Ressourcen zu sparen.  
+> Wer nur die GPIOs verwenden möchte, der kann getrost alle anderen Funktionen deaktivieren.
+
+## GPIOs
+
+Für die Verwaltung der {% abbr GPIO %}s gibt es in der Adapterkonfiguration einen extra Reiter.  
+Hier kann jeder {% abbr GPIO %} einzeln aktiviert und seine Richtung (Eingang oder Ausgang) festgelegt werden. Die {% abbr GPIO %}-Nummerierung richtet sich dabei nach den BCM-Nummern der {% abbr GPIO %}s.  
+Zudem können bestimmte Sonderfunktionen ausgewählt werden.
+
+{% img rpi2-adapter-gpios.webp thumb: GPIO-Einstellungen vom RPI-Monitor Adapter %}
+
+Beim Speichern werden die {% abbr GPIO %}s dann entsprechend der Konfiguration eingerichtet und die zugehörigen Objekte erstellt.
+
+{% img rpi2-adapter-states.webp thumb: ioBroker States vom RPI-Monitor Adapter %}
+
+Der aktuelle Zustand des {% abbr GPIO %} 2 ist damit dann immer über die Objekt-ID rpi2.0.gpio.2.state verfügbar.
+
+## Hinweise zum Multihost
+
+Betreibt man seinen ioBroker nicht auf einem Raspberry Pi, möchte aber einen Raspberry Pi im **lokalen** Netzwerk in diesen mit einbinden, so kann man ioBroker im [Multihost](https://www.iobroker.net/#de/documentation/config/multihost.md) Modus betreiben, wobei der Raspberry Pi dann ein *Slave*-Host ist.
+
+Der Slave-Host ist zudem deutlich sparsamer in Bezug auf die benötigten Systemressourcen und somit optimal für einen Raspberry Pi geeignet.
+
+Der RPI-Monitor Adapter ist dabei dann auf dem Slave-Host zu installieren, damit er auf dem Raspberry Pi ausgeführt wird.  
+Alle States und damit auch die {% abbr GPIO %}s sind dann im gesamten ioBroker verfügbar.
+
+Weiterhin ist es möglich mehrere Raspberry Pi als Slave-Host einzubinden und somit zu steuern.

posts/neue-webseite-2024.md

@@ -53,7 +53,7 @@ Die Suche findet dabei vollkommen clientseitig im Browser statt, wodurch keine D
 
 ### Geringe Datengröße der Seite
 
-Die Startseite ist aktuell lediglich circa 250 kB groß, wobei die vom Server zu ladende Datenmenge dank Komprimierung bei lediglich etwa 150 kB liegt. (Im Vergleich dazu lag die alte Startseite bei rund 900 kB.)
+Die Startseite ist aktuell lediglich circa 300 kB groß, wobei die vom Server zu ladende Datenmenge dank Komprimierung bei lediglich etwa 150 kB liegt. (Im Vergleich dazu lag die alte Startseite bei rund 900 kB.)
 
 ### Sehr schnelle Ladezeiten
 

posts/radiohead-serial-radio-gateway.md

@@ -0,0 +1,62 @@
+---
+title: RadioHead Serial-Radio-Gateway
+author:
+  name: Peter Müller
+  link: https://crycode.de
+banner: banner.webp
+date: 2020-05-16 12:00:00
+updated: 2024-04-18 13:00:00
+categories:
+  - [Mikrocontroller]
+  - [Elektronik]
+tags:
+  - Arduino
+  - Elektronik
+  - Hardware
+  - RadioHead
+---
+
+Da in diversen Projekten und Beschreibungen von mir immer wieder von einem *Serial-Radio-Gateway* (oder auch Radio-Serial-Gateway) für das [RadioHead](http://www.airspayce.com/mikem/arduino/RadioHead/)-Protokoll die Rede ist, möchte ich dieses Gateway hier kurz beschreiben.
+
+<!-- more -->
+
+## Was ist ein Gateway?
+
+Allgemein gesagt ist ein Gateway eine Komponente aus Hardware und/oder Software, welche zwei Systeme miteinander verbindet.
+
+In diesem Fall stellt das Gateway die Verbindung zwischen dem 433&nbsp;MHz Funk und einer seriellen Schnittstelle her. Das RadioHead-Protokoll wird dabei beibehalten. Dadurch wird es sehr einfach möglich, den RadioHead 433&nbsp;MHz Funk von diversen Mikrocontrollern an einen PC oder Raspberry Pi anzubinden.
+
+## Hardware
+
+Die Hardware ist sehr einfach. Als Basis nehmen wir einen Arduino Nano (oder einen anderen Arduino mit USB-Schnittstelle) und schließen an diesen je einen 433&nbsp;MHz Funkempfänger und Funksender an. Dabei wird VCC der Module auf +5&nbsp;V des Arduinos und GND der Module auf GND vom Arduino verbunden. Die Data-Leitung des Empfängers kommt an D2 und die des Senders an D4 beim Arduino.
+
+{% img aufbau.webp thumb: Aufbau der Hardware auf einem Steckbrett %}
+
+Fertig!
+
+> [!NOTE]
+> Ich empfehle bei den Funkmodulen zumindest für den Empfänger Module vom Typ *Superheterodyne* oder *3400RF* zu verwenden, da diese deutlich höhere Reichweiten als die günstigeren *XY-MK-5V* ermöglichen.
+
+## Software
+
+Die Software für den Arduino ist ähnlich simpel. Hier muss nur in der Arduino IDE die RadioHead Bibliothek hinzugefügt werden (wenn nicht schon gesehen) und der folgende Sketch, den ich größtenteils aus den [original RadioHead Beispielen](http://www.airspayce.com/mikem/arduino/RadioHead/examples.html) entnommen habe, auf den Arduino geladen werden:
+
+{% codefile cpp radio-serial-gateway.ino Arduino Sketch für das Serial-Radio Gateway %}
+
+Damit ist dann das Serial-Radio-Gateway auch schon fertig und einsatzbereit. 🙂
+
+## Funktionsweise
+
+Der als Gateway fungierende Arduino empfängt sowohl über den 433&nbsp;MHz Funk, als auch über die serielle Schnittstelle die RadioHead Datenpakete für beliebige Adressen (Promiscuous-Mode) und sendet diese anschließend wieder über die jeweils andere Schnittstelle. Dabei werden die Headerdaten und der Inhalt der Datenpakete eins zu eins übernommen.
+
+Somit wird jede über den Funk empfangene Nachricht an die serielle Schnittstelle und jede über seriell empfange Nachricht per Funk weitergeleitet.
+
+## Verarbeitung der Daten am PC / Raspberry Pi
+
+Die vom Gateway an den PC oder Raspberry Pi weitergeleiteten Daten können hier nicht direkt in einem Terminal oder seriellen Monitor angezeigt werden, da es sich quasi um Binärdaten des RadioHead-Protokolls handelt. Versuche die Daten beispielsweise im seriellen Monitor der Arduino IDE anzuzeigen resultieren nur in wirren Zeichen. Das ist Ok so!
+
+Zur weiteren Verarbeitung der Daten muss die Software das RadioHead-Protokoll, genauer gesagt `RH_Serial`, verstehen können.
+
+Hierzu habe ich für [Node.js](https://nodejs.org/de/) das Modul [radiohead-serial](https://www.npmjs.com/package/radiohead-serial) erstellt, welches das RadioHead-Protokoll mit `RH_Serial` in Node.js umsetzt. Auf diesem Modul basierend habe ich zudem für **ioBroker** den Adapter [ioBroker.radiohead](https://github.com/crycode-de/ioBroker.radiohead) erstellt, wodurch RadioHead relativ einfach in diese Heimautomatisierung eingebunden werden kann.
+
+Für Anwendungen in C/C++ können direkt die RadioHead Quellen genutzt werden, um `RH_Serial` zu integrieren.

posts/radiohead-serial-radio-gateway/radio-serial-gateway.ino

@@ -0,0 +1,58 @@
+#include <SPI.h>
+#include <RH_ASK.h>
+#include <RH_Serial.h>
+#include <RHReliableDatagram.h>
+
+RH_ASK radio(2000, 2, 4);
+
+RH_Serial serial(Serial);
+
+void setup()
+{
+  Serial.begin(9600);
+  if (!radio.init())
+    Serial.println("radio init failed");
+
+  radio.setPromiscuous(true);
+
+  if (!serial.init())
+    Serial.println("serial init failed");
+
+  serial.setPromiscuous(true);
+
+}
+
+uint8_t buf[RH_SERIAL_MAX_MESSAGE_LEN];
+
+void loop()
+{
+  if (radio.available())
+  {
+    uint8_t len = sizeof(buf);
+    radio.recv(buf, &len);
+
+    serial.setHeaderTo(radio.headerTo());
+    serial.setHeaderFrom(radio.headerFrom());
+    serial.setHeaderId(radio.headerId());
+    serial.setHeaderFlags(radio.headerFlags(), 0xFF);
+    serial.send(buf, len);
+  }
+
+  if (serial.available())
+  {
+    uint8_t len = sizeof(buf);
+    serial.recv(buf, &len);
+
+    // Optional: Nachrichten nach Adresse filtern
+    // Kommentar vor den folgenden Zeilen entfernen, um nur Nachrichten an Adressen 0xC0 oder höher weiterzuleiten.
+    // if(serial.headerTo() < 0xC0){
+    //  return;
+    // }
+
+    radio.setHeaderTo(serial.headerTo());
+    radio.setHeaderFrom(serial.headerFrom());
+    radio.setHeaderId(serial.headerId());
+    radio.setHeaderFlags(serial.headerFlags(), 0xFF);
+    radio.send(buf, len);
+  }
+}