AmbiClone v2.0 2020

An updated version of my earlier project with vastly optimised performance, UDP support, and other tweaks (see this blog post).

Various Contiki/Contiki-NG contributions 2017+

Started off during university. I contribute occasionally to various areas such as:

• MQTTv5
• MQTTv3.1.1
• CI enhancements (Travis, Docker)
• Security & integrity issues (buffer overflows, etc.)
• Static code analysis

Unnamed C# app 2019

A quick bespoke WPF app that helps with CMS-related activites for a website selling musical equipment - web scraping, C# Chromium component, translation APIs. v2.0 includes UTF-8 support & user productivity enhancements.

Domino v2 2018-2019

Designed, assembled, and programmed a mass-production version of the passive preamplifier. Complete with a beautiful wooden box (courtesy of Dad), it's currently available for sale.

voleur 2018

A remote volume mixer for Linux. It allows users to change the volume of individual applications playing sound from a webpage (e.g. opened on a phone). The architecture is extensible, allowing different backends to be written to control different things. Available on GitHub (a first attempt written in Rust, then a release written in Go).

Domin0 2018

A remote-controlled audio input switcher and volume box (a passive preamplifier).

Yet Another Ambilight Clone 2016

The system averages the colours around the edge of the screen and projects them through an RGB LED strip (WS2812B). It uses C# and DirectX11 to capture the frames. I experimented with an ATTiny2313 for controlling the LEDs (they have strict timing requirements), but it didn't have enough RAM.

Light-sensitive curtain drawing system 2016

This circuit was meant to close the curtains when it's too sunny, and open them when it gets dark. I couldn't quite get it to work. I wrote a blog post detailing why.

ESP8266 + MeArm 2016

The MeArm is an open source robotic arm controlled by 4 servos. This board I designed for it includes the amazing ESP8266 to allow it to be controlled over WiFi. Also included on the board is an FTDI FT232 chip which allows wired communication and easy programming. The software I wrote allows it to be controlled via WASD or accelerometer. Other functionality inclues the option of recording a series of inputs and them playing them back.

An AVR prototyping PCB 2016

This was my first PCB design. It fits a 20-pin AVR (the ATTiny2313 in my case) and anything smaller. Removes the pain of running jumper cables from the ISP programmer to the breadboard. Designed in KiCad and assembled by hand.

Robot Wars (UoB) 2018

My teammates had participated twice in the past without luck. This year, we managed to win a few battles in the losers' bracket. We had ambitious plans, but the mean little beast in the picture (Fork Off) had to do. It was envisioned as a forklift-type robot, capable of lifting the opponents off the ground and dumping them in the pit.

BAE CTF (encore) 2018

BAE was back with another very cool CTF (with different challenges!). My team of 2 was narrowly beaten by a team of 5 by a difference of less than 1% in score. This time we actually knew how to solve the binary exploit challenges (buffer overflow, shellcode execution).

Inverse kinematics drawing arm (UoB + ARM Hackathon) 2017

A team of 5, we built a two-hinged arm that copies whatever you draw or type. The mechanical engineers on our team designed and built the arm, while the programmers wrote a Processing app that lets you draw, a Python server that works out the movements the arm has to make, and a Python script that coverts fonts into point clouds. We won a special prize for "team most likely to give up at 5AM". We demoed it at one of the Digimakers workshops.

Imagination Technologies Hackathon 2016

I was part of a team of 3. Our task was to assemble and program the MeArm robotic arm in a few hours. I made a simple GUI in Python/Tcl to take input from the keyboard and send it via serial to an Imagination Technologies Creator Ci20 board that drove the servos. We tied first place.

BAE CTF 2016

Participated with a friend. We did all sorts of fun stuff like tapping into Ethernet, steganography, web exploits, stack overflow, file carving, packet analysis, and forensics. We won 1st place and a really cool drone each (thanks, BAE!)

Virtual piano (UoB + ARM Hackathon) 2016

My team and I built a system that allows you to play virtually any musical instrument on any hard surface. We made some tactile sensors that we attached to the fingertips of a pairs of gloves. The gloves were connected to a Raspberry Pi running synthesiser software. There was also a camera tracking the hands using OpenCV, which meant we could create multiple areas, placing them predictably in relation to a fixed token. We didn't end up winning but we got an honourable mention. I was mainly responsible for processing the sensor input and tying everything together in Python.

Fast Associative Floating-Point Addition for High-Performance Computing 2018

I produced the first implementation of the High-Precision Anchored (HPA) format, which enables fast truly associative floating-point addition. I wrote low-level implementations using Intel AVX and Arm SVE intrinsics (Scalable Vector Extensions - Arm's next generation vector architecture) and compared the performance of the various versions. I had early access to the Isambard supercomputer (the world's first large-scale Arm supercomputer).

Building the Internet of Things with LoRaWAN: From Simulation to Deployment 2017

In 3rd year I did an industrial placement with the Toshiba Research Lab in Bristol. I looked at LoRaWAN, a next-generation low-power, wide-area IoT telecommunications stack. I set up a network to allow future experiments (base station and end devices). I also extended an open-source simulator in order to examine the scalability of LoRaWAN networks. I presented this work at the 2017 IEEE Global Communications Conference (Globecom) in Singapore. Paper available here.

IllumiBricks 2017

For the Interactive Devices course, our team of 5 built a set of light-up bricks that can be individually controlled. I mainly worked on electronics and embedded programming. Each brick had an ATTiny85 running the OneWire and WS2812 protocols. We used 3.5mm audio jacks for the connections. We used a special 3.5mm female connector, as the three segments would short when connecting a new brick. The special connector had some mechanical bits that were only actuated when the male plug was fully inserted. Some transistor magic did the rest. The bricks can be used to build 2D/3D displays and models.

A high-performance CPU simulator 2017

It simulated an advanced superscalar out-of-order RISC core. It supported speculative execution by performing various types of branch prediction (with a branch target buffer/branch target access cache). It was a five-stage pipeline with a unified reservation station and a reorder buffer. Though the ISA was fairly simple, I was able to write and run complex programs (such as quick sort) using a compiler I had previously written. On GitHub.

A compiler 2016

We were tasked with building a compiler for a simple subset of C (the While language). Originally, it only included variables (int), arithmetic expressions, strings, boolean expressions, if and while. The lexical and syntax analysis were done in ANTLR, and the rest was written by hand in Java. I added a number of language and compiler features:

• Arrays
• Scopes
• Type checking (scoped)
• Functions (with local variables) + recursion
• Used-before-allocating checks
• Too few/many function arguments
• Check for missing 'return' in non-void functions

An 8-bit CPU 2015

Given a simple ISA, I built a CPU in a simulator. It does fetch, decode, execute, and store in 2 cycles instead of the 3 that were recommended. It had addressable RAM and 3 working registers. An extra feature I added is a subcircuit that detects when the computation is done (there is no HALT instruction).

multiCNME 2013-14

A teacher at my high school created an educational programme that was based on the concept of transdisciplinarity - the idea that instead of studying individual subjects in school, we should study entire topics. An RPG-style educational game was created based on this principle. I was made Project Assistant and was put in charge of programming. I led a team of programmers and graphical designers, all students at my high school. I taught myself ActionScript 3 (Adobe Flash) in anticipation of this. None of us had programmed anything of this scale before, but we managed to make a fairly functional game. I wrote about half of the codebase, and some of the systems I'm particularly proud of were:

• The minimap. It would show your position on the map, as well as a bounding rectangle which represented the area of the map currently visible.
• The minigame system. Every NPC had a minigame (quest) associated with them, which could be triggered by the player. These minigames were separate .swf files, which allowed people to work on them independently from the main game. Once completed, the NPC would be removed from the screen, their successor would appear, and the main game would resume.
• An XML-based system for defining NPCs. Each NPC had an XML file which described their location on the map, catchphrase, quest, and successor. The game would read these files and automatically instantiate, place, and remove NPCs as the game progressed.

AIRCamTimer 2012-14

Timelapse capture software, running on Adobe AIR (ActionScript 3). This was my end of high school project. It takes pictures from a connected webcam at a set resolution, quality, and time interval. Adobe had recently introduced background workers, which were basically another copy of the Flash Runtime running in parallel. I used this to encode the images to JPEG while maintaining a responsive UI.