- The perception node will read the stereo camera's images and find the cones in them, then send them to the rest of the system as one topic, the cone array.
- A YOLO26 model will do the detection, most likely a nano or small one: a larger model sees more, but costs more processing time.
- The FSOCO dataset, a community-driven set of prelabelled images, labels the cones in five classes: yellow, blue, small orange, large orange and unknown.
- The camera is likely to be a Stereolabs ZED X or ZED 2i. The ZED X has a global shutter, which avoids the distortion a rolling shutter like the ZED 2i's causes at high speed, but it only works connected to a Jetson.
Subsystem 02 of 13
Autonomous
Autonomous is developing the driverless software that will find the cones, map the track and drive the car around it. The whole system is coming in 2027: none of it is on the 2026 car, and the camera and the onboard computer are still being chosen.
The stack
- Software
- ROS 2 Jazzy on Ubuntu 24.04
- Languages
- C++20 for critical code, Python 3.12 for tests and tools
- Sensing
- Vision only: a stereo camera, plus the car's own sensor data over CAN
- Mapping
- Graph-SLAM with GTSAM, loop closure at the orange start cones
- Pathing
- Delaunay centreline, Stanley controller and model predictive control
- Onboard computer
- NVIDIA Jetson, model being chosen
- Rules
- Formula SAE Driverless Supplement 2026, version 4.0
Autonomous
Features
- 01
Ten laps, two phases
Lap 1 will be an exploratory lap that maps the whole track while avoiding the cones. Once it is mapped, laps 2 to 10 will be optimized for the fastest speed on the smoothest path.
- 02
A heartbeat on every node
The heartbeat node will monitor every other node. If a critical node crashes or lags, it will shut the whole system down and activate the emergency braking system.
- 03
Cones, found in 3D
A YOLO26 model, most likely nano or small, will find the cones in the stereo camera's images and give their 3D positions to the map.
- 04
Vision only
The cameras alone will identify the cones' colours, judge depth, and handle localization and mapping.
- 05
Tested in simulation
The software will be tested in the Formula Student Driverless Simulator, which publishes the exact position of every cone to check the nodes against.
Block diagram, November 2026
The pipeline
How the nodes of the planned system will connect, drawn from the team's block diagram and reference sheet.
- InputStereo camera
- NodePerception
- NodeSLAM
- NodePathing
- NodeController
- NodeCAN output
- OutputSteering motor and brake actuators
NodeSensor input
- IMU
- GNSS
- Brake pressure sensor
- Steering angle sensor
- NodeVideo captureFrom perception
- NodeData collectionFrom SLAM, pathing and controller
- NodeHardware telemetry
- NodeData relayFrom video capture, data collection and hardware telemetry
NodeHeartbeat monitoring
Will watch every node. If a critical node crashes or lags, it will shut the whole system down and activate the emergency braking system.
Element by element
How each node of the planned system will work, from the camera to the car.
- The SLAM node will take the cone array and the car's own sensor data and build a 2D map of the track, while working out where the car is on it.
- It will be a Graph-SLAM, written in C++ with the GTSAM library, and its landmarks will be the cones alone, so the noise around the track is ignored.
- On lap 1 it will build the map as the car drives, combining wheel odometry and IMU data with the cones' 3D positions in an optimizer running at 10 to 20 Hz.
- When the car sees the large orange start cones again at the end of the lap, a loop closure will snap the drift built up over the lap out of the map.
- The map will then be frozen, and for the remaining nine laps the node will only track where the car is on it, at a low, steady computing load.
- The pathing node will read the track map and find the best path through the cones.
- While the track is being mapped, Delaunay triangulation will join the left (blue) and right (yellow) cones into a mesh of triangles, and the midpoints of their edges will make a safe centreline to follow.
- A Stanley controller will track the path, correcting the steering from the car's speed, its heading error and its cross-track error, the distance from the front axle to the nearest point on the path.
- Model predictive control will look ahead on the finished map and optimize the car's line inside the track.
- The controller node will turn the path into commands for the car: target speed, acceleration, braking and steering.
- It will hand those commands to the CAN controller nodes.
- The CAN data nodes will bring the car's sensor data to the SLAM and controller nodes, so they can see the car's current state: its speed, acceleration, braking and steering angle.
- The CAN controller nodes will send the controller's commands to the car's own components.
- A microcontroller layer will turn those commands into raw CAN packets to drive the steering motor and the brake actuators.
- The heartbeat node will monitor every other node, checking that none has crashed or is lagging.
- If a critical node (vision, SLAM, pathing, controller or CAN) crashes or lags, it will shut the whole system down and activate the emergency braking system.
- If a non-critical one stops, such as the data logger, it will only raise a warning, and the car will keep driving.
Changing for 2027
The perception node will read the stereo camera and find them, and a YOLO26 model, most likely nano or small, will give each cone's 3D position to the map.
The study sets the height, pitch angle and horizontal alignment of the camera's mount on the chassis.
The SLAM node will combine the cones with the car's own sensor data to map the track and place the car on it, correcting the map when it sees the orange start cones again. A map creator and a benchmarking and evaluation suite are the tools to build and measure it.
Path planning will be developed in a custom 2D testing environment built on a kinematic or dynamic bicycle model. The tuned algorithms are then tested in the Formula Student Driverless Simulator, which publishes the exact position of every cone to check the nodes against.
The controller node will turn the planned path into speed, braking and steering commands for the CAN nodes to send to the car. It gets a modular testbench of its own.
The heartbeat node will watch every other node, and if a critical one crashes or lags it will shut the whole system down and activate the emergency braking system. Fault injection tests check that it does.
A stereo depth camera will feed the perception node, which finds the cones in its images and gives their 3D positions to the map.
How it works
The perception node will read the stereo camera and find the cones, the SLAM node will combine them with the car's own sensor data to map the track and place the car on it, the pathing node will find a path through the cones, and the controller node will turn that path into speed, braking and steering commands for the CAN nodes to send to the car.
Lap 1 will be an exploratory lap that maps the whole track, driven to get through safely rather than fast. When the car sees the large orange start cones again, a loop closure will correct the map, which is then frozen, and laps 2 to 10 will be optimized for the fastest, smoothest line.
In the team's block diagram, the perception node also feeds a video capture node, the SLAM, pathing and controller nodes feed a data collection node, and both of those, with a hardware telemetry node, feed a data relay node. A heartbeat node will watch every other node, and if a critical one crashes or lags it will shut the whole system down and activate the emergency braking system.
The 2026 car carries no autonomous hardware: the stereo camera and the NVIDIA Jetson onboard computer are still being chosen, and the software will be packaged in Docker images built for both the team's workstations and the Jetson. Recruits began their first projects in November 2026, working to the Formula SAE Driverless Supplement 2026.
