Science Olympiad Electric Vehicle 2026

My 2025 car was built for speed. That event scored a car on how quickly it covered a set distance and how close to the target it stopped, and it covered 8.3 m in 2.97 s. For 2025-26 the rules changed in two ways that decided this design:

• Time is a target now. The event supervisor picks a target time between 10.0 and 20.0 s, in half-second steps, and the Time Score is the gap between that and the run time. Fast is no longer better; accurate is.
• The can bonus. Two cans stand on a bonus line halfway between the start and the target. The outer can’s inside edge is 100 cm from the straight line between them, and we place the inner can anywhere from 0 to 100 cm inside it. The bonus is −0.5 × (110 − the gap in cm), and it only counts if every part of the car passes between the cans. The closer the cans, the bigger the bonus.

The other rules that shaped the car: a target distance of 7 to 10 m, a Distance Score of 2 points for every centimeter the car stops from the target, at most eight AA batteries, no more than 70 cm from the front of the front wheel to the back of the rear wheels, no wider than 35 cm, and a start by pressing the car with an unsharpened pencil.

My car is 13 cm wide (in my CAD).

I designed version 1 in less than a day, to have a car ready for the competition. It is two modules on a short 3D printed chassis. The rear module carries the brushless motor and the driven rear axle. The front module is a printed fork holding one wheel, and the fork bolts straight to the horn of a 25 kg servo (a DS3225MG in my CAD), so the servo’s output shaft is the steering axis. The eight AA batteries ride on top. Wheelbase 142 mm, width 130 mm (in my CAD).

In the code the steering setting is a whole number of degrees, written to the servo once at startup, with 90 as straight ahead.

For version 2 I chose caliper steering. A digital caliper sits along the car’s spine, and a linkage turns the position of its sliding jaw into a steering angle. It let us set the steering angle precisely. How it works, from my CAD:

1. Same fork, new pivot. I kept version 1’s printed fork, wheel and axle. Where the fork’s four screws went into the servo horn, they now go into a printed bearing holder that turns on a 6202 ball bearing (14 mm bore, 35 mm outside, per the part in my CAD). The steering axis is a bearing now instead of the servo’s gearbox.
2. Arm, link, slider. The bearing holder has a 50 mm arm pointing back along the car. A printed link, 89.4 mm between its pins, joins the end of that arm to a clamp on the caliper’s sliding jaw. The clamp’s pin slides along a line 44.2 mm to one side of the steering axis.
3. Travel to angle. Sliding the jaw back pulls the link and swings the arm, which steers the wheel right; sliding it forward steers left. Near straight ahead, 1 mm of jaw travel is about 2.0° of steering, so one 0.01 mm count on the caliper is about 0.02° (computed from my CAD).
4. A longer car. The front wheel moved about 310 mm forward onto a spine of two 2020 T-slot aluminum extrusions (184.5 mm and 88.5 mm long), for a 452 mm wheelbase. The rear drive, electronics and battery stayed where they were. The car is 525 mm from the front of the front wheel to the back of the rear wheels, inside the 70 cm limit.

The longer wheelbase changes the math on its own: the same arc needs a bigger steering angle, so a fixed error in the angle moves the car about 3.2 times less than on version 1 (computed).

• A D2830 brushless motor (1000 KV, per the part in my CAD) drives the rear axle through an 8 tooth pinion. The code counts 6 turns of the encoder for every turn of the wheels.
• An MT6701 magnetic encoder, read over I2C, sits at the end of the pinion shaft (in my CAD).
• 2.875 in BaneBots wheels.
• An Arduino Nano Every runs everything. The motor’s speed controller takes standard servo pulses: 1500 µs is stop and 2000 µs is full power.
• Eight AA batteries in a removable pack (below).

The electronics module comes straight from my 2025 car (the CAD part is still named for 2024-25), and so do the motor, the encoder mount, the wheels and the pinion.

The code is on GitHub: github.com/jerryli08/sciolyev2026. It is four Arduino sketches. code.ino is my 2025 car’s control loop with a steering servo added and the encoder ratio changed. targetTimeCode.ino, fairfaxCompCode.ino and finalCompCode.ino share one target-time loop and differ in their track settings and speed-controller gains.

Every loop of the target-time code:

1. Debounce two buttons. One toggles a laser output; the other starts and stops the run.
2. Read the MT6701’s angle, unwrap it across 0 and 360 degrees, and turn the change into distance: change in angle ÷ 360 × wheel circumference ÷ 6.
3. Work out speed from that distance and the loop time.
4. Until 5 cm before the target distance, a speed controller holds the car at target distance ÷ target time.
5. In the last 5 cm, a position controller brings the car to the target distance.
6. Add a fixed 0.08 to any forward command, and send it to the motor’s speed controller as a pulse from 1500 to 2000 µs.

distance += -(Δangle / 360) × (π × 2.875 in) / 6        the encoder counts backwards
if distance < targetDist - 5 cm:
    power = speedPID(targetDist / targetTime - speed)
else:
    power = positionPID(targetDist - distance)
esc pulse = 1500 µs + 500 µs × (power + 0.08 if power > 0)

The settings that change for each track sit together at the top of the file under ADJUSTABLE PARAMETERS (EASY ACCESS): the target distance, the target time and, for version 1, the steering angle. In finalCompCode.ino a comment says the servo isn’t used anymore; on version 2 the caliper sets the steering.