Gerardo Tapia-Onate

Romi:

Collaborative Effort with Aiden D. Hall

For our Romi term project, we integrated various skills in robotics to create a robot capable of autonomously navigating an obstacle course. We started by familiarizing ourselves with the Romi chassis, including its motors, encoders, and additional sensors, which helped us understand how each component interacted and addressed key considerations like motor control, encoder resolution, and potential wheel slip. We developed Python classes for motor control and encoder readings, allowing us to accurately control the motors and track the robot’s position. To allow for navigation without a line, we added an IMU for orientation tracking. This enabled the robot to pivot to specific headings and maintain its orientation. For the rest of the autonomous movement, we implemented a line-following system using IR sensor with a feedback loop, allowing the robot to adjust its movement in real-time to follow a precise path. We also incorporated a multitasking scheduler, ensuring that tasks like motor control, sensor reading, and bumper task were managed concurrently. In the final demonstration, we successfully showed the robot’s ability to navigate and complete the obstacle course reliably.

Features

Cooperative multitasking system for concurrent operations
Motor control with PWM and direction control
Quadrature encoder position and velocity measurements
Line following using IR sensor array
Inertial measurement (IMU) for heading control and navigation
PID closed-loop control implementation
Task sharing mechanism for inter-task communication

Hardware

Romi Chassis kit, Polulu Robotics
Romi Ball Caster Kit, Polulu Robotics
Romi Power Distribution Board, Polulu Robotics
Romi Encoder Pair Kit, Polulu Robotics
Nucleo-L476RG microcontroller
QTR-MD-06A Reflectance Sensor Array: 6-channel, 8mm pitch, Polulu Robotics
BNO055 IMU

Wire Diagram:

Track:

Below is the Track that Romi must navigate. Romi must start and end in the gray box as well as hit all 5 check points in numerical order. Romi has the ability to push cups located on the -5s markers outside of the dotted circle. This will reduce the time trial length by 5 seconds. The black squares with a white dot are pillars, while the rectangle labeled Wall is a heavy steel wall.

Demo:

Code Breakdown:

Classes:

Cooperative Multitasking (cotask.py): Manages task scheduling and execution

Inter-Task Communication (task_share.py): Provides thread-safe data sharing between tasks

Motor Driver (motor_class.py): Controls motor speed and direction

Encoder Interface (encoder_class.py): Reads and processes quadrature encoder signals

IR Sensor Interface (IR_Sensor.py): Processes line sensor readings

IMU Interface (IMU.py): Communicates with the BNO055 IMU

PID Controller (PID.py): Implements closed-loop PID control

Bump Sensor (bump_sensor.py): Reads signals from bump sensors

Task:

IMU_Task:

The IMU task is minimal and is responsible for updating the heading share at every run of the task. Upon the first run of the task, the heading is stored in the initial_heading share.

Motor_Task:

The motor control task is responsible for setting the desired effort for the motors. It takes in three shares: the left and right motor effort, and the run state flag to indicate whether to set the efforts or stop the motors.

Line_Task:

The line following task reads linearized data from the infrared sensor based on the white and black calibration values, returns the centroid of the readings, calculates the error from the desired centroid (3.5 because we have a 6 sensor array), and passes the error to the PID controller to calculate the steering correction.

Position_Task:

The position task is used to control portions of the track where the robot is not line following. These two portions of the track are to pass through the diamond and the grid navigation. We chose to switch to encoder and heading control to get through the diamond portion becuase our infrared sensor was too small to respond to the sharp diamond turns without making our line following controller unstable. To traverse through the grid section, we take an intial heading at our start point to use as a reference heading, and when entering the grid, we adjust Romi's heading to 180 degrees from the initial heading. Then we use PID control and encoder distance control to drive through the grid, make a 90 degree turn, and return to line following at checkpoint 5. The states of the position task consist of changing to a desired heading based off of our reference heading and drving forward a set amount of encoder ticks.

Bump_Task: Priority = 5

The bump task, similar to the position task, uses encoder and heading control to maneuver around the wall and to the finish line after bumping into the wall. The states of the line task consist of checking for an input from the bump sensors, and then a series of operations that consist of changing to a desired heading based off of our reference heading and drving forward a set amount of encoder ticks.

Future Improvements:

Implement PID control for heading changes to achieve higher accuracy and higher speed
Implement cascaded control system, which includes adding PID control for motor speed and position
Incorporate larger infrared sensor with more channels to get a larger field of view and achieve faster line following speed
Remove redundent shares and variables to simply code structure
Develop Function for turn state sections to intake a target heading to simplify and reduce code
Develop Function for drive state sections to intake a speed to simplify and reduce code

Full GitHub Repository

Page updated

Google Sites

Report abuse