Portfolio
Autonomous Task Robot
Overview
I worked with a team of engineers to create a task robot for the U of U Spring 2024 Mechatronics competition. We achieved a score of 43/45 points, beating the historical record of 34/45 points. We received 5/16 awards out of 28 groups -- best overall performance, best navigation, best wiring, best mechanical design, and best task accomplishment.
Competition Task
The task of the competition is to pick up colored blocks and magnetically attach them to a target-structure in a specified configuration to earn points.
The robot was required to navigate to a block dispenser to pick up blocks. It was then required to navigate to a 'chassis' with 20 magnetic attachment points. Once at the chassis, the robot had to place the colored blocks in a specific arrangement (based on color) in order to score points.
Hardware
We used an ATMEGA2560 to control 4 Poulou 37D wheel motors (with encoders), 2 Poulou 20D mechanism drive motors, 2 Pololu QTR reflectance sensor arrays, a SHARP IR rangefinder, an Adafruit APDS9960 color and proximity sensor, a hall effect sensor, an XBee RF module, and an IR transmitter.
Software
Our codebase is written in C++11. We developed in the CLion IDE and used Git for version control. Our software has a half object-oriented, half finite-state-machine structure. Here is a copy of the repo: https://github.com/nawper02/Over-Engineered (note: the repo hasn't been cleaned up since a fairly chaotic last week of development)
We pushed the ATMEGA2560 microcontroller to its limits with an optimization based approach to path planning. Our robot can hold 5 blocks, so we wrote an algorithm to find the quickest way to place all 5 blocks in order to finish the task within the time limit. Our algorithm calculates all possible sequences of placements and finds the fastest one by minimizing the cost associated with certain actions (such as moving between locations and actuating our lift mechanism). We are able to control the time we allow for computation with a 'budget'.
Control
A desired pose for the robot (x, y, theta) is transformed with inverse kinematics into a set of desired wheel angles. The present wheel angles are calculated using encoders on each of the wheels. A ramped trajectory is created for each wheel and a PID algorithm minimizes the error between present and desired wheel angles.
Since error accumulates over time while our robot drives, we use two Poulou QTR reflectance sensor arrays at the front and rear of our robot to square up and center over a black line. We generate an angular and translational error using the readings from the QTR arrays and minimize that error with a PID controller.
The position of the lift is localized using a roller switch on a ridged bracket. As the roller switch moves between valleys and peaks, our software increments a count, allowing us to stop the lift at specific locations.
Wiring
We created our electrical system out of ribbon cables, wire loom, DuPont connectors, and prototype boards.
We made a sensor board with an onboard 5V regulated voltage source that all of our peripherals plug in to. A 40-wide ribbon cable bridges the sensor board to our microcontroller.
Mechanisms
We created a dual-action scissor lift driven by a power screw. The power screw was left-hand threaded on one end and right-hand threaded on the other end, meaning that each revolution of the screw resulted in twice the lead of a regular power screw mechanism.
The front links are constrained as fixed revolute joints. The rear links are translating revolute joints. The motor that drives the lift translates on a rail mounted carriage as the lift moves up and down. The motor is fixed to the carriage with a compliant joint to prevent binding.
This particular configuration of joints makes the lift translate forward while it raises up, which is advantageous to the robots task.
Our robot stores the colored blocks on a platform with a belt driven by a DC motor. The belt is driven backwards to load blocks on and driven forwards to push blocks off.
Manufacturing
The majority of parts were CNC machined out of aluminum. Some parts were 3d printed. The 3d printed parts used brass heat-set threaded inserts to mount to the aluminum frames.
Competition footage
In the below video, Over-Engineered competes at 21:13, 31:32, and 42:03. We had a stroke of bad luck at 35:17 where the enemy team stole a block we needed to win. That moment was the reason we didn't get first place despite our high score!
State Transition Diagram
Wiring Diagram
Eye Tracking Controlled Robotic Neck Exoskeleton
Overview
I created an eye tracking control system for the robotic neck exoskeleton developed by the Utah Wearable Robotics Laboratory.
My software runs on a single board computer (the LattePanda 3 Delta) and uses the Pupil Core glasses developed by Pupil Labs.
The neck exoskeleton is designed to control the orientation of the head, and uses 3 RRS (revolute revolute spherical) chains to emulate the motion of the neck.
Motivation
This device is meant for individuals who have limited control of their neck, such as ALS patients. However, controlling such a device in a natural way is challenging. That is why I implemented an eye tracking control system for it; The position of the gaze is naturally correlated with the intended orientation of the head.
Features
My software features the ability to tune servomotor parameters, modify control schemes, and leverage various filtering algorithms to smooth out the eye tracking data. It also shows a real-time plot of your gaze and a 3d simulation of the neck exoskeleton.
Problems
Further work needs to be done to make my control system viable for use. The motion of the neck exoskeleton is jittery due to poorly configured PID gains of the servomotors and the use of motor position control rather than motor velocity control.
See it in action in the video below!
Servo-Actuated Robotic Joystick
Overview
Most joysticks use potentiometers to figure out where the handle is pointed. Most joysticks also use springs to bring the handle back to the center.
I created a joystick that accomplishes both of those things with servomotors.
How it works
A microcontroller (OpenRB-150) mounted to the base of the joystick relays information about the handles position to a host machine. The host machine then sends servo commands back to the microcontroller. This is called 'full-duplex' serial communication.
The Python-based driver software, which runs on the host machine, has a GUI that allows you to configure and switch between the joysticks control modes. It also shows a plot of the joystick position and a plot of the error between the goal positions and present positions. In addition to the built-in control modes that came with the Dynamixel XL330-M288-T servomotors, I wrote my own PID control algorithm so that users can configure the behavior of the joystick with even more flexibility.
What it can do
My joystick is capable of:
Simulating a centering mechanism, like springs, that returns the handle to the center position
Simulating a following mechanism, where the handle is 'weightless', but remains locked in whatever position you leave it in
Simulating a gear-shifting mechanism, like in a manual transmission vehicle
Motivation
The original idea was that a surgeon could use a device like this to control the UWRL Robotic Neck Exoskeleton (see above) while its being worn by a sedated patient. The force feedback could be used to prevent the surgeon from moving the patients head into harmful positions.
See it in action below!
Dual-Action Piston Pump
Overview
A relatively novel design for a piston pump that I came up with--I had the idea when I was little!
Motivation
Most piston pumps have one set of check valves. On the forward stroke of the piston head, the water inside the cylinder is pushed through the output. One flaw of the typical design is that the fluid output is not continuous. My design fixes this flaw by using two sets of check valves and allowing fluid to flow behind the piston head. It is essentially two piston pumps in one, hence the name, 'Dual-Action Piston Pump'. Because of the two sets of check valves, water is pumped on both the forward and backward stroke of the slider crank mechanism, so its fluid output is continuous (well, sinusoidal).
Problems
The original prototype of this device initially worked, but during the ME1000 water pump competition, it failed. One of the D-Shafts in the gearbox stripped.
PAT (Pan and Tilt)
Overview
A simple 2DOF robot that I use to test my servo control code. The pictured design is the 4th generation of PAT. It features a friction-fit table mounting system, skeletal construction for heat dissipation, and ports for cables. It is designed to fit Dynamixel XM430 servomotors.
PAT allows for two rotational movements -- pan and tilt (or pitch and yaw, if you're into aviation). I designed it to perform these movements because it best emulates the movement of the head and neck, which has been the primary focus of my research.
Below, you will find a video of PAT being controlled with eye tracking!
Robotic Ping Pong Ball Launcher
Overview
The ping pong ball launcher was a machine that was capable of launching ping pong balls into targets with a closed-loop control system.
Technical Overview
The ping pong balls could be aimed at the targets using a two-degree-of-freedom aiming system. A belt-driven platform rode along two cylindrical rails in order to position the launcher horizontally. A four-bar linkage was then used to control the elevation angle of the launcher. Atop the launcher was a solenoid that was used to strike the ping pong ball towards the target.
In order to establish its horizontal position, striped encoders were counted using an IR-sensor. The elevation angle of the launcher was established using basic inverse-kinematics.
To hit the targets, an image of the targets was processed to find the coordinates of each target. Basic ballistics calculations were then performed to find the required launch angle to hit the target.
Competition
My teams robot had the best performance out of all other teams in the Spring 2022 ME1010 Ping Pong Ball launcher competition.
We used MATLAB for image processing and programmed the microcontroller in C/C++.
To win, my team implemented techniques like shooting the ball while moving, performing computations while the launcher moved to its target, and ultra-optimized timing in the reloading process.
I must warn you -- the below video is not particularly exciting, but it was still the fastest robot at the competition!
blang
blang is a fully featured desktop rpn calculator. written by me in python!
it supports numbers (duh!), vectors, matrices, and even strings. It can do numerical integration, differentiation, root finding, and every other standard calculator feature you can imagine.
all of its features are automatable with my own ultra-compact functional stack-based programming language, which supports function definition, variables, logical operations, and more.
OpenPore
A microporous medium analysis tool. Generates artificial microporous medium samples by thresholding a four-dimensional function (like 3D Perlin noise, for example, where every point in 3D space has an associated intensity value) to view its level sets.
Implements DBSCAN clustering to segment the pore-space.
Has the ability to load X-ray Computed Tomography images of porous materials and reconstruct them into a 3 dimensional model of the pores.
Has the ability to gather ready-to-plot data on a sample and write it to an excel workbook.
Written by me in Python.
Development of OpenPore is being continued by the University of Utah's department of Mathematics.
Roller Coaster Track Design
Overview
Designed a roller coaster track as part of a class-wide group project for my professional communication class.
Background
The class was split into groups that were responsible for designing different parts of the roller coaster. My team was responsible for the track, and my role in the team was the cad modeling of the track. My teammates performed finite element analysis on my design and chose materials for the track.
Results
I prepared a technical report, presentation, and group collaborative technical report for this project.
Box Counter
A python implementation of 'box counting', a technique to study how 'fractaly' an image is.
Implements a cool denoising algorithm that I wrote, which removes noise without affecting the detail in an images edges like many other denoising algorithms do.
ASCII CLI Library
The challenge: 24 hours, A language I hadn't used, create a command line interface library for making interactable programs in the command line.
The result: A sorta-cool command line interface library with a few fully implemented features! I wrote this in C# and it was one of my first foyers into proper OOP programing.
Features:
Cycle active panel by pressing 'tab'.
Interact with active panel with various hotkeys -- for example, the arrow keys and 'enter' are used to interact with the ListView widget.
Discord bot and server
Me and my friend, Hyrum Coleman, created a discord server for our major and year. We had the idea to create a discord bot for the server, so we did!
We wrote the bot in javascript, and it currently assists over 70 classmates in getting information on final exam times, office hours, and managing roles in the server. It is hosted in the cloud on a linux server and has a professional CD deployment system.
Warning:
Entering Highschool Project Territory!
Highland Rambler Redesign
Redesigned the Highland Rambler newspaper while working as Art Director. Below are the cover pages of two released issues of the highland rambler; On the left is an old issue, and on the right is one I designed.
Utah Women's Mural
As assistant graphic designer & layout artist, I helped prepare and assemble the stenciled pieces, as well as helped prepare the piece for production.
The mural is located in downtown SLC, and is over 6,000 square feet in area.