Robotics Portfolio

Kishan Grewal

Robot learning. Third year at UCL

Extend Robotics, UK

Vision-Language-Action

This was a one-month industry project with Extend Robotics and our first time training a VLA. The task was getting a Franka to pick up a manual service disconnect, the plug that isolates an EV's high-voltage battery, and push it into its socket, which is awkward even by hand. Realistically we had about two weeks for the actual pipeline: learning the XR teleop and tuning it until it felt right, collecting about 200 demos with a Meta Quest 3, working out training, and writing the deployment script. The final SmolVLA policy brings the plug to the socket about 80% of the time and gets it in about 20%.

GitHub

Plug Insertion with SmolVLA

Our first policy output end-effector deltas and kept taking the plug to the wrong place, because at 30 Hz most of each delta is teleop noise, so we were basically training on the noise.

Switching to absolute joint targets fixed that, and we ran it with real-time chunking so the arm keeps moving while the next chunk is computed. The harder problem was that demos of clean successes only cover states close to the good trajectories, so once the policy drifted off that manifold it had never seen anything like where it was and the errors compounded. We started recording demos where we went slightly wrong on purpose and then fixed it, and those went into the final policy. Looking back, DAgger-style interventions would probably have done a lot more, because you'd be correcting the mistakes the policy actually makes rather than the ones we guessed it would.

Meta Quest XR Teleoperation

The controller's pose is taken relative to where it was when the deadman switch was pressed, rotated into the robot's base frame and scaled, and an IK planner turns that into joint targets that a 1 kHz trajectory generator smooths for libfranka. Once a teammate fixed the yaw mapping, the teleop was finally good enough to record demos we'd want to train on.

Karlsruhe Institute of Technology

Reinforcement Learning

Three months at the Karlsruhe Institute of Technology in the MAIRO lab, supervised by Moritz Barten. I took a PPO policy that throws a cube as far as a simulated UR10e can and made it target-conditioned, so it throws to any commanded distance from 1 to 7.75 m, and over three seeds it lands with 12 mm mean error along the throw and 3 cm laterally.

Learning to Aim

Most of the work was in the transfer, not the reward. I widened the actor's input layer for the target observations with zero-initialised weights, so at iteration 0 it is exactly the max-throw policy, and reinitialised the critic, since it had been fitted to the max-distance return.

A freshly initialised critic gives noisy advantage estimates, so the actor's learning rate is held at zero (not frozen, so Adam's moments keep warming up) until the critic's explained variance reaches 0.85, then linearly increased to its base value. Otherwise the first update has a KL of 162 and the policy usually collapses into dropping every throw.

Aimed Throwing

The actor also observes the ballistically modelled landing error if it released right now, so aiming becomes driving an observed quantity to zero instead of learning projectile dynamics implicitly, and ablating it roughly quadruples the error.

An early issue was that contact was only sampled once per env step, so the contact sensor missed impacts that lasted a single physics substep, the episode didn't end at touchdown, and the cube sliding along the ground was counted as throw distance. Sim-to-real on the UR10e is mostly a release problem, since the gripper's opening latency varies from throw to throw and the policy would have to infer it online from its action history. Moving the ballistics from the observation into the action, TossingBot-style, would mean the physics transfers exactly and only the residual has to be learned from real throws.

Personal Project

Learning from Human Video

I filmed 50 takes of my hand moving a bowl onto a plate with a phone, retargeted them into robot demonstrations in the LIBERO simulator, and trained SmolVLA on them, first as demonstrations and then as corrections that finish the policy's own failed attempts. Across the ten libero_spatial tasks, success over the same 1000 test episodes goes from 62.2% to 96.1%.

GitHub

Learning to Retry

A human hand and a Panda gripper are too different to copy poses, so I retargeted relative to the object: the sim bowl follows the real bowl's progress toward the plate and its lift, the gripper holds the grasp LIBERO's own demos use, and each OSC action is computed from the robot's actual state, so every action in the dataset is one that actually produced the next frame.

Trained on the phone demos and its own successes, the policy never retried after a missed grasp, since none of that data contains a retry. So at each failure I froze the simulation, planned a phone take from wherever the arm and bowl had ended up, and recorded only the take, which gave 123 recoveries that start exactly where the policy went wrong.

University College London

Control & Embedded

This was a second-year team project at UCL, a cart that balances a pendulum on an Arduino Giga R1, and we wrote a Kalman filter, wheel speed PIDs and encoder interrupts, and did a lot of tuning. Since the wheels are speed-controlled, the force LQR asks for is integrated through the cart's mass into a velocity target that four wheel PIDs track.

GitHub

Tap-Test Recovery

Tapping the top of the pendulum. It recovers without the cart running off the end of its track.

Recovery from 20°

Released from 20°. Above 3° it runs a separate set of recovery gains, and hands back to the stabilising gains once it's near upright.

2 m Traverse

Moving 2 m with the pendulum up along a trapezoidal velocity profile, which only worked once we added deadband compensation, since below a certain command the motors don't turn at all and the small corrections that keep the pendulum up were being dropped.

MangDang, Hong Kong

ROS 2 on Quadrupeds

ROS 2 packages I wrote for the Mini Pupper 2 during a summer internship at MangDang in Hong Kong, through the HKSTP Global Internship Programme. They're merged into the open-source mini_pupper_ros repo.

GitHub

Person Tracking

YOLO11n runs on the Pi camera, and separate PIDs on yaw and pitch turn the robot toward the person. With only the camera it overshot on every step because the body bobs, so I added IMU heading to the yaw loop.

SLAM and Navigation

SLAM Toolbox for mapping, then AMCL and Nav2 for navigation. Out of the box it kept clipping obstacles, because quadruped odometry is much noisier than the wheeled-robot defaults assume. The fix was mostly config: costmap inflation, DWB critic weights and AMCL motion noise.

Four-Robot Fleet

Four robots driven from one /cmd_vel, and the cheap servos make each one turn slightly every gait cycle, so a heading controller on each robot pulls it back into line using yaw integrated from the gyro.

Nothing observes yaw, so the estimate still drifts with gyro bias, but that drift is slow next to the servo drift it's correcting. I wrote the estimator as an EKF on SE(3) in rclcpp with Eigen because I wanted to learn Lie groups, though the accelerometer only corrects roll and pitch, and with identity Jacobians its covariance and gain updates are exactly a linear Kalman filter's.