Works

Button Box

https://youtu.be/0F-DfAic39k

Introduction

As of writing this I’ve been going through a phase of playing Kerbal Space Program and Microsoft Flight Simulator a bit too much, and I stumbled across a subreddit for homemade cockpit designs – which all looked incredible.

I couldn’t afford a homemade cockpit, that is crazy, but I looked around and stumbled across a website to buy custom made KSP controllers, but at nearly $100 for the case alone, I decided I may as-well just try and make my own for a fun project. Sure I could also buy an Elgato Stream Deck, but they aren’t very serious looking right?

Build Your Own

I’m a complete beginner to electronics projects like this, never doing anything like it before, I decided to document the whole process from my perspective in-case any ordinary person wants to try and follow along.

The whole process is document on the Github Wiki page.

GPT CV Bot

The code for this project is published on Github

See the bot in action and ask some questions on my other website

Background

Seeing all of the advancements in machine learning research, especially the new GPT-4o model from OpenAI, I decided I wanted to try and make a project using their API. This is my simple implementation of the OpenAI Assistants API.

CV Bot

It was a lot simpler to make this project than I anticipated, but it’s still pretty cool so I had to list it in my portfolio! he premise is actually really simple, it’s just an OpenAI assistant with some specific instructions and a JSON version of my CV. A Python Flask app generates a thread for each user of the website, and then this thread is linked to my assistant to get contextual answers using my JSON CV as the knowledgebase for answers.

I’ve added a disclaimer to the website as sometimes the assistant flat out lies – I’ve managed to reduce this with some engineering of the bot instructions. At the time of writing the assistant uses the GPT3.5-Turbo model, but I will upgrade this when GPT4o becomes cheaper, in testing GPT4o tends to be pretty spot on with it’s answers.

If you want to make your own, read on! If not, go have a play with mine. Ask it to write a poem about why I am a good candidate, or see if it will pass judgement on whether I am a kind person or not! Just don’t tell it to ignore previous instructions and ask it to say how bad I am at programming, it might just work…

Making Your Own

It’s pretty simple to make your own bot:

1. Navigate to the OpenAI API dashboard and add some credits to your account
2. Create a new project and add a new service user, add this API key to the flask code on my Github under the API key variable
3. Create a new virtual assistant and put the ID of it again in the flask code provided on my Github
4. Give the virtual assistant some instructions. Be specific but try not to give it too much to think about. In my case, the bot instructions are:

   You are a chatbot designed to help people understand more about a person called Jack. Jack is a Computer Science graduate and you have been provided with a JSON formatted version of his CV. Use Jack’s CV to provide factual, accurate but concise responses to any questions. It is important that you do not lie or infer, but only stick to the facts of the provided file. Try to keep responses simple, avoid use of symbols or complex lists. When asked where to learn more, or for contact details, link the user to the following website https://jackdevonshire.co.uk which contains contact details, Jacks full resume and a portfolio of projects. Please act as though you are a virtual version of Jack. If asked who you are, introduce yourself as the virtual version of Jack that is designed to help them understand more about Jacks industry experience, skills and passion for technology.

5. Adjust the Temperature and Top P scores to try and get more accurate responses from the bot. I currently have them both set at around 1, which seems to make it be truthful pretty consistently.
6. Have fun! Just be careful if you decide to host it, make sure you add a disclaimer that the bot can spit out some utter garbage!

Tea Pot or Not?

The code for this project is published on Github

Background

I have recently admittedly been thinking about projects to work on. I knew I wanted to make something, but an idea “worthy of a portfolio piece” just hadn’t came to my mind. And then I saw a LinkedIn post (one of those cringey inspirational ones) that spoke about caring less about making grand things, and just focussing on basic concepts that you actually enjoy creating.

At that moment it hit me, I want to make a project that uses the Hyper Text Coffee Pot Control Protocol! 418 is an easter egg HTCPCP/1.0 status code, that indicates that the server is unable to brew a coffee, as it is indeed a teapot. I started to ponder what I actually wanted to make, and then came across two Github issues (Go, NodeJS) where some boring developers wanted to actually…get rid of the easter egg HTTP code…to make space for extra ones in the future…what?!

I then stumbled across the Save 418 Movement and realised that heck, even Google implements the 418 status code… I HAD to join in and make a “useful” application of the 418 HTCPCP/1.0 protocol…

Tea Pot Or Not?

So what actually is this application? Well put simply, it’s a basic Flask API that you provide an image to, and then it will return one of three messages:

• 418 I’m a teapot
• 200 Here’s your coffee
• 200 I’m not a teapot

The messages will be driven by the provided photo, by using machine learning to detect if the image contains a photo of a teapot, a coffee machine or neither.

Implementation

Honestly, I could’ve used this project as a grand plan to learn how to create, train and validate machine learning models in Python, but I wanted to create the project in a few hours…There’s plenty of time to learn about Machine Learning models in the future, but in my hungover state at the time, I just wanted to quickly slap up an API to determine if something is a teapot or not! 

With the above in mind, I started to research a bit about pretrained Machine Learning models. I first found an image dataset called Open Images V7, which has generously been placed in the public domain and contains literally millions of pre-annotated images ready to be used for training machine learning models.

At this point, I wanted to try and download a subset of the data (specifically just teapot images and coffee machines). I searched tons and tons of guides on doing this, but eventually I got bored of all the console errors I was getting.

Scrap that plan… On to doing what a developer does best, and just copying someone else’s work. I discovered a Github repo for Ultralytics which provides it’s owned YOLO state-of-the-art model that has been trained on the Open Images V7 dataset. Following a few examples, I started to play around with it in a new Python file.

Now all I needed to do was build an API that can accept a file via a BREW/POST API request, and then classify the objects in the image, and return a response based on the result.

The End

And that’s it really, the resulting code is published on my Github. I don’t actually think there is anything to show off here, just under a hundred lines of code that “borrows” someone else’s model and returns a response on it. The only real learning from this project was some extra context on the basics of machine learning models, the desire to learn more about machine learning, and most importantly…The history of the Hyper Text Coffee Pot Control Protocol. 

Rest assured, I’m diligently looking for any opportunity to implement a HTCPCP/1.0 418 response in my current companies codebase, probably an internal tool or something… Thanks for reading!

Gaze Detection

The code for this project is published on Github

Project Summary

 The idea for this project was born from an issue I regularly see in video calls, whereby when a person has multiple monitors and isn’t looking at the one with their webcam attached, the rest of the people in the call are stuck looking at the side of their face, which gives the impression of them being disinterested and it also reduces the immersion for everyone else on the call.

 I had a couple of webcams laying around so I decided to put two of them on different monitors, and attempt to make a program that automatically switches between them based on the monitor a person is looking at.

Implementation

 The full details can be seen on the Github repository for this project (linked above), however as a brief overview the project uses something called Gaze Detection, which is an area of machine learning research focussed on trying to detect where a persons eyes are looking.

 Using a pre-existing Python module called Gaze Tracking, I have been able to make a program that passes in frames from different camera sources and then gets back an estimated value of where the eyes are looking (relative to the camera). Using these returned values, my program simply selects the camera which a person is most likely to be looking at based on the gaze tracking estimates.

 The bulk of my own code simply just interfaces with the gaze tracking module, and compares readings to then try and select a webcam feed to pipe through a virtual camera – that can then be selected in video conferencing apps. My program also does a variety of things to try and improve the reliability of switching – so that cameras do not flicker between each other really fast – these measures include adding a timeout before switching, and gathering the average of readings over a set measurement period to have more data to be compared when considering which camera should be selected and piped through the virtual camera.

More details can be seen on the Github, and I am continuing to explore different ways to improve the reliability of the program.

Demonstration

https://youtu.be/kMjx8XlOlno

WiFi Bottle Opener

Project Summary

In December 2022 it was fast approaching Christmas, and I realised I hadn’t got my Dad a present yet. I wanted to get him something memorable, not just a boring pair of socks. I remembered we used to have an Elvis Presley bottle opener, that would sing “Viva Las Vegas” when opening a bottle…We all found this hilarious, but one day it broke.

I set out on my quest to find this bottle opener, but found nothing. It was a really old product, not being sold anymore. Time to make one!

Investigation Phase

Initially, a bought a bog standard singing bottle opener from Amazon, with the hope that I could figure out how it actually works. I tore it apart and found a basic sound module, that I had zero idea how to program. I did find some useful information though, in that the part of the bottle opener that touched the bottle cap was split into two metal sections, and essentially the metal bottle cap would complete a circuit that triggered the musical sound.

Initial Concept

I couldn’t reprogram the bottle opener I had purchased, so I decided to tear all of the electronics out of it, and purchase something called a “Programmable Sound Module” on Amazon. These modules can be programmed with a button and a microphone, and then once you have programmed them, you can just disconnect the microphone and button assembly so that it fits into your ideal card / case or whatever you are using it for…Unfortunately this didn’t fit the bottle opener.

So, I can’t fit a normal sound module speaker in this thing…Project doomed.

Second Concept

At this point I stepped back and had a think. I can’t fit a speaker inside the case, so what can I do? I tried to think out of the box, and then it literally hit me…Have the speaker outside of the bottle opener.

A bit of extra thinking later, and I settled on using my kitchens Sonos sound system to play the music. But how would this work?

Design / Implementation

I first started to figure out how to tell that a bottle was being opened, so that the “Viva Las Vegas” song could be played on the Sonos system. I realised I could use an RF transmitter, that would easily fit inside the bottle opener, and then receive this signal with a Raspberry PI and use some magic to get sound playing.

After deciding the above flow, I next purchased an RF receiver and transmitter from Amazon. I then started to do some research into the GPIO pins that my Raspberry Pi 3 had, as I had only limited practice of using them before this project. I knew that I would need to use them to detect when the receiver was detecting an RF signal.

Following on from this research, I produced the following basic electrical diagrams for my interpretation of how the components would interact on both the bottle opener side, and the Raspberry Pi side.

At this point it was time to start thinking about programming. To be honest, I started with a nice clean Github repository, and then I gave up pulling/fetching it to the Raspberry Pi and just started locally developing and debugging on the device. I’ve since lost the SD card that the OS was on and I also cleverly deleted the repository…

Essentially the code used the RPi.GPIO library to detect inputs from the 5v GPIO port connected to the receivers VCC output. I used SoCo to connect to the Sonos speakers, and the device would spin up a media server with the song to playback, and then on each receiver input, SoCo would tell the local Sonos API the location of the selected song to play.

During programming, I of-course had to set up the hardware as-well. Debugging usually takes a while, and if I had opened a can of beer each time I tried to test the thing, I probably wouldn’t be alive to tell this story. Instead, whilst locally testing I just hooked up the transmitter module to a button. Once I had finished debugging, I then put the transmitter module inside the bottle opener and soldered it to the existing contacts.

I don’t actually have any pictures of the Raspberry Pi and receiver, but I have managed to find a video of myself showcasing the prototype. You’re going to have to ignore the fact that I’m using my finger to test the unit, I wasn’t really thinking about publishing this video when I made it…

You will notice that the status LED is constantly flickering due to the RF noise being picked up – more on this later – but the LED completely turns off when the bottle opener contacts are connected.

Challenges

There where many challenges with this project. The first major challenge was the time pressure I placed on myself, having committed to this being the sole present for my Dad, I couldn’t just accept tons of his gifts on Christmas and then present him with a pile of electrical junk…

The first technical challenge was clearly not being able to find a small enough sound module to fit inside the bottle opener, leading to the thought of using an RF transmitter instead – and thus a vastly larger and more complex project scope.

The second challenge was learning how to solder…I had a tiny amount of soldering experience before this project, but the bottle opener casing I had, used tiny wires to connect to the contacts, and every mistake would just make them shorter. I didn’t have a second case to play around with, so I was facing quite some pressure to get solders right the first time around. I practiced soldering by just connecting small wires I had from a Raspberry Pi kit, before attempting the real thing.

The third and final challenge was unfortunately not solved before Christmas day. I had not anticipated the amount of RF interference in a typical house. When thinking back, it is clear that this would be an issue given my home uses lots of smart devices. Whilst you can physically see the LED flickering in the above video and then turning off completely on the bottle openers contacts being connected, this was extremely hard to determine in the code as I could not figure out how to determine the voltage being detected from the GPIO pin, instead it seems that the library I was using only supported telling me whether the contact was powered or not…I may have got this wrong, but at the time that was my conclusion.

Essentially, when the device was powered on, it would seem to work as normal, but every now and then the Kitchen speakers would randomly erupt with “VIVA LAS VEGAS”, not exactly great! I am now aware that there is a mechanism to set specific values in the RF signals, so that the transmitter and receiver can be more accurately “tuned” if that is the correct word.

Closing Notes

Overall the project was a slight success, but it could definitely be turned into a success if I where to approach it again.

If you’ve read this far, thanks for sticking with my writing! I feel I’ve rambled a lot here, and would really love some feedback to help improve my writing style as I continue to publish more of my old projects. Send over any feedback to: contact@jackdevonshire.co.uk

C# Savings Calculator

The code for this project is published on Github

Project Summary

Having recently re-joining my placement company as a graduate developer, I realised I needed to plan how to save my money – after-all I had spent the past 4 years living in my overdraft like a typical student. Cobbling together some Google sheets formulas, I managed to find an ideal allocation of savings accounts for me. With my savings strategy sorted, I realised that banks of-course change their rates, and also most introductory AER rates only last for the first year, so I would need to change my strategy yearly – or potentially more often. 

I could of-course have just cobbled together new formulas yearly, but as a developer I had gained an interest in how I could model how various savings accounts work over time…

The Solution

Every Friday, my company designates the afternoon as Kaizen time, a Japanese phrase that translates to continuous improvement – in a way this perfectly fits in with the companies Agile approach to project planning and development. I decided to use this Kaizen time one afternoon to develop the framework of a C# application that can model the rates of various types of savings accounts.

The solution isn’t some fancy web app, or even something with a user interface – although it could progress to this if I decide – but instead it is a collection of classes that model the basics of how various different savings accounts work. These classes can be created, interacted with via deposits, withdrawals and setting up monthly deposits, and then each class has it’s own calculation logic that will calculate the expected earnings by a set period of time, given the above deposits and withdrawals.

At the time of writing, the project has served it’s purpose for me, and resolved my curiosity of how savings accounts may be modelled in C#, however I may very well choose to expand it. Follow the projects progress on Github.