LUG-Saar Wiki

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Luftsensor wird smart ======

---- datatemplateentry project ----
template        : templates:project
# Kurzer Name des Projekts
name            : 

# Bilddateiname relativ zum Ordner projekte:
# Wenn (noch) kein Bild vorhanden, bitte none.png lassen
imgname_img90   : none.png

# Links zu Seiten der Mitglieder, die am Projekt beteiligt sind, also intern:mitglieder:hubert (mehrere mit Komma getrennt)
person_pages    : 

# Start- und Enddatum im Format JJJJ-MM-TT
start_dt        : 2021-12
end_dt          : 2022-01

# Aktueller Status des Projekts, z.B. fertig, in Arbeit, eingestellt, Idee, ...
status_         : fertig
----


<markdown>

## Was ist das Ziel?

Der Luftsensor *VINDRIKTNING* des schwedischen Möbelhauses IKEA ist aktuell in der Maker-Szene in aller Munde. Der [Bericht](https://www.heise.de/ratgeber/Ikea-Feinstaubsensor-Vindriktning-zum-IoT-Device-aufbohren-6164149.html) in der c't Make 5/2021 zeigt wie der Sensor zu einem IoT-Device umgebaut werden kann. Dabei sollen die eigentlichen Messwerte des Sensors ausglesen werden um diese anschließend bspw. im SmartHome zur Verfügung zu stellen. Von Haus aus leuchtet der Sensor auf der Vorderseite lediglich in den Ampelfarben grün, gelb und rot. Daduch zeigt er dem Benutzer in der Umgebung an, wie es sich um die Luftqualität im Raum stellt. Gleichzeitig sendet der Sensor den genauen Messwert über eine Serielle Schnittstelle intern auf der Platine hin und her (siehe c't Make 05/2021). 
Ziel dieses kleinen "Hacks" ist es nun diese Schnittstelle dazu zu nutzen, die Messwerte auszulesen und im eigenen Netzwerk zur Verfügung zu stellen. WiFi fähige Mikrocontroller der ESP-Serie (ESP8266/ESP32) bieten sich hierzu herforragend an. Die Mikrocontroller dieser Serie verfügen über einen integrierten TCP/IP Stack wodurch typische IoT-Protokolle wie MQTT möglich werden. 


## Firmware

Natürlich können wir die ESP Mikrocontroller von hand zu fuß programmieren. Die Arduino-IDE ist dafür eine mögliche Wahl, welche gleich fertige Bibliotheken für die entsprechenden Varianten der ESP Serie mit sich bringt. Man kann aber auch auf fertige Firmware der Community zurückgreifen. Das hat den Vorteil, dass es viele Softwarelösungen bereits gibt, welche mit allerhand SmartHome kommunizieren können. Darüber hinaus müssen wir nicht in die Tiefe der Mikrocontroller Programmierung im ersten moment einsteigen.  

### Tasmota 

Tasmota ist eine durch die Community entwickelte Open-Source-Firmware vorrangig für ESP-Geräte. Dabei liegt der Fokus auf einer möglichst lokalen (privaten) Steuerung der mit Tasmota betriebenen Geräte. Durch ein breites Portfolion an vordefinierten Templates (mit Sensoren-, Display- und Devicetreibern) lässt sich Tasmota recht schnell Einrichten und auch Aktualisieren. Eine Steuerung kann über MQTT, Web UI, HTTP oder seriell erfolgen, was eine einfache Integration in Hausautomatisierungslösungen ermöglicht.  


### ESPTools

Wie man ESPTool für den Tasmota-Upload einrichtet und konfiguriert zeigt die [Dokumentation](https://docs.espressif.com/projects/esptool/en/latest/esp32/) des Herstellers im Detail. An dieser Stelle zeigen wir lediglich die wichtigsten Schritte, um ein ESP-Board mit Tasmota zu flashen. Dabei beziehen sich die folgenden Informationen auf die Python-Variante.

* ESPTool manuell aus den Quellen installieren

    1. ESPTool herunterladen

        Wenn Sie keine installierte Kopie von Python 2.x oder 3.x haben, laden Sie es von https://www.python.org/ herunter und installieren Sie es.

    2. ESPTool installieren

        * **ESPTool manuell aus den Quellen installieren**
            
            Das ESPTool kann manuell aus den Quellen installiert werden, dazu laden Sie sich die ESPTool-Quellcode von https://github.com/espressif/esptool/releases in     einen beliebigen Ordner herunter. Wechseln Sie in diesen Ordner und installieren Sie Esptool mit dem Befehl:

            ``` 
            python setup.py install
            ```

        * **ESPTool über die Paketverwaltung installieren**
    
            Das ESPTool befindet sich bei vielen Linux Distributionen bereits in den Paketquellen und kann über diese installiert werden. Für Debian,               Ubuntu sowie dere Derivate kann mit:
    
         
             ```
             lug@linux:~$ sudo apt-get install esptool
             [sudo] Passwort für lug: 
             Paketlisten werden gelesen... Fertig
             Abhängigkeitsbaum wird aufgebaut.       
             Statusinformationen werden eingelesen.... Fertig
             Die folgenden zusätzlichen Pakete werden installiert:
             python3-ecdsa python3-pyaes
             Die folgenden NEUEN Pakete werden installiert:
             esptool python3-ecdsa python3-pyaes
             0 aktualisiert, 3 neu installiert, 0 zu entfernen und 0 nicht aktualisiert.
             Es müssen 154 kB an Archiven heruntergeladen werden.
             lug@linux:~$
             ```
         
            das entsprechende Paket installiert werden. 
    
        * **ESPTool über "Paket Installer für Python" (kurz: pip) installieren**

            Einen weiteren konfortablen Weg das ESPTool zu installieren bietet der       "Paket Installer für Python". Gegenüber einer Installation aus den             Paketquellen hat das den Vorteil, das wir immer möglichst aktuelle                   Versionen des Tools bekommen. Dazu einfach als user den folgenden Befehl:
            

            ```
            pip install –upgrade esptool
            ```

            in der Kommandozeile ausführen. Wenn der Befehl mit Root Rechten ausgeführt, werden die erforderlichen Bibliotheken von "pip" systemweit installiert.
            
    3. Benutzerrechte Kontrollieren

       Mit dem Befehl "id" kann geprüft werden, ob der Benutzer in der Gruppe "dialout"   ist. Dies ist erforderlich, damit das ESPTool korrekt auf die Serielle Schnittstelle zugreifen kann. Ohne die entsprechende Berechtigung kann der ESP als User nicht programmiert werden, lediglich wenn das ESPTool als Root ausgeführt wird. Das Ausführen als Root sollte aber wenn möglich immer vermieden werden.
       Je nach Variante der Linux Distribution kann der Name der Gruppe variieren (bspw. serial, etc.). In diesem Fall muss der User natürlich einer anderen Gruppe hinzugefügt werden. 

        ```
        lug@linux:~$ id
        uid=1000(lug) gid=1000(lug) Gruppen=1000(lug),4(adm),5(tty),10(uucp),20(dialout),24(cdrom),27(sudo),30(dip),46(plugdev),118(lpadmin),128(sambashare)
        lug@linux:~$
        ```

### Tasmota Firmware flashen

Bevor wir die eigentliche Tasmota Firmware auf ein ESP8266 Board flashen können, müssen wir dafür sorgen das keine Firmware auf dem ESP vorhanden ist. Dazu verbinden wir das ESP-Modul (in unserem Fall ein WemosD1mini) per USB mit dem Rechner. Mit dem im unteren Listing aufgeführten Befehlt löschen wir den Speicher des ESP-Moduls. 


```
lug@linux:~$ esptool.py --port /dev/ttyUSB0 erase_flash
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: e0:98:06:xx:xx:xx
Enabling default SPI flash mode...
Erasing flash (this may take a while)...
lug@linux:~$
```

Wenn der Speicher des ESPs gelöscht ist, können wir mit dem eigentlichen flashen einer Tasmota Firmware beginnen. Wie im oberen Abschnitt erwähnt gibt es viele vorkonfigurierte Tasmota Varianten welche bspw. typsiche Display anzusteuern. Tasmota kann aber auch auf den ein oder anderen fertigen smarten Steckdosen betrieben werden. In unserem Fall gibt eine fertige Tasmota Firmware aus den [unofficial](https://github.com/tasmota/install/tree/main/firmware/unofficial) Bereich. In der Binärdatei [tasmota-allsensors.bin](https://github.com/tasmota/install/blob/main/firmware/unofficial/tasmota-allsensors.bin) ist der IKEA Leuftsensor VINDRIKTNING schon vorkonfiguriert und muss bspw. in das Download Verzeichnis heruntergeladen werden. Diese Binärdatei können wir dann mit dem folgenden Befehl auf das ESP-Modul flashen:


```
lug@linux:~$ --port /dev/ttyUSB0 write_flash -fs 1MB -fm dout 0x0 Downloads/tasmota-allsensors.bin
```


## Konfiguration

Nachdem wir erfolgreich Tasmota auf das ESP-Modul geflasht haben, können wir mit der Konfiguration beginnen. Dazu startet der ESP initial im Access Point Modus (AP-Modul). Wir scanen die Umgebung nach WiFi Verbindungen und verbinden uns mit dem offenen W-Lan "tasmota-XYXYXY-XYXY". Das Tasmota Modul hat die Standard IP-Adresse *192.168.4.1* und kann über eine Weboberfläche im Browser für die erste Konfiguration darüber aufgerufen werden. Im ersten Schritt müssen wir das Tasmota Modul dann mit unserem WiFi verbinden. Dazu einfach bei der initialen Konfiguration das entsprechende W-Lan auswählen, das Passwort eintippen und speichern.

![](https://codimd.cloud.nerdraum.de/uploads/842a5d4451e89c3259c33e900.jpg)

An dieser Stelle einfach ganz kurz warten, in der Weboberfläche bekommen wir nach einem erfolgreichen Verbindungsaufbau mit unserem eigenen W-Lan die neue IP-Adresse des Moduls angezeigt. Sind wir an dieser Stelle zu ungeduldig können wir as Netz natürlich auch manuel nach neuen Geräten scannen oder im DHCP-Server unseres Routers nachschauen. 

![](https://codimd.cloud.nerdraum.de/uploads/842a5d4451e89c3259c33e901.jpg)

Über die neu vergebene IP-Adresse können wir dann mit der weiteren Konfiguration forfahren. Dazu einfach die entsprechne IP aus dem eigenen Netzwerk im Browser wie gewohnt aufrufen. Um das Modul für unseren Ikea Sensor vorzubereiten wechseln wir in den Bereich "*Configure Modul*". Dort wählen wir dann bspw. den Modul Typ "*Generic (18)*" aus und speichern das ganze. Ist der Modul Typ eingestellt, wählen wir unter dem gleichen Menüpunkt die Paramter für den GPIO Pin aus. Dabei stellen wir den GPIO (bspw. D2 GPIO4) auf den Modus "*VINDRIKTNING*" und speichern das ganze. 

![](https://codimd.cloud.nerdraum.de/uploads/842a5d4451e89c3259c33e902.jpg)


Das Tasmota Modul führt einen Neustart durch und zeigt auf dem Startbildschirm der Weboberfläche die Sensorwerte an, sofern unser Sensor hardwareseitig Richtig angeschlossen ist. 


![](https://codimd.cloud.nerdraum.de/uploads/842a5d4451e89c3259c33e903.jpg)


----
## Quellen:

https://tasmota.github.io/docs/
https://tasmota.github.io/docs/Integrations/
https://ota.tasmota.com/tasmota/release/


</markdown>