XRP Line-Following Robot Using an AI Vision Camera (feat. HuskyLens)

Build a line-following robot using an XRP robot and a DFRobot HuskyLens (SEN0305) AI vision sensor. The HuskyLens provides visual data, and the XRP board (with the RP2350 microcontroller) reads this data and drives the motors using PID controllers for stable line tracking.

Learning Objectives:

1. How to read sensor data from the HuskyLens over I²C
2. How differential-drive robots steer
3. How PID control stabilizes robot motion
4. How to tune a real controller through experimentation

You’ll end with a robot that:

1. Detects and tracks a line using computer vision
2. Computes steering corrections using PID control
3. Adjusts motor speeds to follow the path accurately

All code uploaded to GitHub. Feel free to let us know if you encounter any issues!

1. HuskyLens AI Camera (SEN0305)
2. An XRP robot or kit. If you do not have one yet, you can purchase the entire kit through Sparkfun Electronics. Alternatively, you would buy only the electronics through Sparkfun and 3D print your own XRP chassis!
3. We'll be using:
4. Two XRP DC motors
5. XRP board with an RP2350 microcontroller
6. Battery pack (4 AA batteries)
7. Any XRP Chassis with rails for mounting the camera
8. Quick-connect jumper cables (for I2C and motors)
9. USB cable for flashing/programming
10. Some sort of line path (printed or made with tape)
11. A mount for the HuskyLens to attach to the XRP rails (I have attached the one I used, but feel free to design your own!)

1. Install Thonny, or use the browser-based editor at https://xrpcode.wpi.edu/ (MicroPython).
2. Update the HuskyLens firmware following these instructions (optional): https://wiki.dfrobot.com/HUSKYLENS_V1.0_SKU_SEN0305_SEN0336#4.%20Upgrade%20Firmware

1. Prepare your assembled XRP chassis
2. Attach the HuskyLens to the XRP rails using your HuskyLens mount
3. Angle the camera downward so it clearly sees the floor 1-2 inches ahead of the robot.
4. Make sure nothing blocks the camera’s view (wires, battery pack, etc.).

Tip: A higher camera angle sees more of the line, but the data is noisier. A lower camera angle sees less of the line, but the data is more consistent.

I²C Wiring:

1. HuskyLens SDA → XRP SDA
2. HuskyLens SCL → XRP SCL
3. HuskyLens VCC → 5V
4. HuskyLens GND → GND

1. Power on the HuskyLens.
2. Rotate the dial to Line Tracking mode. Note: The HuskyLens has a built-in Line Tracking mode and can return path information (x and y coordinates of the arrow head and tail) to a microcontroller over I²C. For more information on the HuskyLens, refer to the DFRobot wiki.
3. Put the robot over the line.
4. Aim the crosshair at the line, centered on the screen.
5. Press the top-right “Learn” button until the line becomes highlighted on the display.

1. Design a custom I2C protocol, name it i2c.py, and save it in the root of your directory. An example code is attached below.
2. Request frames from the HuskyLens and print the detected line’s x- and y-positions to verify communication. An example main.py is also attached below.
3. You should see the values change as you move the robot side-to-side over the line.

If you see no data:

1. Re-check that the wiring is correct (Try flipping SDA and SCL)
2. Make sure the HuskyLens is in Line Tracking mode
3. Relearn the line sample

1. Set the desired arrow position and orientation. We want the arrow to:
2. Stay centered horizontally on the screen
3. Point forward (upward)
4. The XRP library includes built-in differential drive and PID controller modules. Initialize PID controllers for x- and y-direction steering.

3. Convert arrow position data into error values for the PID controllers. Positive error means the arrow is too far to the left, so the robot should turn right. Negative error means the arrow is too far to the right, so the robot should turn left.

4. Write a control loop that drives the XRP robot based on the PID outputs and line position

I have attached the full main.py (with comments), ready for running the XRP robot.

1. Place the robot on the line.
2. Start with Ki = 0, Kd = 0, and Kp = 0.1.
3. Run the main script and expect to spend 10–20 minutes tuning.
4. Observe the robot’s behavior:
5. If it does nothing → communication error
6. If it veers sharply → Kp too high
7. If it oscillates widely → increase Kd or lower Kp
8. If it drifts permanently to one side → increase Ki slightly
9. [TODO: Embed sample videos of the robot with varying PID values]

Tuning Process:

1. Increase Kp slowly until the robot responds and begins oscillating around the line.
2. Reduce Kp slightly.
3. Add a small Kd to damp oscillations and improve responsiveness.
4. Add a small Ki only if the robot shows steady bias (for example, due to imperfect mounting or motor asymmetry).
5. Keep the base speed low while tuning. Increase speed afterward and re-tune minimally.

Congratulations on completing the challenge! Feel free to extend your project and share it with the community!