hewittmcg / mte380

Autonomous Terrain-Navigating Robot.

mte380

Background

This repository holds the software developed for MTE380, our third-year design project course. In this iteration of the course, the primary objective was to develop a robot to successfully navigate a 2m x 2m course comprised of various types of terrain.

Watch it in action here!

Hardware

The microcontroller used on the robot is a STM32 NUCLEO-F446RE.

The following sensors were used to determine the robot's position in the course:

• Three VL53L0X time-of-flight (ToF) sensors, one forward-facing and two left-facing.
• An ICM20948 9-DoF inertial measurement unit (IMU) to detect the robot's rotation.
• A downward-facing photoresistor to measure the colour of the terrain below.

The robot was moved by controlling four brushed DC micro metal gearmotors using two L298N motor controllers.

Software

Robot Microcontroller

The embedded C written to govern the robot's movement can be found in mte380/stm32. To run it, a recent STM32CubeIDE install is required. Importing mte380/stm32 into STM32CubeIDE should be possible, but will likely require some troubleshooting.

The robot code consists of the following modules:

Module	Filename	Function
main	main.c	Driver initialization and superloop calling course correction and position determination functions.
IMU Tracking	imu_tracking.c	Functionality to calculate the robot's rotation about the x-axis by numerically integrating each rotational veloicty reading. Used to determine whether the robot's chassis is parallel to the ground, which can affect ToF readings.
Motor Controller Driver	l298n_motor_controller.c	Motor controller driver.
Logger	logger.c	Creates a large buffer to store logs to and outputs logs over serial when requested.
Movement	movement.c	Governs acceleration, enging braking, and turning.
Photoresistor Driver	photoresistor.c	Uses an ADC to estimate the photoresistor's resistance and evaluate the type of surface the robot is above.
Positioning	position.c	Reads from the side ToFs and uses them to make slight corrections to keep the robot heading straight. Reads from the front ToF to assess when to stop and turn.
Position Tracking	position_tracking.c	Very similar to imu_tracking.c. Tracks readings from the front-facing ToF to attempt to discard erroneous readings. Currently unused.

Scripts

Some basic python scripts to read logs over serial and graph the data generated by logger.c can be found at mte380/scripts. Below is an example graph generated by the scripting software:

UART Forwarding

To be able to read the logs generated by logger.c and feed, it was necessary to have a way to connect UART to a computer after previously disconnecting the NUCLEO's ST-Link. Due to how the onboard ST-Link works, a reconnection will trigger a reset of the micro and loss of the logs. The workaround for this is to flash the code found in uart_forward to a second STM32 NUCLEO-F401RE, and connect UART6 on that board to UART6 on the onboard robot microcontroller. The logs generated by the robot are read by the F401RE and sent to the computer running the scripts over serial, avoiding the reset.

Credits

The driver used for the VL53L0X ToF sensor can be found here. It is designed primarily for taking single measurements with polling, but we are using the ToF sensor in continuous ranging mode.

The driver used for the ICM20948 IMU can be found here.

These drivers are licensed under their own respective license terms rather than those of this repository.

mte380's Issues

Add linter

STM32CubeIDE sucks for code styling/indentation consistency

ToF sensor continuous ranging with interrupts

We can save a lot of time by using interrupts and continuous ranging with the ToF sensors to avoid the current blocking polling architecture.

Psuedocode for main() after this change:

main:
  if flag_side_front and flag_side_rear:
    read from front and rear ToF sensors, do course correction

  if flag_forward:
    check if wall and turn if needed

  read IMU values (if implemented)

More accurate course correction

General improvements to the course correction P-loop and related functionality. Considerations include:

• Refactor some of the calculations that are repeated or mostly repeated
• Add tracking for each leg of the course and where we should be stopping, how far we should be from the wall etc
• Instead of just blindly correcting, attempt to correct to the centre of the path that we should be following
• Potentially use a PD-loop
• Depending on how far off the path we are, possibly slow down so that we can correct without going way off track
• Correct immediately after turning to avoid getting way off course before course correction kicks in

Data logging

Log data so we can view it after the run is over, probably use a Python script to graph things like mag readings over time etc

Refactor movement functionality out of main.c

Functions to move forwards/backwards/turn should be moved out of main.c into their own module.

Use engine braking to stop

Currently, to stop we just turn all motors off and coast. We can likely improve our stopping distance by briefly driving all motors in reverse.

Write/integrate IMU driver

Write or find and integrate a driver for the ICM20948 9-DoF IMU.

First reading from continuous ranging ToF sensor is always 8192

Not sure what the cause is, not really a problem with our current implementation but we should look into this a bit. Presumably that part of the register just defaults to 0xFFF or something similar.

Refactor course correction code out of main.c

Move course_correction() and related functions into their own module to reduce clutter.

Refactor helper macros/related into their own module

Create helper.c to hold things like MIN/MAX macros and related

TOF Data averaging

We should be storing some of the TOF data for the side sensors and keep an average reading to try and identify erroneous data if it exists

Motor controller driver improvements

• Track speed of each motor and add function to return it when needed
• Change to control motors entirely using the set speed function (i.e. negative values represent going backwards)

Get printf working

We can't printf over UART, but it would be very helpful in debugging.

General course correction improvements

Improvements after changing out the broken motor. Get rid of most of the stuff to compensate for the weaker right motor, improve stopping, etc