Exploring LEGO NXT with MicroPython

LEGO Mindstorms NXT is a popular robotics kit that has been a favorite among hobbyists, educators, and students for years. It allows users to build and program robots using a graphical programming environment or other programming languages. MicroPython, on the other hand, is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimized to run on microcontrollers. Combining LEGO NXT with MicroPython opens up a world of possibilities for robotics enthusiasts. It enables users to leverage the simplicity and power of Python to control their NXT robots, making it easier to write complex programs and implement advanced robotics algorithms. In this blog post, we will explore the fundamental concepts of LEGO NXT MicroPython, its usage methods, common practices, and best practices.

Table of Contents#

  1. Fundamental Concepts
  2. Usage Methods
  3. Common Practices
  4. Best Practices
  5. Conclusion
  6. References

Fundamental Concepts#

What is MicroPython on LEGO NXT?#

MicroPython on LEGO NXT is a port of the MicroPython interpreter to the NXT brick. It allows you to write Python code that can be executed directly on the NXT, giving you full control over the sensors and motors of the LEGO NXT kit.

Key Components#

  • NXT Brick: The main processing unit of the LEGO NXT kit. It has input ports for sensors and output ports for motors.
  • Sensors: LEGO NXT comes with various sensors such as touch sensors, ultrasonic sensors, light sensors, and sound sensors. These sensors can be used to gather information about the robot's environment.
  • Motors: The motors are used to move the robot. You can control the speed, direction, and rotation of the motors using MicroPython.

Python Libraries for NXT#

MicroPython for NXT provides several libraries to interact with the sensors and motors. Some of the important libraries are:

  • nxt.motor: This library is used to control the motors. You can set the power, direction, and rotation of the motors using functions provided by this library.
  • nxt.sensor: This library is used to read the values from the sensors. It provides functions to get the raw values or processed values from different types of sensors.

Usage Methods#

Setting Up the Environment#

  1. Flash the NXT Brick: First, you need to flash the NXT brick with the MicroPython firmware. You can download the firmware from the official MicroPython for NXT repository.
  2. Connect to the NXT Brick: You can connect to the NXT brick using a USB cable or Bluetooth. Once connected, you can use a terminal emulator to interact with the NXT brick and run your Python code.

Writing Your First Program#

Here is a simple example of a Python program that makes a motor on port A rotate at 50% power for 2 seconds:

import nxt
import nxt.motor
import time
 
# Connect to the NXT brick
b = nxt.find_one_brick()
 
# Get the motor on port A
motor_a = nxt.motor.Motor(b, nxt.motor.PORT_A)
 
# Set the power of the motor to 50%
motor_a.run(power=50)
 
# Wait for 2 seconds
time.sleep(2)
 
# Stop the motor
motor_a.brake()
 
# Disconnect from the NXT brick
b.close()

Reading Sensor Values#

Here is an example of reading the value from a touch sensor connected to port 1:

import nxt
import nxt.sensor
 
# Connect to the NXT brick
b = nxt.find_one_brick()
 
# Get the touch sensor on port 1
touch_sensor = nxt.sensor.Touch(b, nxt.sensor.PORT_1)
 
# Read the value of the touch sensor
is_pressed = touch_sensor.is_pressed()
 
print("Touch sensor is pressed:", is_pressed)
 
# Disconnect from the NXT brick
b.close()

Common Practices#

Error Handling#

When working with the NXT brick, it is important to handle errors properly. For example, if the NXT brick is not found or there is a problem with the sensor or motor, your program should handle these errors gracefully. Here is an example of error handling when connecting to the NXT brick:

import nxt
 
try:
    # Try to connect to the NXT brick
    b = nxt.find_one_brick()
    print("Connected to the NXT brick")
except nxt.locator.BrickNotFoundError:
    print("NXT brick not found. Please check the connection.")

Using Loops#

Loops are very useful when you want to perform a task repeatedly. For example, you can use a loop to continuously read the value from a sensor and take appropriate actions based on the value. Here is an example of using a loop to continuously read the value from a light sensor:

import nxt
import nxt.sensor
import time
 
# Connect to the NXT brick
b = nxt.find_one_brick()
 
# Get the light sensor on port 2
light_sensor = nxt.sensor.Light(b, nxt.sensor.PORT_2)
 
try:
    while True:
        # Read the light level
        light_level = light_sensor.get_light_level()
        print("Light level:", light_level)
        time.sleep(0.5)
except KeyboardInterrupt:
    print("Program interrupted by user.")
finally:
    # Disconnect from the NXT brick
    b.close()

Best Practices#

Code Modularity#

It is a good practice to break your code into smaller functions and classes. This makes your code more organized, easier to understand, and easier to maintain. For example, you can create a function to control the movement of the robot:

import nxt
import nxt.motor
import time
 
def move_forward(b, power=50, duration=2):
    # Get the motors on ports A and C
    motor_a = nxt.motor.Motor(b, nxt.motor.PORT_A)
    motor_c = nxt.motor.Motor(b, nxt.motor.PORT_C)
 
    # Set the power of the motors
    motor_a.run(power=power)
    motor_c.run(power=power)
 
    # Wait for the specified duration
    time.sleep(duration)
 
    # Stop the motors
    motor_a.brake()
    motor_c.brake()
 
# Connect to the NXT brick
b = nxt.find_one_brick()
 
# Move the robot forward
move_forward(b)
 
# Disconnect from the NXT brick
b.close()

Documentation#

Adding comments to your code is very important. It helps other developers (and your future self) understand what the code is doing. You can also write docstrings for your functions and classes to provide more detailed information about their usage.

def move_forward(b, power=50, duration=2):
    """
    Move the robot forward.
 
    Args:
        b (nxt.brick.Brick): The NXT brick object.
        power (int): The power level of the motors (0 - 100).
        duration (float): The duration in seconds to move forward.
    """
    # Get the motors on ports A and C
    motor_a = nxt.motor.Motor(b, nxt.motor.PORT_A)
    motor_c = nxt.motor.Motor(b, nxt.motor.PORT_C)
 
    # Set the power of the motors
    motor_a.run(power=power)
    motor_c.run(power=power)
 
    # Wait for the specified duration
    time.sleep(duration)
 
    # Stop the motors
    motor_a.brake()
    motor_c.brake()

Conclusion#

LEGO NXT MicroPython provides a powerful and easy-to-use way to control LEGO NXT robots. By leveraging the simplicity and flexibility of Python, you can create complex robotics programs with ease. In this blog post, we have covered the fundamental concepts, usage methods, common practices, and best practices of LEGO NXT MicroPython. We hope this information will help you get started with using MicroPython on your LEGO NXT kit and inspire you to create amazing robots.

References#

2025-10