Andrew Williams

Using hardware I accumulated through college, I wanted to build something that felt like real firmware. Something that could measure time precisely, respond in real-time, and follow sound engineering practices. This project enabled that goal through an ultrasonic sensor that encodes distance as the width of an echo pulse.

I configured a hardware timer on the MSP430 in capture mode to timestamp the rising and falling edges of the echo pulse, then computed the pulse width from those interrupt-driven timestamps. Those pulse widths were then converted to centimeters, with light filtering added to prevent readings from jumping or latching incorrectly at the edges of the detection range.

To visualize the computed distance, I implemented an LCD driver for an I2C backpack, including initialization and a small API for writing strings and values to keep the main loop readable. The system was structured around a simple pipeline: trigger → capture echo → compute distance → update LCD + LED outputs.

Modern software systems increasingly rely on access to real-time data, but many avionics platforms expose data through proprietary legacy interfaces that can't be modified without impacting certification or flight-critical behavior. The challenge was to design a system that could observe and distribute avionics data in real time while remaining non-intrusive, deterministic, and fully compatible with existing certification constraints.

I designed and implemented a modular C++ and Python software architecture that generates, ingests, translates, and disseminates avionics bus data through a controlled, observational pipeline. The system emphasized non-intrusive data exposure that preserved certified system boundaries while enabling downstream analysis and application access.

I architected an offline machine learning workflow to characterize avionics data behavior, then deployed the resulting static model artifacts into the real-time pipeline to preserve deterministic execution. The processed data propagated to a secure dashboard endpoint that visualized data frames and highlighted ML-detected deviations in real time.

My team and I were tasked with designing a driving simulator capable of providing real-time feedback to a human operator while combining realistic vehicle control, simulation fidelity, and adaptive software behavior. The project needed to integrate physical input devices with a simulation environment while maintaining responsiveness and a coherent user experience.

We constructed a driving simulator using Unreal Engine that integrated steering wheel hardware, haptic feedback, and software-driven coaching. The system combined simulation logic with external AI-based services to generate contextual feedback for the driver, emphasizing timing, responsiveness, and usability rather than visual realism alone.

The simulator was designed as a modular system, separating simulation logic, input handling, and feedback mechanisms that allowed iterative development and testing.

I was inspired to strengthen my understanding of firmware, bare-metal programming, soldering, and PCB design through a hands-on project. This motivated me to design and build a compact macropad that balanced simplicity, reliability, and usability.

I designed a custom 3×3 macropad PCB using KiCad, integrating mechanical switches, diodes, and an Arduino microcontroller. I assembled and soldered the hardware, then developed and flashed custom QMK firmware in C to define keymaps, layers, and macro behavior.

The firmware configuration emphasized modularity and flexibility, allowing the device to be easily reprogrammed and adapted to different workflows without hardware changes.