Posts on Intelligent Dithering

Dual Screen DIY CyberDeck

Wed, 30 Jul 2025 10:52:46 +0000

A cyberdeck is a custom-built, portable computer, often with a cyberpunk aesthetic, designed for accessing and interacting with cyberspace. In science fiction, they are used by hackers to connect to digital worlds, often for activities like hacking, data theft, or controlling machines. Real-world cyberdecks are typically built around single-board computers and designed to evoke this cyberpunk style and scratch an itch for the maker who designs it.

There are plenty of “cyberdeck” builds out there but this latest one from Sector 07 has really caught my eye. It is a Dual Screen DIY Cyberdeck built around the Raspberry Pi single board computer featuring twin rotating touchscreens.

This one has it all.

Stunning retro-futuristic look
Dual rotating touch screens
Snap-fit 3D printed enclosure
Access to GPIO for prototyping
Integrated keyboard
Open source files and parts so you can build your own
Extensive documentation

The attention to detail that Sector 07 have given to this device is amazing. It looks like a finished product and the aesthetic is super cool.

Take a break to watch the video below, it really is worth your time and if you decide to build one yourself or have other cyberdecks you think we should know about let us know in the comments.

5 Father's Day Gift Ideas for Geeks

Fri, 06 Jun 2025 00:00:00 +0000

Father’s Day 2025 is rapidly approaching so here are a few ideas to help you keep that geeky dad in your life happy!

Whether it is for a new dad, a dad-to-be or an old hand, these gifts will hopefully spark your inspiration and ensure they have a smile on their face come the 15th June.

Raspberry Pi Starter Kit

Mid-life crisis hits people differently, but a new hobby is usually on the cards. If they are interested in tech and tinkering, then a Raspberry Pi will open a whole world of possibilities for them. From Home Automation to programming, robot building or just playing around with some LEDs anyone who likes to fidget and tinker will love this.

🔗 https://amzn.to/4kRJKxI

Home Assistant Green

The Home Assistant / Nabu Case Green is a dedicated hardware device to run your Home Assistant software. As it is made by Nabu Casa, it is fully supported by them. It is one of the easiest and most reliable ways to get started on your Home Automation journey. I run my house on one of these and it hasn’t missed a beat in over 9 months. It is what I connect my DIY home energy monitoring project to.

🔗 https://amzn.to/4jEvSpJ

Soldering Iron Kit

No self-respecting geek should be without a soldering kit in their home. Especially paired with the Raspberry Pi, soldering can be incredibly rewarding when you build your first circuit and control it from code that you wrote. Being able to fix faulty Christmas tree lights and other items around the home just makes having a kit like this all the more worthwhile.

🔗 https://amzn.to/3TaplIq

Mini Bluetooth Label Printer - BIG DISCOUNT!

Once you start amassing tinkering kit, you will end up with drawers and drawers of components and it soon gets hard to find things. And another critical component of a mid-life crisis is a sense of dread and overwhelm leading to a deep want to reorganise EVERYTHING. Labelling is your friend in this endeavour!

Plus this one is on a deep discount at the moment. Snap it up before it’s too late!

🔗 https://amzn.to/4dRyv69

Precision motorised screwdriver

Once you get into tinkering a decent screwdriver set is an absolute necessity. You want a kit that has lots of tiny interchangeable heads and these kits also come with an electric screwdriver designed for working with very delicate screws found in electronics. Save your aging wrists and invest in one of these today. You won’t regret it!

🔗 https://amzn.to/4kMY36I

Cheap DIY 8 Port IP KVM on a budget

Fri, 31 Jan 2025 00:00:00 +0000

Building a cheap IP KVM using open source software and Raspberry Pi

We recently had a small server outage in work. Nothing mission critical, it was over a weekend and coming up to Christmas holidays. It could wait, but that little itch in my brain couldn’t let it sit. I tried several remote remedies to bring it back online but it needed physical access. It had to wait until Monday.

We use older Mac Minis as compact Linux servers and they have been working brilliantly for years. And so much quieter than sitting beside a massive rack of noisy servers!

But if they go down physical access can be a pain as we don’t have a KVM switch. I really wanted to go for an IP KVM switch but they are so expensive! So I figured we could come up with a cheaper solution using, you guessed it, a Raspberry Pi!

So the plan was to get a cheap 8-port USB and HDMI KVM switch, attach it to a PiKVM device to get it on the network and Bob’s your uncle, you now have a DIY IP KVM. I hit a few snags along the way but we got it running, so this is documentation of the process for my own records and to help anyone else hoping to replicate this.

DIY IP KVM Parts

Step 1: Fit the KVM Switch

This part was the easiest. Just hook up all your servers to the KVM switch and test it out.

However it was at this point I noticed what could have been a show stopper. Most KVM switches have a key sequence you can use to switch between machines, usually something like tapping Scroll Lock twice and then hitting Escape, or Scroll Lock followed by the number of the port you wish to switch to. This one didn’t! It comes with a switch panel with 8 buttons on it and an IR remote, as well as being able to press the illuminated buttons on the front panel.

Step 2: Setup and connect PiKVM

This step is well documented at the PiKVM website. Basically download the appropriate image for your Raspberry Pi it will be hosted on (I used a Pi4), flash it to an SD card, boot the Pi and then SSH in to configure some options.

You will also need to connect the WaveShare HDMI capture device to the CSI port on the Pi and connect the HDMI output from the KVM switch to the Pi.

BONUS TIP: If you connect this via the HDMI mirror splitter device, you can have the display going to the PiKVM AND a physical monitor, which means we can remote in or just use the physical keyboard etc at the server rack.

Then you will need to connect the power to the PiKVM via the USB-C Power and data splitter cable, so that power goes into the Pi 4 power port and then use a USB-C to A cable to connect the other half to the KVM switch keyboard and mouse port.

This KVM switch has 4 ports so we are able to connect the PiKVM for control as well as a physical keyboard and mouse.

Step 3: Reverse engineer the control box!

As previously mentioned, the KVM switch did not have keyboard hotkey switching so I couldn’t remotely switch from the PiKVM software. Oops!

So I took apart the control box that was connected via a USB cable. Unfortunately it doesn’t use the USB protocol, just the cables! Luckily a bit of Googling located someone who had already worked out the communication signals it was using. It seems to send a pulse of varying length to choose the port it switches to.

I used the Python code from here and saved it to /usr/local/bin/kvm.py making sure to chmod +x to make it executable.

This reddit post also has some useful pointers.

/usr/bin/local/kvm.py

 1#!/usr/bin/env python
 2import RPi.GPIO as GPIO
 3import sys
 4import time
 5
 6input_pin = 24 # connected to 'D+' pin on mini USB
 7output_pin = 23 # connected to 'D-' pin on mini USB
 8
 9def setup():
10GPIO.setmode(GPIO.BCM)
11GPIO.setwarnings(False)
12GPIO.setup(input_pin, GPIO.IN)
13GPIO.setup(output_pin, GPIO.OUT)
14GPIO.output(output_pin, GPIO.HIGH)
15
16def get_port() -> int:
17while GPIO.input(input_pin) == GPIO.LOW:
18time.sleep(0.001)
19while GPIO.input(input_pin) == GPIO.HIGH:
20time.sleep(0.001)
21start = time.time()
22while GPIO.input(input_pin) == GPIO.LOW:
23time.sleep(0.001)
24stop = time.time()
25return round((stop - start) * 50)
26
27def set_port(port: int):
28GPIO.output(output_pin, GPIO.LOW)
29time.sleep(0.02)
30GPIO.output(output_pin, GPIO.HIGH)
31time.sleep(0.02)
32GPIO.output(output_pin, GPIO.LOW)
33time.sleep(0.02 * port)
34GPIO.output(output_pin, GPIO.HIGH)
35
36setup()
37set_port(int(sys.argv[1]))

Then in the /etc/kvmd/override.yaml file I added the following:

/etc/kvmd/override.yaml

 1kvmd:
 2 gpio:
 3 drivers:
 4 kvm_set_input_1:
 5 type: cmd
 6 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 1]
 7 kvm_set_input_2:
 8 type: cmd
 9 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 2]
10 kvm_set_input_3:
11 type: cmd
12 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 3]
13 kvm_set_input_4:
14 type: cmd
15 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 4]
16 kvm_set_input_5:
17 type: cmd
18 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 5]
19 kvm_set_input_6:
20 type: cmd
21 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 6]
22 kvm_set_input_7:
23 type: cmd
24 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 7]
25 kvm_set_input_8:
26 type: cmd
27 cmd: [/usr/bin/sudo, /usr/local/bin/kvm.py, 8]
28 scheme:
29 kvm_input_1_button:
30 driver: kvm_set_input_1
31 pin: 0
32 mode: output
33 switch: false
34 kvm_input_2_button:
35 driver: kvm_set_input_2
36 pin: 0
37 mode: output
38 switch: false
39 kvm_input_3_button:
40 driver: kvm_set_input_3
41 pin: 0
42 mode: output
43 switch: false
44 kvm_input_4_button:
45 driver: kvm_set_input_4
46 pin: 0
47 mode: output
48 switch: false
49 kvm_input_5_button:
50 driver: kvm_set_input_5
51 pin: 0
52 mode: output
53 switch: false
54 kvm_input_6_button:
55 driver: kvm_set_input_6
56 pin: 0
57 mode: output
58 switch: false
59 kvm_input_7_button:
60 driver: kvm_set_input_7
61 pin: 0
62 mode: output
63 switch: false
64 kvm_input_8_button:
65 driver: kvm_set_input_8
66 pin: 0
67 mode: output
68 switch: false
69
70 view:
71 header:
72 title: Input
73 table:
74 - ["#Console:", "kvm_input_1_button|Prox1", "kvm_input_2_button|Prox2", "kvm_input_3_button|Prox3", "kvm_input_4_button|Lambda", "kvm_input_5_button|NA01", "kvm_input_6_button|NA02", "kvm_input_7_button|ProxBackup", "kvm_input_8_button|FOG"]

The bottom section labelled “view” creates a new button in the top menu of PiKVM called Input, and then it has 8 buttons within it. The names of the buttons are Prox1, Prox2 etc. You should change those to the names of the machines you have connected to each port.

Then I cut open an old Mini-USB cable and exposed the data lines. You do not need the red or black power lines. I soldered on DuPont connectors and attached the data lines to pins 23 and 24 on the Pi GPIO pins.

I then tested the switching using the kvm.py script above from the command line. Bingo!

Conclusion

It was a lot of fiddling about but we now have web based IP KVM access to all of our servers and the ability to easily switch between them in the web interface.

PiKVM also has the ability to emulate a USB disk or CD drive, so you can upload ISOs to it and attach them, allowing you to fully reimage a machine remotely. It really is a fantastic project and I am glad it exists!

DIY Whole Home Energy Monitoring with Home Assistant

Mon, 25 Mar 2024 00:00:00 +0000

Why energy monitoring?

I recently decided I wanted more data on our home energy usage. Unfortunately our meter box is over 20 years old and our energy supplier wont replace it until it is 30 years old. It is an old spinning disk style meter with analog display.

I had considered using a camera and some machine learning to read the digits from the display, but I think monitoring the actual power usage will be much better. Doing this is dangerous however so I needed a way to do it without my wife cashing in the life insurance!

CT Clamps measure the magnetic field coming from an electrical cable. My measuring the strength of the field via the induced current into a coil, you can get a measurement of the current flowing through the wire without being electrically connected to it. Split core CT Clamps make this even safer, by allowing you to “clamp” the sensor around the wire without having to disconnect anything.

Important warning

I am not a qualified electrician. Using even these “safe” CT clamps does have a risk associated with it, and being in and around your electricity meter is obviously risky business. Please consult a suitably certified expert before attempting any of this! YOU HAVE BEEN WARNED!

The Plan

My plan is to build a small system using some pre-made circuit boards for this purpose. Then install ESPHome onto an ESP8266 chip to allow easy programming and connection with Home Assistant. Once it is all installed, I should be able to have a nice simple gauge on my Home Assistant dashboard showing the live energy usage in the house. Home Assistant will also graph this data historically to allow us to see patterns of use and perhaps adjust our behaviour to help reduce our energy costs.

The parts should cost less that £20 ($25 USD).

The Parts

Prepare the sensor

The first thing to do was to assemble the parts. This was pretty straightforward once I had the header pins soldered onto the Wemos D1 Mini. Just snap the two parts together and then connected it to my Mac via USB cable.

Then I navigated to the ESPHome web installer. I had to do this using Google Chrome as Safari on Mac does not currently support WebSerial.

Just click Connect and then choose the serial port from the menu that pops up. Add in your home WiFi details and that is your ESPHome device created and it should appear in Home Assistant ready for adoption.

Once I had the device connected to Home Assistant it was time to program it. ESPHome allows you to use YAML files to configure the devices. Simply change the YAML, hit Save and Install and then choose WiFi. This will send your new device configuration over to the ESPHome device and reboot it, displaying logs to show how it went.

Here is the code I used for my sensor:

 1substitutions:
 2name: esphome-web-6eb49e
 3friendly_name: CT Clamp
 4
 5esphome:
 6name: ${name}
 7friendly_name: ${friendly_name}
 8name_add_mac_suffix: false
 9project:
10name: esphome.web
11version: '1.0'
12
13esp8266:
14board: esp01_1m
15
16# Enable logging
17logger:
18
19# Enable Home Assistant API
20api:
21
22# Allow Over-The-Air updates
23ota:
24
25# Allow provisioning Wi-Fi via serial
26improv_serial:
27
28wifi:
29# Set up a wifi access point
30ap: {}
31
32# In combination with the `ap` this allows the user
33# to provision wifi credentials to the device via WiFi AP.
34captive_portal:
35
36dashboard_import:
37package_import_url: github://esphome/example-configs/esphome-web/esp8266.yaml@main
38import_full_config: true
39
40# To have a "next url" for improv serial
41web_server:
42
43# Example configuration entry
44sensor:
45- platform: ct_clamp
46sensor: adc_sensor
47name: "Measured Current"
48id: home_current
49update_interval: 15s
50filters:
51- calibrate_linear:
52# Measured value of 0 maps to 0A
53- 0 -> 0
54- 0.028 -> 8.8
55
56# Example source sensor
57- platform: adc
58pin: A0
59id: adc_sensor
60
61- platform: template
62id: my_power
63name: "Home Power"
64lambda: return id(home_current).state * 230;
65device_class: power
66unit_of_measurement: 'W'
67update_interval: 15s

You have to calibrate the sensor using a known load. How I did this was to strip back the out sheath from an extension cable, allowing me to access the live wire separately. I could then clamp the CT over the live wire, and then plug in a known load to the extension cable. I also used a plug in energy monitoring plug to verify results.

Do not make a cable like this!

I ran a hairdryer on its medium setting and saw that it produced 4.4 amps on the digital meter, while the ESPHome chip was reporting 0.014A. I then ran it on max, and saw the digital meter showing 8.8 amps of draw, and the ESPHome showing 0.028.

So in the YAML file under the calibrate linear section I add 0 -> 0 and 0.028 -> 8.8. This will then allow the sensor to work out what to convert when taking reading. I should probably have put in more readings to help make it more accurate but for my needs this will suffice.

Install the sensor

Happy that I had reasonably accurate readings it was now time to install the sensor. Luckily for me my power meter has the output cables easily accessible. It was simply a matter of installing the CT Clamp around one of the cables and then powering on the sensor.

I also 3D printed the case for the Wemos and adaptor board to keep everything neat and safe.

Within minutes I had data flowing to Home Assistant. All that was left to do is add it to the dashboard.

I chose to use the Gauge type widget for this and will adjust the markings of the green, yellow and red areas as I monitor our usage.

Conclusion

This was a really fun little project. For under £20 I now have a gauge of how much energy we are using despite having an incredibly old analog power meter.

This project hit a lot of areas: soldering, 3d printing, software, hardware and a little bit of potentially dangerous electricity. Perfect mix for tinkering!

I hope to make a few more dashboard widgets translating the power usage into monetary value to give us a better sense of how much things cost to run. This will hopefully help us as a family adjust our behaviours a little to save some money (and perhaps the planet!).

If you give this a go be sure to heed the warnings and let me know in the comments how you get on!

Happy tinkering!

TLS Inspector: essential free iOS app for webmasters

Sun, 24 Mar 2024 00:00:00 +0000

TLS Inspector is a great free app from developer Ian Spence that I use quite regularly at home and especially in work.

It is great for quickly checking for expiry dates on certificates, or why a certificate is not working as expected. You can also delve into the certificate chain to check for any inconsistencies. Very useful if you think a website might be suspect!

There have been other apps like this in the past but the one feature that I particularly love about TLS Inspector is the Share Sheet extension. This allows you to quickly check website you have open in Safari simply by using the share menu. No faffing about copying the URL, switching apps, trying to paste it and remove the non-domain bits.

Just tap “Show Certificate” and off you go!

Download a copy of it for free now from the App Store.