Home
About
Contact
Resume
Portfolio
Goals 
This is my portfolio of technical projects, including my ECE1100 discovery project.
CircuitDojo is my project for ECE1100 at Georgia Tech. The primary goal is to replace the Ni MyDAQ in classroom environments with a hackable, fully open-source alternative that can be made at home with ~$10-$15 of parts and some soldering skill, and can be cheaply mass-produced for intro ECE classes.
Pictured here is the actual board I run CircuitDojo on! It is just an Arduino Uno - while eventually the goal is fully custom hardware, it isn't there yet. CircuitDojo is capable of using all of the Uno's pins in a variety of ways. In this configuration, analog 0 is tied to digital 3, which is a PWM pin - so we can output PWM from digital 3 to see if analog 0 picks it up. It does! While the PWM subsystem of an Arduino Uno is too slow to approximate a real voltage, it's clear that the measured voltage jumps follow the duty cycle.
Over the course of ECE1100, I was able to overhaul the old interface, add support for the ADC and PWM peripherals inside the Amega328p, and massively improve the performance and stability of the software. Modern CircuitDojo is reliable and safe, while being sufficiently featureful to almost fully replace the MyDAQ for introductory courses.
Currently, introductory classes at Georgia Tech use the NI MyDAQ as a tool for debugging and testing digital and analog circuits. A MyDAQ is mandatory for many classes (e.g. ECE2020 and ECE2040). Unfortunately, the MyDAQ is also extremely expensive (costing $2-300 each), unreliable and dangerous on many Windows computers (there are many reports of serious damage to the operating system just from installing the software!), and impossible to use with Linux or Mac computers.
This affects many students: for instance, I don't have access to a Windows computer, and am not able to use a MyDAQ to participate in class. To get around this in ECE2020, I built the first iteration of CircuitDojo and used it to successfully complete each in-class lab, demonstrating that the advanced features of the MyDAQ are not necessary for an introductory class, and can be replaced with a simple, open-source, cross-platform, and extremely cheap alternative.
My ultimate goal is to get the MyDAQ removed as a required material from every introductory ECE course, replaced with a very cheap and hackable open-source CircuitDojo that doesn't impose requirements on students' hardware and works reliably.
CircuitDojo is actually two separate pieces of software: the board firmware, called Dojocore (designed to run on a low-cost AVR microcontroller), and the desktop software.
The original CircuitDojo Desktop implementation looked like this - it was simple, functional, and fully digital. It was sufficiently powerful for use in introductory digital design (ECE2020), but without ADC sampling features, it was limited.
The main stack has not changed - the desktop software is written entirely in idiomatic safe Rust (ensuring stability and support across platforms), and Dojocore is still written in C. However, the software is evolving to meet the real needs of an introductory class.
Modern CircuitDojo is much more user-friendly, and has support for ADC inputs and PWM outputs. It is already a sufficient MyDAQ replacement for non-oscillating purposes: e.g., simple circuit probing and analysis. This covers the majority of use cases I've seen for MyDAQ.
It cannot be used for high speed sampling as an architectural limitation of the Atmega328p, so it will never be able to show voltages on microsecond scales - but the current sample rates are sufficient for most low-speed use cases.
The goal will always be to remain as cheap as possible while being useful as a probe, so there are currently no plans to port to a more sophisticated microcontroller with faster ADCs.
As an example, I can use CircuitDojo to test a simple resistor network like this one:
Rather than manually connecting and disconnecting and probing with a multimeter,
I can simply assemble a circuit and test it with CircuitDojo: this ensures I don't
accidentally damage the circuit by jiggling wires, for instance,
and allows me to run a variety of experiments (e.g. the behavior under a PWM output), like so:
The voltage divider is about 20:1, so instead of reading a full 5 volts,
we only read 4.76. Note that I can test with the power off to verify that
there is no voltage coming from elsewhere changing this result,
and turn it back on, allowing me to verify that the voltage divider works
without having to touch the hardware.
Developing CircuitDojo has taught me an incredible amount about asynchronous system design, desktop software development, and small embedded microcontrollers. The limited UART speed of the Atmega328p has led me to develop an extremely optimized binary communications protocol which encodes most state changes within a single byte!
Over the course of development, I have gained significant experience with Rust - I have become far more familiar with
the quirks of the basic design patterns and understand better why they exist. An example of this was my move from
ringbuf to crossbeam: when I originally developed CircuitDojo, I assumed using Ringbuf
would be superior for its performance, but I now understand that the documentation and wider acceptance of
Crossbeam is a better long-term choice for desktop software.
At this point, the software no longer needs more work before hardware is ready, so I will be focusing entirely on hardware from here on out.
The hardware is unfortunately still in the early design phase - currently, Dojocore runs solely on an Arduino Uno. Eventually, it will run on a custom Atmega328p-based board - essentially an Arduino Uno, but with fewer features, and with support for higher voltages.
I will be able to apply what I've learned at Gatch to the hardware. I have very little prior experience with hardware development, so I'm learning a lot from my classes, and will be able to use that knowledge to improve the quality of the CircuitDojo project.
My homelab is an extremely useful agglomeration of a bunch of random hardware. It runs my Samba share, my local Git server, a bunch of websites, some video games, a Discord bot, an internet forum, and a bunch of other odd services I decided would be fun to try.
It runs Kubernetes (K3S), which has been both an incredible headache and an extremely worthwhile learning experience.
Coming in at a thrilling 4@3.3ghz, the primary node in my homelab is an old Optiplex I got from a friend-of-a-friend. When it arrived it had an shorted out front panel and was surprisingly otherwise intact. It now runs the control plane for K3S, along with a ton of containers. Affectionately named "doobian", it's been hosting almost all of my websites for almost 3 years.
The second node in my cluster is an old Thinkcentre M720q - a minicomputer made by Lenovo for whatever reason. It's not actually mine; a friend got it from a project she did, and didn't want to deal with transporting it to her out-of-state college. It now runs mainly a Minecraft server, but theoretically can host any of my many services, should K3S so provision.
The network switch for this whole affair is a really old Asus router. I've been meaning to buy a proper OpenWRT switch, but this works fine for now!
Building and running a homelab has taught me an enormous amount about Linux administration, containerization, hardware management, distributed systems, and more! Thanks to this homelab I've managed to more or less escapeb big tech in my personal life - I can NAS without Google Drive, host websites without Microsoft, talk over selfhosted Matrix without Discord/Slack/Gmail, etc.
On "Scrappy's Performance Division" (an unofficial combat robotics team comprised of me and a few mechanical engineers), I'm working on generation 2 of an aerodynamic combat robot named "McMurtry's Roomba" for its inspiration, the McMurty Spierling.
It uses an electronic ducted fan to suction itself to the playing field, making it nearly impossible to push off; massive hobby racing motors geared down 30:1 make it quite strong. McMurtry's Roomba competes in Dragon Con Robot Battles every year since 2024 (when it was just a giant wooden hexagon that did not move) - every year is a complete redesign, but we keep the name.
Aside from being extremely fun, this has been a very educational project; beyond teamwork and budget management skills, we've learned to weld, to 3d print, to safely handle highly energetic electronics, and to build our iconic wooden frames (every year we swear not to build another wood robot, and every year we build another wood robot anyways), among other things.
The current iteration exists only as Solidworks design files, but it's looking like this will be our strongest year yet!