Because of the global chip shortage, I decided to take a rest from hardware projects, and experiment more with software. At first I played with calculating Julia sets, and as this produced aesthetically pleasing results, I continued on to generate plots of the Mandelbrot set and the burning ship fractal. The sets were calculated in C for speed and access to multithreading, while the actual images were generated with Python via Matplotlib. The source code for the project and instructions can be found here.

Continue reading “Julia”

Pet on a Chip

A few years back in high school I worked on building the robot described in the 1979 book “How to Build Your Own Working Robot Pet” by Frank DaCosta. The robot was controlled by an 8085 (an 8-bit microprocessor), and required a ton of 74xx series logic chips to interface to the various control and sensor systems on the robot.

For my senior design project in college, I wanted to create a new robot where all of the control logic would be integrated onto a single chip, and so Pet on a Chip was born. This new robot improved upon the original by drastically reducing power consumption, size, weight, and improving maneuverability, and all of the control logic was implemented on an FPGA. This project built off of my TinySoC project I had worked on during the summer.

Continue reading “Pet on a Chip”


Due to the COVID lockdown, I had lots of free time this past summer, so I decided to teach myself more about FPGAs. In this time between semesters I developed tinySoC, a small system on a chip consisting of an 8-bit CPU, an 80 column VGA graphics card, GPIO and counter/timer peripherals, and a UART, all implemented on an ice40 FPGA. I also developed an assembler, as well as other utilities for loading programs into the FPGA’s internal block memory without having to rerun synthesis and place-and-route.

Continue reading “TinySoC”

Multibot ROS Package

While interning at Technion’s Cognitive Robotics Lab, I developed Multibot, a ROS package to aid in the simultaneous simulation of multiple Turtlebots. The research conducted at the lab was primarily focused on robot planning algorithms and models, and I was initially tasked to design and implement a navigation system for the Turtlebots to navigate a city street-like environment, utilizing a system of social laws to ensure safe operation. However, when I arrived for my second day at work, I was informed that the one other engineer who worked with the Turtlebots, and had given me my initial training the day before, had a heart attack and was recovering in the hospital. Since he was in the process of modifying the robots, several of them were non-functioning, and I was instructed to pursue my project in simulation instead. I was usually alone in the lab, however occasionally several graduate students would stop by and offer some helpful advice. After figuring out the basics of ROS, and writing some nodes in Python, I eventually was able to simulate a single Turtlebot in Gazebo, and visualize it sensor data in rviz. After this I focused on building both a virtual street environment to maneuver the robot, and develop a navigation stack that allowed the bot to autonomously move from one address to another while obeying traffic laws. This involved multiple parts: SLAM was used to localize the robot on the navigation map, and avoid barriers, while an auxiliary map server was created containing information on proper lanes of travel, allowing the robot to plan its path in accordance to the rules of the road. Additionally, I wrote multiple programs that created annotated maps on the fly, allowing the auxiliary map server to be used with the rest of the navigation stack.

While this system worked well for a single robot, I had no means of simulating multiple robots in the same environment, while simultaneously viewing their sensor data within a single rviz process. One of the grad students at the lab had previously worked on creating a package to implement multi robot simulation, however it had been difficult, and it no longer worked due to recent updates in ROS. For the rest of my internship, I directed my efforts to creating a new package to allow for multi robot simulation in Gazebo, and visualization in rviz. It proved to be quite difficult, as the available ROS documentation was abysmal, so much of the time was spent reverse engineering the current system for launching the simulation of a single robot, before then creating a package to work with multiple robots. After I had finally got it to work, I spent the last of my time writing extensive documentation for the package, so that hopefully it will be useful to others in time to come, and may spare them some of the pain and frustration I experienced.

Open Source 8085 Assembler

Initially while working on the robot dog project, I used to write and assemble programs by hand and load them into memory using switches and buttons. This was not a particularly pleasant experience however, so I used a free assembler to generate my machine code, and an AVR-microcontroller board that I would plug into the dog to load its memory with the program. This system greatly sped up development time, but it was still frustrating to work with because the assembler didn’t have as many directives and symbolic features as I would have liked, and the output had to be processed by a custom Python script to put it into a form that was then easy to load onto the AVR programmer. While I searched for other freely available 8085 assemblers, I found none which would simultaneously run on my operating system, support the directives and symbolic features I wanted, and produce an output that was easy to load into memory. This being the case, I decided to write an assembler to suit my needs. The resultant project was a command line interfaced two-pass assembler written in Python with a customizable output format that allowed for easy debugging. While I have been working on this project off and on for a few years (it’s hard to find the time at school), this past summer I rewrote the entire thing, and added a bunch of features, and in December I included documentation and posted it to GitHub.

Example Source File
Corresponding Assembler Output, With Debugging Info (Truncated)

Line Following Robot


In 2012 I constructed the line following robot described in David Cook’s Book, Robot Building for Beginners. During its operation the robot follows a path of colored masking tape on the ground. The robot functions by illuminating the floor and measuring the intensity of the light reflected back with two pairs of sensors on either side of the robot. The sensor pairs straddle the line of tape, and sense if the robot begins to veer, by detecting a change in the amount of light reflected. If the robot drifts, or the path curves, the robot cuts power to the appropriate motor causing the robot to turn and center itself over the line. Once centered the the robot continues straight again. This robot is purely analog, meaning no programming was necessary.

Continue reading “Line Following Robot”

Obstacle Avoidance Robot


This is an obstacle avoidance robot I built during 2013-14. During operation the robot drives forward until it senses an obstacle in its path with its sonar. It then comes to a halt and scans to either side, comparing the amount of free space. The robot then rotates in place towards the direction with the most room, and then drives forward. This process is repeated, the end result being the robot explores a room without running into obstacles. The robot also has optical sensors directed at the floor scanning for sudden drop offs, such as stairs. If it senses a drop off, the robot brakes, and again scans the room for another path to take. There are also optical encoders on the wheels so that the robot can calculate how far it has traveled.

This robot was built entirely from scratch. Some of the most important things I learned how to do while building this robot were how to program microcontrollers, how to etch and drill double sided printed circuit boards, and how to machine acrylic sheets.

Continue reading “Obstacle Avoidance Robot”

The Robot Pet


For the past three years or so I have been working on constructing the robot described in the 1979 book How to Build Your Own Working Robot Pet by Frank DaCosta. While it could use some more work, I feel it has reached the point where I can call it complete.

The robot consists of a tricycle like chassis with a steerable powered wheel in the front, and two free spinning wheels in the back. On the head there are three sonar sensors facing right, left and to the front, and on the neck, there is a microphone for voice control. There is also a speaker for emitting electronic “barks.” I have tried to stay as true to the original design as possible, so the electronics mostly consists of 74LS series parts, some linear ICs, and a bunch of discrete components.

Continue reading “The Robot Pet”