DEV Community: 砂田沙耶

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

砂田沙耶 — Sun, 30 Mar 2025 23:30:25 +0000

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.

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.

Word Blocks (SPIKE App 3)

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);
}

The robot and block placement during the test:
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):
1.2% - C Language (spike-rt)
2.5% - Python (Pybricks)
3.22% - Word Block (SPIKE App3)
4.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? - 3

砂田沙耶 — Mon, 24 Mar 2025 00:09:39 +0000

Does the Programming Environment Affect Rotation Accuracy? A 90° Test Using the Gyro Sensor
When using LEGO SPIKE Prime in robotics competitions, how much does the choice of programming environment affect rotation accuracy?
To investigate this, I conducted an experiment comparing different programming environments.

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 motor: Port A
Right motor: Port B

Test Method

To compare the environments, I conducted the following test:

Use the hub’s gyro sensor to rotate the robot 90°
Measure the difference between the target angle (90°) and the actual rotation
Perform 10 trials for each environment and calculate the average error

Program Code:
Word Blocks

Python (SPIKE App 3)

import motor, motor_pair, time
from hub import motion_sensor, port, button

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

for i in range(10):
    # Wait for the left button to be pressed
    while not button.pressed(button.LEFT):
        pass

    while button.pressed(button.LEFT):
        pass   

    # Reset yaw
    motion_sensor.reset_yaw(0)
    time.sleep_ms(50)   # Wait for yaw angle to reset

    start = motion_sensor.tilt_angles()[0]*0.1

    # Turn right
    while (abs(motion_sensor.tilt_angles()[0]*0.1) < 90):
        motor_pair.move_tank(motor_pair.PAIR_1, 300, -300)

    # Stop turning
    motor_pair.stop(motor_pair.PAIR_1,stop=motor.BRAKE)

    time.sleep_ms(500)
    stop = abs(motion_sensor.tilt_angles()[0]*0.1)
    print("start:", start, "stop:", stop)

Python (Pybricks)

from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch

hub = PrimeHub()
left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
right_motor = Motor(Port.B, Direction.CLOCKWISE)

for i in range(10):
    # Wait until button is pressed
    while not any(hub.buttons.pressed()):
        wait(10)
    # Wait for all buttons to be released.
    while any(hub.buttons.pressed()):
        wait(10)

    while not hub.imu.ready():
        wait(10)

    # Reset the IMU
    hub.imu.reset_heading(0)
    wait(500)
    start_heading = hub.imu.heading()

    # Turn right
    while abs(start_heading - hub.imu.heading()) < 90:
        left_motor.run(300)
        right_motor.run(-300)

    # Stop turning
    left_motor.brake()
    right_motor.brake()

    wait(500)
    stop_heading = round(hub.imu.heading(), 1)
    print("start:", start_heading, "stop:", stop_heading)

C Language (spike-rt)

#include <t_syslog.h>
#include <stdlib.h>
#include <kernel.h>

#include <spike/hub/system.h>

#include <gyro_turn.h>

#include "spike/pup/motor.h"
#include "spike/pup/colorsensor.h"
#include "spike/pup/forcesensor.h"
#include "spike/pup/ultrasonicsensor.h"

#include "spike/hub/battery.h"
#include "spike/hub/button.h"
#include "spike/hub/display.h"
#include "spike/hub/imu.h"
#include "spike/hub/light.h"
#include "spike/hub/speaker.h"

#include <pbio/color.h>

#include "kernel_cfg.h"
#include "syssvc/serial.h"
#include "math.h"

pup_motor_t *motorA;
pup_motor_t *motorB;
pup_device_t *ColorSensor;
pup_device_t *ForceSensor;
pup_device_t *UltraSonicSensor;

// 0:roll(x) 1:pitch(y) 2:yaw(z)
float ang_v[3] = {0};
float imu_offset[3] = {0};

float start_value; // Gyro value at start
float stop_value; // Gyro value at stop

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);

  imu_setup(imu_offset); // Offset calibration

  int8_t i;
  for (i = 0; i < 10; i++) {
    // 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);
    }
    // Wait for the left button to be released
    while (pressed & HUB_BUTTON_LEFT) {
      hub_button_is_pressed(&pressed);
      hub_light_on_color(PBIO_COLOR_BLUE);
    }

    dly_tsk(500*1000);
    sta_cyc(CYC_HDR); // Start gyro sensor monitoring
    hub_imu_init(); // Initializing the IMU

    // Reset yaw
    ang_v[2] = 0;
    start_value = ang_v[2]; 

    // Turn right
    while (fabs(ang_v[2]) < 90) {
        pup_motor_set_power(motorA, 30);
        pup_motor_set_power(motorB, -30);
    }

    // Stop turning
    pup_motor_brake(motorA);
    pup_motor_brake(motorB);

    dly_tsk(500000);
    stop_value = ang_v[2];
    syslog(LOG_NOTICE,  "start: %d.%02d stop: %d.%02d",  
      (int)start_value, (int)((start_value - (int)start_value) * 100), 
      (int)stop_value, (int)(fabs(stop_value - (int)stop_value) * 100));
}
  stp_cyc(CYC_HDR); // Stop gyro sensor monitoring
}

void gyro_monitor(intptr_t exinf)
{
  float ang_raw[3]; // IMU angular acceleration
  hub_imu_get_angular_velocity(ang_raw);

  // Offset Correction
  ang_v[0] += (ang_raw[0] - imu_offset[0]) * 0.001;
  ang_v[1] += (ang_raw[1] - imu_offset[1]) * 0.001;
  ang_v[2] += (ang_raw[2] - imu_offset[2]) * 0.001;
}

void imu_setup(float offset[3]){
  dly_tsk(3*1000*1000);

  hub_light_on_color(PBIO_COLOR_ORANGE);

  hub_imu_init(); // Initializing IMU

  float ang_raw[3]; // Raw IMU angular velocity

  // Offset calibration
  for(int i=0; i<1000; i++){
    hub_imu_get_angular_velocity(ang_raw);
    offset[0] += ang_raw[0];
    offset[1] += ang_raw[1];
    offset[2] += ang_raw[2];
    dly_tsk(1*1000);
  }

  offset[0] /= 1000;
  offset[1] /= 1000;
  offset[2] /= 1000;
}

Results: Which Environment Was Most Accurate?

Here are the average rotation errors (smaller is better):
1️⃣ 6.4° - C Language (spike-rt) 🏆
2️⃣ 8.6° - Python (Pybricks)
3️⃣ 9.6° - Python (SPIKE App 3)
4️⃣ 17.1° - Word Blocks (SPIKE App 3)
Additionally, I measured the error fluctuation range (stability):
1️⃣ 0.8° - C Language (spike-rt) 🏆
2️⃣ 0.9° - Word Blocks (SPIKE App 3)
3️⃣ 1.0° - Python (Pybricks)
4️⃣ 1.2° - Python (SPIKE App 3)

Key Takeaways:

C Language (spike-rt) had the most accurate rotation (smallest error)
C Language (spike-rt) also had the most stable results (smallest variation) ________________________________________

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!

🔹 More tests are planned, including further evaluations for robotics competitions. Stay tuned for future updates! 🚀

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

砂田沙耶 — Mon, 17 Mar 2025 00:11:17 +0000

Does the Programming Environment Affect Precision? A 360° Rotation Test
When using LEGO SPIKE Prime in robotics competitions, does the choice of programming environment impact movement precision?
To investigate this, I conducted an experiment comparing different programming environments.

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 motor: Port A
•Right motor: Port B

Test Method

To compare the environments, I conducted the following test:

Command the robot to rotate 360° using a specified motor angle
Measure the difference between the target and actual rotation angles
Perform 10 trials for each environment and calculate the average error
The same logic was used for all environments

Program Code (for all environments):
Word Blocks (SPIKE App3)

Python (SPIKE App3)

tread = 8
d_tire = 5.6
goal = 360;

for i in range(10):
motor.reset_relative_position(port.A, 0)
start_angle = motor.relative_position(port.A)
motor.run(port.A, -300)
motor.run(port.B, -300)

while tread/d_tire*goal > -motor.relative_position(port.A):
pass

motor.stop(port.A, stop=motor.BRAKE)
motor.stop(port.B, stop=motor.BRAKE)

time.sleep_ms(500)
print("error:", abs(motor.relative_position(port.A)-start_angle) - tread/d_tire*goal )

Python (Pybricks)

hub = PrimeHub()
motorA = Motor(Port.A, Direction.COUNTERCLOCKWISE)
motorB = Motor(Port.B, Direction.CLOCKWISE)

tread = 8
d_tire = 5.6
goal = 360

for i in range(10):
start_angle = motorA.angle()

motorA.run(300)
motorB.run(-300)

while tread/d_tire*goal > motorA.angle() - start_angle:
pass

motorA.brake()
motorB.brake()

wait(500)
print("error", motorA.angle()-start_angle - tread/d_tire*goal )

C Language (spike-rt)

void Main(intptr_t exinf)
{
dly_tsk(5000000);

uint8_t tread = 8;
float d_tire = 5.6;
uint32_t goal = 360;

motorA = pup_motor_init(PBIO_PORT_ID_A, PUP_DIRECTION_COUNTERCLOCKWISE);
motorB = pup_motor_init(PBIO_PORT_ID_B, PUP_DIRECTION_CLOCKWISE);

int8_t i;
for (i = 0; i < 10; i++){
pup_motor_reset_count(motorA);

pup_motor_set_speed(motorA, 300);
pup_motor_set_speed(motorB, -300);

while(tread/d_tire*goal > pup_motor_get_count(motorA));

pup_motor_brake(motorA);
pup_motor_brake(motorB);

dly_tsk(500000);

float error = pup_motor_get_count(motorA) - (tread / d_tire * goal);
syslog(LOG_NOTICE, "error: %d.%05d", (int)error, (int)((error - (int)error) * 100000));
}
}

Results: Which Environment Was Most Precise?

Here are the average rotation errors (smaller is better):
1️⃣ 12° - C Language (spike-rt) 🏆
2️⃣ 13° - Python (Pybricks)
2️⃣ 13° - Python (SPIKE App 3)
4️⃣ 14° - Word Blocks (SPIKE App 3)
Additionally, I measured the error fluctuation range (consistency):
1️⃣ 2° - Python (SPIKE App 3) 🏆
2️⃣ 3° - C Language (spike-rt)
2️⃣ 3° - Word Blocks (SPIKE App 3)
4️⃣ 5° - Python (Pybricks)

Key Takeaways:
C Language (spike-rt) had the most accurate rotation (smallest error)
Python (SPIKE App 3) had the most stable results (smallest variation)

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!

To See More

If you're interested in more LEGO SPIKE Prime experiments with C language, check out this related article:

More tests are planned, including further evaluations for robotics competitions. Stay tuned for future updates! 🚀

Comparing LEGO SPIKE Prime Programming : Which is Best for Robotics Competitions? - 1

砂田沙耶 — Mon, 10 Mar 2025 05:37:08 +0000

Does Programming Environment Affect Performance? A Comparison for Robotics Competitions
When using LEGO SPIKE Prime for a robotics competition, does the programming environment impact performance? I conducted an experiment to compare different programming environments and see how they affect robot movement.

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

Test Method
To compare the environments, I ran the following test:

The robot moves straight and stops when the color sensor detects red
Travel distance before detection: ~30 cm
Speed: ~900 deg/s
Measure the stopping distance (braking distance) from the moment red is detected until the robot stops completely
Conduct five trials for each environment and calculate the average stopping distance
The same logic was used for all environments

Program Code:

Word Blocks (SPIKE App 3)
Python (SPIKE App 3)

from hub import port
import motor,color_sensor,time
import color

motor.run(port.A, -900)
motor.run(port.B, 900)

while color_sensor.color(port.C) != color.RED:
    pass

motor.stop(port.A,stop=motor.BRAKE)
motor.stop(port.B,stop=motor.BRAKE)

time.sleep_ms(1000)

Python (Pybricks)

from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor
from pybricks.parameters import Color, Port, Stop
from pybricks.tools import wait

# Initialize the sensor.
sensor = ColorSensor(Port.C)

# Initialize the motor.
left_motor = Motor(Port.A)
right_motor = Motor(Port.B)

wait(500)

left_motor.run(-900)
right_motor.run(900)
while sensor.color() != Color.RED:
    pass
left_motor.brake()
right_motor.brake()

wait(1000)

C Language (spike-rt)

#include <stdlib.h>
#include <kernel.h>

#include <spike/hub/system.h>

#include <stopAtRed.h>

#include "spike/pup/motor.h"
#include "spike/pup/colorsensor.h"

#include <pbio/color.h>

pup_motor_t *motorA;             // Variable for using motor A
pup_motor_t *motorB;             // Variable for using motor B
pup_device_t *ColorSensor;       // Variable for using color sensor

void Main(intptr_t exinf)
{
  // Wait 3 seconds
  dly_tsk(1000000);

  motorA = pup_motor_init(PBIO_PORT_ID_A, PUP_DIRECTION_COUNTERCLOCKWISE);
  motorB = pup_motor_init(PBIO_PORT_ID_B, PUP_DIRECTION_CLOCKWISE);
  ColorSensor = pup_color_sensor_get_device(PBIO_PORT_ID_C);

  pup_motor_set_speed(motorA, 900);
  pup_motor_set_speed(motorB, 900);

  while(pup_color_sensor_color_name(ColorSensor, true) != 'r');

  pup_motor_brake(motorA);
  pup_motor_brake(motorB);

  dly_tsk(1000000);
  // End the program
  exit(0);
}

Robot Configuration
I used the following robot setup:

Left motor: Port A
Right motor: Port B
Color sensor: Port C

Results: Which Environment Performed Best?
Here are the average stopping distances (shorter is better):

24mm - C Language (spike-rt) 🏆
26.6mm - Python (Pybricks)
27mm - Word Blocks (SPIKE App 3)
27.2mm - Python (SPIKE App 3)

The C language environment (spike-rt) had the shortest stopping distance, meaning it responded the fastest.

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!

To see more
If you're interested in more LEGO SPIKE Prime experiments with C language, check out this related article:

More tests are planned, including further evaluations for robotics competitions. Stay tuned for future updates!

Introducing SPIKE-RT: The C Language Software Platform for LEGO SPIKE Prime

砂田沙耶 — Mon, 03 Mar 2025 01:05:50 +0000

Overview
This article introduces SPIKE-RT, a software platform that enables C language programming for LEGO SPIKE Prime. Unlike existing platforms that primarily use MicroPython, SPIKE-RT provides a real-time operating system (RTOS) environment based on TOPPERS/ASP3, allowing for real-time programming and efficient hardware control. This makes it a valuable option for developers who require high performance and precise control in their SPIKE Prime projects.

What is SPIKE-RT?
SPIKE-RT is a real-time operating system (RTOS) based software platform designed for LEGO SPIKE Prime, developed as the successor to EV3RT. It is built on TOPPERS/ASP3 RTOS, providing a C language programming environment under the MIT license. SPIKE-RT aims to enable real-time programming and enhance control applications' reliability and performance on LEGO SPIKE Prime.

What is TOPPERS/ASP3?
TOPPERS/ASP3 is an open-source RTOS targeting embedded systems that require high reliability, safety, and real-time performance. It extends the μITRON 4.0 specification and supports preemptive multitasking with priority-based scheduling. Its architecture is designed to maintain real-time properties while facilitating complex application development.

Comparison with Existing Software Platforms

LEGO Education SPIKE App: The official platform that provides a programming environment using MicroPython and Scratch. It appears to be based on a MicroPython runtime.
Pybricks: An open-source platform for LEGO devices that supports programming using MicroPython.

Both are based on the MicroPython runtime. Compared to SPIKE-RT, the following issues can be considered:

Limitations in Language Extensibility: Existing software assets written in C cannot be reused.
Constraints in Real-Time Performance: Issues such as garbage collection can affect real-time behavior. SPIKE-RT enables real-time programming with C, allowing the reuse of existing C software assets and supporting the development of applications with real-time requirements.

Device Support

SPIKE-RT supports a wide range of devices in the LEGO SPIKE Prime ecosystem:

Hub Internal Devices: Matrix LED, Single LED, Buttons, Accelerometer/Gyroscope (IMU), and Speaker. While external flash memory is not supported.

PUP (Powered Up) Devices: Color Sensor, Distance Sensor, Force Sensor, and Motors.

User Interface of SPIKE-RT
API Support:

TOPPERS/ASP3 API for real-time control
C Standard Library (Newlib)
SPIKE API for controlling LEGO SPIKE Prime devices Communication Interfaces:
Serial communication through PUP Port F (USART), USB Virtual COM Port, and Bluetooth Serial, all accessible via standard C I/O functions (fprintf()/fscanf()). Development Environment:
Compiler: GCC
Build System: GNU Make
Programming Method: USB DFU SPIKE-RT's user interface provides a flexible and familiar development environment for C programmers, supporting real-time device control and communication.

To see more
If you want to see a demonstration of SPIKE-RT in action, please refer to the following.

Reference
This article is based on information from https://github.com/spike-rt/materials/tree/main/2023-03-11_OSC2023OnlineSpring.

Testing LEGO SPIKE Prime with C: Line Follower Speed & Stability

砂田沙耶 — Wed, 05 Feb 2025 04:17:48 +0000

I tried controlling the LEGO SPIKE Prime using C language to evaluate its usability, processing speed, and potential for robot competitions. To test its performance, I implemented a Line Follower algorithm.

Two Key Experiments

**
1.Comparing the Line Follower performance using SPIKE App’s Word Blocks vs. C language
2.Maximizing Line Follower speed using C language with PD control
**

1. Comparing SPIKE App Word Blocks vs. C Language

**
I created a Line Follower program using both SPIKE App (Word Blocks) and C language, keeping the control logic the same.

The C language version provided more stable driving performance compared to the SPIKE App.
Watch the comparison video here: [Video Link]
Below is the source code for both versions:

2. Improving Line Follower Speed with C

**
I tested how much I could increase the Line Follower speed using C language.

Watch the actual test video: [Video Link]
Without extensive tuning, I achieved speeds of approximately 820 deg/s.
Adding a second color sensor or optimizing the robot assembly could further improve stability.

Development Environment & Resources

**
For C programming, I used this development environment: [spike-rt]
If you want to try it, there is a beginner-friendly tutorial available, including a trial (as of February 2025).

🔹 Download the program used in this article: [Download Link]

To see more

If you want to see a demonstration of SPIKE-RT in action, please refer to the following.

Future Tests & Robot Competition Applications
I plan to conduct further tests on the usefulness of C language for robot competitions and will share my findings in upcoming articles. Stay tuned!

DEV Community: 砂田沙耶

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

Tested Programming Environments

Robot Configuration

Test Method

Results: Which Environment Was Most Accurate?

Want to Try C Programming on LEGO SPIKE Prime?

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

Tested Programming Environments

Robot Configuration

Test Method

Results: Which Environment Was Most Accurate?

Want to Try C Programming on LEGO SPIKE Prime?

Related Articles

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

Tested Programming Environments

Robot Configuration

Test Method

Results: Which Environment Was Most Precise?

Want to Try C Programming on LEGO SPIKE Prime?

To See More

Comparing LEGO SPIKE Prime Programming : Which is Best for Robotics Competitions? - 1

Introducing SPIKE-RT: The C Language Software Platform for LEGO SPIKE Prime

SPIKE-RT supports a wide range of devices in the LEGO SPIKE Prime ecosystem:

Testing LEGO SPIKE Prime with C: Line Follower Speed & Stability

Two Key Experiments

1. Comparing SPIKE App Word Blocks vs. C Language

2. Improving Line Follower Speed with C

Development Environment & Resources

To see more