Project in Action

About the Project

Machine Capabilities

The Lobster PCB Mill is a fully automated PCB prototyping solution which aims to do for PCB design what 3D printing did for mechanical design. This project was designed and developed as my capstone project for the Mechatronics Engineering program at University of Waterloo. The machine is capable of producing 2-layer prototype PCBs with 0.1mm trace spacing, 0.5mm component size (0402), and 0.5mm vias without any user interaction. The project code is fully open source

Mechanical

The mechanical design of the mill is fully custom, featuring 3 individually controlled toolheads for milling/drilling, a PCB flipping mechanism, a mechanical press, and a wire extrusion head. The XY motion carriage uses linear rails and 2mm pitch lead screws with anti-backlash nuts for precise motion. Other components such as the wire feeding head, press, and milling heads use lead screws with a higher pitch and linear rods to save cost where precise motion is less important. BLDC motors and drone ESCs are used to power the drilling/milling heads, and a single servo motor actuates the wire cutters used on the wire feeding head.

The machine produces PCBs by first drilling holes for vias and through-hole components with 2 of the 3 toolheads. Wire is fed into each of the via holes, cut to length, and pressed to form an electrical connection between the top and bottom layers. An engraving head then mills out any copper where it isn’t needed, forming the final board (similarly to chemical PCB etching).

Computer Vision

Computer Vision is used during the wire alignment process to account for any bends or variations in the wire as it is fed, as well as to deal with skew issues that arise from the PCB flipping mechanism. Cameras and LEDs mounted on the wire head provide a view of the clippers, via hole, and wire in one shot. The computer vision algorithm isolates the via hole and wire with seperate masks, tracking the position of the wire tip relative to the via hole. By moving proportionally to the detected displacement, the machine can converge on the hole location to reliably feed wire into the hole.

Firmware

The machine is controlled using a Raspberry Pi, and two control boards (BTT octopus and arduino RAMPS). The machine uses a modified version of Klipper Firmware to communicate with both control boards to handle sensor input, servo control, ESC control, and stepper motor control. The use of klipper allows the machine to take advantage of a multicore 32 bit arm processor and Linux USB camera drivers for computer vision, while offloading the real time motor and sensor processing to the 16 bit control boards.

The modified firmware adds support for multiple toolheads as well as each of the custom motions added (wire cutting, pressing, flipping). The firmware uses microstepping on all axes to increase motion resolution, and additionally implements closed-loop position control using encoders on the x-y axis to compensate for the nonlinearities typical when using the microstepping feature on any stepper driver.

The modified firmware adds conductive probing on each of the 3 toolheads, and uses it to build a heightmap of the raw material before each PCB is milled. The firmware uses this information and bilinear interpolation to compensate for warping in the PCB material during milling, ensuring a constant cutting depth and width. Skew correction and position offsets were added to the firmware as well to compensate for the distance between toolheads, and misalignment in the pcb flipping mechanism.

The firmware presents a web interface via Octoprint allowing the machine to be controlled with a web browser, and allowing gcode files to be uploaded the same way.

Shortcomings

Project Website

Project Github

Project in Action

About the Project

As an assignment in preperation for 4th year design projects, I created an all-terain autonomous rover with 4 of my friends over the course of a month. The rover is designed to accurately and autonomously navigate an obstacle course containing sandy and rocky terrain, as well as pit traps. The rover is equipped to assess it’s position and orientation within the course, and make adjustments accordingly.

The robot was designed around an Arduino Uno, which was programmed in C and handles the sensor input, processing, and control. The robot uses 2 Time of Flight sensors which read distances to the walls of the course, and an IMU which measures angular velocity and linear acceleration to determine the robots orientation and track it’s movement through the course. Fusing the data from each of these sensors provides real time tracking of the robots absolute position within the course. The robot is equipped with custom 3D-Printed compliant wheels which feature large notches to help the robot traverse large ledges on the course. The rover features a dual motor gearbox controlled by the microcontroller using an H-bridge IC, and timing belts to couple the rotation of the front and back wheels. This provides the rover with 4WD and tank-like steering, allowing it to turn in place and navigate rough terain more easily.

Throughout this project I was primarily responsible for the mechaical design, including the design of the compliant wheels, as well as sharing responsibility for the navigation code. I also shared responsibility for the overall system design, including sensor selection and high level electrical design.

Project in Action

About the Project

For the Ludum Dare 48 game jam, I created a pixel art platformer with one of my oldest friends. In this game you descend through a dungeon level with 2 different enemy types, special obstacles, and fight a boss at the end. Since the game is fairly short, a timer is included for those who decide to speedrun the game.

This game was created in the Godot Engine, with all art, sound, and programming being completed within the span of the game jam. The game jam spanned 72 hours, of which I spent 24 moving back from my co-op job. Regardless of the extra difficulty this added, my friend and I were both proud of the result and will be doing more game jams in the future.

Play Down Dog

Ludum Dare Page

Project on Github

Project in Action

About the Project

As an introduction to Schematic Capture, PCB Design, and Circuit Design, I decided to build a custom handheld emulator based around the Raspberry PI. For this project, I wanted to create a handheld emulator capable of emulating consoles from the PS1 era and before. I wanted to include analog joysticks for input, a reusable battery and charging circuit, as well as a touch screen for use with Nintendo DS emulation.

The project uses Emulation Station on the Raspberry PI, SPI for analog to digital conversion, includes a LiPo battery and charging circuit, and has a headphone jack and micro USB charging port. Analog to digital conversion, input was done in C++ using the WiringPi library and linux libevdev to convert the GPIO inputs into OS readable input events.

The entire project, including circuit design, PCB design, mechanical design, programming, and assembly was done over the course of 2 months. The project even includes a custom 3D printed enclosure with custom buttons.

This project is one of my favourite projects to date, and I have plans to create an improved version based around the Raspberry Pi CM4, making it thinner and adding new features.

Project in Action

About the Project

As a first year project, I created a chess playing robot with two of my friends over the course of a month. The robot can accurately navigate the board, pick up pieces, and perform any legal chess move (including castling and en-passant). The robot can asses the current state of the board, make an informed decision, and execute a chosen move autonomously.

The robot was designed using the LEGO NXT robotics kit, and used custom laser cut gears and tracks in the assembly. The movement and control of the NXT robot was programmed in RobotC, communicating with an external phone via bluetooth to handle the computer vision and decision making. The phone app used to control the robot was programmed in Java and compiled using Android Studio. The app used OpenCV to determine the board state using special colour combinations painted on each piece. The board state was then passed into a custom neural network trained to choose the best move from a list of possible moves. This move was then converted to a unique string command, and sent to the NXT via bluetooth, after which the command would be parsed, and the move executed.

During this project, I designed the custom neural network, designed and laser cut the custom gears and gear tracks, designed the claw mechanism and carriage, programmed the movements, and aided in other parts of the design when needed.

Project in Action

About the Project

For the ludum dare 40 game jam, I created a low-poly 3D driving game my best friend from high school. In the game you must dodge the obstacles scattered about the road, but the twist is that the game will apply several disorienting effects to make the driving experience more difficult.

This game was created in the Unity Engine using C#, with all art, sound, and programming being completed within the span of the 72 hour game jam. This was my first game jam ever, and is an unforgettable high school experience for me. This experience inspired me to complete the ludum dare 48 game jam with another friend.

Play Make It Home

Ludum Dare Page

Project on Github

Project in Action

About the Project

Snowboard madness is a pseudo-3D game created in Java as a project for a programming summer camp I attended. This project uses simple linear equations to give the illusion of sprites approaching in 3D space. This project was completed in 12 total hours over the course of two days.

Project on Github

Project in Action

About the Project

Terrarithmetic is an math teaching game I created with a friend in grade 10 as a cumulative project. This project was written entirely in Java without the use of any 3rd party libraries whatsoever.

The project is heavily inspired by old top-down pokemon games, and uses a math based combat system to teach basic arithmetic operations such as addition, subtraction, multiplication, and division.

For this project, I had to implement a custom tile based world, and tile based rendering engine, as well as custom asset management, input handlers, and audio handlers. This was one of the most intensive projects I completed in high school, but is still one of my favourites.

Project on Github