Physics simulations of a dice bouncing in a box and a trebuchet firing. The simulations were made in Python using SymPy and NumPy, and use both lagrangian dynamics and rigid body transformations to generate the trajectories.

I built a line following robot. I used SOLIDWORKS to design custom laser cut and 3D printed parts, and KiCAD to design PCB's for my microcontrollers and other components. The robot uses a Raspberry Pi Pico W to read a downward facing camera and display its view on an OLED screen. The camera data is sent to a PIC32 microcontroller, which sends PWM signals to the drive motors based on a PID feedback loop.

I build combat robots with the Northwestern University Robotics Club. We compete in tournaments all over the country. Recently I've been redesigning one of our mini bots, Junior, to replace its aluminum chassis with a 3D printed unibody. I also design parts for our 30lb robots, and machine them using conversational and CNC milling.

Junior is a minibot that fights alongside our 30lb combat robots allowing us to get a weight bonus. Currently it has an aluminum chassis that takes a long time to machine and repair.

I've spent many hours in the machining shop on the mills making parts for our combat robots. Our most commonly used materials are aluminum, steel, and titanium.

I simulated three robot swarm behaviors. The first one is a "Reynold's flock." The second uses "hop count" to determine a coordinate system and display a Northwestern N. The third sorts the robots into cocentric rings based on the Brazil nut effect.

A simulation of the KUKA youBot performing a pick-and-place motion. All code was written in MATLAB using the Modern Robotics code library. The code generates the end effector trajectory based on the desired pick-and-place locations, then uses a PI feedback controller to apply joint forces resulting in correct end-effector twists to follow the trajectory.

For my final project for the class Self Driving Cars with Duckietown at ETH Zurich, I programmed an autonomous intersection navigation behavior that allows multiple cars to safely navigate intersections.

The duckiebots can follow lane markings using a histogram filter for state estimation. Using their camera, they can detect the red intersection markings and determine the available turn options. I trained a YOLOv5 object detection model on images of duckiebots to be able to recognize when another bot is at an intersection. Whenever a duckiebot is detected on the right side of the screen, the bot will wait at the intersection until the other bot moves. When the intersection is clear, the duckiebot will execute its action, using PID control based on the wheel motor encoder readings to achieve a desired turn or straight action.

Below is a video of the resulting behavior

The right of way rule allows for up to three duckiebots to safely navigate intersections

As a next step, I wanted the duckiebots to be able to communicate using their LED's. I was able to get an LED detection model, but I did not have time to use it to add any interesting behaviors.

For one of my other classes at ETH Zurich, Planning and Decision making for Autonomous Robots, I programmed a multi agent path planner for differential drive robots. While I initially tried using an RRT based planner, what ended up working best was a grid based approach. The robots construct an intial path to their respective goals using A* search, and then recalculate their plan whenever they encounter another agent on their path.

For my capstone project at Northwestern University, my team built a haptic finger and thumb interface to teleoperate a robot finger and thumb and perform dexterous tasks. The goal was to achieve high stiffness bilateral control between the two systems. I was mainly responsible for the mechanical design of the haptic finger.

Our design had three rotational degrees of freedom. Two were actuated (MP and IP joint), and one passive at the fingertip.

We used cable drive transmissions to achieve zero backlash, low friction actuation. The main disadvantage of cable drives, their limited range of motion, was not an issue since we don't want the system to overextend the user's finger in any way, so the joint limits were a benefit. The design features nested cable wheels that rotate independently on a fixed shaft. This saved space and kept forces restricted mostly to one plane, although the assembly process was made a little more difficult. Each cable is terminated on a screw that allows for adjustable tension.

For motors, we chose Maxon ECX Torque 22XL motors for their high torque, high torque constant, and very low rotor inertia. We wanted to keep inertia in our system as low as possible to maximize torque transparency for the end user. These brushless motors are controlled using field oriented control with magnetic encoders.

With our combined haptic/robot finger/thumb interface, we achieved a 500 N/m virtual object stiffness (enough to tell the difference in hardness between different objects during teleoperation), and could complete various dextrous tasks such as a pinch grip, and unscrewing a vial cap.

For the final project of ME495 Embedded Systems in Robotics at Northwestern, groups of five students use Franka Emika Panda robot arms to create various behaviors, tasks, or games. My group chose to have our robot draw portraits, and called it the "Doodle Droid."

Almost all of our code was written as ROS2 Python nodes. We controlled the robot arm movements using a custom wrapper around the MoveIt ROS2 interface. The robot first determines the pose of the drawing surface using the RGB camera of a RealSense mounted to the robot arm to detect four AprilTags in the paper corners. Then, an image is inputted either by file or live through a webcam. The image is converted into lines, and a route planner determines the order in which to draw lines using a greedy travelling salesmen-like algorithm.

My main contribution to the project was writing the calibrator node, which detects the paper pose, allowing the robot to draw the picture with any paper orientation and table height. I wanted to achieve an accurate paper surface height within 1mm to be able to draw consistent line thicknesses. It was difficult to get this level of precision, but after performing an extrinsic handeye camera calibration, intrinsic calibration, and by averaging 120 detected AprilTag poses, I achieved the desired accuracy.

I also wrote some OpenCV code to remove background from the live webcam photos and preprocess them so they convert better into line images. Finally I designed a spring loaded pen attachment, that afforded us some imprecision in robot movements.