Nachdem ich feststellen musste, dass meine Power Bank beim Betrieb eines WeMosD1 oder Nodemcuv2 nach ca. 10 sec abschaltet, hatte ich die Motivation mir etwas einfallen lassen. Im Internet findet man einige Schaltungen zu dem Thema, jedoch hatte ich keine Lust, mir so viele Bauteile zu bestellen. Da ich noch einen Digispark Rev3 USB Mikrokontroller rumliegen hatte probierte ich verschiedene Setups aus. Das Ergebnis zeige ich hier in meinem Blog Post.

Ich bin noch am überlegen ob ich das WLAN in den DeepSleep Mode setze und der DigiSpark mir den WeMosD1 oder NodemcuV2 wieder aufweckt nach einer gewissen Zeit. Dadurch würde ich wieder einiges an Stromverbrauch sparen. Dafür müsste ich dann aber den Mikrokontroller alle 15 Sekunden aus dem DeepSleep holen damit die Stromaufnahme wieder über den 100mA liegen. Ich werde weiter experimentieren und berichten.

Benötigte Hardware

Benötigte Software

  • Arduino IDE
  • ATTinyCore library
  • PrusaSlicer

3D Gehäuse Tinkercad

Aufbau Digispark WeMosD1 Adapter

Die meisten Power Banks benötigen einen Zyklischen Strom von 100mA alle 15 Sekunden für eine Dauer von ca. 2 Sekunden. Mit der Kombination aus Digispark und einem WeMos D1 komme ich auf einen Stromverbrauch von 101mA und wenn die LED Zyklisch geschalten wird 104mA für die 2 Sekunden. Natürlich sind 100mA bei einer Power Bank schon viel als Permanent Strom aber es ist eine sehr einfache Lösung.

Digispark WeMosD1

LG Akku: 10400mAh
WeMosD1: 80mA
DigiSpark: 25mA

Akkulaufzeit: ah / a x 60
Minuten: 10.4Ah / 0.104A x 60 = 6000 min
Stunden: 10.4Ah / 0.104A = 100 Stunden
Tage: 10.4Ah / 0.104A / 24 = 4,16 Tage

4 Tage sind leider verdammt wenig! Kommt natürlich auch auf das Projekt an.

Code

// KEEP POWERBANK ALIVE

int led = 1;

void setup() {
  pinMode(led, OUTPUT);     // red LED for debug blink
}
 
void loop() {
  digitalWrite(led, HIGH);   
  delay(1500);             // led ON timer            
  digitalWrite(led, LOW); 
  delay(14000);            // led OFF timer
}

Mit einem WeMosD1 mini und dem DigiSpark liegt man knapp unter den 100mA was dazu führt das die Power Bank abschaltet. Mit dem Code Schnipsel wird die LED Zyklisch geschalten was zu einer Stromaufnahme knapp über 100mA führt.

Hinweis

Natürlich übernehme ich keinerlei Haftung dafür was mit eurer Power Bank passiert da es da auch einige schwarze Schafe gibt. Ich habe auch schon eine Power Bank auf Amazon gesehen die diese Abschaltung nicht besitzt. Da es aber lediglich zwei Mikrokontroller sind die betrieben werden sollte eigentlich nichts passieren. Trotzdem sind Power Banks nicht aus dauerhafte Stromquelle geeignet / vorgesehen.

vor längerer Zeit habe ich mir einen SmartMirror für das Betriebssystem MirrorOs von der Firma Glancr gebaut. Das Einrichten des Betriebssystem ist für jeden Einsteiger in das Thema SmartMirror der auch nicht viel Software Kenntnisse hat genau das richtige. Vor allem die das Video und die Tipps für den Bau des Spiegels waren sehr hilfreich. Mit der Zeit ist mir das ganze aber zu langweilig geworden nur Termine, Tankpreise, Wetter, Uhrzeit, etc. anzeigen zu lassen. Da ich im letzten Jahr viel mit HomeAssistant gearbeitet und einige Sensoren im Haus am laufen habe, fand ich die Idee meinen HomeAssistant Lovelace auf dem SmartMirror anzeigen zu lassen ziemlich cool.

Bau des SmartMirror

SmartMirror fertig

So sieht mein fertiger SmarMirror aus. Ich habe mir damals eine Steckdose für hinter den Spiegel installieren lassen die über den unteren rechten Schalter geschalten wird.

Der Spionspiegel ist mit Magneten im Rahmen befestigt wodurch ich ihn jederzeit herausnehmen kann. Das Spionspiegelglas sollte auf der Rückseite mit schwarzer Folie abgelebt werden bis auf den Teil wo der Monitor sitzt. Ansonsten kann es sein das man ein wenig durchsehen kann.

Bildergalerie

Benötigte Software

Raspberry Pi OS Anpassung

Damit der Raspberry Pi mit der gewünschten HTML aufstartet benötigt man den Chromium Kiosk Modus. Da wir die Einstellungen unter Raspberry Pi OS vornehmen ist Chromium bereits vorinstalliert. Dadurch benötigen wir nur noch die Software Unclutter um den Mauszeiger ausblenden zu können.

sudo apt-get update 
sudo apt-get install unclutter

Als nächstes richten wir den Autostart von Chromium ein. Hierfür öffnen wir folgende Datei:

/home/pi/.config/lxsession/LXDE-pi/autostart

oder

sudo nano /etc/xdg/lxsession/LXDE-pi/autostart

Hier muss jetzt folgendes stehen:

# Mauszeiger Ausblenden
@unclutter

# Bildschirmschoner deaktivieren
#@xscreensaver -no-splash  
@xset s off
@xset -dpms
@xset s noblank

# Startet im Vollbild und im Inkognito Modus, ohne Adressleiste und Knöpfe und ohne die Möglichkeit den Vollbildmodus mit F11 zu deaktivieren 
@chromium-browser --incognito --disable-notifications --kiosk http://homeassistant.local:8123/lovelace/0

Hassio Anpassung an SmartMirror

Nach dem wiederholten Scheitern von Chrome, die Anmeldedaten für Home Assistant dauerhaft zu schreiben, bin ich auf eine Seite gestoßen, auf der steht, dass dies gewollt ist. Abhilfe schafft nur, die IP-Adresse des Raspberry Pi als vertrauenswürdiges Netzwerk unter /config/configuration.yaml anzugeben. Hier ist ein Codeausschnitt meiner configuration.yaml:

# Beginning of configuration.yaml
homeassistant:
  name: homeAssistant
  auth_providers:
    - type: trusted_networks
      trusted_networks:
        - 192.168.178.XX
        - 127.0.0.1
        - ::1
      allow_bypass_login: true
    - type: homeassistant

# Configure a default setup of Home Assistant
...
...

Home Assistant Lovelace

Die Darstellung der Benutzeroberfläche kann mittels individuellem Hassio Lovelace angepasst werden.

Hier können alle möglichen und zur verfügung stehenden Entitäten angezeigt werden.

Mit der Hilfe eines WEMOS D1 und eines einfachen Radar Sensors kann im Pellet Tank der aktuelle Füllstand gemessen und grafisch dargestellt werden. In meinem Fall verarbeite ich die Werte mittels HomeAssistant (hassio). Im Falle von einer geringen Füllstandsmenge kann als Beispiel eine Benachrichtigung per Telegram eingerichtet werden.

Benötigte Hardware

Benötigte Software

3D Gehäuse Tinkercad

Aufbau Pelletsensor

ESP Home config.yaml

Update Intervall ist hier in der yaml auf 1h eingestellt. Somit wird jede Stunde der Füllstand abgefragt.

esphome:
  name: ultraschall
  platform: ESP8266
  board: d1_mini

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  password: „XXX“

wifi:
  networks:
  - ssid: XXX
    password: XXX
  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: Ultraschall
    password: XXX

captive_portal:

sensor:
  - platform: ultrasonic
    trigger_pin: D1
    echo_pin: D2
    name: "Pelletsfüllstand"
    update_interval: 1h

Home Assistant grafische Darstellung

Home Assistant station

In order to make the daily electricity consumption for the family visible, I built a small home assistant monitor.

Since I still had an old Raspberry Pi 3 + Kuman Touch Display brought around, the idea was implemented quickly.

Most of the work on this project was the 3D printer case. I found various housings at thingiverse, but none of them were upright. I redesigned an existing project from Thingiverse for my purposes, but the picture currently only shows a prototype which I am very happy with.

Hardware required for commissioning

Required software

3D printer housing

Home Assistant 3D Print

This is my first draft of a 3D printer case based on an existing project from Thingiverse.

I’m still trying to find time to familiarize myself with OpenSCAD. At the moment I am creating new or working on existing projects with the help of Tinkercad. I am currently assuming that it will take longer to become familiar with OpenSCAD in order to design complex models.

Software setup of Raspberry Pi OS

The first steps on how to get a Raspberry Pi OS image on an SD card can be found quickly via google. I use the SD formatter to format the SD card and the BelenaEtcher program to write the image onto the SD card.

After the image has been flashed on the SD card, the standard settings in the Linux operating system are configured such as network, language, keyboard layout, etc. Then you will be asked whether the Linux system should be brought up to date.

The 5 inch display will probably already work with the Raspberry Pi 3, but without the touch screen function. The correct drivers have to be installed for this to work. Here are the steps that need to be taken in order for the touchscreen to function properly:

  1. Install Raspberry Pi OS official mirror
  2. Clone repo from GitHub to your pi
    • sudo rm -rf LCD-show
    • git clone https://github.com/goodtft/LCD-show.git
    • chmod -R 755 LCD-show
    • cd LCD-show/
  3. Step3, According to your LCD’s type, excute:
    • In case of 5″ LCD
      • sudo ./LCD5-show
    • If you need to switch back to the traditional HDMI display
      • sudo ./LCD-hdmi
  4. Wait a few minutes,the system will restart automatically, enjoy with your LCD
  5. Rotate LCD display
    • ./rotate.sh 270

Since the display is now running and rotated with the correct drivers, we can focus on the Chrome Kiosk mode. For this I found another blog that describes these steps really well and in great detail. Therefore I will save myself a new description. Here is an example code for the auto start:

# Mauszeiger Ausblenden
@unclutter

# Bildschirmschoner ausschalten
#@xscreensaver -no-splash  
@xset s off
@xset -dpms
@xset s noblank

# Startet im Vollbild und im Inkognito Modus, ohne Adressleiste und Knöpfe und ohne die Möglichkeit den Vollbildmodus mit F11 zu deaktivieren 
@chromium-browser --incognito --disable-notifications --kiosk http://homeassistant.local:8123/lovelace/0

# Oder (dementsprechend aus kommentieren) 

# Startet im Vollbildmodus, ohne Adressleiste und Knöpfe und im Inkognito Modus.
#@chromium-browser --incognito --start-fullscreen http://homeassistant.local:8123/lovelace/0


 

Software setup Home Assistant

After the repeated failure of Chrome to persistently write the login data for Home Assistant, I came across a page that says this is wanted. The only remedy is to specify the Raspberry Pi’s IP address as a trusted network under /config/configuration.yaml. Here is a code snipped of my configuration.yaml:

# Beginning of configuration.yaml
homeassistant:
  name: homeAssistant
  auth_providers:
    - type: trusted_networks
      trusted_networks:
        - 192.168.178.XX
        - 127.0.0.1
        - ::1
      allow_bypass_login: true
    - type: homeassistant

# Configure a default setup of Home Assistant
...
...

Ready to start

Now everything should start automatically after the power supply is plugged in. If this is not the case, I have probably forgotten something in my description. If so, drop me a line.

I currently have my home automation running on a Raspberry Pi 4 with Home Assistant (hassio). My idea was to control the whole thing with a voice assistant. Since you can run the Mycroft in a Docker environment, I want to do the whole setup with only one Raspberry Pi. I don’t think that the Pi’s resources are sufficient, but it’s worth a try. The first attempts with a Raspberry Pi 3 show that it has to struggle with Mycroft via docker.

Required Hardware:

  • Raspberry Pi 3/4 + standard cables
  • Micro SD card min 8 GB
  • Jack to jack cable
  • Speaker with audio jack
  • USB Microphone
  • HMI cable and Monitor for first setup

Required Software

Raspberry Pi setup

Most will know how to create a boot image on an SD card. With belena.io, the whole thing works very quickly and is actually self-explanatory. After inserting the SD card and starting Debian, you have to make the standard settings (WiFi setup, language, …).

The next step should be to enable the ssh interface under Debian (Settings -> Interface -> Activate SSH). Now you no longer need the monitor and you can continue to set up everything via the SSH terminal. An SSH terminal connection can be established with the Macbook with the following command:

sudo ssh pi@192.168.178.xx

Now we are on the Raspberry Pi and can do the first installations. The first thing you should do is bring Debian up to date with the following command:

sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade

Docker on Raspberry Pi

I stuck to this website when installing Docker. Many thanks for the clear instructions.

Get Mycroft Docker Development Environment

I tried to get the whole thing to work with the instructions on Github but failed again and again in some places. Ultimately, I found my own way that is similar to the Github guide.

Pull mycroft respository from GitHub

git clone https://github.com/MycroftAI/docker-mycroft.git

Build the docker image in the directory were you pulled the repository.

docker build -t mycroft .

Run the following command to start up mycroft:

docker run -d \
--name mycroft \
-v /home/pi/mycroft:/root/.mycroft \
-v /home/pi/mycroft_skills:/opt/mycroft/skills \
--device /dev/snd \
-e PULSE_SERVER=unix:${XDG_RUNTIME_DIR}/pulse/native \
-v ${XDG_RUNTIME_DIR}/pulse/native:${XDG_RUNTIME_DIR}/pulse/native \
-v ~/.config/pulse/cookie:/root/.config/pulse/cookie \
-p 8181:8181 \
mycroft mycroftai/docker-mycroft:latest

Check if the docker container is up and running by typing:

pi@raspberrypi:~ $ docker ps -a

If you want to remove the docker container you have to type in:

pi@raspberrypi:~ $ docker rm mycroft

Your Docker container is now set up and is just waiting to be started. With the command ” sudo systemctl enable docker “, which is described under ” Docker on Raspberry Pi “, Docker is started automatically when booting.

The best thing to do after restarting is to check whether the Docker container is already there ( docker ps -a ). The command to start mycroft Container is:

docker start [container_ID]

Enter container:

docker exec -it mycroft /bin/bash

After Mycroft is running, the device must still be connected to the MycroftAI. To do this, you first have to register at mycroft.ai. For the device connection you have to excecute the following command:

./startup.sh 

The speaker will let you know what to do ( register on mycroftAI ). A voice tell you to add the device ID. After that it will take a few moment until the terminal gui will appear.

By typing only ./start-mycroft.sh you will get an info which commands you can use. Now you can execute all the commands you want which are available, for example (simple audio test):

./start-mycroft.sh audiotest

With the command ./startup.sh cli the terminal cli will be opened like in the Picroft Image.

Mycroft CLI

Install nano to edit container file

To change a file directly in the terminal you need an Editor. In my case I will use nano. To install vi you have to paste the following commands:

apt-get update
apt-get install nano

While looking for new sensors, I came across the AZ-Envy from AZ-Delivery and was initially enthusiastic about the description of the sensor board. Of course, I ordered three of them. Anyone who has already dealt with the price issue for sensors knows that one sensor alone is quite expensive, but three or five in a pack usually only cost a few euros more. This is probably due to the fact that the free shipping costs and the processing fee which is also part of the price.

Now a few sentences about the board. I don’t understand why no data lines were added to the USB port. As a result, installing the firmware (for beginners as described so nicely in the ad) is extremely complicated. The standard ESP32 or ESP8266 can be flashed much more easily. Of course, once the first firmware is flashed, all other changes can be made via an Over The Air Update (OTA).

But what bothers me most about the board design is that the temperature sensor is right next to the heater of the gas sensor. Even if the sensor has been running for a while, the temperature sensor spits out a wide variety of values. Unfortunately, no offset helps to adjust the temperature. I haven’t compared the humidity with any other product so far, but from what I’ve read on the Internet, the Dev-Board doesn’t seem to work reliably either.

Hardware required for commissioning

Required software

3D printer housing

Download 3D-print Box

Creation of the firmware flash file

There are two ways to create the flash file. Here I am describing one of them.

  • Flash file created with ESPHome.io
  • Flash file created with HomeAssistant

Generate firmware with HomeAssistant

ESPHome HomeAssistant

Install ESPHome under HomeAssitant.

Configure and open ESPHome

Press the + button at the bottom of the page

Enter Projektnamens

Enter SSID (WLAN Name)

Enter WLAN Passworts

Press button “next”

Choose ESP8266

Press button”next”.

A congratulation logo should appear. In case of an error, simply press “next” again

The new project has been created and is not yet connected (therefore red).

Press Install and then Manual download

The firmware is compiled and then downloaded.

This file can then be installed via the terminal.

EZ-Envy-1.yaml

esphome:
  name: humidity
  platform: ESP8266
  board: nodemcuv2
  
i2c:
  - sda: GPIO4
    scl: GPIO5
    id: bus_a

sensor:
  #Temperatur und Luftfeuchtigkeit
  - platform: sht3xd
    i2c_id: bus_a
    address: 0x44
    
    temperature:
      name: "Temperatur"
      id: "temperature"
      filters:
      - offset: -10.0
    humidity:
      name: "Luftfeuchtigkeit"
      id: "humidity"
      filters:
      - offset: 8.0
    update_interval: 10s
    
  # MQ2 Smoke Gas Sensor
  - platform: adc
    pin: A0
    name: "Gassensor"
    update_interval: 10s
    #filters:
    #  - multiply: 100
        #unit_of_measurement: "%"
    filters:
     lambda: |- 
       return (x * 1024/5);
    unit_of_measurement: "ppm"  
    icon: "mdi:percent" 
    
    
# Enable logging
logger:

....
....

AZ-Envy Firmware flashing via Terminal

AZ-Envy

First you have to connect the FT232RL Flasher Board to the AZ-Envy. However, you only need three individual wires (jumper wire). Only the pins GND, RX, TX need to be connected.

Then the AZ-Envy must be supplied with voltage and the FT232RL USB cable is then connected to the PC. You can also connect both USB cables to a USB hub (with external power supply) and then go from there to the PC.

The following steps have to be taken:

  • Create Firmware flashfile with HomeAssistant or ESPHome.
  • Connect EZ-Envy to FT232RL
  • Connect the AZ-Envy and FT232RL to a USB hub with an external power supply
  • Connect the USB hub to the PC
  • Open Terminal and go to the ESPTool folder
  • Command: sudo python esptool.py –port / usbPort / write_flash 0x00000 yourFile.bin
sudo python esptool.py --port /dev/tty.usbserial-A50285BI write_flash 0x00000 ez-envy-1.bin

Known issues during flash process

If the device is not recognized correctly and the following output appears.

  1. Hold down the flash button on the EZ-Envy
  2. Unplug the EZ-Envy’s USB cable and plug it in again.
  3. Now the firmware should be flashed (see picture below)

My conclusion on the AZ Envy

As a development board, I think the board is really successful and it’s fun to work with. If you print out the corresponding case, the price is still reasonably reasonable. The housing also shields the temperature sensor a little from the heating of the gas sensor. Unfortunately, this does not make the temperature values more accurate either.

I will now use my sensor as a gas sensor in the boiler room.

Mit der Hilfe eines ESP8266 und eines einfachen IR Modules kann am Stromzähler der aktuelle Stromverbrauch ausgelesen werden ohne das man den Stromzähler PIN benötigt. Die ausgelesenen Werte können dann mittels Home Assistant HASSIO grafisch dargestellt werden.

Das ganze ist entstanden aufgrund meines Balkonkraftwerkes. Ich wollte einfach wissen was ich aktuell einspeise und was ich verbrauche. Bei einem Balkonkraftwerk sollte man vor dem Kauf wissen welchen Grundverbrauch man hat damit man ermitteln kann ob es sich überhaupt lohnt ein doppeltes Solarmodul mit 600W zu kaufen oder doch lieber ein einzelnes mit 300W. Aktuell habe ich ein 300W Solarmodul am EG Stromzähler und ein doppeltes Modul mit 600W am OG Stromzähler hängen. Dadurch ist der Grundbedarf gedeckt und die Solarmodule sollten sich nach ca. 4-5 Jahren amortisiert haben.

Digitaler Stromzähler

Benötigte Hardware

Benötigte Software

3D Gehäuse Tinkercad

Aufbau

IR Modul TCRT5000 modifikation

Auf dem TCRT5000 befindet sich eine Lesediode und eine Schreibdiode. Die Schreibdiode wird auch als Näherungssensor verwendet wodurch es zu Problemen kommen kann beim Ablesen des Stromzählers.

In meinem Fall habe ich die hellere (weiße Diode) einfach ausgelötet. In anderen Beiträgen habe ich gesehen das auch nur der Vorwiderstand entfernt wird.

Den TCRT5000 habe ich am Nodemcuv2 an den Pins D5, 3V3 und GND angeschlossen die direkt nebeneinander liegen.

eHz Elektronischer Haushaltszähler

eHz Digitaler Stromzähler (ESP8266)

Das Gehäuse aus dem 3D Drucker passt beim eHz Elektronischen Haushaltszähler. Mit zwei Magneten wird das Gehäuse am Zähler befestigt da der Stromzähler Eigentum des Netzbetreibers ist!

Die rechten beiden IR Dioden werden beim IR Lese-Schreibekopf verwendet (Volkszähler). Dabei wird permanent zwischen den Unterschiedlichen zur verfügung stehenden Zählerständen geschalten und diese ausgelesen (PIN muss beim jeweiligen Energiekonzern angefragt werden).

In unserem Fall benutzen wir die mittlere IR-Diode zum auslesen des aktuellen Stromverbrauchs am Zähler. Zum testen einfach den IR Sensor mit der Hand an die zu testende IR-Diode halten und in den ESP-Home live loggs schauen ob sich der Wert verändert. Ich hatte noch einen Baustrahler im Keller angeschlossen um zu schauen ob die Werte plausibel sind.

Ein Sensor am ESP8266

ESP Home ein Sensor config.yaml

Update Intervall ist hier in der yaml auf 60s eingestellt. Alle 60s sollte sich der aktuelle Stromverbrauch ändern.

esphome:
  name: strom
  platform: ESP8266
  board: nodemcuv2
  
# Sensor configuration
sensor:
  - platform: pulse_counter
    pin: D5
    name: "Energieverbrauch"
    unit_of_measurement: 'W'
    update_interval: 60s
    filters:
      - multiply: 6
    accuracy_decimals: 0
    icon: 'mdi:flash'
    id: energieverbrauch_w
    
  - platform: total_daily_energy
     name: "Tagesverbrauch"
     power_id: energieverbrauch_w

time:
  - platform: sntp
    id: my_time

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  password: „xxxxxxxxxx“

wifi:
  ssid: „xxxxxxxxxx“
  password: „xxxxxxxxxx“

captive_portal:

Home Assistant grafische Darstellung

Spannungsversorgung Verteilerkasten

Aktuell habe ich im Haus an jedem meiner Zähler einen Sensor mit Magnet befestigt. Die Sensoren sind an einem ESP8266 nodemcuv2 angeschlossen (Spannung, Masse, D5 und D6).

Die Zählerschranksteckdose die den Nodemcuv2 betreibt habe ich mir extra dafür eingebaut

ESP Home Logs

INFO Reading configuration /config/esphome/strom.yaml...
INFO Detected timezone 'CET' with UTC offset 1 and daylight saving time from 27 March 02:00:00 to 30 October 03:00:00
INFO Starting log output from strom.local using esphome API
INFO Successfully connected to strom.local
[19:32:31][I][app:102]: ESPHome version 2021.9.3 compiled on Oct 10 2021, 21:35:03
[19:32:31][C][wifi:501]: WiFi:
[19:32:31][C][wifi:361]:   SSID: 'xxxxxxxxxxxxxxx'[redacted]
[19:32:31][C][wifi:362]:   IP Address: xxx.xxx.xxx.xx
[19:32:31][C][wifi:364]:   BSSID: xx:xx:xx:xx:xx:xx[redacted]
[19:32:31][C][wifi:365]:   Hostname: 'strom'
[19:32:31][C][wifi:369]:   Signal strength: -51 dB ▂▄▆█
[19:32:31][C][wifi:373]:   Channel: 6
[19:32:31][C][wifi:374]:   Subnet: 255.255.255.0
[19:32:31][C][wifi:375]:   Gateway: xxx.xxx.xxx.x
[19:32:31][C][wifi:376]:   DNS1: xxx.xxx.xxx.x
[19:32:31][C][wifi:377]:   DNS2: (IP unset)
[19:32:31][C][logger:193]: Logger:
[19:32:31][C][logger:194]:   Level: DEBUG
[19:32:31][C][logger:195]:   Log Baud Rate: 115200
[19:32:31][C][logger:196]:   Hardware UART: UART0
[19:32:31][C][pulse_counter:147]: Pulse Counter 'Energieverbrauch'
[19:32:31][C][pulse_counter:147]:   State Class: 'measurement'
[19:32:31][C][pulse_counter:147]:   Unit of Measurement: 'W'
[19:32:31][C][pulse_counter:147]:   Accuracy Decimals: 0
[19:32:31][C][pulse_counter:147]:   Icon: 'mdi:flash'
[19:32:31][C][pulse_counter:148]:   Pin: GPIO14 (Mode: INPUT)
[19:32:31][C][pulse_counter:149]:   Rising Edge: INCREMENT
[19:32:31][C][pulse_counter:150]:   Falling Edge: DISABLE
[19:32:31][C][pulse_counter:151]:   Filtering pulses shorter than 13 µs
[19:32:31][C][pulse_counter:152]:   Update Interval: 60.0s
[19:32:31][C][total_daily_energy:024]: Total Daily Energy 'Tagesverbrauch'
[19:32:31][C][total_daily_energy:024]:   Device Class: 'energy'
[19:32:31][C][total_daily_energy:024]:   State Class: 'total_increasing'
[19:32:31][C][total_daily_energy:024]:   Unit of Measurement: 'Wh'
[19:32:31][C][total_daily_energy:024]:   Accuracy Decimals: 2
[19:32:31][C][total_daily_energy:024]:   Icon: 'mdi:flash'
[19:32:31][C][captive_portal:148]: Captive Portal:
[19:32:31][C][ota:029]: Over-The-Air Updates:
[19:32:31][C][ota:030]:   Address: strom.local:8266
[19:32:31][C][ota:032]:   Using Password.
[19:32:31][C][api:135]: API Server:
[19:32:31][C][api:136]:   Address: strom.local:6053
[19:32:31][C][api:140]:   Using noise encryption: NO
[19:32:31][C][sntp:044]: SNTP Time:
[19:32:31][C][sntp:045]:   Server 1: '0.pool.ntp.org'
[19:32:31][C][sntp:046]:   Server 2: '1.pool.ntp.org'
[19:32:31][C][sntp:047]:   Server 3: '2.pool.ntp.org'
[19:32:31][C][sntp:048]:   Timezone: 'CET-1CEST-2,M3.4.0/2,M10.5.0/3'
[19:32:32][D][pulse_counter:159]: 'Energieverbrauch': Retrieved counter: 68.00 pulses/min
[19:32:32][D][sensor:121]: 'Energieverbrauch': Sending state 408.00000 W with 0 decimals of accuracy
[19:32:32][D][sensor:121]: 'Tagesverbrauch': Sending state 6002.70361 Wh with 2 decimals of accuracy
[19:32:32][D][pulse_counter:159]: 'Energieverbrauch': Retrieved counter: 68.00 pulses/min
[19:32:32][D][sensor:121]: 'Energieverbrauch': Sending state 408.00000 W with 0 decimals of accuracy
[19:32:32][D][sensor:121]: 'Tagesverbrauch': Sending state 6002.70361 Wh with 2 decimals of accuracy
[19:33:32][D][pulse_counter:159]: 'Energieverbrauch': Retrieved counter: 67.00 pulses/min
[19:33:32][D][sensor:121]: 'Energieverbrauch': Sending state 402.00000 W with 0 decimals of accuracy
[19:33:32][D][sensor:121]: 'Tagesverbrauch': Sending state 6009.40381 Wh with 2 decimals of accuracy

Zwei Sensoren an einem ESP8266

Natürlich kann man auch zwei Stromzähler mit einem ESP8266 betreiben.

An den grün markierten Stellen haben ich die Jumper wire eingesteckt.

ESP Home zwei Sensoren config.yaml

esphome:
  name: strom
  platform: ESP8266
  board: nodemcuv2
  
# Stromzähler OG
sensor:
  - platform: pulse_counter
    pin: D5
    name: "Energieverbrauch_OG"
    unit_of_measurement: 'W'
    update_interval: 60s
    filters:
    # - multiply: 0.06   in kWh # ( 60s/1000 pulses per kWh )
      - multiply: 6    # in W   # ( Wert * 3600 / 10 )
    accuracy_decimals: 0
    icon: 'mdi:flash'
    id: energieverbrauch_og
    
  # Dieser Sensor errechnet die Wh aus den aktuellen Verbrauchswerten in W  
  - platform: total_daily_energy
    name: "Tagesverbrauch_OG"
    power_id: energieverbrauch_og

# Stromzähler EG    
  - platform: pulse_counter
    pin: D6
    name: "Energieverbrauch_EG"
    unit_of_measurement: 'W'
    update_interval: 60s
    filters:
    # - multiply: 0.06   in kWh # ( 60s/1000 pulses per kWh )
      - multiply: 6    # in W   # ( Wert * 3600 / 10 )
    accuracy_decimals: 0
    icon: 'mdi:flash'
    id: energieverbrauch_eg
    
  # Dieser Sensor errechnet die Wh aus den aktuellen Verbrauchswerten in W  
  - platform: total_daily_energy
    name: "Tagesverbrauch_EG"
    power_id: energieverbrauch_eg    
    
time:
  - platform: sntp
    id: my_time

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  password: "xxxxxxxxxxxxxxxxxxxxxxxxxxxx"

wifi:
  ssid: "xxxxxxxxxxxxxxxx"
  password: "xxxxxxxxxxxx"

captive_portal:

ESP Home Logs zwei Sensoren

[11:22:17][D][pulse_counter:159]: 'Energieverbrauch_EG': Retrieved counter: 2.00 pulses/min
[11:22:17][D][sensor:121]: 'Energieverbrauch_EG': Sending state 12.00000 W with 0 decimals of accuracy
[11:22:17][D][sensor:121]: 'Tagesverbrauch_EG': Sending state 146.35190 Wh with 2 decimals of accuracy

[11:22:17][D][pulse_counter:159]: 'Energieverbrauch_OG': Retrieved counter: 96.00 pulses/min
[11:22:17][D][sensor:121]: 'Energieverbrauch_OG': Sending state 576.00000 W with 0 decimals of accuracy
[11:22:17][D][sensor:121]: 'Tagesverbrauch_OG': Sending state 516.67249 Wh with 2 decimals of accuracy

[11:23:17][D][pulse_counter:159]: 'Energieverbrauch_EG': Retrieved counter: 0.00 pulses/min
[11:23:17][D][sensor:121]: 'Energieverbrauch_EG': Sending state 0.00000 W with 0 decimals of accuracy
[11:23:17][D][sensor:121]: 'Tagesverbrauch_EG': Sending state 146.35190 Wh with 2 decimals of accuracy

[11:23:17][D][pulse_counter:159]: 'Energieverbrauch_OG': Retrieved counter: 98.00 pulses/min
[11:23:17][D][sensor:121]: 'Energieverbrauch_OG': Sending state 588.00000 W with 0 decimals of accuracy
[11:23:17][D][sensor:121]: 'Tagesverbrauch_OG': Sending state 526.47168 Wh with 2 decimals of accuracy

Wie man dem Log entnehmen kann ist im unteren Abschnitt bei EG 0.00 Pulses zu sehen, bitte nicht verwundern das liegt an meinem Balkonkraftwerk was gerade mehr Leistung generiert als verbraucht wird.

Bei weiteren Fragen einfach schreiben.

Mycroft / PiCroft is an open source voice assistant.

Hardware required

  • Raspberry Pi
  • Display (in my case 5″Display)
  • JBL GO Bluetooth Speaker
  • Keyboard for setup

PiCroft first setup

PiCroft Setup

Connect JBL Go Bluetooth speaker

Install Pulseaudio-module-bluetooth

sudo apt-get install pulseaudio-module-bluetooth

Setup for setting bluetooth connection every startup at: /sudo nano /etc/rc.local

# Connect Bluetooth Speaker JBL Go
printf "### Connect Bluetooth Speaker ###"
echo "power on \nagent on \ndefault-agent \nconnect XX:XX:XX:XX:XX:XX \nquit" | bluetoothctl

This file needs to be edited at to get audio output: sudo nano /etc/mycroft/mycroft.conf

{
  "play_wav_cmdline": "aplay %1",
  "play_mp3_cmdline": "mpg123 %1",
  [...]
}

Short description

SodaStream Oled Display

Everyone who owns a SodaStream has probably asked themselves how full my CO2 cylinder is. In most cases the cylinder is empty once you have been shopping. Most SodaStream users have a second cylinder, but it still sparked my creativity to come up with a simple solution.

The small software program is currently used to determine the number of impacts pressed and shown on the display (line 2). In line 3 is the added time of the duration / length of the pushed pushes. These values can be used to roughly estimate how much Co2 is still in the cylinder. What is shown graphically in line 4 by means of a progress indicator.

Hardware required

  • Wemos D1 mini (ESP8266)
  • Limit switch Ender 3 Pro
  • OLED Display I2C 0,96 Zoll
  • Cable / single wires
  • 3D Printer + Filament
  • Soldering iron with equipment

Software required

  • Arduino IDE
  • Tinkercad
  • Ultimaker Cura / Prusa Slicer

3D Printer settings

Ender 3 Pro

Print Settings

3D Printer Tinkercad STL File

Tinkercad SodaStream

Arduino IDE Software Code

I have to adapt to publish (currently code excerpt).

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ESP8266WiFi.h>

#define SCREEN_WIDTH 128 // display width, (pixels)
#define SCREEN_HEIGHT 64 // display height, (pixels)

// I2C connected display SSD1306 
#define OLED_RESET     0 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define NUMFLAKES     10 // Number of snowflakes in the animation example

#define LOGO_HEIGHT   16
#define LOGO_WIDTH    16
static const unsigned char PROGMEM logo_bmp[] =
{ B00000000, B11000000,
  B00000001, B11000000,
  B00000001, B11000000,
  B00000011, B11100000,
  B11110011, B11100000,
  B11111110, B11111000,
  B01111110, B11111111,
  B00110011, B10011111,
  B00011111, B11111100,
  B00001101, B01110000,
  B00011011, B10100000,
  B00111111, B11100000,
  B00111111, B11110000,
  B01111100, B11110000,
  B01110000, B01110000,
  B00000000, B00110000 };

Result Pictures

ToDo

  • Wemos D1 Mini ESP.deepSleep
  • One Case for alle the stuff
  • Smaler Display Case
  • Battery shield + display battery status
  • Change Wemos D1 Mini to ESP8266 BLE + IOS App

Control of a relay module using an Arduino Nano v3

Since I have to reset my work hardware or switch the voltage several times a day from home office, I built a small circuit from an old Arduino Nano v3 and a relay module that enables me to do this. Since I found it awkward to start the relay every time via the Arduino IDE with the serial monitor, I also wrote a GUI that can be executed using JAVA JDK for easy handling.

Hardware required

  • Arduino Nano v3
  • Relais Modul
  • RGB LED (not needed)
  • Single Wires
  • Solder stuff
  • 3D Printed case

Schematics

Tinkercad circuits Arduino Nano

Code

Code for Arduino IDE which worked with the attached GUI.

#define LEDR 8     // red
#define LEDG 9     // green
#define LEDB 10    // blue
#define RELAIS 11  // relais

void setup() {

  // set LED's pin to output mode
  pinMode(LEDR, OUTPUT);
  pinMode(LEDG, OUTPUT);
  pinMode(LEDB, OUTPUT);
  pinMode(RELAIS, OUTPUT);
  
  Serial.begin(9600);          //start serial communication @9600 bps
}

void loop(){
  
  if(Serial.available()){      //id data is available to read

    char val = Serial.read();

    if(val == 'b'){             //if b received
      digitalWrite(11, HIGH);   //turn on relais
      digitalWrite(10, HIGH);   //turn on green led
    }
    if(val == 'f'){            //if f received
      digitalWrite(11, LOW);    //turn off all led
      digitalWrite(10, LOW);
    }      
  }
}

Processing IDE GUI for MacOS

With Processing IDE it is easy to create a JAVA GUI for Arduino which is running on MAC OS X and Windows. The only think what you have to install additional is the latest JAVA SDK.

3D Printer Settings

Print Settings

Result