Starting to follow the line

 

We started with a new approach to line following. Initially we attempted to use 5 IR sensors but we found there was too much overlap in the reflection of the IR beams, causing inaccurate readings. We switched to 3 sensors, but still had problems. Firstly we added fairings to block the overlap. Then we switched to following a white line on a black background (luckily the kitchen table was black!). These changes resulted in setup the could reliably detect the line. Now we needed so code....

We started by creating our own algorithm which gave each of the line sensors a number which is what we used to to set the motor steering angle to. However we found that we kept overshooting the sharp turns, so we added a small code snippet to make it reverse when we overshot the end of the line. This worked but was not very reliable.

We had read previously (See book review on "Robotics at Home with Raspberry Pi Pico") about using a PID algorithm. However it sounded complicated to code, so was asked Bing Co-Pilot "write the code in CircuitPython to do line following using PID algorithm with 3 digital line sensors, driving 2 motors". We modified this to use out own motor setup functions and watched it wiggle down the line. After a bit of tuning, success! We had a pretty reliable line following robot.

import time

import board

import pulseio

from digitalio import DigitalInOut, Direction, Pull

# Initialize the motors

left_motor = pulseio.PWMOut(board.D9, frequency=50)

right_motor = pulseio.PWMOut(board.D10, frequency=50)

# Initialize the line sensors

line_sensors = [DigitalInOut(board.D2), DigitalInOut(board.D3), DigitalInOut(board.D4)]

for sensor in line_sensors:

    sensor.direction = Direction.INPUT

    sensor.pull = Pull.UP

# PID constants

Kp = 1.0

Ki = 0.0

Kd = 0.0

# PID variables

integral = 0.0

previous_error = 0.0

while True:

    # Read the line sensors

    line_readings = [not sensor.value for sensor in line_sensors]

    # Calculate the error

    error = line_readings[0] - line_readings[2]

    # Calculate the PID terms

    proportional = error

    integral += error

    derivative = error - previous_error

    # Calculate the motor speeds

    left_speed = 0.5 + Kp*proportional + Ki*integral + Kd*derivative

    right_speed = 0.5 - Kp*proportional - Ki*integral - Kd*derivative

    # Set the motor speeds

    left_motor.duty_cycle = int(left_speed * 65535)

    right_motor.duty_cycle = int(right_speed * 65535)

    # Update the previous error

    previous_error = error

    # Wait for a short period of time

    time.sleep(0.01)

Tank Style Steering with the GamePad

We were thinking about having a new method of control for our robot, of which we concluded that we wanted to try using both analogue joysticks on our GamePad controller. We had already decided to use the messages from an EP32, that was paired via Bluetooth to the controller.  The ESP32 was running Bluepad32 for the complicated stuff. The commands from the controller were being sent as JSON over a UART/serial interface to the Raspberry Pi Pico. The Pico is the mastermind / brains behind the operations of controlling out actual robot hardware. The messages told us what the event from the GamePad was (e.g. Button pressed) and the analogue values / position of the joysticks at the time. In CircuitPython code, we parsed the message and used the values to set the motor speeds as needed. The Y value from the left joystick was used for both the left side motors, and the Y value from the right joystick was used for both the right motors. The allowed the robots to be steered like a tank with both sides being controlled independently. This gave the ability to turn more sharply - almost spinning on the spot - by driving the motors sets in opposite direction.  Fun driving times!