Comparing LEGO SPIKE Prime Programming: Which Is Best for Robotics Competitions? - 4 : Color Detection Accuracy

When participating in a robotics contest using LEGO SPIKE Prime, choosing the right programming environment can impact performance. In this experiment, we tested how accurately different programming environments detect colors while the robot is in motion.

Supplies

1 PC with Windows 10 or 11 operating system.

Tested Programming Environments

I compared the following four environments:

Word Blocks (SPIKE App 3) → Download here
Python (SPIKE App 3) → Download here
Python (Pybricks) → More info
C Language (spike-rt) → GitHub repository

Robot Configuration

For the test, I used a car-type robot with the following setup:

Left wheel motor: Port A
Right wheel motor: Port B
Side-facing color sensor: Port C
Downward-facing color sensor: Port D

Test Method

To compare the environments, I conducted the following test:

The side-facing color sensor detects various block colors while the robot moves.
The downward-facing color sensor detects black and stops the robot.
Each environment was tested five times, and the average results were compared.
Programs were optimized for each environment while keeping the movement speed nearly the same.

Programs

Python (SPIKE App 3)

# Set up all devices

LineSensor = port.D

ColorSensor = port.C

colors = []

color_now = None

# Color reading task

async def color_task():

global color_now

while True:

color_now = color_sensor.color(ColorSensor)

await runloop.sleep_ms(1)

async def main():

global colors

global color_now

motor_pair.pair(motor_pair.PAIR_1, port.A, port.B)

motor_pair.move(motor_pair.PAIR_1, 0, velocity=900)

while color_sensor.reflection(LineSensor) > 50:

if len(colors) == 0 or color_now != colors[-1]:

colors.append(color_now)

await runloop.sleep_ms(1)

motor_pair.stop(motor_pair.PAIR_1, stop=motor.BRAKE)

print(colors)

runloop.run(color_task(), main())

Python (Pybricks)

# Set up all devices.

hub = PrimeHub()

left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)

right_motor = Motor(Port.B, Direction.CLOCKWISE)

line_sensor = ColorSensor(Port.D)

color_sensor = ColorSensor(Port.C)

# Variables for color detection

color_now = None

colors = []

# Color reading task

async def color_task():

global color_now

while True:

color_now = await color_sensor.color(surface=True)

await wait(1)

async def run():

global colors

global color_now

# start moving

left_motor.run(900)

right_motor.run(900)

while await line_sensor.reflection() > 50:

if len(colors) == 0 or color_now != colors[-1]:

colors.append(color_now)

await wait(1)

left_motor.brake()

right_motor.brake()

print(colors)

async def main():

await multitask(color_task(), run())

run_task(main())

C Language (spike-rt)

pup_motor_t *motorA;

pup_motor_t *motorB;

pup_device_t *ColorSensor;

pup_device_t *LineSensor;

char colors[30]; // Array to store detected colors

char color_now;

void Main(intptr_t exinf)

{

motorA = pup_motor_init(PBIO_PORT_ID_A, PUP_DIRECTION_COUNTERCLOCKWISE);

motorB = pup_motor_init(PBIO_PORT_ID_B, PUP_DIRECTION_CLOCKWISE);

LineSensor = pup_color_sensor_get_device(PBIO_PORT_ID_D);

ColorSensor= pup_color_sensor_get_device(PBIO_PORT_ID_C);

int8_t i = 0;

// Wait for left button to be pressed

hub_button_t pressed;

while(!(pressed&HUB_BUTTON_LEFT)){

hub_button_is_pressed(&pressed);

hub_light_on_color(PBIO_COLOR_GREEN);

}

sta_cyc(CYC_HDR); // Start color_task

// Start moving

pup_motor_set_speed(motorA,900);

pup_motor_set_speed(motorB,900);

// Add detected colors to the array

while (pup_color_sensor_reflection(LineSensor) > 50 ) {

if (i == 0 || color_now != colors[i-1]) {

if (i < sizeof(colors) - 1) {

colors[i] = color_now;

i++;

}

// Stop moving

pup_motor_stop(motorA);

pup_motor_stop(motorB);

stp_cyc(CYC_HDR); // Stop color_task

// Output the colors detected

int8_t j;

for (j = 0; j < 30; j++) {

syslog(LOG_NOTICE, "%d : %c", j, colors[j]);

}

// Read color every 1ms

void color_task(intptr_t exinf)

{

color_now = pup_color_sensor_color_name(ColorSensor, true);

}

Video

Comparing LEGO SPIKE Prime Programming : Which Is Best for Robotics Competitions? - 4

Expected color detection sequence:

None → Red → None → Green → None → Green → Red → None → Yellow → Blue → None → Green → None → Red → None → Blue → None

Results: Which Environment Was Most Accurate?

The environment with the least misdetections was C Language (spike-rt):

2% - C Language (spike-rt)
5% - Python (Pybricks)
22% - Word Block (SPIKE App3)
27% - Python (SPIKE App3)

Observed Trends

Word Block & Python (SPIKE App3):

More likely to misdetect colors when changing to/from green (often detecting light blue or black by mistake).
More likely to misdetect white when changing from yellow.
More likely to misdetect light blue when changing from blue.
Seemed to detect background colors instead of "None" when the object’s color was ambiguous or distant.

Pybricks & C (spike-rt):

More likely to misdetect yellow when changing from green.
More likely to misdetect white when changing from yellow.

Want to Try C Programming on LEGO SPIKE Prime?

If you’re interested in trying C on SPIKE Prime, there are beginner-friendly learning materials available. As of March 2025, a trial version is also accessible—give it a try!

Comparing LEGO SPIKE Prime Programming: Which Is Best for Robotics Competitions? - 4 : Color Detection Accuracy