Education

In May 2023 I graduated from Olin College of Engineering with a B.S. in Electrical and Computer Engineering. Well, sort of…

More details 🔽

I didn’t technically graduate^*.

During the pandemic, I took a semester off to do a co-op at Apple in the Special Projects Group. Because of this, completion of my degree was delayed by a semester.

However, I decided that for my final semester, I would study abroad in Italy. In August 2023, I moved to Florence to take cooking classes to satisfy a minor in culinary arts.

^*Though I did walk across the stage and receive an empty diploma.

At Olin, my coursework included:

• Software Systems
• Embedded Systems Programming in Rust (IS)
• Probabilistic Modeling
• Introduction to Microelectronic Circuits
• Computer Architecture
• Analog and Digital Communications
• Quantitative Engineering Analysis

(IS): Independent Study

Work Experience

At a glance…

More details 🔽

Zipline

Embedded Avionics Intern | May - Aug 2023

Zipline’s Platform 2 drone consists of two vehicles: a zip, which is the hovering drone; and a droid, a small delivery robot stowed in the zip that is lowered by winch to drop off the package.

My intern project was to design, develop, and test zip-to-droid communications. The vehicles communicate things like motion commands and vehicle state over a wireless link. The code was entirely written in Rust.

In addition to the design, I also spent time collecting performance metrics like latency. The data analysis, in addition to some probabilistic modeling, proved that the solution was able to meet worst-case latency requirements while balancing wireless channel utilization.

Apple SPG

Embedded Controls Software Intern | May-Aug 2022, Jan-Aug 2021

I spent the two summers (as well as a semester off from school) as an embedded controls software intern at Apple in the Special Projects Group in Sunnyvale, California.

I am under a strict NDA, but can say that I was an embedded software controls engineer building a product that has not reached the market.

I worked closely with electrical, mechanical, and controls engineers to develop integrated engineering systems, and developed firmware drivers for interfacing with sensors and other hardware peripherals.

Indico AI

Back-End Software Intern | May-Aug 2020

My first college internship was at Indico, a startup that works on machine-learning solutions for document processing. I worked on their back-end systems, which comprised of a set of microservices.

My main project was developing a cache using Redis for validating permissions for a request across all the microservices. You can read more about it here.

This internship taught me a lot about professional software engineering and distributed systems. While back-end isn’t the field I work in anymore, I still use skills I learned from Indico everyday.

Yay Brigade

Full-stack Software Intern | Jan-Aug 2019

I worked at Yay Brigade, a small design firm in downtown Los Angeles, during my gap year before college. I worked closely with Roman, the co-founder, as well as various visiting designers. We worked on websites for various groups in Los Angeles.

I also started exploring back-end software while at Yay Brigade. I built a tool called Status that displayed a list of the websites and whether or not they were online. It would email us after a site had been down for longer than an hour.

navigate down to learn more

🔽

Year 1

As a first-year on the electrical subteam, I designed, fabricated, and tested a PCB called the Brake System Plausibility Device, or BSPD.

This is a safety-critical board that will shutdown the car if power is being delivered to the motor while the brake pedal is pressed for longer than half a second. The throttle system should prevent torque requests during braking, but this circuit acts as a fail-safe.

Year 2

As a sophomore, I founded and led the telemetry subteam. We worked on a system to stream data from our vehicle’s CAN bus to an off-board computer in real-time. I led the system design and worked with other senior engineers to execute testing and an initial implementation of the system.

This was during a remote year (due to the Covid-19 pandemic), so keeping members engaged proved to be the biggest challenge. But through team bonding events, regular meetings and 1:1s, we were able to lay a solid foundation for the following year.

Year 3

As a junior, I decided to revamp our entire system for writing firmware and designing PCBs. This included a lot of projects:

• I moved the team to a monorepo that has all of our electrical and software work.

• I collaborated with teammates on a system to describe our CAN bus using a YAML spec that would be compiled into a DBC file as well as generated into a C library.

• I worked on revamping our entire firmware system, including writing libraries for SPI, UART, CAN, ADC, timers, and more for our microcontroller, and rewrote most of our firmware images to use these libraries.

This was a busy year…

Year 4

As a senior, I decided to scale back my technical contributions to the team in favor of engaging in knowledge transfer. Over the summer, I led a series of sessions in which I taught the incoming electrical subteam leads about the fundementals of embedded systems and how to write low-level code. I also led talks on the systems of our car including high-voltage power distribution.

I also took on the role of financial manager on the team, organizing a $65,000 budget. My goal is to be as transparent as possible with the rest of the team as well as with Olin College, and I achieved this by organizing regular financial updates and keeping in close contact with the Olin finance offices.

SCOPE PCB

PCB for a single-watt scale electrical generator.

Partially redacted due to NDA.

See the public-facing presentation here.

navigate down to learn more

🔽

For my senior capstone (SCOPE), I worked with a company to develop a single-watt scale electrical generator. The motor is driven externally and the microcontroller (STM32F3) uses PWM commutation to control the motor driver to generate the optimal amount of energy to reduce startup torque.

On board, there is a motor driver IC, a battery charging IC and battery management system, a 5V buck converter, and a microcontroller. I developed the entire board from scratch and testing will happen in Spring 2023.

I collaborated with a classmate on the firmware image for the microcontroller. The code, written in Rust, implements a trapezoidal commutation for power generation as well battery management for the two LiPo batteries used as energy storage.

I developed the schematic and layout in KiCad, following best practices with lots of review from professors and subject matter experts.

MKVI Harness

A wire harness for an electric race car.

navigate down to learn more

🔽

On our Formula team’s MKV vehicle, the wire harness was a massive sore spot. The team had little experience in harness design or construction, so the result was a rat’s nest of cabling with no wire protection. This led to issues like wires getting pinched and shorting power supplies (through fuses, of course) to ground.

When we took the car to competition, this was the biggest source of feedback from the judges. Something needed to change for our next vehicle, MKVI.

CAN Bootloader

A bootloader that can reprogram chips using CAN.

Code repository. Documentation.

navigate down to learn more

🔽

Historically, on our Formula team, whenever we wanted to update the firmware on our circuit boards, we had to use an in-system programming (ISP) dongle and plug into each board manually.

This often meant opening up enclosures, and required us to have a large programming header on each board, adding height and exposed copper.

I developed a bootloader for the ATmega16m1, the microcontroller we use on the team, that allows us to update the firmware of any ECU on our CAN bus.

This means:

• No more programming dongles
• No more opening enclosures
• No more large programming headers

The bootloader runs when the chip receives power, checks EEPROM for a validity stamp on the image, and then boots into either the image or the updater.

The updater uses a state-based approach for doing firmware updates. You can find a diagram for the state machine here.

I also wrote a Python client that handles all interaction with the bootloader. I implemented a command-line interface that engineers can use to manually ping and firmware-update the boards, but the client is application-agnostic and could just as easily be used in, for example, a continuous integration setup.

AIR Control

High-voltage power distribution for an EV.

Code repository. Documentation.

navigate down to learn more

🔽

In an electric vehicle, we need to safely connect our high voltage battery and motor controller. However, connecting it directly is dangerous for the system—we can end up with a massive surge of current and potentially weld our contactors shut.

On our Formula team, I rewrote the firmware for the contactor control system (which we call AIR Control 1). Because it is a safety-critical system, I put a lot of focus on simplicity and robustness.

The system is implemented as a state machine and goes through precharging the capacitance in the motor controller and handles fourteen possible faults.

1: AIR stands for accumulator isolation relay

I also designed a test rig that simulates the inputs to the microcontroller and reads outputs over both GPIO and CAN. Tests are written in Python and fully exercise the state machine.

The code is highly organized and commented so as to be simple to read and straightforward to understand. This is important because safety-critical systems need to be auditable and easily parseable by a human.

MKV BMS

A battery management system for a 400V EV battery.

Code repository. Documentation.

navigate down to learn more

🔽

The BMS core uses isoSPI to communicate with peripheral boards, each containing two LTC6811 battery management integrated chips.

I adapted Linear Technology’s (now Analog Devices) drivers to fit our microcontrollers, and implemented a 100 Hz loop that monitors the temperatures and voltages.

The Gauntlet

Gradient descent algorithm simulated for a
differential-drive robot.

navigate down to learn more

🔽

For my Quantitative Engineering Analysis course (sophomore year), the goal of the final project was to navigate a simulated Roomba-like robot through a world called The Gauntlet, avoiding obstacles (boxes) until finally reaching the goal (cylinder).

The robot was equiped with a LIDAR camera that sampled points around it. I used a random sample consensus (RANSAC) algorithm to organize the individual points from LIDAR into a series of lines and a circle (the goal).

From the lines and the circle, the code then generated a vector field and then apply gradient descent to navigate the robot towards the goal.