I'm a computer engineer interested in robotics and embedded programming. I have experience in C, C++, Rust, Python, and JavaScript.

In college, I led a senior design team that developed a chess-playing robot arm. I wrote firmware for the Annin Robotics AR3 arm and all of the code required to integrate it with ROS and MoveIt. I also implemented dynamic scene tracking (via ArUco markers) all of the logic for moving the arm, and various ROS nodes for integrating with other hardware and software. To account for significant backlash in the arm's joints, I wrote an evolutionary algorithm that visually determined the gripper's pose and estimated the error in each joint.

Additionally, I designed and built a gripper with an integrated time-of-flight camera, which I used for visual servoing when aligning with pieces.

An overhead Kinect is used to identify chess pieces using a fine-tuned YOLOv8-based classifier.

This project won the "Best in Show" for electrical and computer engineering.

When working with robotics, I've always been much more enthusiastic about projects that involve physical robots rather than simulation. For this reason, I developed a platform to put on top of a Roomba so that I could use it as a robotic base. I started out with a Raspberry Pi and an RPLidar A2.

I have since acquired an Nvidia Jetson, which is much more powerful than the Raspberry Pi and has a built-in camera. I redesigned the platform to accommodate the Jetson.

The system runs ROS2 and has been a lot of fun to use. I have run SLAM, navigation, and autonomous obstacle avoidance, among other things.

• View (some of) the source code at github.com/ZachDaChampion/Roomba-ROS-Jetson

I disassembled an old laptop and used its internals to create a smart mirror. The mirror runs Linux and displays a web page that I created. Right now it just shows the date and time, but when I have more time I plan to add weather, news, and other information.

A genetic algorithm that simulates a population of snakes. Each snake is controlled by a neural network, and the network is trained by having the snakes compete against each other. The snakes are given a score based on how long they survive and how many apples they eat. The snakes with the highest scores are allowed to reproduce, and their neural networks are combined to create the next generation of snakes. Snakes can die from running into walls or each other's bodies.

This project is implemented in C++ with the QT framework.

• View the source code at github.com/ZachDaChampion/Snake-World

In order to get more comfortable with the QT framework, I created a simple program that visualizes the A* and Dijkstra search algorithms. The program allows you to create a weighted grid, add walls, and select a start and end point. Pathfinding algorithms can be run at varying speeds and the results can be viewed in real time.

This project is implemented in C++ with the QT framework.

• View the source code and download a release at github.com/ZachDaChampion/Search-Visualizer

I designed and 3d-printed a simple quadrature encoder. It uses two photointerruptors to measure the rotation of a spinning disk. The disk has a series of slits around its perimeter that the photointerruptors can detect.

Due to 3d-printing limitations, I could not get very high precision. The disk has 15 slits, giving it 60 pulses per revolution. The encoder can therefore measure rotations to an accuracy of 1/60th of a revolution, or 6 degrees. I was unable to get the encoder to count accurately with higher precision because the slits were too small to be reliably detected.

That being said, the final encoder was perfectly accurate. It accumulated zero error even when spinning at high speeds.

This encoder was used in a school project in which dynamic band-stop filter was generated and applied to a live audio signal. The encoder controlled the frequency range of the filter.

A website for ranking TV episodes. This was my first project done with a modern web framework and I chose to learn Vue. I primarily used this project to improve my design skills, focusing on making a good-looking site with natural animations. I also wanted to build my own backend, so I used Node.js and Express to create a REST API.

• View the source code at github.com/ZachDaChampion/rankr
• Visit the site at rankr.zachchampion.tech

A website for picking a random "card" out of a virtual hat. I originally made this for some friends who wanted to pick a random movie to watch from a list that we had made. The site allows you to create multiple hats, each with a different set of cards. You can also configure the hat to select more than one card at a time to give you a small list of options.

This was my second web project. This time I used Svelte, a framework that compiles to vanilla JavaScript. I found it much easier to use than Vue. This project is entirely client-side, so I didn't need to worry about a backend; everything is stored in the browser's local storage.

I did extend this site for a class project, adding a backend with PHP and MySQL to enable live collaboration between users. However, this version is not currently hosted.

• View the source code at github.com/ZachDaChampion/hat-picker
• Visit the site at zachdachampion.github.io/hat-picker

In high school I participated in Vex Robotics. This is where I first learned C and C++. Most of my time in high school was spent in robotics, so I have quite a few projects from that time.

Having been my team's programmer for all four years of high school, I wrote quite a few robot programs. I've included some of the more notable ones below.

This was the first time that I used PROS, an open-source C(++) framework for Vex robots, rather than the relatively limited RobotC. This codebase includes PID controllers, automated macros, recording and playback of actions, and a custom (and very bad) sensor fusion algorithm.

• View the source code at github.com/77788J/77788J-Mark_VII
• Watch the robot in action
  • Autonomous routine: https://youtu.be/3ucRSPnvfCc
  • Another autonomous routine: https://youtu.be/Mr4lmr4Meqw

The first robot we built for the 2018-2019 season used a transmission between the chassis and lift to conserve motors. Controlling both systems simultaneously required carefully tuned control loops as well as a dynamic priority system to ensure that both subsystems remained stable.

• View the source code at github.com/77788J/77788J-TP-Mark-I

This code was written for a later robot that did away with the transmission. It included a Pixy camera that was used to automate intaking balls, aiming the catapult (the game involved shooting balls at targets), and following objects during the autonomous period.

• View the source code at github.com/77788J/77788J-TP-Mark-II
• Watch the robot in action
  • Autonomous routine: https://youtube.com/shorts/iE0eHTyWHIA

With this robot, we bit off much more than we could chew. The robot only lasted for a few weeks before we reverted to our previous design, so the code did not get much use. It was, however, the first time I used OkapiLib, a library included with PROS 3 that provided lots of useful functionality such as PID controllers, odometry, and motion profiling. This robot also had a transmission, this time between the chassis and the 'tilter'. This transmission was much more complicated (and, apparently, fragile) than the one used in the previous season, and it required a more complicated control system. A state machine was needed on top of the PID controllers and priority system to keep the transmission working properly.

• View the source code at github.com/77788Y/77788Y-Mark-II

This code was based on our first robot for the 2019-2020 season, so it does not include OkapiLib. It instead uses custom PID and motion profiling.

• View the source code at github.com/77788Y/77788Y-Mark-1.5
• Watch the robot in action
  • Early season "reveal" video: https://youtu.be/MkmrA7s2rX0
  • Autonomous routine: https://youtu.be/h7xMGhkN6eA

This was a simple Java program that I wrote to help plan autonomous routines for our robot. It allowed the user to draw a path on the game field and would provide angles and distances for each path segment.

• View the source code at github.com/77788J/ITZ-Auto-Planner
• Download the latest release at github.com/77788J/ITZ-Auto-Planner/releases

An improvement of "ITZ Auto Planner" from the previous season, this web-based program allowed the user to draw paths comprised of both lines and arcs. Paths could be saved to a file and loaded later. They could also be exported as C++ code for use in the robot's autonomous period.

• View the source code at github.com/77788Y/Vex-Auto-Generator

• Visit the site at 77788y.github.io/Vex-Auto-Generator/

•