Open-Source 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.

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!

Make the ultimate bootable USB drive

Sun, 15 Oct 2023 00:00:00 +0000

Creating a USB Swiss army knife full of tech tools for all your geeky needs

Today we are going to make the ultimate bootable USB drive to have with you at all times. This is an invaluable tool and it is all made possible by the Open Source tool Ventoy.

This post is available in video form on YouTube as well for the visual learners among us.

Ventoy is basically a bootloader that goes onto a USB drive that allows you to easily boot from any of the ISO disc images contained within it. This allows you to have a single USB drive with all of the tools you need on it, Windows installer images, file rescue kits, hacking tools etc.

It lets you make a personalised USB Swiss army knife of all the tools you use most often.

Preparation to make the bootable USB drive

What do we need to begin:

A USB drive to hold our ultimate bootable USB toolkit
I find that keeping the drive below 128GB helps with compatibility with some older BIOS versions. I found this great little drive on Amazon that I use personally
The Ventoy application
You can get this from Ventoy.net for either Linux or Windows. Download the appropriate file and extract the contents of the zip file.
ISO files you want to boot from
You will need some disk images that you want to put onto the bootable USB drive. I would recommend things like the Windows installer DVDs, Hirens BootCD, Clonezilla, SystemRescue etc. Maybe even a Ubuntu Live CD would be useful!

Creating the bootable USB drive

Once you have the Ventoy application downloaded, extract the files and run the file called Ventoy2Disk.exe

You will get a window like the one below.

Choose your bootable USB drive in the dropdown and double check to make sure it is the right one. This tool will destroy all data on the drive so be very sure at this stage!

Click Install. It will warn you twice that it is going to wipe the drive before proceeding. The process only takes 20 seconds or so.

Once it has completed you will have a new USB drive show up in Windows Explorer named Ventoy.

Now all you have to do is copy over your ISO files to that drive. It really is that simple!

If you need to update or add a new ISO file in the future, just plug the drive in and copy the files over. You do not need to run the Ventoy2Disk app again unless you wish to update the Ventoy boot loader (perhaps if they release updates to fix bugs on certain systems)

Using your new bootable USB drive

Once you have made the drive and copied over some ISO files now you just need to try it out.

Plug the drive into a computer and turn it on. If the computer is set to boot from USB drives, the Ventoy boot window will appear. If not you may have to press the appropriate key to bring up the boot menu on your computer (typically one of the top row function keys)

When the Ventoy window appears, simply choose the ISO you wish to boot from and hit Return. It really is that easy!

No more lugging around a bag full of poorly labelled USB drives with every possible Windows or Linux install on them. Everything in one place on your new Swiss army knife of IT tools!

Let me know if you find this useful and what tools you like to put on your bootable USB disk.

Free Digital Signage with Raspberry Pi and Google Slides

Wed, 27 Sep 2023 00:00:00 +0000

Using a Raspberry Pi with Google Slides is an excellent way to make very cheap and effective digital signage. In this guide I will show you how to build this. This is an updated method as the Screenly / Anthias software doesn’t seem to like 4K screens for Google Slides! And the beauty of it: once you set it up, you don’t have to touch the Pi again, just edit the Google Slides presentation and watch your screens update!

UPDATE: The Raspberry Pi Trading Company have just announced the release of the Raspberry Pi 5. Read all about it on my new post here. (It can run dual 4K displays, so it will be perfect for your next digital signage project!)

What you need:

What you need:

Raspberry Pi 4 and power adaptors etc
Big screen or TV
SD Card 8GB or larger
Google account
About 30 minutes!

Step 1: Prepare your Google Slides presentation for Digital Signage

Before we start, you should have a Google Slides presentation prepared that you want to show on your digital signage. Make the presentation with no transitions or timings, as it will be set to the same timings for every slide in the sharing phase.

Once you are happy with your slides, click on File -> Share -> Publish to Web. Then choose to advance slides every X seconds (set it to 5 if just images, longer if your slides will have a lot of text to read)

Make sure that the “Start slideshow as soon as the player loads” and
“Restart the slideshow after the last slide” boxes are ticked.

Then click Publish.

Copy the URL that is shown and save it somewhere you can get later.

Step 2: Prepare the SD Card

Download Raspberry Pi Imager from https://www.raspberrypi.com /software/

Preparing the SD Card for your Digital Signage

Click on Choose OS
Select Raspberry Pi OS (other)
Select Raspberry Pi OS Lite (64-bit)
Select Choose Storage
Choose your memory card from the list (be careful not to select the wrong drive!)
Click on the gear icon
Choose a hostname for the device
Enable SSH using password authentication
Set the username and password
Configure Wireless if you will be using it (I use Ethernet for a more reliable connection)
Set Locale Settings (not essential but makes date and time correct)
Hit Save
Now click Write to wipe and install on the SD Card

Once complete, put the card in to the Raspberry Pi and fire it up.

Step 3: Log in and setup the Pi

Log in using SSH with whatever username and host name you gave the Digital Signage Pi during the SD Card prep phase. For example “ssh Colin@digitalsign.local”

Update the software on the Pi first by using the following command

1sudo apt update && sudo apt upgrade -y

This will update the Pi software list followed by installing all of the missing updates. The -y on the end just tells it to go ahead without prompting you for confirmation.

Once this is done we will install the packages needed to put our Pi into Kiosk mode. We will install Chromium browser and set it up to launch a webpage (our Google slides presentation) and make that page fullscreen.

1sudo apt install --no-install-recommends xserver-xorg x11-xserver-utils xinit openbox chromium-browser -y

Once this installation has completed we just need to configure the browser to launch at login and tweak a few other settings.

First of all we need to make sure the Pi is in the correct graphics mode. Do this by editing the config.txt file in the boot folder.

1sudo nano /boot/config.txt
2
3or on the newer BookWorm Pi OS Lite
4sudo nano /boot/firmware/config.txt

Look through the file to find the line similar to
dtoverlay=vc4-kms-v3d

Make sure that it reads dtoverlay=vc4-fkms-v3d and NOT kms (that little f is very important, without it the slides can be a little jerky)

Once that is done, save the file by pressing Ctrl-O then Return to save and then Ctrl-X to exit.

Next we will edit the file /etc/xdg/openbox/autostart using the command below.

1sudo nano /etc/xdg/openbox/autostart

And then copy and paste the following code into the file, making sure to edit the “your-url-here” bit at the end. In here you want to paste the Google slides publish URL we got in Step 1.

 1# Disable screen saver / screen blanking / power management
 2xset s off
 3xset s noblank
 4xset -dpms
 5
 6#Allow quitting the X server with CTRL-ATL-Backspace
 7setxkbmap -option terminate:ctrl_alt_bksp
 8
 9#Start Chromium browser in kiosk mode
10sed -i 's/"exited_cleanly":false/"exited_cleanly":true/' ~/.config/chromium/'Local State'
11sed -i 's/"exited_cleanly":false/"exited_cleanly":true/; s/"exit_type":"[^"]+"/"exit_type":"Normal"/' ~/.config/chromium/Default/Preferences
12chromium-browser --disable-infobars --kiosk 'http://your-url-here'

Again, Ctrl-O and Return to save the file and then Ctrl-X to exit nano.

Next we will make the X server start on login. Edit the .bash_profile file by doing
nano ~/.bash_profile and pasting the following code and saving using Ctrl-O then Return followed by Ctrl-X to exit.

1[[ -z $DISPLAY && $XDG_VTNR -eq 1 ]] && startx -- -nocursor

Now we need to tell the Pi to autologin every time it restarts so that the slides will display automatically. Do this by running sudo raspi-config.

In the text menus that appear choose 1. System Options, then S5 Boot / Auto Login and then choose B2 Console Autologin
Then press Tab twice to highlight Finish and hit Return. When asked to reboot choose Yes.

The Pi will now reboot and when it comes back on it should auto login in start to display your slides!

Congratulations! You have just built a very cheap and fast digital signage solution. Hook it up to a nice big TV and you are off!

Bonus step: Auto power off and on

When I use this method to make digital signage I like to use the crontab to turn the display off and on using a schedule. Most modern TVs will go into standby mode when the HDMI source turns off, saving energy when your display is not in use.

To edit the crontab use sudo crontab -e

If it is your first time it will ask what you want to use to edit it, I suggest nano as we are used to this from previous steps.

Here is the crontab I use

1#reboot the Pi Mon-Fri at 8am. This refreshes the slides and ensures the TV wakes up
20 8 * * 1-5 sudo reboot >/dev/null 2>&1
3
4#this turns the display output on
515 8 * * 1-5 sudo vcgencmd display_power 1 >/dev/null 2>&1
6
7#Disable HDMI end of day Mon - Fri 530pm. TV should go to sleep after
830 17 * * 1-5 sudo vcgencmd display_power 0 >/dev/null 2>&1

I hope this guide is useful to you, please share it and let me know how you use your Pi in digital signage!

Teaching with Moodle: An Introduction

Tue, 03 Jan 2017 00:00:00 +0000

If you are a beginner to the Moodle Learning Management System or even a current user just wishing to update and hone their skills then I can highly recommend this free online course delivered by the Moodle team themselves.

The course will take you through the basics of using Moodle to deliver Learning and Teaching to your students and showcases some of the excellent widgets and tools on offer.

And because the course is run on Moodle itself, you get to experience the learning as a student would on your course. I found this perspective really helped spark some ideas for ways to deliver content to make it more fun and engaging.

You can sign up here but as there are peer assessed sections you need get signed up this week to make sure you don’t miss any deadlines. They run these courses approximately every 6 months.

The course is free and should only require 3-4 hours per week of time (probably less if you have used Moodle before). The community engagement aspect will also allow you to see how Moodle is used in a variety of learning environments and you will leave enthused and bursting with ideas!

Here is a copy of the course outline. You also get a digital certificate on completion of the course, which you may be able to use towards whatever form of Professional Development scheme your institution operates.