Thomas makes & shares:

Our custom round home control panels

2025-12-21T11:50:00+01:00

Side and front view of the touch screen. Arc lines indicate 3kW of solar is going to the car, while 2.5kW is pulled from the grid.

This affordable ESP32 based touch panel with IPS capacitive screen made me reconsider not putting home automation screens in the house.

Its round shape is perfect for showing power curves on its circumference and makes it slightly more organic than the rectangular light boxes we immediately recognise as phones or computers.

I ended up designing and 3D printing an enclosure for it and combining OpenHASP with some python code to integrate it with the Home Assistant setup.

Note

This page is still a work in progress, I already wanted to share this project and will add more details and source code references in the future.

Table of Contents

Impressions
Architecture
Mechanics
- Assembly
Firmware
OpenHASP design
Home Assistant Automations
AppDaemon Controls
- A bit more details on the Power Arc

Impressions

The Lilygo T-RGB-2.8 device is about the right size to blend into the row of existing light switches on our kitchen wall.

Photo of the panel installed on the kitchen wall next to the sink.

The IPS resolution is the basis of a proper picture frame, and adding translucent shortcut icons over the picture allows it serve form as well as function. The display module's capacitive touch screen and PSRAM memory give it the feel and performance of a high end product.

The panel is showing power use on a needle gauge, in the middle some the power of some individual devices is shown.

Some of the core house infrastructure only has proper control via phone Apps, like the upstairs Airco indoor units, the central ventilation (a C+ extraction system actually), the car charger and car (preheat shortcuts). A wall panel would also allow easy control of motorized window shutters on different floors and show a glance on the actual energy consumption.

The panel is showing a media player controlling the living room speakers.

Architecture

The OpenHASP firmware is configured by hand and the widgets are defined using a custom crafted pages.jsonl file that defines the page and widget layout.

I use AppDaemon to host python scripts that react to MQTT and Home Assistant websocket events. AppDeamon allows you to spin up instances of automation crafted in Python using a YAML file. In my case I created media player and thermostat controller classes that are referenced in the YAML file for each thermostat control that appears on the touchscreens.

In some sense it mimics the MVC architecture:

Model: Home Assistant offering a data model (state) and allows service calls to trigger device actions.
View: OpenHASP presents LVGL widgets and sending input events to the local MQTT server.
Controller: the AppDaemon automation in Python is updating Home Assistant and OpenHASP widget state

Mechanics

I created a 3D design using OpenSCAD that fits onto a Niko switch coverplate. It looks like the display is part of the switch plate (to me at least) and since the display is very thin, it allows me to install the display without creating extra holes in the wall.

This mechanical adaptor piece which I call the 'saddle' (since it sits on top of a curved surface) features

ventilation holes
alignment studs for the display backlight and Niko coverplate
a slight recess on the top for double sided adhesive tape.
the volume of the Niko coverplate substracted

Its diameter matches the display so that no extra border is visible around the display.

Display 'saddle'

You can find the files here:

saddle.scad

saddle.stl

Assembly

Preparation

Start with a new Niko switch coverplate that is one size bigger than the one that is currently installed, the saddle is placed onto it.

A marker is used to mark a cut-line. After marking, a Dremel or Stanley knife can be used to remove the excess plastic. Superglue is used to fix the saddle onto the Niko plate.

marking where to cut the plastic

Next up is soldering power leads to the circuit board.

Pieces of double sided adhesive tape are placed around the inner edge of the saddle.

Assembly alignment jig.

Mounting the display module

I designed this alignment ring to easily mount the display onto the saddle:

aligner.scad

aligner.stl

The display is placed onto the alignment ring and the saddle will slide into the ring and stick to it when both pieces are mated together. The backlight cover will fit exactly between the alignment studs visible at the bottom, so that the alignment angle is also perfect.

display in place.

Installation

During installation onto the wall the power leads are connected to a 5V power supply behind the light switch. Next the switches are fixed back into the wall box. Some extra slack in the leads will allow the assembly to be dangling on the side while installing.

Once the lightswitches are back in place, the switch cover assembly is snap-pushed onto the switches. Easy!

Firmware

The display is being configured over I2C by bit banging I2C using SPI over an I2C port expander chip. It looks like a strange decision but the display is driven in a parallel configuration which requires a lot of pins. This leaves I2C as only free external interface, which still makes it possible to connect some sensors or other peripherals.

Other hardware is also doing this so porting OpenHASP to this board was a matter of adding the right register configuration values from the SDK examples.

https://github.com/HASwitchPlate/openHASP/pull/958

OpenHASP design

I created a python script so I can generate the pages.jsonl file from a YAML file. YAML is more readable and you can use the merge key to reuse parts of the file. If you don't like long files you can still put your existing JSON lines in the YAML to start with, since JSON is valid YAML.

The conversion script allows me to do some pre-processing magic like aligning widgets on a circular path, and the merge key <<: is used to put YAML reference labels (&circlebutton) on duplicated blocks to copy and paste (*circlebutton) the content later on.

pages:
  1:
    comment: Home
    bg_color: "#0000000"
    swipe: 1
    circle_arrange:
      objects: [24, 25, 23, 30, 31, 32, 33, 34, 35]
      screen_diameter: 480
      edge_clearance: 20
      widget_diameter: 80
      text_font_size: 24
      offsets: [0,  -5]
    objects:
      10:
        obj: img
        src: L:/kids.png
        auto_size: 1
        swipe: 1
      24:
        <<: &circlebutton
          obj: btn
          w: 60
          h: 60
          bg_color: "#444444"
          border_color: "#FFFFFF"
          border_width: 2
          radius: 400
          text_font: 24
          text_color: "#FFFFFF"
          bg_opa: 128
        comment: power
        action: p2
        text: \uF40B
        x: 330
        y: 60
      25:
        <<: *circlebutton
        comment: music
        action: p4
        text: \uE75A
        x: 400
        y: 180

Note that OpenHASP supports 12 pages by default, add a higher value like -D HASP_NUM_PAGES=30 to your .ini file.

Home Assistant Automations

I have an automation that turns on the backlight of the display when the Siemens LOGO PLC reports the wired movement sensor detects movement.

AppDaemon Controls

At this point I have several controllers that I use to control Home Assistant via the OpenHASP panel:

Thermostat control
Media player control
Power Arc control
input select to dropdown box synchronizer
Periodic chores checklist backed by Grocy data.
Biggest power consumers visualizer

I should bundle these up in a repository and share them. Let me know if you are interested.

A bit more details on the Power Arc

Let's look at the code of one of the automations I made, the power arc.

This automation will update the length and color of arc lines like explained on my PowerGauge page.

To make the design a bit slicker, I use overlapping arcs indicating the power level of e.g. grid and solar power.

powerdial_round1_homepage:
  module: powerdial
  class: PowerDial
  lwt_topic: hasp/round1/LWT
  device_topic: round1
  page: 1
  arcs:
    - ids: [100]
      sensors:
      #FIXME: explicitly mention argument names instead of using a list
      - [sensor.total_power_consumption, 1, "#ffff00"]
    - ids: [101,102]
      sensors:
      - [sensor.solaredge_ac_power, 1, "#00ff00"]
      - [sensor.electricity_meter_power_consumption, 1000, "#ff0000"]
    - ids: [110, 111]
      complement: true
      sensors:
       -  [sensor.electricity_meter_power_production, 1000, "#ff00ff"]
       -  [sensor.car_solar_power_2, 1, "#1affff"]
  scale: 10000

The python code is fairly straightforward.

 1 @dataclass
 2 class Dial:
 3     entity_name: str
 4     multiplier: float
 5     color: str
 6     complement: bool
 7     scale: int
 8     value: float
 9     @property
10     def watts(self)->float:
11         return self.value * self.multiplier
12     @property
13     def widget_value(self)->str:
14         val = self.watts
15         if self.complement:
16             val = self.scale - val
17         return str(val)
18
19 @dataclass
20 class ArcWidget:
21     ids: List[int]
22     sensors: List[Dial]
23
24 class PowerDial(HassHaspWidget):
25     """
26     This layers multi color arcs on top of each other.
27     Suggested use:
28     The first is from left to right, and will show grid use and solar
29     The second is from right to left, and will show grid injection and battery charge power
30     of these pairs, the one with the smallest value will be in the foreground so at a glance
31     the power level of each entity can be estimated.
32     """
33     arcs: List[ArcWidget] = None
34
35     @property
36     def use_random_values(self):
37         return self.args.get('use_random_values',False)
38
39     def arc_color_topic(self, id_):
40         return f"hasp/{self.device_topic}/command/p{self.page}b{id_}.line_color10"
41
42     def arc_value_topic(self, id_):
43         return f"hasp/{self.device_topic}/command/p{self.page}b{id_}.val"
44
45     def recalculate(self):
46         """ Order the arcs so the shortest one rendered using the one in the foreground """
47         for arc in self.arcs:
48             arc.sensors.sort(key= lambda x: x.watts if x.complement else -x.watts)
49
50     def redraw(self):
51         for arc in self.arcs:
52             for widget_id, sensor in zip(arc.ids,arc.sensors):
53                 self.mqtt_publish(self.arc_value_topic(widget_id), sensor.widget_value)
54                 self.mqtt_publish(self.arc_color_topic(widget_id), sensor.color)
55
56     def mqtt_publish(self, topic, payload):
57         self.call_service("mqtt/publish", topic=topic, payload=payload)
58
59     def update(self, entity_name, attribute, old, new, cb_args):
60         for arc in self.arcs:
61             for sensor in arc.sensors:
62                 if sensor.entity_name == entity_name:
63                     sensor.value = float(new)
64                 if self.use_random_values:
65                     sensor.value = ((sensor.scale/10)+(sensor.scale/10)*random.random()) / sensor.multiplier
66         self.recalculate()
67         self.redraw()
68
69     def hass_subscribe(self):
70         for arc in self.arcs:
71             for sensor in arc.sensors:
72                 self.listen_state(self.update, sensor.entity_name)
73
74     def initialize(self):
75         HassHaspWidget.initialize(self)
76         scale = int(self.args['scale'])
77         self.arcs = []
78         for arc in self.args['arcs']:
79             complement = bool(arc.get('complement', False))
80             sensors = [
81                 Dial(
82                     entity_name = sensor[0],
83                     multiplier= float(sensor[1]),
84                     color= sensor[2],
85                     complement= complement,
86                     scale = scale,
87                     value = 0) \
88                 for sensor in arc['sensors']]
89             self.arcs += [ ArcWidget(arc['ids'], sensors)]
90
91         self.mqtt_subscribe()
92         self.hass_subscribe()
93         self.redraw()

Modbus Current Clamps for your breaker box

2025-09-06T22:15:00+02:00

Introduction

Modbus current measurement device

To feed my power optimization obsession, I already built some strange devices and did some interesting experiments.

With a new electricity panel in place, I really needed to add current monitoring to 16 of the circuits to keep an eye on things.

I like Modbus for wired sensors for its simplicity, and found this reasonably priced device that seemed to be a good solution.

The HDXXAXXA16GK-D has 16 screw terminal inputs to connect the current transformers that it ships with. It takes 8-28VDC power supply and has the usual A/B RS485 Modbus-RTU connections.

Table of Contents

Introduction
Concept
Configuring the device
Installing the device
Home assistant configuration
Visualisation of power use in Home Assistant

Concept

Home Assistant can track the energy consumption in your house, but it needs sensors to do so. In Belgium, the obvious way to start is to tap in to the grid utility meter, which has a P1 port, this is a serial port that dumps the meter data every 5 seconds or so.

Your solar production can be tracked by reading the inverter data, either via Modbus or via an API, in my setup, the solaredge inverter is read via the Solaredge Modbus integration over TCP/IP.

If you want to add accurate tracking of individual devices, a nice and easy way is to use a smartplug, which is low entry and easy to install. But if you want to track the power consumption of your entire house, it may be safer to use current clamps on the main circuits in your electrical panel. This way you can avoid depending on the electrical reliability of the smartplugs, especially for high power devices like electrical boilers or heaters.

Installing actual energy meters per circuit would be more accurate, but

are very expensive
they would take up a lot of space.
are harder to retrofit.

I opted to use proper modbus energy meters for the heatpumps and EVSE (car charge point) though, since I want proper tracking for them, and energy meters take power factor into account and have a better sampling rate.

Colorful Home Assistant energy graphs

Since we are interested in power and energy, and the current clamps only measure current, we need to do some calculations in home assistant. We can use the P1 grid meter's reported line voltages and combine the data in home assistant template sensors.

Configuring the device

I always trial-run a modbus device on desk with a USB to RS485 adapter before installing it in the panel.

For starters, we need to assign the device a unique Modbus address using modbus-cli (and perhaps run pip install modbus_cli first) since the device is connected together with several other modbus devices on the same RS485 bus.

To set the slave address to 4:

modbus /dev/ttyUSB0 -p 2 -b 9600 -P n -s 1 3=4

You can also try to read some of the registers to see if the device is working. To read the version register:

modbus /dev/ttyUSB0 -p 2 -b 9600 -P n -s 4 0

Installing the device

The device is installed in the electrical panel, powered by a 24VDC power supply, and connected to the RS485 bus. The 16 supplied current clamps are connected to the 16 channels, and clamped around the live wire of each circuit. The device can be mounted on a DIN rail, but it's quite big to fit the cabinet that I have, so i used the flanges on the side to screw it to the backplate of the cabinet.

Warning

Make sure to turn off the power in the electrical panel before working in it, and if you are not comfortable doing so, hire a professional electrician. Working in an electrical panel can be dangerous and even deadly. Always follow local regulations and guidelines. I am not responsible for any damage or injury caused by actions taken based on this information. This is not a step-by-step guide, just a description of what I did. Your situation may be different, so adapt accordingly. Always prioritize safety and compliance with local laws. If in doubt, consult a professional electrician.

Warning

The current clamps are transformers, and the secondary side should never be open-circuited while current is flowing in the primary side. This can cause high voltages and damage the device or cause injury. Always turn off the circuit in question before connecting the clamp's measurement output wires to the meter.

Home assistant configuration

To keep the configuration concise, I used only two yaml entries, one for the version register (as a sanity check), and another one with a slave_count of 16 to read all the channels in one go. Home assistant can then even use a single modbus command, to speed things up.

These are the additions to modbus.yaml:

- name: clamps_version
  slave: 4
  address: 0
  data_type: uint16
- name: clamps_channel
  unique_id: clamps_channel
  slave: 4
  #off by one so channel_1 is actually channel one
  address: 7
  precision: 2
  scale: 0.01
  data_type: uint16
  device_class: current
  unit_of_measurement: A
  slave_count: 16

In template.yaml a template entity is created to calculate the power consumption of the circuit:

- trigger:
  - platform: time_pattern
    minutes: "/1"
  - platform: state
    entity_id:
      - sensor.clamps_channel_1
      - sensor.sdm630_phase_1_line_to_neutral_volts
    not_from:
      - "unknown"
      - "unavailable"
    not_to:
      - "unknown"
      - "unavailable"
  sensor:
     - name: car_clamp_power
        unique_id: car_clamp_power
        unit_of_measurement: W
        device_class: power
        state_class: measurement
        state: >
        {% set current = states('sensor.clamps_channel_1')|float %}
        {% set voltage = states('sensor.sdm630_phase_1_line_to_neutral_volts')|float %}
        {% set power = current*voltage*3 %}
        {{ '%0.3f' | format(power) }}
        attributes:
        dummy: "{{ now().minute }}"

And in sensor.yaml an energy meter that integrates the power of the circuit over time:

- platform: integration
  name: car_clamp_energy
  source: sensor.car_clamp_power
  round: 2

Visualisation of power use in Home Assistant

Home assistant power visualisation using bar-card and custom template card.

Home assistant has built-in energy tracking and visualisation, but no overview of the power use.

To have such a nice live visualisation, I set up a home assistant dashboard that displays the real time power usage. This dashboard uses the config-template-card with bar-card and the power-flow-card-plus.

I use the following YAML configuration entered in the dashboard editor since this custom card can not be configured via custom UI dialog.

type: custom:config-template-card
variables:
  - entity: sensor.warmtepomp_int_power
    name: Heatpump resistor
  - entity: sensor.car_grid_power_2
    name: Laadpaal grid
  - entity: sensor.car_solar_power_2
    name: Laadpaal solar
  - entity: sensor.tuinhuis_power
    name: Tuinhuis
  - entity: sensor.nikoplug_power
    name: Ventilatie
  - entity: sensor.badkamer_chauffage_power
    name: Badkamer
  - entity: sensor.kitchen_1_power
    name: Keuken ww
  - entity: sensor.droogkast_power
    name: Droogkast
  - entity: sensor.wasmachine_power
    name: Wasmachine
  - entity: sensor.fornuis_power
    name: Fornuis
  - entity: sensor.kitchen_2_power
    name: Keuken links
  - entity: sensor.oven_power
    name: Oven
  - entity: sensor.sdm120_1_power
    name: Warmtepomp
  - entity: sensor.sdm120_2_power
    name: Airco
  - entity: sensor.veranda_power
    name: Veranda
entities:
  - sensor.airco_power
  - sensor.warmtepomp_int_power
  - sensor.boiler_power
  - sensor.tuinhuis_power
  - sensor.car_solar_power_2
  - sensor.car_grid_power_2
  - sensor.nikoplug_power
  - sensor.badkamer_chauffage_power
  - sensor.kitchen_1_power
  - sensor.droogkast_power
  - sensor.wasmachine_power
  - sensor.fornuis_power
  - sensor.kitchen_2_power
  - sensor.oven_power
element:
  type: custom:bar-card
  entities: |-
    ${ vars.filter(v => {
      let ent = states[v.entity];
      if(ent === undefined || ent.state === undefined) {
        console.warn(`Power meter: Entity ${v.entity} not found`);
      }
      else if(ent.state === 'unknown') {
        console.warn(`Power meter: Entity ${v.entity} state is unknown`);
      }
      else if(isNaN(ent.state)) {
        console.warn(`Power meter: Entity ${v.entity} state is not a number`);
      }
      else return Number(ent.state) > 5 || true;
    }).sort((v1,v2) => states[v2.entity].state - states[v1.entity].state)}
  direction: right
  entity_row: true
  min: 0
  max: >-
    ${ Math.max(...vars.map(v => states[v.entity]).filter(e => !!e).map(e =>
    e.state).filter(n => !isNaN(n))) }
  height: 20px
  stack: vertical
  decimal: 0
  icon: mdi:flash
  positions:
    icon: "off"
    indicator: outside
    name: inside
    value: inside
  severity:
    - color: "#a1a1a18a"
      from: 0
      to: 2
    - color: "#3ea8328a"
      from: 2
      to: 10
    - color: "#85a8328a"
      from: 10
      to: 50
    - color: "#a8a4328a"
      from: 50
      to: 200
    - color: "#a887328a"
      from: 200
      to: 500
    - color: "#a867328a"
      from: 500
      to: 1000
    - color: "#a846328a"
      from: 1000
      to: 3000
    - color: "#a832328a"
      from: 3000
      to: 10000
  style: "#states > * {\n  margin: 1px;\n}\nbar-card-name,\nbar-card-value {\n  font-size: 0.9rem;\n  color: #ffffffaa;\n  font-weight: bold;\n}\nbar-card-value\t{\n  font-weight: bolder;\n}\nbar-card-indicator {\n  margin-top: 4px;\n  transform: scaleY(-1);\n}"

www.thouters.be facelift 2025

2025-07-05T17:45:00+02:00

test

Pelican static site generator logo

Halfway 2025 I gave my homepage a facelift by putting on my web developer hat and doing some HTML and CSS work.

I wanted to have a summary of all customisations I have done to the Pelican configuration, so I wrote this post about it.

Snapshot photo

For the record, here is a screenshot of the website at the time of writing;

thouters.be website screenshot in 2025

The codebase

I set up Pelican some years ago since I use and prefer reStructuredText over markdown, and like the fact that Pelican is written in Python and customisable. Each post has its own file in the repository, and a makefile triggers an upload to my web server using rsync.

The theme

I used the Blue Penguin theme by Tyler Carr as basis for the website style, but heavily modified it over the years. The Blue Penguin Dark theme exists nowadays, I don't exactly remember if I used the dark theme, or if I darkened it myself.

Flexible Box layout cards from Ghost's Casper theme

I've (jealously) been eyeballing some homepages that use Ghost, and they all use a flexible box layout (ccs display: flex;) combined with some slick visual design.

Martijn Braam created a jinja HTML template to render his website with such a design and shared in the spook repository's static_casper folder. I could also find the HTML style file (CSS) in the repository.

Infinite scrolling

When websites have a lot of data to display they typically paginate/limit the data that is presented when the webpage loads. Remember the Gooooooooogle at the bottom of your search results, with every o representing one of the result pages you can click? Nowadays you typically get a 'load more' at the bottom of a webpage, or a webpage that you can seem to scroll indefinitely on (e.g. an algorithm firehose like xitter or Tiktok).

On my front-page, you used to have to click a next page / previous page to navigate the large list of posts, but by adding a small piece of ready made javascript, the content of the next pages gets loaded into the front-page when scrolling downwards.

<script src="https://www.thouters.be/theme/js/infinite-scroll.pkgd.min.js"></script>
<script>
    let elem = document.querySelector('.post-feed');
let infScroll = new InfiniteScroll( elem, {
  // options
  path: '.next_page',
  append: '.post',
  history: false,
});
</script>
<script>
  document.getElementById('js-only-message').style.display = 'block';
</script>

Visually attractive summaries

The ghost theme's article card features a title, a summary and a picture.

These can be extracted from your posts by some plugins.

The featured_image plugin can extract the first image from an article and exposes it in the template.

PLUGINS += ['featured_image']

The summary itself can be retrieved by the summary plugin:

PLUGINS += ['summary']

By default the summary plugin extracts the first paragraph, but by using markers like PELICAN_BEGIN_SUMMARY in your content you can pick a snipet of the intro section instead.

I typically begin my posts with metadata, an image and summary markers:

:author: Thomas Langewouters
:description: website stuff
:date: 2025-04-10 17:45
:tags: homepage, etching, diycircuitboard, kicad
:slug: ThoutersDotBeAnno2025
:image: https://www.thouters.be/img/ThoutersDotBeAnno2025/pelican-logo.svg


.. figure:: {static}img/ArticleName/image.png
   :alt: image
   :align: center

   description of the image that is used as featured image.


.. PELICAN_BEGIN_SUMMARY

some introduction that also serves as summary


.. PELICAN_END_SUMMARY

.. contents:: Table of Contents

Better fitting cover images

My articles usually start with an image/photo of the project. The featured-image plugin picks this up and no additional work is required.

The ghost theme uses an object-fit: cover property for the image in the post preview cards, which makes it clip the image if the photo is a square instead of a wide rectangle.

Sometimes this is not what you want. the :image: metadata tag can be used to set a custom one that has different aspect ratio and doesn't clip the image beyond recognition.

The article listing also features a reading time, provided by the reading time plugin.

Stripping link tags from the summaries

The summaries are displayed on the front page in link target (an anchor hyperlink tag; <a href=) so they can be clicked. To avoid the inconsistency nested links would bring, the summaries themselves can't contain links themselves.

I implemented an extra template filter to do this stripping in the jinja_filters plugin (you can find it in this pull request, a the time of writing it's not yet merged)

PLUGINS += ["pelican.plugins.jinja_filters"]

And used like this:

<div class="post-card-excerpt">
    {{ article.summary |unwrap_links }}
</div>

Visitor comments

Carl Schwan had an interesting idea, he uses a static site generator as well, and that means the website can't accept and store data, like for visitor comments.

Handling and storing the comments would even expose you to GDPR requests and require cookie banners. It's better if you can delegate this to a third party service.

So static websites usually use a third party service like github utterances.

Carl's idea was to create a mastodon toot per article (a toot is a social media post, 'tweet') , and have people discuss and reply to that specific toot on the mastodon (fediverse) social network. Other people have made similar implementations as well.

This works fine if your reading audience has a mastodon account, and great if they find their way to your website via the mastodon toot that you are using as the discussion board.

I adapted his javascript code to fit my website style.

It's not so accessible than other options like discus though, visitors need to have a fediverse account, and most people simply don't have an account.

Pagination paths

I don't like subfolders for tags or index pages, so I changed this pelican setting:

 # example pagination pattern
 PAGINATION_PATTERNS = (
     (1, '{url}', '{save_as}'),
-    (2, '{base_name}/page/{number}/', '{base_name}/page/{number}/index.html'),
+    (2, '{base_name}/page-{number}-', '{base_name}/page-{number}-index.html'),

Devcontainer

Devcontainers are a nice way to create a reproducible development environment that has all the necessary packages to render your pelican homepage:

{
    "name": "Pelican Static Site Generator",
    "image": "mcr.microsoft.com/devcontainers/python:1-3.12-bullseye",

    // Features to add to the dev container. More info: https://containers.dev/features.
    "features": {
        "ghcr.io/devcontainers/features/git:1": {},
        "ghcr.io/devcontainers/features/github-cli:1": {}
    },

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    "forwardPorts": [8000],

    // Use 'postCreateCommand' to run commands after the container is created.
    "postCreateCommand": "pip install --user -r requirements.txt && pip install --user -r pelican-plugins/requirements.txt",

    // Configure tool-specific properties.
    "customizations": {
        "vscode": {
            "extensions": [
                "ms-python.python",
                "ms-python.flake8",
                "ms-python.black-formatter",
                "bradlc.vscode-tailwindcss",
                "formulahendry.auto-rename-tag",
                "ms-vscode.vscode-json",
                "redhat.vscode-yaml",
                "yzhang.markdown-all-in-one"
            ],
            "settings": {
                "python.defaultInterpreterPath": "/usr/local/bin/python",
                "python.linting.enabled": true,
                "python.linting.flake8Enabled": true,
                "python.formatting.provider": "black",
                "files.associations": {
                    "*.html": "html",
                    "*.j2": "jinja-html"
                }
            }
        }
    },

    // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
    "remoteUser": "vscode",

    // Add environment variables
    "containerEnv": {
        "PELICAN_THEME_PATH": "${containerWorkspaceFolder}/theme"
    },

    // Add workspace mounts for better performance
    "mounts": [
        "source=${localWorkspaceFolder}/output,target=${containerWorkspaceFolder}/output,type=bind,consistency=cached",
        "source=${localWorkspaceFolder}/output_drafts,target=${containerWorkspaceFolder}/output_drafts,type=bind,consistency=cached",
        "source=${localWorkspaceFolder}/output_local,target=${containerWorkspaceFolder}/output_local,type=bind,consistency=cached"
    ],

    // Add useful tasks
    "portsAttributes": {
        "8000": {
            "label": "Pelican Dev Server",
            "onAutoForward": "notify"
        }
    }
}

It needs a requirements.txt file with a list of python packages:

# Pelican and core dependencies
pelican[markdown]>=4.8.0
invoke>=2.0.0
livereload>=2.6.3

# Plugin dependencies
Markdown>=3.4.0
Pillow>=9.0.0
beautifulsoup4>=4.11.0
pelican-sitemap>=1.0.0
pelican-featured-image>=1.1.0
pelican-seo>=1.4.0
pelican-neighbors>=1.2.0
pelican-readtime>=0.2.1

# Local plugins (editable installs)
-e ./jinja-filters

# Development tools
flake8>=5.0.0
black>=22.0.0

# Additional useful packages for static site generation
jinja2>=3.1.0
python-dateutil>=2.8.0
feedgenerator>=2.0.0

Build the devcontainer with devpod up (potentially add --ide=none):

devpod up . --devcontainer-path=.devcontainer/devcontainer.json

Now you should be able to use this command (Makefile rule is shown) to generate your HTML:

publish:
    devpod ssh . --command "pelican -s pelicanconf_publish.py"

Or add -rl to have pelican serve the HTML locally as preview and for e.g. proofreading your drafts articles with a custom configuration file.

publish:
    devpod ssh . --command "pelican -rls pelicanconf_drafts.py"

The custom configuration files makes the articles not marked as published explicitly published:

import os
exec(open(os.path.join(os.path.dirname(__file__),"pelicanconf.py")).read())

SITEURL = 'https://www.thouters.be/'
SITENAME = "Thomas shares DRAFTS"
OUTPUT_PATH = "output_drafts"
RELATIVE_URLS = True

DEFAULT_METADATA = {
    'status': 'published',
}

TODO/wish list

I still need to check which plugin for displaying a photo album with thumbnails will work best for me.
When I have a project with PDF attachements, some simple macro to show a box with pdf icon and filename would be nice to have.

Rainwatertank Level Pressure Probe

2025-06-30T20:00:00+02:00

Pressure based water level sensor

A few years ago, I designed and built my own rainwater tank level sensor for fun. Unfortunately the unthinkable happened: the grommet sealing the cable inlet leaked and its insides got wet... I had to fix it or get an other one.

My brother had installed a submersible Pressure Transducer in his rainwater tank, and rather than improving my old project I chose to use his aproach and get an off the shelve sensor to measure the tank level and use the saved time for other fun projects.

Table of Contents

Principle
Current loop to Modbus
- Configuring and testing
Automations

Principle

Pressure level transmitter principle.

The weight of the water column creates a pressure difference which the transmitter module converts to an electric current value.

This sensor is a drop-in replacement for my own rainwater tank level sensor, so hooking the sensor up is exactly the same.

Note

In the article I wrote about the sensor I designed I explain how the current loop principle works, check it out for more juicy details.

Current loop to Modbus

I bought a very crappy Analog to digital conversion module on Aliexpress:

It's a 6€ "4-20MA RS485 Voltage Current Analog Collector ADC Modbus RTU 4-Channel N4AIA04 Voltage Current Acquisition Module", which I plan to replace with a device of my own design somewhere in the future.

Analog (4-20mA and 0-10V) to Modbus converter

The modbus protocol is quite simple. It defines some commands to query devices on a shared serial bus. This is the same serial encoding you find on FTDI USB to serial cables and Arduino UART pins, although the electrical connection works half-duplex, only one device talks at the same time. The electrical signals are set up in a differential way, this makes it possible to have a long bus cable of a twisted wire pair, with devices connected onto this cable at any point of the cable.

The modbus commands are fairly simple, and can be implemented using modbus libraries on python or embedded platforms like the arduino. For our purposes we need a PC modbus client to configure our modbus device, and the home assistant integration to send read register commands to the device to read the current register's value.

The N4AIA04 manual.pdf lists the commands and other device details.

Configuring and testing

First we need to set the Modbus address to be an unique value using modbus-cli (and perhaps run pip install modbus_cli first):

modbus  -b 9600 -s 1 /dev/ttyUSB0  14=6

Read current values

modbus  -b 9600 -s 6 /dev/ttyUSB0  2 3

Next we need some Homeassistant configuration, first we set the details in modbus.yaml on how to read the sensor:

- name: level_current
  slave: 6
  address: 2
  scale: 0.1
  precision: 1
  data_type: uint16
  unit_of_measurement: mA
  device_class: current

And add a template sensor(template.yaml):

- trigger:
    - platform: time_pattern
      minutes: "/1"
    - platform: state
      entity_id:
        - sensor.filtered_level_current
      not_from:
        - "unknown"
        - "unavailable"
      not_to:
        - "unknown"
        - "unavailable"
  sensor:
    - name: rainwater_level
      unique_id: rainwater_level
      unit_of_measurement: "%"
      device_class: signal_strength
      state_class: measurement
      state: >
        {% set l = states('sensor.filtered_level_current')|float %}
        {% set level = (((l - 4)/16) * 100 ) %}
        {{ '%0.3f' | format(level) }}
      attributes:
        dummy: "{{ now().minute }}"

To overcome the noise of the crappy ADC Modbus module, I added a low pass filter:

- platform: filter
  name: "filtered_level_current"
  entity_id: sensor.level_current
  filters:
    - filter: time_simple_moving_average
      window_size: "01:00"
      precision: 2

Automations

What's next is to add an automation that sends me an alert when the water level gets too low. For the time being my obsession about the data and plots keeps me informed, but at one point it will grow old and the toilet might stop flushing suddenly...

Power indicator Gauge

2025-06-16T23:00:00+02:00

Openhasp device

My openHASP control panels have been eye catchers on my desk for years now. I've been using the WT32-SC01 Plus one for over a year to keep an eye on the electric power use in our house.

I designed a fancy power dial with extra arc indicators on the outside and a dynamic list of the biggest power consumers in the middle..

Table of Contents

The idea
Implementation
Hardware
Appdaemon automation
OpenHASP design
Home assistant dashboard equivalent
Chores

The idea

I had this idea of using a classic needle gauge to show the momentary power level, and add a few colored arcs to the sides to visualize these things:

Momentary total power consumed by all devices
In green, the solar production arcs up from the left side, if this arc matches the needle, or goes above it, all is good.
In red, the power used from the grid, ideally no red line appears at all!
In magenta, the power injected to the grid arcs from the right side back to the left. If its length is equal to the green arc, we're injecting all solar production.
In turquoise, the solar power used for charging the car is shown arcing from the right. If there's more solar than the car can handle, a piece of magenta might pop over it at the bottom.

placeholder

Concept diagram

Here are some early screenshots of the prototypes:

Screenshots

I added a top 4 of the biggest consumers along with progress bars representing their relative demand (including colors, car solar use is blue!). I got this idea from Sean Blanchfield's blog post on Real Time Device Power Meter for Home Assistant. I have the same view on my Home assistant dashboard using the widget mentioned on that post, and it's so nice it shouldn't be missing from my openHASP page!

Raspberrypi running openHASP showing the consumers.

Implementation

Hardware

I had WT32-SC01 board, it's a nice display with a capacitive touchscreen layer, way better than the resistive ones on my previous builds. I wanted to use the same shaped enclosure as my my other openhasp builds and found this WT32-SC01-Plus Stand With Socket enclosure on printables.com.

Appdaemon automation

This appdaemon script monitors the homeassistant entities, and will publish messages to the MQTT server to update the openHASP widget state to reflect the new values.

The appdaemon apps.yaml creates an instance of the automation and sets the parameters. Note that in the YAML snipet below there are some YAML merge keys and reference labels to reuse parts of the yaml configuration.

powerconsumers_desk:
  <<: *plate_desk
  page: 2
  <<: &powerconsumers
    module: powerconsumers
    class: PowerConsumers
    widget_start_id: 42
    widgets: 4
    sensors: &power_sensors
      sensor.sdm120_2_power: Airco
      sensor.warmtepomp_int_power: WP Weerstand
      sensor.sdm120_1_power: Warmtepomp
      sensor.tuinhuis_power: Tuinhuis
      sensor.car_solar_power_2: Laadpaal Zon
      sensor.car_grid_power_2: Laadpaal Net
      sensor.nikoplug_power: Ventilatie
      sensor.badkamer_chauffage_power: Badkamer
      sensor.kitchen_1_power: Keuken-ww
      sensor.kitchen_2_power: Keuken l
      sensor.droogkast_power: Droogkast
      sensor.wasmachine_power: Wasmachine
      sensor.veranda_power: Veranda
      sensor.fornuis_power: Kookvuur
      sensor.oven_power: Oven
      sensor.berging_power: Diepvries
    force_bar_color:
      "Laadpaal Zon": "#008b8b"

The implementation in Python:

import appdaemon.plugins.hass.hassapi as hass
from decimal import Decimal
from datetime import timedelta, datetime
import mqttapi as mqtt

default_colors = (
    (0, 2, '#6f706f'),
    (2, 10, '#0c7600'),
    (10, 50, '#537600'),
    (50, 200, '#767200'),
    (200, 500, '#765500'),
    (500, 1000, '#763500'),
    (1000, 3000, '#761400'),
    (3000, 10000, '#760000'),
)

class PowerConsumers(hass.Hass, mqtt.Mqtt):
    @property
    def force_bar_color(self):
        return self.args.get('force_bar_color',{})
    @property
    def widget_start_id(self):
        return self.args['widget_start_id']
    @property
    def widgets(self):
        return int(self.args['widgets'])

    @property
    def device_topic(self):
        return self.args['device_topic']
    @property
    def sensors(self):
        return self.args["sensors"]
    @property
    def lwt_topic(self):
        return self.args["lwt_topic"]
    @property
    def page(self):
        return self.args['page']
    @property
    def colors(self):
        return self.args.get('colors',default_colors)

    def validate_args(self):
        assert isinstance(self.colors, list) or isinstance(self.colors, tuple), f"colors must be a list or tuple"
        for value in self.colors:
            assert isinstance(value, list) or isinstance(value, tuple), f"list entry {value} should be a list or tuple"
            assert isinstance(value[0], int), f"list entry {value[0]} should be a number"
            assert isinstance(value[1], int), f"list entry {value[1]} should be a number"
            assert isinstance(value[2], str), f"list entry {value[2]} should be a string"
            assert value[2].startswith("#"), f"list entry {value[2]} should be a HTML color"
            assert len(value[2])==7, f"list entry {value[2]} should be a HTML color"

    def update(self, entity, attribute, old, new, cb_args):
        self.log(f"got update for  {entity}: {new}")
        new = int(float(new))
        self.db[entity] = new
        self.redraw()

    def redraw(self):
        print("redrawing!")
        if len(self.db) == 0:
            return
        highest = max((float(v) for v in self.db.values()))
        to_show = list(reversed(sorted(self.db.items(), key=lambda x:x[1])))
        to_show = list(to_show)[0:self.widgets]
        for i, (e, v) in enumerate(to_show):
            try:
                self.publish_entry(i, self.sensors[e], float(v)*100/highest, v)
            except ZeroDivisionError:
                pass

    def watt_to_color(self, watt):
        for start, end, color in self.colors:
            if watt > end:
                continue
            if watt < end:
                return color
        return self.colors[0][2]
    def publish_entry(self, index, name, percent, value):
        topic = f"hasp/{self.device_topic}/command/p{self.page}b{self.widget_start_id+3*index+0}.val"
        self.call_service("mqtt/publish", topic=topic, payload=f"{percent}")
        if name in self.force_bar_color.keys():
            color = self.force_bar_color[name]
        else:
            color = self.watt_to_color(value)
        self.call_service("mqtt/publish", topic=f"hasp/{self.device_topic}/command/p{self.page}b{self.widget_start_id+3*index+0}.bg_color10", payload=color)
        self.call_service("mqtt/publish", topic=f"hasp/{self.device_topic}/command/p{self.page}b{self.widget_start_id+3*index+1}.text", payload=name)
        self.call_service("mqtt/publish", topic=f"hasp/{self.device_topic}/command/p{self.page}b{self.widget_start_id+3*index+2}.text", payload=f"{value}W")

    def initialize(self):
        self.db = {}
        self.mqtt = self.get_plugin_api("MQTT")
        self.validate_args()

        for entity_name in self.sensors.keys():
            try:
                self.db[entity_name] = int(float(self.get_state(entity_name)))
            except Exception as e:
                self.log(f"can't retrieve entity {entity_name} on start")
            self.listen_state(self.update, entity_name)

        self.mqtt.listen_event(self.mqtt_message_received_event, "MQTT_MESSAGE", topic=self.lwt_topic)

    def mqtt_message_received_event(self, event, data, kwargs):
        #topic,message
        assert event == "MQTT_MESSAGE"
        self.log(f"MQTT {event} **{data}")
        topic = data.get("topic")
        payload = data.get('payload')
        if payload.startswith("{"):
            payload = json.loads(payload)
        self.redraw()

OpenHASP design

This is the list of OpenHASP widgets that make up the plate's 'page' that displays the power gauge, it consists of JSON lines, one line per widget:

{"page":2,"comment":"---------- Page 2 ----------", "bg_color":"#000000", "swipe":1}
{"id":13,"obj":"gauge","x":20,"y":20,"w":260,"h":260, "min":0,"max":10000, "val":2000, "critical_value": 10000, "scale_end_color": "#FF0000", "format": 3, "bg_color":"000000", "scale_grad_color":"#ffffff", "scale_end_color":"#ffffff", "line_color10":"#ffff44","line_width10":5,"line_opa":255, "line_color":"#ffffff","line_color60":"#ffffff","scale_grad_color":"#ffffff","scale_grad_color60":"#ffffff","scale_end_color60":"#ffffff", "bg_color10":"#ffff44", "border_color20":"#000000"}
{"page":2,"id":17,"obj":"arc","x":6,"y":10,"w":270,"h":290,"min":0,"max":10000,"val":2000,"border_side":0,"type":0,"rotation":0,"start_angle":135,"end_angle":45,"adjustable":"false","line_width":21,"line_width10":10,"line_color10":"#00ff00","line_color20":"#ffffff","line_opa30":"0","bg_opa":0,"pad_top20":5,"pad_bottom20":5,"pad_left20":5,"pad_right20":5,"pad_bottom":5,"pad_left":5,"pad_right":5}
{"page":2,"id":20,"obj":"arc","x":16,"y":10,"w":270,"h":270,"min":0,"max":10000,"val":3000,"border_side":0,"type":0,"rotation":0,"start_angle":135,"end_angle":45,"adjustable":"false","line_width":21,"line_width10":10,"line_color10":"#ffff00","line_color20":"#ffffff","line_opa30":"0","bg_opa":0,"pad_top20":5,"pad_bottom20":5,"pad_left20":5,"pad_right20":5,"pad_bottom":5,"pad_left":5,"pad_right":5}
{"page":2,"id":18,"obj":"arc","x":16,"y":10,"w":270,"h":270,"min":0,"max":10000,"val":500,"border_side":0,"type":0,"rotation":0,"start_angle":135,"end_angle":45,"adjustable":"false","line_width":21,"line_width10":10,"line_color10":"#ff0000","line_color20":"#ffffff","line_opa30":"0","bg_opa":0,"pad_top20":5,"pad_bottom20":5,"pad_left20":5,"pad_right20":5,"pad_bottom":5,"pad_left":5,"pad_right":5}
{"page":2,"id":25,"obj":"arc","x":16,"y":10,"w":270,"h":270,"min":0,"max":10000,"val":0,"border_side":0,"type":2,"rotation":0,"start_angle":135,"end_angle":45,"adjustable":"false","line_width":21,"line_width10":10,"line_color10":"#008b8b","line_color20":"#ffffff","line_opa30":"0","bg_opa":0,"pad_top20":5,"pad_bottom20":5,"pad_left20":5,"pad_right20":5,"pad_bottom":5,"pad_left":5,"pad_right":5}
{"page":2,"id":19,"obj":"arc","x":16,"y":10,"w":270,"h":270,"min":0,"max":10000,"val":0,"border_side":0,"type":2,"rotation":0,"start_angle":135,"end_angle":45,"adjustable":"false","line_width":21,"line_width10":10,"line_color10":"#ff00ff","line_color20":"#ffffff","line_opa30":"0","bg_opa":0,"pad_top20":5,"pad_bottom20":5,"pad_left20":5,"pad_right20":5,"pad_bottom":5,"pad_left":5,"pad_right":5}
{"obj":"label","id":16,"x":0,"y":220,"w":300,"h":24,"text":"\uF40B kW","align":"center","text_color":"#ffffff","value_font":22,"bg_color":"#000000","bg_opa": "0","radius":0,"border_side":0}
{"page":2,"id":60,"obj":"obj","x":75,"y":75,"w":150,"h":150,"radius":1000,"border_color":"#000000","bg_opa10":188,"bg_color10":"#000000"}

{"obj":"bar","id":42,"x":80,"y":110,"w":140,"h":4,   "border_width":0,"val":70,"bg_color10":"#a83232", "bg_color":"#111111","radius10":5,"radius00":5}
{"obj":"label","id":43,"x":80,"y":89,"w":139,"h":20,"bg_color":"#000000","border_color":"#C7BAA7","border_width":0,"text":"Warmtepomp hitte","text_font":16,"align":"left"}
{"obj":"label","id":44,"x":80,"y":90,"w":140,"h":20,"bg_color":"#000000","border_color":"#C7BAA7","border_width":0,"text":"10W","text_font":16,"align":"right"}

{"obj":"bar","id":45,"x":80,"y":140,"w":140,"h":4,   "border_width":0,"val":50,"bg_color10":"#3ea832", "bg_color":"#111111","radius10":5,"radius00":5}
{"obj":"label","id":46,"x":80,"y":120,"w":139,"h":20,"bg_color":"#111111","border_color":"#C7BAA7","border_width":0,"text":"Thuinhuis","text_font":16,"align":"left"}
{"obj":"label","id":47,"x":80,"y":120,"w":140,"h":20,"bg_color":"#000000","border_color":"#C7BAA7","border_width":0,"text":"20W","text_font":16,"align":"right"}

{"obj":"bar","id":48,"x":80,"y":170,"w":150,"h":4,   "border_width":0,"val":20,"bg_color10":"#a8a432", "bg_color":"#111111","radius10":5,"radius00":5}
{"obj":"label","id":49,"x":80,"y":150,"w":139,"h":20,"bg_color":"#111111","border_color":"#C7BAA7","border_width":0,"text":"Keuken","text_font":16,"align":"left"}
{"obj":"label","id":50,"x":80,"y":150,"w":140,"h":20,"bg_color":"#000000","border_color":"#C7BAA7","border_width":0,"text":"30W","text_font":16,"align":"right"}

{"obj":"bar","id":51,"x":80,"y":200,"w":150,"h":4,   "border_width":0,"val":20,"bg_color10":"#a8a432", "bg_color":"#111111","radius10":5,"radius00":5}
{"obj":"label","id":52,"x":80,"y":180,"w":139,"h":20,"bg_color":"#111111","border_color":"#C7BAA7","border_width":0,"text":"Keuken","text_font":16,"align":"left"}
{"obj":"label","id":53,"x":80,"y":180,"w":140,"h":20,"bg_color":"#000000","border_color":"#C7BAA7","border_width":0,"text":"30W","text_font":16,"align":"right"}

{"page":2,"id":61,"obj":"obj","x":0,"y":0,"w":320,"h":420,"border_opa":0, "border_color":"#000000","bg_opa10":0,"bg_color10":"#ffffff", "swipe":1}

{"page":0,"comment":"---------- All pages ----------","swipe":1}
{"page":0,"obj":"btn","id":1,"x":0,  "y":420,"w":80,"h":50,"opacity":255,"text":"\uE75A","radius":0,"border_width":"0","bg_color":"#444444","text_font":24,"action":"p1","text_color":"#ffffff"}
{"page":0,"obj":"btn","id":2,"x":80,"y":420,"w":80,"h":50,"opacity":255,"text":"\uF40B","radius":0,"border_width":"0","bg_color":"#44444","text_font":24,"text_color":"#ffffff", "action":"p2"}
{"page":0,"obj":"btn","id":3,"x":160,"y":420,"w":80,"h":50,"opacity":255,"text":"\uE210","radius":0,"border_width":"0","bg_color":"#444444","text_font":24,"text_color":"#ffffff","action":"p3"}
{"page":0,"obj":"btn","id":5,"x":240,"y":420,"w":80,"h":50,"opacity":255,"text":"\uE2DA","radius":0,"border_width":"0","bg_color":"#444444","text_font":24,"text_color":"#ffffff","action":"p4"}

{"page":0, "obj":"label","id":4,"x":0,"y":0,"w":300,"h":30,"text":"?\uE2DA","value_font":22,"bg_color":"#000000", "text_color":"#ffffff", "bg_opa": 0,"radius":0,"border_side":0, "align":"right"}

Home assistant dashboard equivalent

Home assistant power visualisation using bar-card and custom template card.

Check out my article on the modbus current clamps to see how I measure the power on several of the breaker circuits of my house and how to add a similar bar card visualisation.

Chores

I also added a page to the openHASP displaying the periodical house chores tracked in Grocy. This deserves its own article actually!

chores

Rainwatertank Usage meter

2025-04-18T23:15:00+02:00

Home assistant graph of water usage, the lightest shade is rain water measured by DIY solution, the darkest shade reported by the tap water utility meter over P1 connection.

I integrated a 7€ YF-B7 water flow sensor into my home assistant setup using an off the shelve 35€ modbus based pulse counter.

The sensor

The flow sensor connected to the rain water pump.

I bought from a "YF-B7 Water Flow Sensor with Temperature Sensor - Brass - G1/2" from tinytronics.nl. This device uses a magnetic propeller sitting in the water feed to trigger pulses in a hall effect sensor.

A summary of its specifications:

Water flow sensor:
    Supply voltage: 5-18V DC
    Signal voltage: 4.7V (with 5V DC power supply)
    Connector: JST-SM 3p female
    Pulse frequency per L/min: 11Hz*
    Duty cycle pulse: 50% ±10%
    Measuring range: 1-25L/min
    Accuracy: ±3%*
Temperature sensor:
    Type: NTC
    Resistance: 50KΩ
    Beta value: 3950
    Connector: JST-SM 2p female
    Thread: M8
Water connection: G1/2"
Maximum water pressure: 17.5bar
Working temperature: 1-100°C
Suitable liquids: Water**
Material: Brass
Dimensions: See images

Pinout (water flow sensor):

Red: Vcc/plus (supply voltage)
Black: GND/min
Yellow: Signal

Pulse counter

I have several sensors in my garden shed, and they are all read via a 2 wire RS485 serial bus.

I figured I could use an off the shelve pulse counter to keep track of the water use. This way the more complex real-time tracking part can be kept close to the sensor since modbus is probably too slow and it keeps things simple.

The €34.89 "WJ150-485 1 Way Encoder Pulse Signal Counter or 2 Way DI High-speed Counter Modbus RTU Module" from Aliexpress was a good fit, it had good documentation and I got it to work in an hour.

Mechanical sensor parts assembled with a very short sensor tube to fit the picture.

In set-up mode, which is enabled by connecting a wire to one of the module's screw terminals, the module can receive ASCII commands, so a modbus RTU client is not even necessary.

I sent this command to it using a serial terminal to set module address from '01' to '05', module type '00', baudrate at 9600 ('6'):

%01050006

After a powercycle I checked if I could read the pulse count, and after blowing on the water flow meter, the count register increased!

thomas@roper ~ % modbus  -b 9600 -s 1 /dev/ttyUSB0  h@32/\<I
Parsed 0 registers definitions from 1 files
32: 2819 0xb03

Home assistant setup

I added this modbus.yaml entry:

- name: water_counter
  unique_id: water_counter
  slave: 5
  address: 32
  swap: word
  data_type: uint32

And a template sensor to convert the pulse count to liters (template.yaml):

- trigger:
    - platform: time_pattern
      minutes: "/1"
    - platform: state
      entity_id:
        - sensor.water_counter
      not_from:
        - "unknown"
        - "unavailable"
      not_to:
        - "unknown"
        - "unavailable"
  sensor:
    - name: regenwater
      unique_id: regenwater
      unit_of_measurement: L
      device_class: water
      state_class: total_increasing
      state: >
        {% set count = states('sensor.water_counter') | float %}
        {{ '%0.3f' | format(count*6.0/(4*660)) }}
      attributes:
        dummy: "{{ now().minute }}"

Now I can view pretty bar charts in the Home Assistant Energy overview.

The accuracy might be rough, but I did some napkin math and it seems to be ballpark-accurate.

Laser engraved and etched circuit boards!

2025-04-10T17:45:00+02:00

etch tank

Nowadays diode laser engravers are powerful enough to cut through a few millimeters of wood and you can get a fairly large one for under 200 euros.

Cutting wood into shapes always was a makerspace thing I loved to have in my home lab, but it didn't justify buying one.

A laser engraver can also make it easy to prepare bare circuit boards for etching at home though! I'll explain how I do this, and how it makes creating PCB's very easy if you have an etch tank in your lab.

Table of Contents

Concept

Engraving wood and creating wooden boxes is nice. I love even more the idea of being able to create prototype PCB circuit boards at home quickly and easily.

Sculpfun S9 diode laser engraver.

I figured the engraving process can be used to burn away paint to expose it for etching, getting rid of the tedious photo-transfer or toner-transfer masking method which makes alignment for dual sided boards a chore. YouTube showed me several people had the same idea already, and I could learn a lot from them.

Being scared of sharks and lasers, but considering I already had some quality eye protection and a small room where I could set up a webcam to watch the engraving process with, I bought the thing!

One of these youtube videos shows a clever engraving fixture for the circuit board, making it easy to do two-sided boards.

Note

This is still a new project, and on the first attempt I had some issues with engraving accuracy which might be caused by belts not tight enough and the frame not being aligned correctly. I'll update the pictures when I solve these issues.

Why roll your own PCB's?

Nowadays Chinese boardhouses offer cheap prices and fast delivery times. However, it's still several days waiting time, and when you're iterating on a design with a tight deadline and making lots of (beginner) mistakes, this can create a lot of stress.

Next to that, creating your own PCB's adds the artisanal touch to your project.

DIY PCB making comparison

There is always some work involved creating your own circuit boards. I think my method is however relatively convenient compared to other processes.

Process	Advantages	disadvantages
Photo transfer	€ cheap	🖨 printer needed, transparencies photo resist coated board needed 🔦 UV exposure equipment 🧪 developing step 🧪 Chemical etching 👀 manual alignment of layers
Toner transfer	€ cheap single sided pcbs can use toner transfer as silkscreen	🖨 Laser printer required 🔥 Clothes iron needed messy paper soaking 🧪 Chemical etching 👀 manual alignment of layers
Fiber laser	no need to etch, copper is vaporized completely can laser away top coating to get soldermask effect	€ Expensive laser machine needed
Thouters.be method™	👀 Easy alignment of front/back layers no transparency mask needed for Soldermask UV exposure easy Silkscreen solution	€ Diode laser machine needed + Lightburn license 👓 be safe when using the LASER! Two coats of paint needed (but feedstock can be prepared up front) 🧪 Chemical etching

Required tools

A laser engraver. I used a Sculpfun S9, but a CNC3018 with laser addon might be a better option.
A saw or something else to cut the PCB's with; either a acryl cutting knife, plate shear or fine saw will do
If you want to do vias or through-hole components
- PCB drills
- some power tool to drill PCB holes with (a hand tool can also work for larger holes)
If you want to do vias
- A riveting tool (a 4 euro center punch hole marker will work fine)
An etch tank
- can be as simple as a plastic box/tray with water + iron-3-phosphate
- (you can DIY) a more fancy device
- have it as small as possible to minimize the amount of chemicals, and keep in mind that some chemicals need heating/air bubbling.

Required consumables

Blank (dual sided) copper clad FR4 board (I used 7cmx5cm PCB blanks from aliexpress, note they measured 71mmx51mm)
Etch Masking paint: matte black spray paint (I used the cheapest one I could find from the local home improvement store)
Regular paper painters tape
Solder Mask paint, either
- industry standard UV curable soldermask paint + a piece of transparency or glass to press onto the paint
- heat resistant (black) spray paint (I used the cheapest one I could find from the local home improvement store)
Silk screen paint: white UV curable soldermask paint (or acrylic crafts paint, cheap one from a color assortment I had around).
If you want to do vias
- through-hole 'via rivets' (length 2.5mm, m0.9 500pcs 3eur from Aliexpress)
To avoid via's
- 1206 size 0Ohm smd resistors to jump across 2 traces
- 0805 size 0Ohm smd resistors to jump across 1 track.
An etching chemical (I use sodium persulphate from reichelt - needs heating but etches very well)
optionally: 150T silkscreen printing mesh to spread the UV paint more evenly

Filing/squaring the PCB stock

The boards need to be fairly exact dimension-wise, and also need to have nice right angles. To make it easy to prepare them, I made 3D printed parametric jig to clamp the PCB stock and easily file the pcb to size.

Parametric to-size perpendicular filing jig

You can slide a pcb into this template from two sides, in the middle it has an opening so you can see that the pcb edge is completely against the template.

filing jig with pcb inserted

I have one that is 1mm to large, and one of the exact dimensions, the larger one is used to create the first right angle between two adjecent sides, the second exact one will trim the other two sufficiently to perfection.

Use it this way:

Change the openscad file to have the board dimensions, set the oversize value to 1 (mm). Or, if the bare pcb is very trapezoidal, you may need to file away more than 1mm to get the sides perpendicular and a larger value may be required.
generate and print the two jigs
Put the pcbstock in the largest jig and make sure one side of the pcb is perfectly aligned with the inside of the jig
Clamp the jig and file off the parts sticking out. You now have one 90degree angle on the board.
rotate the pcb 180 degrees, and put the pcb in the jig that is exactly the target size
clamp the jig and file off the parts sticking out
the pcb should now be perpendicular and to size.

Painting the PCB stock

Prepare a piece of cardboard sheet with holes to fit several PCB's in to hold the PCB's when painting. I used the the array feature in lightburn to replicate a rectangle in a grid.

lightly sand with steel wool, clean with isopropyl alcohol
place the PCB's in the carboard sheet with holding squares. Put the cardboard in a cardboard box to catch excess paintdrops and to angle the sheet.
Spraypaint the PCB's on both sides
let dry, 15min in the sun will do.

Prepare the design for engraving

Design rules

Set the via and drill hole size to something you can drill and rivet.

minimum clearance: 0.3mm
minimum track width: 0.8mm

The minimum track with is a bit wider than SMD footprint pads for SOT-23 and SOT-8, but those can be used without issue.

Panellisation

Optionally, you can panellize several boards to etch several designs on one piece of feedstock. To do that:

Create a new separate kicad project.
open the board editor and choosing "Append board".
Group everything in the board (right click selection, group) and select 'create from selection' 'create array'.

Note

The array intervals should include the board size, so measure those first and add some inter-board spacing for sawing later on.

Generate SVG files

Kicad export settings

Generate bitmaps

I created this bash script I call prepare.sh that uses the ImageMagick 'convert' command line tool to do the boring work of inverting, mirroring and centering the design on the pcb feedstock. Somehow the svg's from KiCAD don't seem to render correctly in LightBurn.

#!/bin/bash
set -ex
echo "$1 board size x (mm)"
echo "$2 board size y (mm)"
echo $3 - input
echo $4 - output
border_cm=0.05
x_mm=$1
y_mm=$2
infile=$3
outfile=$4

echo "$cm - substrate size (rectangle)"
dpi=3000
echo $dpi - dpi
x_pixels=$(python -c "print(int(round($x_mm* 0.1* $dpi / 2.54)))")
y_pixels=$(python -c "print(int(round($y_mm* 0.1* $dpi / 2.54)))")
border_pixels=$(python -c "print(int(round($border_cm* 1.0* $dpi / 2.54)))")
echo pixels: $y_pixels $y_pixels

#render as bitmap
inkscape "$infile" --export-filename="exported.png" -d $dpi
#remove transparency
convert exported.png -format png -background white -alpha background -alpha off nontransparent.png

#invet colors
case $infile in
      (*_Cu*)
        echo image should be inverted
        convert nontransparent.png -channel RGB -negate inverted.png
      ;;
      *)
        #do nothing
        cp nontransparent.png inverted.png
      ;;
esac

convert inverted.png -gravity center -extent ${x_pixels}x${y_pixels} -background white "$outfile"
case $infile in
      (*-B_*)
        echo image should be mirrored
        convert "$outfile" -flop "$outfile"
      ;;
esac

#cleanup
rm exported.png
rm nontransparent.png
rm inverted.png

This wrapper script then calls the previous script for each svg file:

#!/bin/bash
set -ex
for file in *.svg
do
    ./prepare.sh 51 71 $file "${file%%.*}".png
done

Use boardloom to create a Lightburn project

Creating a lightburn project, importing 6 layers and manually drawing the contours cut layer takes a lot of time, and I don't like manual GUI work. Fortunately the LightBurn file format is XML based and very easy to understand. I created a python program I call Boardloom that creates a project file based on a simple configuration file and the KiCAD output.

This allows you to keep your laser settings across projects and save a lot of time. Here is an example of a configuration file:

project:
  input_files_prefix: "pir-24v-"
  output_name: "pir-24v.lbrn2"
board:
  width: 50
  height: 70
  workarea_x: 120
  workarea_y: 110
layers:
  - board_contour:
    handles_dia: 10
    line_settings:
      max_power: 100
      speed_mm_sec: 5
  - match: "F_Cu"
    name: "Copper Front"
    image_settings:
      mirror_y:  true
      max_power: 80
      speed_mm_sec: 10
      dither_mode: "threshold"
      line_interval_mm: 0.0847
  - match: "B_Cu"
    name: "Copper Back"
    hide: true
    image_settings:
      mirror_y:  true
      max_power: 80
      speed_mm_sec: 10
      dither_mode: "threshold"
      line_interval_mm: 0.0847
  - match: "F_Mask"
    name: "Soldermask Front"
    center_on_board: true
    line_settings:
      max_power: 20
      speed_mm_sec: 5
  - match: "B_Mask"
    name: "Soldermask Back"
    hide: true
    center_on_board: true
    line_settings:
      mirror_y: true
      max_power: 20
      speed_mm_sec: 5
  - match: "F_Silkscreen"
    name: "Silkscreen Front"
    hide: true
    image_settings:
      mirror_y:  true
      max_power: 33
      speed_mm_sec: 5
      dither_mode: "threshold"
      line_interval_mm: 0.0847
  - match: "B_Silkscreen"
    name: "Silkscreen Back"
    hide: true
    image_settings:
      mirror_y:  true
      max_power: 33
      speed_mm_sec: 5
      dither_mode: "threshold"
      line_interval_mm: 0.0847

After running boardloom, you can open the file in LightBurn and start lasering right away, the LightBurn UI will look like this:

LightBurn screenshot with the PCB project layers.

Manually create a LightBurn project

Create a contour layer and draw a rectangle the size of the board
Set the contour coordinates
- Important here is that you do this so that the laser head will move out of place when it is done so you can access the board area easily. I use x=80, y=110.
Create a handles layer with cutouts to grab under the board to remove it (note the half circles on my cardboard photos).
Switch to a new layer by clicking the colored layer numbers on the bottom side of the screen
Drag a png to the application canvas
In the image/layer settings
- disable bidirectional scanning
- set DPI to 300
- set image mode to threshold
- set speed to 10
- set power to 100%
- you can click set defaults to avoid setting these every time.
Repeat the steps for the png images for F_Cu and B_Cu (and F_Mask, B_Mask if you will use soldermask)
Align all layer images by setting the XPos and YPos to be consistent with the contour rectangle

lightburn layers

Prepare the machine for engraving

Warning

Always use adequate eye protection LASER glasses 👓 when working with LASER machines, or you WILL ruin your eyes, LASERs are not toys!
Use mechanical ventilation/extraction! Vaporized paint is not healthy!

Cut a piece of cardboard
Fix the cardboard on the worksurface, I used these 3d printed pins enlarged in PrusaSlicer at 138% size to hold the cardboard onto my honeycomb bed.
Laser-cut out the contour of the PCB stock and handle holes out of the cardboard.

The copper layers

Engrave the board's copper layers

Make sure that in the cuts/layers sidebar, the only output switch is the layer you want to cut/engrave
engrave side 1
flip the board
engrave side 2 (mirrored vertically by the script)

Note that with these settings, the example board of a few square centimeters takes ~20minutes. There is room for experimentation to optimize these settings.

lasering in progress

Etch the board

Warning

Always use adequate eye protection 👓 when working with ACID.

Drill a hole in the board to hang it in the etching tank.

etched front side

etched back side

The solder mask

Solder mask protects the copper traces from corrosion and heat.

Remove all etch mask paint (eg. Wipe the board with isopropyl alcohol)

There are two options here, a simple one that puts paper tape covering over the solderpads and coats the entire board with spraypaint, after drying the tape is removed to expose the pads. In the second option we will coat the entire pcb with UV curable PCB soldermask paint, and clean the paint off the pads with the LASER.

A simple solution for through hole boards

When not doing SMD components, it is possible to use a transparent pcb coating spraypaint like KONTACT CHEMIE PLASTIK 70. This paint can be soldered through, but we can also cover the pads with painters tape before spray painting.

You can also use black heat resistant spraypaint, but you won't see the traces.

To begin with, cover the necessary board area with painters tape.

board covered with tape (improvised picture with mismatching design files)

We will cut the contours of the copper areas of the solder pads; they need to stay clean of paint.

If not using boardloom;

Add the soldermask image to the project if not done already, and make sure it is aligned.
right-click the image and select Trace image.
Use the 'offset shape' (Alt-O) function to add a 0.5mm clearance around the pad, check the 'delete original shape' box.
Set settings to 5mm/sec 40% power (white tape) or 20% (yellow tape)
Laser the image.

trace dialog

paint mask applied for the soldermask layer

heat resistant spraypaint applied

After the spraypaint has dried I use a spudger from a silicone seal kit set to wipe the extending pieces of tape off the board. Any firm but soft plastic (so it does not scratch the paint) can be used for this.

soldermask masking tape removed

You can also use green UV soldermask, in that case I burn the contours of the tape again at 20%,5mm/s before I peel off the tape using tweezers:

First attempt with UV soldermask and acrylic silkscreen paint

Using UV curable paint, laser cleaning pads

Applying solder mask paint using a 3D printed embroidery ring.

I had some leftover pieces of mosquitto frame extrusions and I quickly modeled a simple corner piece in #openscad so i could build a picture frame sized frame. It seems to do seem to keep an ok-ish tension on the screen printing mesh, better than the embroidery ring does, but I had to add some paper tape to the mesh to make it just as thick as the flyscreen it is designed to work with.

I found a spring loaded pcb holder on the internet, which I figured would go neatly under it, but I ended up designing my own which uses threaded rods cut to lenght, and has magnets to hold the pcb holder down onto to the worksurface.

Using the clamp and flyscreen frame

Laser cleaning the pads happens at 5mm/s @ 20%

The silk screen

Silkscreen test result

Design rules

For text I used 1.5mm font size, 1.0mm was barely readable. If you want to make sure lines are readable, Use a 0.2mm width. If you use soldermask paint that hides tracks, it's best that you also export the 'Fab' layers which contains outlines of components. However the KICAD footprints overlay the lines on top of pads sometimes. You can try modifying the footprints and removing those if you tweak the footprint to make the lines thicker.

Lightburn design preparation

Add the silkscreen image to the project
Double check the design rules enforced that no silk screen got on the solder pads.
- You could also use the 'boolean subtract' function to fix this in lightburn
right click the image and select Trace image.
On the Cuts/Layers sidebar, select 'Fill' mode for this layer
Double-click the layer in the Cuts/layers list to bring up the 'Cut settings editor'
- Set speed to 5 mm/sec
- Set Max Power to 30% (black spraypaint) or 20% (green uv soldermask)
- Disable bi-directional fill

Painting and drying

Apply painters paper tape to the board and engrave the image.

Applying paint

Next we add the acrylic paint, and spread it using a spatula.

Applying paint

I put it on my Prusa 3D printer heatbed at 85 degrees for 15minutes, but I'm not sure what the perfect drying process is.

Note

When using white UV paint, you can apply a coat of uv paint using silk screen printing mesh, dry it on your 3d printer and user your laser to cure the paint (detailed instructions to be determined and added here).

Drilling holes

I already had a Dremel 4200, and 3D printed this drill press fixture from printables.com:

3D printed drill press

I designed a flange to mount the vertical tube on a wooden plank so I could skip the 24+hour print of the base, the flange only took 3hours to print.

The solderpaste stencil

Note

I'm experimenting with doing a solderpaste stencil using the same paper tape method as used for the other non-copper layers, stay tuned!

The test project

I wanted to try this process out with a small PCB, and already had a simple project in mind. This small circuit drops 24V DC to 5V so a hobby motion sensor (which capacitors are not rated for 24V) can be powered from the house's domotics power supply. The motion sensor outputs a logic high level of 3v3 which needs to be translated to 24V, which is done with a pair of transistors. The motion sensor 2.54mm pin header is included, along with 5.08mm pitch screw terminals. A few via's are put onto the board, although they may not be functionally necessary.

For the via's brass rivets will be used, which i will solder, so i wanted some heat stops around the pads. To save time if this can be set in KICAD, I just added a few 2.54mm pin headers

The png output is shown here:

Simple project to try out the pcb fabbing process

The populated end result

B_Cu

F_Cu

B_MaskCu

F_Mask

Time to get creative!

Here is a picture of the second board design I etched, there is a hand drawn part as well, done with permanent marker. DIY etching opens up this possibility!

the morse crab

Presentation May 2025

Thumnail of the talk video

I gave a presentation about this on Newline.gent, which was recorded and can be viewed at: https://www.youtube.com/watch?v=GN7vuh23kpM

You can download the presentation here:

newline2025-rolling-your-own-pcbs-nohandouts.pdf

DIY Heatpump drip tray

2024-09-05T21:10:00+02:00

My drip tray, installed.

An outdoor heatpump unit pulls water from the air since moisture condenses on its cold radiator. In very cold temperatures it forms ice, which is suddenly thawed all at once in a 'defrost cycle'.

Our heatpump outdoor unit was installed over our driveway, and we walk under it on the way to our back door. The installer did not place a capture tray, but I want to avoid water dripping and pooling on the driveway during the heating season so we don't get a slippery ice spot. So I built a capture tray.

Table of Contents

Possible solutions
My solution
Assembly process
Installation
Design Files

Possible solutions

Buy a drip tray accessory from the heatpump manufacturer

Online prices are around 400 euros. Kind of expensive.

Install a plastic rain gutter

The L shape of the exposed radiator together with a hole in the middle would make building an F shape of rain gutter an impractical build, which would be inconvenient to mount under the outdoor unit. Plus, it would look a bit strange, and grey.

Use a plastic box lid

I don't expect to find any box lid really rigid and flat at the same time, since they are mostly injection molded into a rigid shape.

My solution

Requirements

To avoid resonance because of the compressor vibrations, and avoid storm winds making it move will have to be a solid construction.

It should not freeze shut, so water should not pool together, if I mount the tray under angles I won't have that issue.

I chose to build a tray myself and came up with a simple mounting mechanism.

Design

I measured the area I want to cover under the unit and made a simple OpenSCAD design of cylindrical spacers that are cut through with a board positioned under x and y angles.

OpenSCAD render of the construction

The cylindrical spacers will be mounted to the mounting brackets the unit sits on using threaded rods cut to length.

I printed them in PETG on my Prusa 3D printer.

Sheet plastic

I bought a sheet of 5mm thick white PVC foam board of 1m by 0.5m. It cost me 18EUR. This foam board is easily cuttable with a stanley knife and can be glued with pvc glue or superglue.

I was able to cut out all necessary parts out of this single board.

The cutting pattern of the PVC foam board

Mounting

The mounting rods

I bought a 1m piece of 8mm threaded stainless steel rod together with some nuts and washers. I cut it into parts 17cm long.

Assembly process

To glue the parts together, both sides were

degreased
rubbed with the pvc glue bottle's glue brush.
held together using glue clamps and pieces of metal from my shed for half an hour

Glueing in progress

The assembly of parts

I cut a rectangular piece of foamboard to reinforce the drain wall. The drain hole was offset by 2mm to the bottom corner so the water would flow out easily.

Fitting the runoff pipe

The last parts were glued together. Next the location of the mounting holes was marked, and round spacers cut from scrap were glued onto the mounting holes. This would function as a barrier preventing the water to exit.

More glueing

I should have offset the hole in two directions, you can see there is a small corner where water can pool. No worries, I had a tube of bathroom silecone already open, so i applied silecone over the inside welds.

The runoff from the top

You can already see the angle and length differences of the spacer cylinders:

Drip tray seen on its side

The assembly resting on a table

Installation

Finally the tray was mounted and a hole was drilled in the rain pipe, and a piece of airco drain pipe is used to connect the two. When time comes for maintenance, the tube can be easily disconnected to avoid cleaning chemicals flowing to the rain water tank.

A final picture of the tray installed in place

The underside of the unit

Design Files

The cylindrical supports:

// render in higher detail
$fn=200;
lekbak_base_x = 940;
lekbak_base_y = 400;
lekbak_base_z = 10; // actually 5mn but I glued a 5mm washer on mounting spots
lekbak_lowsize_z = 30;

mounthole_left_x = 150;
mounthole_x_interval = 600;
mounthole_right_x = mounthole_x_interval + 190;
mounthole_wall_y_earth = 50;
mounthole_front_y_earth = 250;
z_drop_on_x_size  = 20;
z_drop_on_y_size  = 20;

angle_x = asin(z_drop_on_x_size / lekbak_base_x);
angle_y = asin(z_drop_on_y_size / lekbak_base_y);

// show the values
echo(angle_x);
echo(angle_y);

// the base board under angles
module base()
{
    translate([0,0,15+lekbak_base_z  ])
        translate([lekbak_base_x/2,lekbak_base_y/2,0])
            rotate([angle_y,-angle_x,0])
                cube([ lekbak_base_x, lekbak_base_y, lekbak_base_z],center=true);
}

// for visualisation purposes
module reference()
{
translate([0,0,-1])
    color("green")
        cube([ 1000, 500, 1]);
}

// supports to be cut with the base board
module supports()
{
    union()
    {
        a = [
            [mounthole_right_x, mounthole_wall_y_earth, mounthole_front_y_earth],
            [mounthole_right_x, mounthole_front_y_earth],
            [mounthole_left_x, mounthole_wall_y_earth],
            [mounthole_left_x, mounthole_front_y_earth]
        ];
        for (i=[0:3])
        {
            x = a[i][0];
            y = a[i][1];
            translate([x,y,0])
            {
                difference()
                {
                    cylinder(z_drop_on_x_size+30,d=25);
                    cylinder(100,d=8.2);
                }
            }
        }
    }
}
// cut the base out of the supports
difference()
{
    supports();
    base();
}

if(1) // disable for final render
{
    base();
    reference();
}

Files:

Custom motion sensor wall mount

2024-06-13T20:10:00+02:00

A motion sensor with pushbutton behind it.

Motion sensors; the simplest kind of automation, and the most useful. Especially during night, when you're finding your way to the smallest room in the house. I could not find a sensor I liked however, and also did not want to spend a lot of money on something ugly. So I designed and 3D printed my own.

A friend of mine built a motion sensor wallplate like this, with the exception of using glue to stick it together. I designed and 3D printed a slightly more complicated contraption, which can be pushed to bring the room light up from night setting to full brightness.

Table of Contents

Components
- The motion sensor
- The wall plate
A fixed sensor mount
Sensor mount with integrated button
Design files

Components

The motion sensor

HC-SR501 'Arduino/hobby' Motion sensor

This simple sensor can be bought for about 4.2€ and accepts voltages up to 24V. Double check the input capacitor rating though, mine was only rated for ~15V, so I replaced mine with a brand-name capacitor rated a lot higher than 24V.

Its output is a 3v3 logic signal. This can be used to drive a (power) transistor which in turn can drive a 24V relay or PLC digital input.

The wall plate

Wall plate (blindplaat)

Our switches and sockets are made by Niko. They also manufacture a 'blank' plate that can be used as a placeholder to fit an extra switch or power socket at a later time.

The blankplate has mounting holes on the back and costs also about 4.2€. That makes it ideal for creating DIY controls.

I designed and printed a drill guide to easily mark the center and used a step drill to create the big hole to fit the motion sensor through.

A fixed sensor mount

I created this PIR mounting plate initially, and it worked perfectly.

Motion sensor mount

Sensor mount with integrated button

When adding a night mode to the lighting system, I needed an override button to turn on the full brightness in case it is ever needed.

I designed this new mount plate that adds small switches.

Button guide and PIR mount parts

I added a bit of lubricant where both parts make contact and slide.

Seen from the side, with screw touching blindplate

Switches visible from the side

Design files

You can find the STL and OpenSCAD design files at https://www.printables.com/model/911623-motion-sensor-blindplaat-mount

Rollershutters control panel

2024-06-12T20:10:00+02:00

Shutter control panel

When we renovated our living room, we upgraded the window roller shutters with electric motors. While we usually only open and close all of them together, we still want to be able to set them to individual positions. I decided to make a central control panel with 6 physical buttons and implement some logic in the Siemens Logo controller to control the motors.

Table of Contents

Goal
Parts
- Buttons
- Motor
- Controller
- Relays
Circuit

Goal

My goal was to create a simple control panel that makes the following things easy:

Open and close all rollers with a single button push (⇩/⇧)
Open and close individual shutters with two (or more) button pushes (roller button(s) + ⇩/⇧)
Stop the movement by hitting the ⇧ or⇩ button again.

The power is cut to the motors after a timeout.

I drew a state diagram illustrating the operation:

placeholder

State diagram.

Parts

Buttons

6 way Pushbutton

The 6 way Niko button pad from the product family I bought the rest of our switching gear from was very expensive (80€). The plastic button cover available in many colors is only a few euro's. That opens experimentation options, and I plan to laser engrave the icons on top at one point.

Motor

The roller motors are controlled with two 230V signals, one to run up, one to run down. Only one of these should receive line voltage, or the motor stalls. The motor has internal end stops which are calibrated on installation time, so it can be left powered.

Motor diagram

Controller

The central Siemens mini-PLC controls the motors:

Siemens logo PLC

I always buy the 24V version with transistor outputs, and use interface relays.

Relays

The Schneider Harmony (24V coil voltage) interface relays control the mains voltage.

I originally planned to use one of these hooked up to the neutral of each motor, and one for each direction:

single pole make and break relay

By having one single pole relay per motor, I planned to reduce the number of outputs from 8 to 6, and occupy minimal cabinet space. However, leaving some motors neutral floating while having the control lines connected to other motors draws current through the floating motors, which makes that configuration unusable.

For that reason I had to use the dual pole variant as roller selector. By The way these relays can be operated manually and locked into position in case of 24V PSU failure.

dual pole make and break relay

Circuit

High voltage drivers

placeholder

Relay schematic, example with only two rollers

This relay circuit makes it impossible to connect both direction lines to the line voltage. The up direction is prefered in case both directon relays are energized.

Input

The human interface is as simple as can be, the 6 momentary button switches are feeding 24V to the LOGO! inputs when pushed.

Siemens Logo logic

placeholder

Logo configuration diagram

The LOGO! configuration is pretty simple, it consists of these parts:

A SET/RESET flipflop with pulse input per relay
The B054 timer triggers the flipflop RESET inputs 30seconds after a button push, clearing all state.
B058/B059/B060 set all roller selectors if the ⇧ or ⇩ button is pressed and no roller is selected.

Virtual Solar/Grid power meters

2024-01-29T21:10:00+01:00

block diagram

I want to keep counters for how much solar panel energy and grid energy my car uses. I have power meters for the Solar, Grid and the car. The power the rest of the house uses is however unknown, and measured by the grid meter. Determining the car's part of grid and solar power requires some calculations.

I created home assistant template sensors to come up with these power numbers, and added integrators to obtain energy meters. The energy flow plus card can show these in real time on the Home assistant dashboard.

Table of Contents

Splitting the power
- Scenario's
Home assistant entities
Limitations and conclusion

Splitting the power

Scenario's

To end up with two virtual power meters, we need a formula for the solar and grid part of the power mix. Since we are dealing with an unknown part of House power use, I drew vector diagrams for each scenario that is possible:

Grid + Solar
Grid only
Solar only

Every consumer (house, car) and producer (solar, grid) is represented by an arrow. The following abbreviations are used:

X: The device, the car in this case
H: Devices in the Home
S: Solar production

block diagram

Scenario's of production and consumption

With every scenario plotted, the parts of interest can be marked:

XS: Device used solar power
XG: Device used grid power

Home assistant entities

Working around an integration sensor caveat

The Riemann sum integral integration in Home Assistant can be used to turn the power measured by a home assistant entity into an energy measurement.

I am observing an issue with this however. The algorithm will calculate the area of a geometric shape of the input samples amplitudes and the time between the samples and add these finite sums.

If the power value stays zero for a while the next input value will cause it to report an amount of energy was used in the period that the power value was zero.

integration sensor output with error marked.

A workaround that I found online for this is to update the sensor every second and add a dummy attribute containing the current time.

Template sensor

Here is a listing of the template sensor code as I use it:

- trigger:
    - platform: time_pattern
      minutes: "/1"
    - platform: state
      entity_id:
        - sensor.electricity_meter_power_production
        - sensor.electricity_meter_power_consumption
        - sensor.solaredge_ac_power
        - sensor.sdm630_total_system_power
      not_from:
        - "unknown"
        - "unavailable"
      not_to:
        - "unknown"
        - "unavailable"
  sensor:
    - name: car_grid_power
      unique_id: car_grid_power
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {% set production = states('sensor.electricity_meter_power_production')|float %}
        {% set consumption = states('sensor.electricity_meter_power_consumption')|float %}
        {% set g = consumption - production %}
        {% set s = states('sensor.solaredge_ac_power')|float /1000 %}
        {% set d = states('sensor.sdm630_total_system_power')|float /1000%}
        {%- if d < 0.0001 -%}
        0.000
        {%- elif g > 0 and g < d -%}
        {# grid+solar #}
        {{ '%0.3f' | format(g) }}
        {% elif g >= 0 %}
        {# grid only #}
        {{ '%0.3f' | format(d) }}
        {% else %}
        0.000
        {% endif %}
      attributes:
        dummy: "{{ now().minute }}"
    - name: car_solar_power
      unique_id: car_solar_power
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {% set production = states('sensor.electricity_meter_power_production')|float %}
        {% set consumption = states('sensor.electricity_meter_power_consumption')|float %}
        {% set g = consumption - production %}
        {% set s = states('sensor.solaredge_ac_power')|float /1000 %}
        {% set d = states('sensor.sdm630_total_system_power')|float /1000%}
        {%- if d < 0.0001 -%}
        0.000
        {%- elif g > 0 and g < d -%}
        {# grid+solar #}
        {{ '%0.3f' | format(d-g) }}
        {% elif g >= 0 %}
        {# grid only #}
        0.000
        {%- else -%}
        {# solar only #}
        {{ '%0.3f' | format(d) }}
        {%- endif  %}
      attributes:
        dummy: "{{ now().minute }}"

Energy meters

And these are integrated into energy meters by the following old-style sensors:

- platform: integration
  name: total_car_grid_energy
  source: sensor.car_grid_power
  round: 2

- platform: integration
  name: total_car_solar_energy
  source: sensor.car_solar_power
  round: 2

Limitations and conclusion

The code I shared can only be used to track one device in your house in its current form, but I think it is useful nonetheless.

I hope someone finds this useful and can reuse it or use it as inspiration.

Solar Matched Electric Heating

2023-12-27T20:10:00+01:00

A heater power-controlled to consume all excess solar production!

I built a prototype test setup that makes sure every Watt produced by our solar panels is used by an electric heater. It uses an industrial power controller and some code to match the heater's power usage to whatever power is not used by the house.

This would make it possible to maximize our solar self consumption, which is required to get a decent return on your solar investment.

For us, injecting to the electricity grid is giving away power, we have to pay about 15x as much compared to what the utility pays us for returning energy to the grid.

Table of Contents

High level overview
Electrics
- Power controller
Siemens Logo AQ and Home assistant
Power optimizer
- Trial run
Final thoughts on all of this

High level overview

Pending renovation works adding a heat pump, our heating is still handled by existing electric convection heaters. The thermostat runs these at a full power of 5kW which poorly matches the solar production on a winter day where we might get a average 1 to 2 kW but produce enough energy in total to keep the house warm.

Note: As of 2024 we heat using a heatpump!

block diagram

Block diagram

We have a 'DSMR' digital utility meter that reports the grid consumption and injection every few seconds over a serial line. I integrated it into home assistant, which allows its data to be observed in the energy and history dashboards, and to be used in automations.

The meter calculates the net power in and out per AC (sine) cycle, so using a solid state relay to duty cycle the heater is not an option, we need a power controller that will create an exact average load every 50Hz cycle.

I previously bought a Siemens Logo logic controller with analog output module and a lighting dimmer I can control with it.

Siemens logo logic controller

I already prototyped controlling the Logo's analog output from Home Assistant using Modbus over TCP, and realized I could re-use this setup and replace the dimmer with an industrial power controller performing phase angle power control.

Note: the open energy monitor project has good documentation on what they call PV Energy Diversion, they describe an implementation using a microcontroller.

Electrics

Test setup (convection heater not visible)

Power controller

I bought a 'RGC1P23V30ED Solid State Contactor, 85-265Vac, 30A Carlo GAVAZZI'. This device can perform phase angle power control by firing its SCR at a certain angle of each AC sine wave. This is the way classic filament lights are dimmed. I think it's reasonably priced at 138€ for industrial gear.

Carlo GAVAZZI power controller

The power controller has an analog voltage input as control signal.

Siemens Logo AQ and Home assistant

The simplest way to interface the logo with home assistant is by enabling a modbus server in the Logo.

After doing so, the modbus register map can be accessed given an off-by-one is respected :-).

Modbus Address space

Logo sketch

The Logo runs a simple sketch that will continuously set its analog output (AQ) to the value of an analog variable (AM)

Logo sketch

Modbus Hub configuration

You need to configure the modbus device in the configuration.yaml's modbus section.

- name: "logo1"
  delay: 5
  timeout: 5
  type: tcp
  host: "192.168.2.28"
  port: 502

Input Number

To set the heater power, I created an 'input number' which triggers an automation to perform a modbus write. I set the scale to the heater's maximum output power, and the unit to Watts so this can be plotted nicely.

Note that this is not the actual power. Since we have a feedback loop in the automation below, all solar production will be consumed but this value will not be exactly the heater power since it's not a measurement.

heatdump_level_variable:
  name: heatdump level
  initial: 0
  min: 0
  max: 2000
  step: 1
  unit_of_measurement: W

Automation

After setting up this automation, changing the input number slider will change the Logo's analog output.

- alias: modbusupdate
  description: "Push input_number value to modbus register"
  trigger:
    - platform: state
      entity_id: input_number.heatdump_level_variable
  condition: []
  action:
    - service: modbus.write_register
      data:
        hub: logo1
        unit: 1
        address: 528
        value: "{{ int(states('input_number.heatdump_level_variable')|int * 1000/2000) }}"

Power optimizer

I'm very fed up with YAML automations in home assistant. I tried pyscript which is very promising, but this time I wanted to give appdaemon a try.

I created this simple automation which has an obvious issue: that the power consumption and production values from a DSMR telegram are fed sequentially to the power_update() callback via state update events, which will cause it to produce an output based on old and new data, resulting in bad output.

During my (short) testing I did not observe any weird behavior caused by this. I just simply coded it and it started doing its thing!

class HelloWorld(hass.Hass):
    """ Note: All units are watts """
    consumption = Decimal("0")
    production = Decimal("0")
    heater_max_power = Decimal("2000")
    heater_min_power = Decimal("10")
    current_heater_power = 0
    def initialize(self):
        self.listen_state(self.on_measurement_update, "sensor.electricity_meter_power_consumption")
        self.listen_state(self.on_measurement_update, "sensor.electricity_meter_power_production")

    def set_heater_power(self, watt_value):
        """ Calculate and set the available heater power needed """
        watt_value_clipped = min(watt_value, self.heater_max_power)
        self.set_heater(watt_value_clipped)

    def set_heater(self, value):
        self.set_value("input_number.heatdump_level_variable", value)

    def calculate_next_heater_power(self, grid_power, old_heater_power):
        """ grid power: negative is consumption """
        # don't let the value go negative
        heater_power = max(0,grid_power + old_heater_power)
        if heater_power >= self.heater_min_power:
            return heater_power
        return 0

    def on_measurement_update(self, entity, attribute, old, new, cb_args):
        self.log(f"{entity}: {new}")
        # A very hackish way to add consumption and production :-(
        if "production" in entity:
            self.production = Decimal(new)*1000
        if "consumption" in entity:
            self.consumption = Decimal(new)*1000
        grid_power = self.production - self.consumption
        self.log(f"power is {grid_power} ")
        heater_power = self.calculate_next_heater_power(grid_power, self.current_heater_power)
        self.current_heater_power = heater_power
        self.set_heater_power(heater_power)

Trial run

I took a screenshot of the operating values during the experiment since it's the only way to 'demo' this. A few notes on this graph:

I was doing live changes to the system at the time, so there are gaps and spikes.
The big blocks of grid consumption can be explained by the house's electrical convection heaters running to heat the house.
The 'heatdump level' needs to be multiplied by two, it was not actually in Watts, but per-mille at this point in time(the range of the analog out).
The net grid usage apeared pretty stable at 0W at this point, the meter's kWh readings also stayed constant.

History data during the experiment

Final thoughts on all of this

Integration into an existing heating system

To fit this into an existing heating system, a circuit like this could be used:

integration idea

Conceptual schematic

Here an existing thermostat would ensure a minimum ambient temperature, while a new one (possibly the cooling output of the thermostat) would cut the control signal to the heater to prevent things getting to hot on sunny days.

The second analog out is used to provide a 'full power' signal to the power controller.

If you want to create a fully continuous heating system, you can feed an analog value to this analog output and have it sent to the power controller by setting the first thermostat setpoint very high.

Cost considerations

The Siemens components cost me about 250€ which is quite expensive but actual professional equipment (it will be used as home automation controller for the simple reliable things).

There are probably cheaper Digital-to-analog options possible that can be combined with an ESPHome or raspberry pi to reduce cost. I bought a cheap off the shelve PWM to 0-10V module I'm going to experiment with.

The RGC1P23V30ED power controller cost 138€. I looked at other power controllers, but the RGC1P23V30ED looked like the most reliable and best bang for the buck.

The required netfilter to minimize electro-magnetic interference also costs 110€. Which brings the minimal bill of materials to 250€. The filter also has a current draw of several watts continuously. The power controller and filter also require a separate electricity cabinet that is deeper than the normal Belgian breaker boxes, likely a metal one that can heatsink the filter and power controller at the same time.

Don't forget to include a suitable fuse to protect the power controller, the power controller datasheet provides specifications for this.

Cost-benefit

If you have a gas heating system and have the same energy provider as I do, the return on injecting a kWh to the grid is the same as the cost of a kWh gas, I'm not sure what the additional taxes or distribution costs are for gas, but if there are any additional costs, you would be better off running an electric heater with it on cold days.

For every kWh I immediately use to heat the house, I save over 0.28€. So imagine a total setup cost of 300€ (I added 50€ there for a small metal enclosure and esphome to generate 0-10V), this thing would need to burn 1.2MWh of solar to break even. I don't know how much solar production we will get in the first half of the year, so can't estimate how soon the hardware would pay itself back.

Anyway, any situation will differ, so if you consider a similar aproach, enjoy the napkin math 🧐.

Rainwater Pump and filter box

2023-12-19T13:30:00+01:00

I chose to place our our rainwater tank's pump and filter in the garden shed slightly away from the main house. This allowed for a cheaper pump outside the tank and minimizes in-house technical equipment and noise.

Table of Contents

Pump housing
Pump
Filter
Tools
Filter Routing matrix
Tracing
Leaky filter issues

Pump housing

The pump is located in an old garden shed, which is open to the elements. To protect it from freezing temperatures, I prototyped a box out of trash ceiling planks and my dad helped turn that into a a sturdy box using scrap wood obtained while deconstructing our attic space.

The front panel of the housing is held in place using nuts over two threaded rods so it can be easily removed to clean the filter.

There is plenty of space in the middle to still fit a back up tank with float valve to switch over the system to drinking water when the tank runs dry.

Pump

I bought a DAB Jetinox 82 pump with control-d pressure controller. I added a sand filter at the suction side, but in I wouldn't add one if I were to do this over.

I had a lot of issues with this filter drawing air, and would have already removed it if it was trivial to do. I will probably remove it rather sooner since its placement deep inside the box means the top panels have to be removed to sevice this filter.

Filter

I bought a Honeywell honeywell ff60 triplex filter. I fitted it inside the pump box so the water traveling the long pipe to the house can be as clean as possible. This way a minimal amount of dirt will settle inside the pipe.

Tools

I had to join a lot of valves together and bought a spool of Locktite 55 PTFE sealing cord. Worth the investment since you can untighten the joint a bit after tightening it.

Filter Routing matrix

At the front of the box I mounted an elaborate and over engineered combination of valves, T junctions and other things. This allows me to re-route the water when the filter needs servicing or if I want filtered water on the garden tap. It also allows to cut off and drain the garden tap so it does not break from freezing.

pipestand

Inputs and outputs:

A:	To the rainwater tank's floating oneway valve
B:	Coupling to connect a backup water tank during tank maintenance/cleaning
C:	Garden tap/hose on shed wall.
D:	Pressure line to house.
E:	freeze drain

Valves:

1:	Shutoff of rainwater tank
2:	Shutoff of maintenance supply
3:	Filter input shutoff
4:	Filter output shutoff
5:	House shutoff
6:	Unfiltered water to garden tap
7:	Filtered water to garden tap
8:	Garden tap winter shutoff
9:	Garden tap drain point
10:	Garden tap.

Tracing

I have 2 meters of 10W/m tracing cable to prevent the pump and filter from freezing if temperatures were to dip under 0C for a long time. I still need to add a thermostat that activates the heating element.

Leaky filter issues

The triplex filter got leaky in december after having the pump turned off and the system presure dropped to connect a toilet to the rainwater system. The plastic lock rings came really loose, I had to apply a quarter turn to tighten them up!

I already observed the filter leaking a bit during the summer after dropping the pressure, and I'm not sure what I can do about this...

First steps with Rust on the stm32

2023-08-03T20:10:00+02:00

A stm32 based traffic light I built for fun (and my kids) years ago

Since the Rust programming language is all the rage, I started exploring this programming language during the summer. These are my notes on what I needed to do to set up a working development environment using the hardware I already had in my lab.

Hello World blinky

To start off simple, I followed instructions on https://github.com/stm32-rs/stm32f1xx-hal to build the blink example program.

Flashing Using Black magic probe

Connecting the device

To connect the STM32 black magic probe to the Device under test, the usual connections are required:

B8 = SWDCLK
B9 = SWDIO
Vcc = Vcc
GND = GND

Installing a working GDB

To avoid hitting this compatibility bug I hit with gdb-multiarch, I installed the first older (8.3) GDB that came to my mind:

wget -P /tmp --progress=dot:giga https://developer.arm.com/-/media/Files/downloads/gnu-rm/9-2019q4/gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2
sudo mkdir -p /opt/TOOL_ARMGCCEMB
sudo tar -xf /tmp/gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2 -C /opt/TOOL_ARMGCCEMB
rm /tmp/gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2
sudo apt install libncurses5

I could then successfully run the commands found on the black magic probe website. A quick look through the project folder revealed the .elf program file. As you can see, GDB can step through the code.

thomas@roper ~ % /opt/TOOL_ARMGCCEMB/gcc-arm-none-eabi-9-2019-q4-major/bin/arm-none-eabi-gdb
GNU gdb (GNU Tools for Arm Embedded Processors 9-2019-q4-major) 8.3.0.20190709-git
Copyright (C) 2019 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "--host=x86_64-linux-gnu --target=arm-none-eabi".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word".
(gdb) target extended-remote /dev/ttyACM0
Remote debugging using /dev/ttyACM0
(gdb) monitor swdp_scan
Target voltage: Not Detected
Available Targets:
No. Att Driver
 1      STM32F1 medium density
(gdb) att 1
Attaching to Remote target
warning: No executable has been specified and target does not support
determining executable automatically.  Try using the "file" command.
0x08000b54 in ?? ()
(gdb) file /home/thomas/pets/verkeerslicht-rust/target/
.rustc_info.json    CACHEDIR.TAG        debug/              thumbv7m-none-eabi/
(gdb) file /home/thomas/pets/verkeerslicht-rust/target/thumbv7m-none-eabi/
CACHEDIR.TAG  debug/
(gdb) file /home/thomas/pets/verkeerslicht-rust/target/thumbv7m-none-eabi/debug/
.cargo-lock           .fingerprint/         build/                deps/                 examples/             incremental/          verkeerslicht-rust    verkeerslicht-rust.d
(gdb) file /home/thomas/pets/verkeerslicht-rust/target/thumbv7m-none-eabi/debug/verkeerslicht-rust
A program is being debugged already.
Are you sure you want to change the file? (y or n) y
Reading symbols from /home/thomas/pets/verkeerslicht-rust/target/thumbv7m-none-eabi/debug/verkeerslicht-rust...
(gdb) load
Loading section .vector_table, size 0x130 lma 0x8000000
Loading section .text, size 0x2d78 lma 0x8000130
Loading section .rodata, size 0x9cc lma 0x8002eb0
Start address 0x8000130, load size 14452
Transfer rate: 11 KB/sec, 903 bytes/write.
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/thomas/pets/verkeerslicht-rust/target/thumbv7m-none-eabi/debug/verkeerslicht-rust
^C
Program received signal SIGINT, Interrupt.
0x08000c82 in cortex_m::peripheral::syst::<impl cortex_m::peripheral::SYST>::has_wrapped (self=0x8002a3b <stm32f1xx_hal::timer::counter::SysCounterHz::wait+22>)
    at /home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/cortex-m-0.7.7/src/peripheral/syst.rs:136
136         }
(gdb) bt
#0  0x08000c82 in cortex_m::peripheral::syst::<impl cortex_m::peripheral::SYST>::has_wrapped (self=0x8002a3b <stm32f1xx_hal::timer::counter::SysCounterHz::wait+22>)
    at /home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/cortex-m-0.7.7/src/peripheral/syst.rs:136
#1  0x08002a3a in stm32f1xx_hal::timer::counter::SysCounterHz::wait (self=0x20004f84) at /home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/stm32f1xx-hal-0.10.0/src/timer/counter.rs:270
#2  0x08000a52 in verkeerslicht_rust::__cortex_m_rt_main () at src/main.rs:49
#3  0x080008f2 in main () at src/main.rs:19
(gdb) l 0
file: "/home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/cortex-m-0.7.7/src/peripheral/syst.rs", line number: 0, symbol: "???"
1       //! SysTick: System Timer
2
3       use volatile_register::{RO, RW};
4
5       use crate::peripheral::SYST;
6
7       /// Register block
8       #[repr(C)]
9       pub struct RegisterBlock {
10          /// Control and Status
file: "/home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/cortex-m-0.7.7/src/peripheral/syst.rs", line number: 0, symbol: "???"
1       //! SysTick: System Timer
2
3       use volatile_register::{RO, RW};
4
5       use crate::peripheral::SYST;
6
7       /// Register block
8       #[repr(C)]
9       pub struct RegisterBlock {
10          /// Control and Status
(gdb) n
stm32f1xx_hal::timer::counter::SysCounterHz::wait (self=0x20004f84) at /home/thomas/.cargo/registry/src/github.com-1ecc6299db9ec823/stm32f1xx-hal-0.10.0/src/timer/counter.rs:273
273                 Err(nb::Error::WouldBlock)
(gdb)
270             if self.tim.has_wrapped() {
(gdb)
275         }
(gdb)
verkeerslicht_rust::__cortex_m_rt_main () at src/main.rs:49
49              block!(timer.wait()).unwrap();
(gdb)
Note: automatically using hardware breakpoints for read-only addresses.
49              block!(timer.wait()).unwrap();
(

Turning it into a traffic light

Armed with VIM ALE configured with rust-analyzer and the stm32 hal code, my next steps are to convert this simple program to Rust, trying to map the code using Rust concepts I knew already.

For my original traffic light gimmic, I quickly whipped up a truth table as multi dimensional C array. I'll have to see how to elegantly implement the logic to call gpio set_high and set_low() functions.

To be continued...

OpenPlank Proof Of Concept

2023-01-11T20:10:00+01:00

The first (crude) prototype with sloppy veneer edges

In November 2022 I saw a cool Internet Of Things controller at a Matter event. They were marketing it as an unobtrusive way to interact with technology. Unlike the usual glass surface finish of touch screen devices, it looks like a wooden plank that is sensitive to touch and uses a LED pixel matrix behind the wood to visualize icons and text.

Since the device wasn't available for sale, I wondered how easy it would be to DIY a (much) simpler version that I could use for some of the same tasks.

I worked on this for a few hours each week, and by the end of December I had this simple proof of concept, making use of cheap parts and easy to assemble.

I call it the OpenPlank. Check it out...

Table of Contents

LED Display
- HUB75 interface
Input
Chassis
- Double size chassis
- Mechanical assembly
User Interface
- Simulator
Circuit
Demo video
Design Files
Work in progress

LED Display

I started this project by looking at the options for the LED display that were available. I found that there are Chinese LED matrixes on the market that you go by the search term 'HUB75 P2.5', where the P2.5 stands for the pitch between the LED pixels(in this case 2.5mm). The most pixel-dense displays I found have a 1mm pitch, and there are more coarse displays with eg 5mm pitch.

I opted for a P2.5 display since that would work with the idea I had for the touch input.

These displays can be daisy-chained; they can be connected together and driven as a single larger display.

HUB75 interface

I found and used the PxMatrix library, which was easy to set up and to get working. I found out that the display I had has a 1/16 configuration. The display is driven using a SPI host and the signals are wired in such a way that it is configured as one large shift register. For more information about HUB75 display matrices, you can read this sparkfun article or search the web.

Input

To avoid a complicated touch layer design, I wanted to check if a circuit board with vertical copper strips could provide a simple one dimensional (along the X axis) input.

I designed a cover with 'sieve' hole pattern grid and printed it. I then cut and applied a few strips of copper tape to see if a touch controller I had on stock would sense the touch when the veneer was held before it.

This worked, so I quickly hacked together a design in KiCAD.

Touch layer circuit board

I made this design simple and quick, its main features are:

The 1.2mm holes are aligned with the LED's
It has a 10mm bezel around the display that can be used as glue surface.
There is no bezel on right side so two boards can be put next to each other seamlessly
there are 2.54mm pitch SMT connectors on back to plug the MPR121 boards onto.

Once consideration with this setup is that the holes need to be aligned with great care, since the RGB LED pixels are made out of three LED dies that are slightly offset. Misalignment would block one of the colors partly. Fortunately the veneer diffuses the light and makes it less of an issue.

Touch digitizer

I started with MPR121's since I already had a few of these boards from a previous project. They can be arranged in a grid too to create a 5x7 or 4x8 grid.

As an alternative I found a software library to do touch using only a simple analog mux (documentation for it can be found here). This has some special microcontroller requirements, but could still be an option.

Device input backup plan

In case the touchscreen approach would not work, I also have some gesture sensor I can use (APDS-9960 Gesture sensor if I recall correctly). I may add it anyway to automatically wake up the device when a hand gets near it.

Chassis

As initial prototype I designed a chassis (plural chassis /-iz/ from French châssis, the load-bearing framework of an artificial object) that holds a single display. The chassis has:

a 1mm bezel around the touch PCB which keeps it in place for alignment when glueing.
10mm glue contact bezel with the touch PCB
openings for the touch PCB's connectors.
slots to insert discs behind the LED board to keep it in place but easy to remove.

Double size chassis

A chassis around two displays would be too big for my Prusa MK3's printbed, so I designed one that uses Butterfly joints to connect both parts. This fits together perfectly with the butterfly joints, and feels quite solid.

Mechanical assembly

I printed a plastic block a bit smaller than the display to apply pressure to the touch PCB from the back when clamping for glueing, and four brackets that hold the bezel's Y dimension together.

I used a transparent contact glue, applied with a conference badge as spatula but a credit card sized plastic card would also work I think.

Both parts are plastered with the glue using the spatula, left to dry for 10 minutes and afterwards put together and rubbed to remove air (check youtube for video's on how to apply veneer).

Before applying glue it is important to use painter's masking tape to cover surfaces that should not get glue onto them, as well as the backside of the touch board so glue does not get pushed trough the holes.

After glueing the PCB onto the chassis body, the wood veneer (I used Cricut maple veneer) is glued to the PCB, trimming the edges must be done carefully, since you can easily cut off too much, as I did with my first prototype.

User Interface

I plan to use LGVL - Light and Versatile Graphics Library to make the user interface as generic as possible and to reuse things like swipe detection and widgets.

It will need to run in a monochrome mode, with a small framebuffer and tiny fonts. It may also require some rewriting of the rendering code that renders widgets too large by default. Writing some glue code to feed LVGL's pixel output to the HUB75 driver will also be needed.

I found a nice article on using LVGL with monochrome displays which makes it look easy.

Simulator

While waiting for parts, I started working on a PC simulator which renders the LVGL framebuffer pixels on an SDL surface as round pixels.

The simulator is still in early stages, since the electronic and mechanical parts arrived quickly and writing some proof of concept software for it only took a few minutes.

It should also include downsampling of touch events to match the coarse touch PCB. This way the user interface can be a realistic representation of the hardware. I plan to also use it to check if this setup is good enough to use slider widgets.

Chassis STL object

https://www.printables.com/model/373360-openplank-mk0-12-chassis

Work in progress

You can follow me on Mastodon to read updates on this project.