Let your plant twitter if it needs to be watered

You often forget to water your plants? We already created a guide how to make sure you will be informed to water your plant when you’re coming home. But let’s try something that is a bit crazier! Wouldn’t it be cool if your plant would have it’s own Twitter account and tell you what to do?

What you need

  • one or more Mi Flora Plant sensors
  • a Raspberry Pi or PC running Home Assistant
  • a Twitter account

Installing the software

The base configuration of the Mi Plant sensor has been documented in our first flower sensor article.

Configuring the Twitter integration

If you have already a twitter account, go to apps.twitter.com and create a new App. You need to input some data and then you will get the consumer key/secret and you can create an access token.

Now, configure a notifier in your configuration.yaml file as follows:

notify:
  name: pflanzentwitter
  platform: twitter
  consumer_key: xxxxxxxxx
  consumer_secret: xxxxxxxx
  access_token: xxxxxxxx
  access_token_secret: xxxxxxx

Just copy the tokens from the developer web site into the configuration.

Create some twitter rules

Now, it your turn to find some cool post for your plant. Here is an example that I use. I’ve create a seperate automations.yaml file, that will be included in the main configuration:

- alias: Basil - sunny
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_light_intensity
    above: 9800
  action:
    service: notify.pflanzentwitter
    data:
      message: "Basil: Nice sunny day today \U0001f60e"

- alias: Basil - dark
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_light_intensity
    below: 100
  action:
    service: notify.pflanzentwitter
    data:
      message: "Basil: It's getting dark outside, good night! \U0001f303"

- alias: Basil - first light
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_light_intensity
    above: 100
  action:
    service: notify.pflanzentwitter
    data:
      message: "Basil: Good morning! \U0001f305"

- alias: Basil - above 30 degree
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_temperature
    above: 30
  action:
    service: notify.pflanzentwitter
    data:
      message: "Basil: Hot day today, it's over 30 degree celsius now. \U0001f321"

- alias: Basil - water warning 2
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_moisture
    below: 25
  action:
    service: notify.pflanzentwitter
    data:
      # Cactus emoticon
      message: "Basil: What about some water for me? \U0001f335"

- alias: Basil - water warning 3
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_moisture
    below: 20
  action:
    service: notify.pflanzentwitter
    data:
      # Skull emoticon
      message: "Basil: Water me or I will die of thirst. \U0001f480"

- alias: Basil - water warning 4
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_moisture
    below: 10
  action:
    service: notify.pflanzentwitter
    data:
      # Skull emoticon
      message: "Basil: Help! Water! \U0001f480\U0001f480\U0001f480"

- alias: Basil - enough water
  trigger:
    platform: numeric_state
    entity_id: sensor.basilikum_moisture
    above: 50
  action:
    service: notify.pflanzentwitter
    data:
      message: "Basil: I'm feeling better, thank you for the water. \U0001f3a0"

You might ask yourself, what those crazy \U000xxxx numbers are? These are just emoticons. Have a look here for their unicode character codes.

Monitor your plants with Home Assistant

I love to have a lot of plants in my apartment, but unfortunately I sometimes forget to water them. So why not using modern technology to make sure, I don’t ever forget it again.

What you need

  • A Raspberry Pi or a Linux-PC with a supported Bluetooth LE interface.
  • Bluez
  • Mi Plant flower sensor for every plant
  • Home assistant

Setup

Home assistant

First you should install Home Assistant and make sure everything works well. Home assistant provides good documentation how to setup the platform.

Bluetooth software

The Linux bluetooth software might not yet be installed on your system.

Check communication with the plant sensor

The easiest way to make sure your PC can read data from the sensor is using the hcitool command line tool.

hcitool lescan
LE Scan ...
XX:XX:XX:XX:XX:XX (unknown)
XX:XX:XX:XX:XX:XX Flower mate

It might list a lot of other devices. Just make sure, it can also see the “Flower mate” device. If you can’t see this device, the distance between the flower sensor and your PC might be too large. Try moving the plant near your PC and check if it works then.

Integrate polling into Home Assistant

First, you need to poll the data from the sensor in Home Assistant:

sensor
  platform: miflora
  mac: xx:xx:xx:xx:xx:xx
  name: Flower 1
  force_update: false
  monitored_conditions:
   - moisture
   - light
   - temperature
   - conductivity

As the MAC address, you need to use the address that is shown in the hcitool lescan output.

Notify yourself when you come home

It doesn’t make much sense to send you a notification during the day that you should water the flowers. You might have forgotten it already when you come home. So let’s just send a notification when you come home.

Setup presence detection

Home Assistant documentation how to do this. There are a lot of different device trackers. Have a look and decide what works best for you.

Setup notifications

The next step is sending a notification to you. For this guide I use Pushetta, but Home Assistant provides a large number of notification mechanisms. Have a look at them and select the one that fits best for you.

An example notifier configuration might look like this:

notify
  name: pushetta
  platform: pushetta
  channel_name: mychannel
  api_key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Define the automation

Now comes the new rule:

automation:
  alias: Alarm me to water plants
  trigger:
    platform: state
    entity_id: device_tracker.myname
    from: 'not_home'
    to: 'home'
  condition:
    condition: numeric_state
    entity_id: sensor.flower1_moisture
    below: 20
  action:
    service: notify.pushetta
    data:
      message: 'Water Flower 1!'

What does this do? First it checks it check, if you came from (device tracker changes from not_home to home) and check then if the moisture is below a well-defined threshold. The value might be a bit different for your plant, you need to adjust this. If the moisture is too low, it sends a notification via Pushetta.

You can combine multiple plants in the condition statement or create an automation for every single plant. I personally prefer the latter as I then know exactly which plant I should water.

Long-term monitoring

It often helps to have long-term data available to optimize not only watering, but also fertilize in the right intervals. While you can store the whole history within Home assistant, it isn’t really optimized for this use case. Therefore I recommend to use InfluxDB for this. This is a time-series database specifically designed to store sensor data over a long period. To visualize the data, I use Grafana. With this, you can create nice reports like this:
TODO

Überwachung der Kohlendioxid-Konzentration

Beim Atmen wandeln Menschen und Tiere eingeatmeten Sauerstoff und im Körper gespeicherten Kohlenstoff in Kohlendioxid um. Daher hat die ausgeatmete Luft eine höhere CO2-Konzentration als die eingeatmete. Das ist ein ganz normaler biologischer Prozess. Im Freien ist das völlig unkritisch, da Pflanzen genau das Gegenteil tun und die CO2-Konzentration damit stabil bleibt (wir vergessen hier mal die Erhöhung der CO2-Konzentration durch das Verbrennen fossiler Brennstoffe).
In geschlossenen Räumen kann sich die CO2-Konzentration allerdings schon deutlich erhöhen. Gerade modernere Gebäude ohne Lüftungssystem sind da recht problematisch. Daher ist es hier keine schlechte Idee, die CO2-Konzentration zu messen um ggf. stärker zu lüften.

Im Freien liegt die CO2-Konzentration in der Regel zwischen 250 und 350 ppm (parts per million – CO2 Anteil pro 1 Million), in Innenräumen kann die Konzentration recht schnell auf mehrere tausend PPM steigen (1000 ppm entsprechen dann 0.1% CO2 Anteil). In diesem englischsprachigen Dokument kann man gut sehen, dass CO2-Konzentrationen über 1000ppm zu Müdigkeit, schlechter Konzentration, erhöhtem Puls und anderen unerwünschten Nebenwirkungen führen kann.

Eine einfache Methode zur Messung von CO2 sind sogenannte An easy method to monitor CO2 levels are nichtdispersive Infrarotsensoren. Um diese an einem PC or Raspberry Pi zu nutzen, ist es am einfachsten, einen Sensor mit einer seriellen Schnittstelle zu wählen. Der MH-Z19 ist dafür eine gute Wahl. Er ist recht günstig, bietet eine serielle Schnittstelle und läuft mit einer Betriebsspannung von 3.3V. Damit kann er direkt an einen Raspberry Pi angeschlossen werden bzw. mit einem einfachen Konverter auch an PC oder Mac.

Schaut man von unten auf den Sensor, so sieht man die folgenden Anschlüsse:

hmz19-pinout

Der Pinabstand beträgt 2.54mm, damit kann man ganz einfach entsprechende Header anlöten:

co2sensor_pins

Nun lässt sich der Sensor einfach mit Kabeln mit z.B. an einen Raspberry Pi anstecken::

co2sensor_cables

Verbinden mit dem Raspberry Pi

Der Sensor kann direkt an einige Pins des 40-poligen GPIO-Anschlusses angesteckt werden:

Funktion Pin MH-Z19 Pin RPI
VCC 6 1
GND 7 6
RX 2 8
TX 3 10

Anschluss an PC und Mac

Um den Sensor an PC oder Mac anzuschliessen, wird zusätzlich ein kleiner USB/seriell Adapter benötigt:

usbser1

Für diese Konverter gibt es keine standardisierten Anschlüsse. Daher muss man hier schauen, wie der Konverter belegt ist. Dann verbindet man den Sensor wie folgt: VCC auf 3.3V, TX auf RX, RX auf TX und GND auf GND.

Software

Der Sensor ist recht einfach mit einem eigenen Programm auszulesen. Allerdings geht es auch komplett ohne Programmierung. Am einfachsten geht das mit Home Assistant, denn hierfür haben wir bereits ein Modul entwickelt. Dieses muss nur in der Konfiguration aktiviert werden:

sensor 3:
  platform: mhz19
  serial_device: /dev/serial0

Wer selst etwas programmieren will, kann z.B unsere pmsensor Bibliothek nutzen, die diesen Sensor auch direkt unterstützt.

Reverse engineering the Mi flora plant sensor

The Xiaomi Mi plant sensor is a well-made plant sensor that does not only measure the humidity, but also fertility, temperature and environment light. Pretty cool for a small device like this. And even cooler is that it uses Bluetooth Low energy for communication with your mobile device. This should make it easily hackable.

Ok, let’s start and check what characteristics are available:

handle = 0x0002, char properties = 0x02, char value handle = 0x0003, uuid = 00002a00-0000-1000-8000-00805f9b34fb
handle = 0x0004, char properties = 0x02, char value handle = 0x0005, uuid = 00002a01-0000-1000-8000-00805f9b34fb
handle = 0x0006, char properties = 0x0a, char value handle = 0x0007, uuid = 00002a02-0000-1000-8000-00805f9b34fb
handle = 0x0008, char properties = 0x02, char value handle = 0x0009, uuid = 00002a04-0000-1000-8000-00805f9b34fb
handle = 0x000d, char properties = 0x22, char value handle = 0x000e, uuid = 00002a05-0000-1000-8000-00805f9b34fb
handle = 0x0011, char properties = 0x1a, char value handle = 0x0012, uuid = 00000001-0000-1000-8000-00805f9b34fb
handle = 0x0014, char properties = 0x02, char value handle = 0x0015, uuid = 00000002-0000-1000-8000-00805f9b34fb
handle = 0x0016, char properties = 0x12, char value handle = 0x0017, uuid = 00000004-0000-1000-8000-00805f9b34fb
handle = 0x0018, char properties = 0x08, char value handle = 0x0019, uuid = 00000007-0000-1000-8000-00805f9b34fb
handle = 0x001a, char properties = 0x08, char value handle = 0x001b, uuid = 00000010-0000-1000-8000-00805f9b34fb
handle = 0x001c, char properties = 0x0a, char value handle = 0x001d, uuid = 00000013-0000-1000-8000-00805f9b34fb
handle = 0x001e, char properties = 0x02, char value handle = 0x001f, uuid = 00000014-0000-1000-8000-00805f9b34fb
handle = 0x0020, char properties = 0x10, char value handle = 0x0021, uuid = 00001001-0000-1000-8000-00805f9b34fb
handle = 0x0024, char properties = 0x0a, char value handle = 0x0025, uuid = 8082caa8-41a6-4021-91c6-56f9b954cc34
handle = 0x0026, char properties = 0x0a, char value handle = 0x0027, uuid = 724249f0-5ec3-4b5f-8804-42345af08651
handle = 0x0028, char properties = 0x02, char value handle = 0x0029, uuid = 6c53db25-47a1-45fe-a022-7c92fb334fd4
handle = 0x002a, char properties = 0x0a, char value handle = 0x002b, uuid = 9d84b9a3-000c-49d8-9183-855b673fda31
handle = 0x002c, char properties = 0x0e, char value handle = 0x002d, uuid = 457871e8-d516-4ca1-9116-57d0b17b9cb2
handle = 0x002e, char properties = 0x12, char value handle = 0x002f, uuid = 5f78df94-798c-46f5-990a-b3eb6a065c88
handle = 0x0032, char properties = 0x0a, char value handle = 0x0033, uuid = 00001a00-0000-1000-8000-00805f9b34fb
handle = 0x0034, char properties = 0x1a, char value handle = 0x0035, uuid = 00001a01-0000-1000-8000-00805f9b34fb
handle = 0x0037, char properties = 0x02, char value handle = 0x0038, uuid = 00001a02-0000-1000-8000-00805f9b34fb
handle = 0x003b, char properties = 0x02, char value handle = 0x003c, uuid = 00001a11-0000-1000-8000-00805f9b34fb
handle = 0x003d, char properties = 0x1a, char value handle = 0x003e, uuid = 00001a10-0000-1000-8000-00805f9b34fb
handle = 0x0040, char properties = 0x02, char value handle = 0x0041, uuid = 00001a12-0000-1000-8000-00805f9b34fb

Looks like some standard characteristics (the uuid’s starting with 00002) and a lot of non-standard. Let’s check the standard characteristics first. UUID 00002a00-0000-1000-8000-00805f9b34fb should contain the device name:

# gatttool --device=C4:7C:8D:60:8F:E6 --char-read -a 0x03
Characteristic value/descriptor: 46 6c 6f 77 65 72 20 6d 61 74 65 

“46 6c 6f 77 65 72 20 6d 61 74 65” is “Flower mate” in ASCII. Cool. Seems that Xiaomi is using the standards – not something we see from every Chinese company.

How do you know that this UUID contains the name? Check out the list of GATT characteristics on the Bluetooth web site.

Ok, let’s have a look at all characteristics that return values:

0x03 : 160823-164329 : 46 6c 6f 77 65 72 20 6d 61 74 65
0x05 : 160823-164329 : 00 00
0x07 : 160823-164329 : 00
0x09 : 160823-164329 : 0a 00 14 00 00 00 f4 01
0x0e : 160823-164329 : 01 00 ff ff
0x12 : 160823-164329 : c3 c8 fd 30
0x15 : 160823-164329 : 98 00
0x17 : 160823-164329 : 1f 8e 8e 13 86 dd a0 d8 52 66
0x1d : 160823-164329 : 4c cc ca 13 fc fa f7 a6 51 50 c6 85 ee 61 85 47 7f 3d d6 6b
0x1f : 160823-164329 : 2e a1 bc 3e b3 87 94 e9 68 6f ff b7
0x2f : 160823-164329 : 00
0x33 : 160823-164329 : aa bb
0x35 : 160823-164329 : f5 00 00 00 00 00 00 10 61 00 00 00 00 00 00 00
0x38 : 160823-164329 : 64 10 32 2e 36 2e 32
0x3c : 160823-164329 : aa bb cc dd ee ff 99 88 77 66 55 44 33 22 11 10
0x3e : 160823-164329 : aa bb cc
0x41 : 160823-164329 : 81 8d 23 00

Hmm, look pretty wild. Looking at the data you have no idea what they might encode.

Let’s try something different and dump all values every 10 minutes.

We see a lot of values that do not change at all like this:

0x38 : 160823-073844 : 64 10 32 2e 36 2e 32
0x38 : 160823-074852 : 64 10 32 2e 36 2e 32
0x38 : 160823-075856 : 64 10 32 2e 36 2e 32
0x38 : 160823-080859 : 64 10 32 2e 36 2e 32
0x38 : 160823-081909 : 64 10 32 2e 36 2e 32
0x38 : 160823-082914 : 64 10 32 2e 36 2e 32
0x38 : 160823-083918 : 64 10 32 2e 36 2e 32
0x38 : 160823-084922 : 64 10 32 2e 36 2e 32
0x38 : 160823-085925 : 64 10 32 2e 36 2e 32
0x38 : 160823-090931 : 64 10 32 2e 36 2e 32
0x38 : 160823-091936 : 64 10 32 2e 36 2e 32
0x38 : 160823-092940 : 64 10 32 2e 36 2e 32
0x38 : 160823-093945 : 64 10 32 2e 36 2e 32
0x38 : 160823-094951 : 64 10 32 2e 36 2e 32
0x38 : 160823-100006 : 64 10 32 2e 36 2e 32
0x38 : 160823-101010 : 64 10 32 2e 36 2e 32
0x38 : 160823-102014 : 64 10 32 2e 36 2e 32
0x38 : 160823-103018 : 64 10 32 2e 36 2e 32
0x38 : 160823-104022 : 64 10 32 2e 36 2e 32

Others seem to change randomly like this

0x41 : 160823-073844 : d4 0d 23 00
0x41 : 160823-074852 : 31 10 23 00
0x41 : 160823-075856 : 8e 12 23 00
0x41 : 160823-080859 : f0 14 23 00
0x41 : 160823-081909 : 4d 17 23 00
0x41 : 160823-082914 : aa 19 23 00
0x41 : 160823-083918 : 02 1c 23 00
0x41 : 160823-084922 : 5f 1e 23 00
0x41 : 160823-085925 : bc 20 23 00
0x41 : 160823-090931 : 19 23 23 00
0x41 : 160823-091936 : 76 25 23 00
0x41 : 160823-092940 : d3 27 23 00
0x41 : 160823-093945 : 30 2a 23 00
0x41 : 160823-094951 : 97 2c 23 00
0x41 : 160823-100006 : f4 2e 23 00
0x41 : 160823-101010 : 51 31 23 00
0x41 : 160823-102014 : ae 33 23 00
0x41 : 160823-103018 : 06 36 23 00
0x41 : 160823-104022 : 63 38 23 00
0x41 : 160823-105025 : c0 3a 23 00

But then there is one characteristic with very controlled changes:

0x35 : 160823-073844 : f2 00 00 68 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-074852 : f2 00 00 54 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-075856 : f1 00 00 54 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-080859 : f2 00 00 54 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-081909 : f2 00 00 68 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-082914 : f2 00 00 54 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-083918 : f2 00 00 68 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-084922 : f2 00 00 68 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-085925 : f2 00 00 57 00 00 00 10 66 00 00 00 00 00 00 00
0x35 : 160823-090931 : f2 00 00 57 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-091936 : f2 00 00 57 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-092940 : f2 00 00 57 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-093945 : f2 00 00 57 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-094951 : f2 00 00 6b 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-100006 : f2 00 00 6b 00 00 00 10 63 00 00 00 00 00 00 00
0x35 : 160823-101010 : f2 00 00 6b 00 00 00 10 63 00 00 00 00 00 00 00
0x35 : 160823-102014 : f2 00 00 79 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-103018 : f2 00 00 79 00 00 00 10 63 00 00 00 00 00 00 00
0x35 : 160823-104022 : f2 00 00 6b 00 00 00 10 65 00 00 00 00 00 00 00
0x35 : 160823-105025 : f2 00 00 79 00 00 00 10 65 00 00 00 00 00 00 00

Seems like there are 4 bytes of values and a lot of zeros. Could these 4 byte be the sensor values? They are!
Now let’s check the values in the Mi app on the iPhone:

  • 24.2 degree celcius
  • 121 Lux
  • 16% moisture
  • 101 us/cm fertility (whatever this means)

Except for the temperature these values map nicely to the data:

  • 16 = 0x10 – byte 8
  • 121 = 0x79 – byte 4
  • 101 = 0x65 – byte 9

The only thing that isn’t yet clear is the encoding of the temperature.

Also the sensor should be able to measure up to 10000 lux. This won’t work with a single byte. So, let’s put another plant it into the bright sunlight:

25 01 00 f7 26 00 00 28 0e 01 00 00 00 00 00 00
  • Fertility is now 270, which is bytes 9 and 10 (MSB byte 9, LSB byte 10)
  • Sunlight is 9975 lux which is stored in bytes 4 and 4 (MSB byte 4, LSB byte 5)
  • And now it is also getting clear how the temperature is encoded. It is in 0.1 degree Celcius steps in bytes 1 and 2, which gives us 29.3 degree celcius in this example (which fits the data displayed by the app).

Messungen mit dem ESP8266

Wer nur schnell ein paar Umgebungsparameter (z.B. Temperatur oder Luftdruck) messen möchte und diese an einen zentralen Server senden möchte, für den bietet sich der ESP8266 an. Und das tolle daran: Das geht sogar komplett ohne Programmierung. Einfach mal die ESP Easy firmware anschauen. Mit dieser Firmware kann man die entsprechenden Sensoren einfach über ein Webinterface konfigurieren ohne selbst irgendetwas programmieren zu müssen:

ESPEasy1

Das richtige BLE Modul für dein Projekt

Bluetooth Low Energy wird immer populärer. BLE verbraucht nicht nur weniger Strom als “klassische” Bluetooth-Schnittstellen, sondern bietet sogar noch eine höhere Sendereichweite. Das wird durch eine reduzierte Datenrate erreicht. Damit eignet sich BLE nicht für grosse Datenübertragungen. Gerade für Sensoranwendungen ist das aber normalerweise kein Problem.

Leider haben viele Prototyping-Plattformen wie Arduino und ESP8266 noch kein BLE integriert. Man muss also Zusatzmodule nutzen, von denen es sehr viele verschiedene gibt.

Allerdings sollte man vor der Bestellung das Datenblatt des Moduls genau lesen.

hm13

Ich erhielt heute dieses HM13-Modul, welches recht günstig ist. Geplant war damit einen Bluetooth-Pflanzensensor anzufragen. Als ich aber das Datenblatt richtig las, stellte ich fest, dass dieses Modul nur für eine serielle Datenverbindung über Bluetooth gedacht ist. Man kann es nicht als “allgemeines” Bluetooth-Interface nutzen.

Daher hier nochmal der Tip: Datenblätter vor der Bestellung lesen! Ansonsten kauft man evtl. Sachen, die man nicht brauchen kann.

Überwachung von Waschmaschine und Trockner

Vermutlich kennen viele das Problem: Man legt die Wäsche in die Waschmaschine und vergisst sie dann. Wenn die Wäsche ein paar Stunden im Trockner liegt, ist das bei modernen Trocknern kein grosses Problem, aber die Wäsche in der Waschmaschine für einige Stunden zu vergessen ist kein Spass.

Nolan Gilley hat einen interessanten Artikel geschrieben, wie man Beschleunigngssensoren nutzen kann, um Waschmaschine und Trockner mit Home Assistant zu überwachen. Hier geht es zum englischsprachigen Artikel.

protoboard

I werde das demnächst mal selbst probieren. Es wäre sicher spannend, das Konzept auszubauen und statt des ESP8266 eine Bluetooth-Low-Energy chip zu nutzen und die Betriebsspannung direkt aus den Vibrationen zu erzeugen. Allerdings sind Piezo-Elemente für derartige Anwendungen recht teuer, weshalb sich das wohl finanziell nicht lohnt.

Fantastisch oder Fantasie? Kapazität von gefälschten LiIon Akkus

Auf einigen Chinesischen Shopping-Webseiten und auf eBay findet man LiIon-Akkus mit fantastischen Kapazitäten.

fake_batteries

Es gibt dort “UltraFire”-Akkus der Grösse 18650mit einer Kapazität von fast 10Ah. Das scheint etwas zu gut, um wahr zu sein. Ist es auch.

Fangen wir mal mit einem ganz einfachen Faktencheck an und schauen auf die UltraFire Webseite. Hier sehen wir, dass Akkus der Grösse 18650 mit einer Kapazität von 2500mAh angegeben sind. Es ist also klar, dass es sich bei den Angeboten um Fälschungen handelt. Aber könnten die Fälscher nicht vielleicht doch gute Akkus bauen, die die vierfache Kapazität des Originals aufweisen? Wohl kaum. Diese Akkus sind also nicht nur Fälschungen, auch die Kapazität ist inkorrekt angegeben.

Aber haben Sie vielleicht wenigstens die gleiche Kapazität wie die Ultrafire-Originale? Ich habe das wie folgt geprüft: Der Akku wurde voll aufgeladen und dann mit einem konstanten Strom von 500mA entladen, bis die Zellspannung auf 2.7V gesunken war. LiIon-Zellen sollten nie auf weniger als 2.7V entladen werden, da sie sonst zerstörte werden können. Die 500mA sind gewählt worden, um den Akku nicht einem grösseren Stress auszusetzen.

Nun lässt sich die Kapazität sehr einfach mit der Formel “Strom x Zeit” ermitteln.

Für die Messung wurde eine elektronische Last genutzt, die nicht nur diese Berechnung gleich mit erledigt, sondern den Test auch automatisch bei 2.7V Zellspannung abbricht.

Alternative Messungen
Hat man keine Konstantstromquelle zur Verfügung, reicht auch ein einfacher Widerstand. Als grobe Näherung kann man die Zellspannung dann als konstant 3.7V annehmen. Die wirkliche Kapazität wird dann geringer sein, aber die Messung gibt einen guten Anhaltspunkt. Wichtig ist allerdings auch hier, dass das Entladen bei 2.7V Zellspannung abgebrochen wird, um die Batterie nicht zu zerstören.

Ergebnisse

Jetzt wird es lustig (oder auch nicht). Obwohl ich nicht erwartet hatte, dass die Kapazität auch nur annähernd der aufgedruckten Kapazität entspricht, war das Ergebnis noch viel schlimmer als erwartet. So sah die Messung eines “9800mAh”-Akkus aus:

LiIon capacity test

Ernsthaft? Nicht mal 1100mAh? Das sind gerade mal 11% der “Soll”-Kapazität. Das bedeutet, dass dieser Akku sogar eine schlechtere Kapazität aufweist als Standard NiMh-Akkus. Ich bin nicht sicher, wie man einen derart schlechte LiIon-Akku bauen kann.

Wenn sich jemand fragt, warum das Display 3.143V anzeigt: Wenn die Last abgeschaltet wird, erholt sich die Zellspannung wieder. Sowie man die Last aber wieder einschaltet, fällt die Spannung innerhalb weniger Sekunden wieder auf unter 2.7V. Der Akku ist also wirklich “leer”.

Da ich nicht sicher war, habe ich die Messung mehrfach wiederholt und auch einen zweiten Akku getestet. Alle Messungen zeigten ein Ergebnis in der gleichen Grössenordnung.

Ich habe auch zwei Akkus in Grösse 16340. Diese waren mit einer Kapazität von 2300 mAh angegeben. Die wirkliche Kapazität lag bei 230-240mAh und damit auch gerade mal bei 10-11% der Sollkapazität.

Fazit

Zwar gibt es auf einigen Shopping-Seiten sehr billige LiIon-Akkus. Aber selbst in Anbetracht der sehr niedrigen Preise kann ich diese nicht empfehlen. Ich rate davon ab, diese auch nur für Tests zu kaufen, sie sind das Geld nicht wert.

Dieser Tests sagt nichts aus über UltraFire-Akkus. Die getesteten Akkus waren ganz klar Fälschungen. Ich werde versuchen, irgendwo ein paar UltraFire Originalakkus zu beschaffen und testen, wie sich diese verhalten.

Günstige Temperatur- und Luftfeuchtigkeitssensoren

Eines der ersten Dinge, die man in der Regel bei der Hausautomatisierung implementiert sind Messungen von Temperatur und Luftfeuchtigkeit. Diese beiden Werte haben nicht nur einen hohen Einfluss auf das persönliche Wohlbefinden, sondern sind auch einfach zu messen. Meist werden hierfür die DHT-Sensoren genutzt. Diese sind nicht nur sehr günstig, es existieren auch sehr viele Codeschnippsel und Bibliotheken für Arduino, ESP8266 und Raspberry Pi. Das macht die Integration sehr einfach. Aber wie unterscheiden sich die Sensoren?

DHT11

Das ist die kleinste Version und billgste Version. Sie ist einfach an der blauen Farbe zu erkennen.Die Auflösung von Temperatur und Luftfeuchtigkeit sind ganze Grad bzw. %
Der Sensor kann einfach auf eine Leiterplatte gelötet oder auf ein Steckbrett gesteckt werden. Das macht Experimente sehr einfach.

DHT22

Dieser Sensor sieht dem DHT11 sehr ähnlich, ist allerdings etwas grösser und weiss. Er bietet eine Auflösung von 0.1°/0.1%. Auch dieser Sensor kann direkt auf eine Leiterplatte gelötet oder auf ein Steckbrett gesteckt werden.

AM2301 (DHT21)

Das ist der grösste Sensor. Er unterscheidet sich von den beiden vorherigen vor allem dadurch, dass er Kabel als Anschlüsse hat. Das macht das Experimentieren auf einem Steckbrett etwas komplizierter. Die Grösse und die Anschlusskabel machen diesen Sensor vor allem für grössere Geräte interessant.Wenn die Schaltung selbst viel Wärme abgibt, ist dieser Sensor auch zu empfehlen, da man ihn in einiger Entfernung von der Wärmequelle positionieren kann.

Genauigkeit

Wie genau sind diese Sensoren? Der DHT11 hat im Vergleich zum DHT21/22 nur eine Auflösung von 1%/1°. Allerdings sollte man die Auflösung nicht mit Genauigkeit verwechseln. Man könnte jetzt die Datenblätter anschauen. Allerdings empfehle ich die Seite von Robert. Er hat viele Messungen mit diesen Sensoren gemacht. Daraus ist zu erkennen, dass DHT11 und DHT22 ähnlich genau sind.
Allerdings würde ich dennoch eher die Sensoren mit 0.1° Auflösung empfehlen, da sich damit langsame Änderungen besser beobachten lassen. Da die Sensoren wenig Rauschen lassen sich mit der höheren Auflösungen Trend besser erkennen. Gerade in modernen Wohnräumen ändert sich die Temperatur oft nur sehr langsam. Selbst wenn man die Heizung abschaltet, dauert es Stunden, bis die Temperatur um 1°C gesunken ist. Mit einer Auflösung von 0.1°C kann man diese Änderungen besser beobachten.

Das folgende Bild zeigt das:
trend
Mit 0.§% Auflösung sieht man den Trend recht gut (grüne Linie), während es mit 1% Auflösung (orangene Linie) schwer möglich ist.

Defekte

Es gibt einige Berichte im Internet über defekte Sensoren. Ich habe gestern einen Prototyp auf dem Steckbrett in ein anderes Zimmer verschoben. Danach sahen die Messungen so aus:
Screenshot 2016-08-01 09.58.35
Das ist sicher nicht korrekt. Die neue Messung besteht praktisch nur noch aus Rauschen und ist praktisch nutzlos. Es scheint, dass der Sensor beschädigt wurde. Ob es sich um ein ESD-Problem handelt oder etwas anderes schiefgegangen ist, kann ich im Moment allerdings nicht sagen.

Empfehlung

Aufgrund der geringen Auflösung würde ich den DHT11 nicht nutzen. Speziell für die Heizungssteuerung ist eine Auflösung von 1°C zu gering. Abhängig von der Anwendung sollte man daher DHT21 oder DHT22 wählen. Generell müssen die Sensoren in einiger Entfernung von Teilen platziert werden, welche Wärme abgeben. Ansonsten werden die Messungen völlig falsch sein.

Reingeschaut: Xiaomi Mi Temeratur-/Luftfeuchtigskeitssensor

Viele dürften Xiaomi aus dem Bereich Smartphones kennen. Diese Geräte werden auch in Europa immer populärer. Im Heimatmarkt in China verkauft Xiaomi allerdings noch viele andere Produkte, u.a. Hausautomatisierungskomponenten. Ich persönlich fand dem Mi Temperatursensor sehr interessant. Er ist sehr klein mit einem Durchmesser von lediglich 36mm. Damit lässt er sich einfach an vielen Stellen installieren. Positiv anzumerken ist die sehr gute Fertigungsqualität. Auch wenn das Gehäuse aus Plastic besteht, ist es doch sehr gut verarbeitet. Manch “westliches” Gerät könnte sich davon eine Scheibe abschneiden.

Der Sensor ist dafür gedacht, mit einem Xiaomi Smarthub zusammen zu arbeiten. Aber geht es evtl. auch ohne? Lässt sich der Sensor in bestehende Hausautomatisierungen einbinden? Schauen wir doch mal rein:

P7260896

Als Stromversorgung dient eine XR2032 Batterie. Ich hoffe, dass diese wenigstens ein Jahr hält. Was finden wir auf dem Board?

mi-therm-board

Auch hier sieht man eine sehr gute Verarbeitungsqualität. Als Hauptprozessor dient ein JN5169 von NXP. Dabei handelt es sich um einenZigbee controller. Erinnert sich noch jemand an Zigbee? Auch wenn heute die meisten neuen Lösung eher auf Bluetooth-Basis gebaut werden, ist Zigbee eigentlich eine recht spannende und stromsparende Funktechnologie. Da es seit Jahren stabil funktioniert (so benutzt z.B. Philips Zigbee für seine Hue Beleuchtungen), spricht nichts gegen den Einsatz. Der einzige Haken besteht darin, dass kein PC direkt mit einem Zigbee-Gerät kommunizieren kann. Es ist daher immer noch etwas Zusatzhardware nötig. Einen entsprechenden Zigbee-Controller kann man jedoch recht einfach an PC, Arduino oder Raspberry Pi anschliessen. Ist es damit einfach zu integrieren? Das hängt davon ab, wie die Datenübertragung selbst funktioniert. Wir werden uns das in einem zukünftigen Artikel noch genauer anschauen.