FTC 11201
Shooter
Leo worked on the robot's shooter for the DECODE game.
Leo is a freshman at Piedmont High School. His favorite language is Python, and he also writes Java and C++. His robotics seasons: FIRST LEGO League 2023 and 2024, FTC Team 11201, and now FRC Team 8033.
Now
Freshman at Piedmont High School in Piedmont, California, on the software subteam of FRC Team 8033.
Every season, Leo has been on the software side, and every season, the robot got bigger.
2023–24
Software
MASTERPIECE season. Leo wrote the code for the team's LEGO robot.
2024–25
Software
SUBMERGED season. His second year programming the team's robot.
2025–26
Software lead
DECODE season. Leo led the software team and worked on the robot's shooter and intake. The team won the Design Award.
2026–27
Software subteam
His first season on Piedmont High's FRC team, programming a full-size competition robot.
FTC 11201
Leo worked on the robot's shooter for the DECODE game.
FTC 11201
Leo worked on the robot's intake for the DECODE game.
FTC Team 11201 Piedmont Pioneers, 2025–26
In progress
Leo is building a self-driving RC car on the open-source DonkeyCar platform. There's no hand-written steering logic. A neural network watches the road through a camera and learns to steer by copying how Leo drives.
These are 60 real frames from Leo's training data, recorded in the Donkey simulator at 160×120 pixels. The needle shows the steering he used at each moment.
Picture in, steering out. That pairing, repeated tens of thousands of times, is all the model learns from.
Leo drives the simulator track with a PS4 controller. To keep sessions on target, he wrote a lap counter that reads the simulator's telemetry, counts completed laps, tracks the best lap time, and feeds a live on-screen overlay. The goal is 20 clean laps before training.
mycar/lap_counter_part.py
class LapCounter:
"""Tracks completed laps using the sim's last_lap_time telemetry
and writes live state to a file for the overlay to display."""
def run(self):
info = getattr(self.gym_env, 'info', {}) or {}
lap_time = info.get('last_lap_time', 0.0)
if lap_time and lap_time != self.last_seen_lap_time:
self.last_seen_lap_time = lap_time
self.lap_count += 1
if self.best_lap_time is None or lap_time < self.best_lap_time:
self.best_lap_time = lap_time
While he drives, each camera frame is saved alongside the exact steering and throttle he was using. Those records become the training set: 35,059 frames in his main simulator dataset.
mysim/data/catalog_0.catalog
{"_index": 0,
"_session_id": "26-05-28_0",
"cam/image_array": "0_cam_image_array_.jpg",
"user/angle": 0.0,
"user/mode": "user",
"user/throttle": 0.0}
A track that turns left more than right teaches the car to favor left turns. Leo's fix: flip every image left to right and negate its steering angle. Every lap gains a mirror-image twin, and the dataset doubles without driving another lap.
mysim/flip_augment.py
""" Double the training dataset by horizontally flipping all images and negating steering angles. Writes to data_aug/ directory. """ from PIL import Image, ImageOps img = ImageOps.mirror(Image.open(src)) new_r["user/angle"] = -r["user/angle"] # negate steering
A convolutional neural network learns to turn a frame into a steering angle and throttle. Leo has trained two kinds: a linear model that outputs a number directly, and a categorical model that chooses from a set of steering bins.
mysim/myconfig.py
DEFAULT_MODEL_TYPE = 'categorical' BATCH_SIZE = 64 LEARNING_RATE = 0.0005 # python train.py --tubs data/ --model models/mypilot_cat.h5
For the real car, Leo wrote a standalone vision-drive script. The AI's throttle is capped at 40% for the first tests, and switching back to manual mode instantly acts as an emergency stop.
mycar/vision_drive.py
SAFE_THROTTLE_SCALE = 0.4 # cap AI throttle for the first real-world test
class SafetyGate:
"""'user' mode drives manually (also acts as e-stop); any other
mode runs the AI pilot with throttle capped."""
def run(self, user_mode, user_angle, user_throttle, pilot_steering, pilot_throttle):
if user_mode == 'user':
return user_angle, user_throttle
return pilot_steering, pilot_throttle * SAFE_THROTTLE_SCALE
A full-stack system that watches live camera feeds, detects people, vehicles, and animals, recognizes familiar faces, and raises alerts. It has a web dashboard and a Flutter phone app. Leo built it with help from an AI coding assistant (Claude Code).
Follow one camera frame through the system. Select a stage to see what it does.
config.yaml
detection: model: "yolov8n.pt" # nano = fastest confidence_threshold: 0.62 # 0=person 1=bicycle 2=car 3=motorcycle 5=bus 7=truck 14=bird 15=cat 16=dog target_classes: [0, 1, 2, 3, 5, 7, 14, 15, 16] motion: enabled: true algorithm: "MOG2" # skip frames where nothing moves
Keras, TensorFlow Lite, OpenCV, YOLOv8, face_recognition, Pillow
FastAPI, SQLAlchemy, SQLite, Flutter
FIRST LEGO League, FIRST Tech Challenge, FIRST Robotics Competition, DonkeyCar
For robotics, internships, and summer programs.
leokthakur@gmail.com