2. Hello, World!

It’s a tradition when learning a new programming language to create a “Hello, World!” program. You’re going to write “Hello, World!” on the Light Matrix of the SPIKE Prime Hub. First, make sure your SPIKE Prime Hub is turned on and connected to the SPIKE App. Then follow these four steps:

1. Make sure the Code Editor is empty by deleting any existing code.

2. Press the Copy icon in the top right corner of the example below to copy the code.

3. Right-click or long-press the Code Editor and then choose Paste from the menu to paste the code.

4. Press the Play button to run the program.

from hub import light_matrix

light_matrix.write('Hello, World!')

You’ll see the text “Hello, World!” scrolling across the Light Matrix.

Let’s look at the code line by line.

The first line imports the light_matrix module from the hub module, which controls the Light Matrix of the Hub. After importing a module, you can use its various functions.

The final line calls the write() function from the light_matrix module to write “Hello, World!” on the Light Matrix.

Define a Function

In the previous example, you used the write() function. A function is a block of code that performs a task when you call it. You define a function with the def keyword, followed by the function name, parentheses, and a colon. The body of the function is indented and contains all the code that runs when you call the function. You call a function by writing the function name and parentheses. Make sure to unindent the function call, otherwise it’s part of the function body.

The example below defines the hello() function, which writes “Hello, World!” on the Light Matrix, and calls the function once. Try to run the example code. Remember to first delete any existing code from the Code Editor, before you copy, paste, and run the code.

from hub import light_matrix

def hello():

    light_matrix.write('Hello, World!')

hello()

Add a Parameter

In the example above, the hello() function has no parameters, so it writes “Hello World” on the Light Matrix each time you call it. To make it more dynamic, add a parameter name inside the parentheses of the function definition. The code block in the function body can then use this parameter to do something different based on its value. An example of this is the write() function, which has one required parameter: the text to write on the Light Matrix.

The example below adds a name parameter to the hello() function, which then writes 'Hello, ' + name + '!' on the Light Matrix. Notice the + operator, which lets you add pieces of text together. Text is also known as a string, or type str. It is surrounded by either single (') or double (") straight quotation marks, using the same type around a given text string. The updated hello() function has one required parameter of type str, so you can pass the string 'World' as an argument when you call it to write “Hello, World!” on the Light Matrix.

Try running the example code. Don’t forget to delete any existing code from the Code Editor before you copy, paste, and run your new code.

from hub import light_matrix

def hello(name):

    light_matrix.write('Hello, ' + name + '!')

hello('World')

You’ll see the text “Hello, World!” scrolling across the Light Matrix once again.

Challenge

Can you change the code so the Hub greets you instead of the world?

4. Controlling Motors

You’re ready to connect and use the motors. Connect a motor to port A and try the program below.

import motor

from hub import port

# Run a motor on port A for 360 degrees at 720 degrees per second.

motor.run_for_degrees(port.A, 360, 720)

You should see the motor run 360 degrees (one complete rotation) at 720 degrees (two rotations) per second.

Let’s examine the code line by line.

The first line imports the motor module that controls the motors.

The second line imports port from the hub module, which holds the value for each port. You can write port.A for port A, port.B for port B, and so on to specify the port(s) you want.

The final line calls the run_for_degrees() function with three arguments:

1. The first parameter specifies which motor to run, using the port value.

2. The second parameter specifies the number of degrees to run.

3. The third parameter specifies at what velocity to run the motor, in degrees per second.

Multiple Motors

Now connect a second motor to port B and try the program below.

import motor

from hub import port

# Run two motors on ports A and B for 360 degrees at 720 degrees per second.

# The motors run at the same time.

motor.run_for_degrees(port.A, 360, 720)

motor.run_for_degrees(port.B, 360, 720)

Notice that both motors run 360 degrees (one rotation) at 720 degrees per second, starting and ending at the same time. Since the two motor statements are on separate lines, you might expect them to run one by one. However, they run at the same time because the run_for_degrees() is an awaitable function. That means you can wait for it to complete, but you don’t have to. By default, the program immediately continues to the next line of code while the awaitable code runs to completion in the background. This makes it possible to run multiple commands at the same time.

Run Loop, Async, and Await

To effectively use awaitable code with the flexibility to run commands either concurrently or sequentially, you must run your code in an asynchronous function using a run loop. The runloop module controls the run loop on the Hub, and lets you run asynchronous functions with its run() function. An asynchronous function, also known as a coroutine, is an awaitable that uses the async keyword before the function definition. The convention is to name the coroutine containing your main program main(). The code below shows the general structure of a program using a run loop.

import runloop

async def main():

    # Write your program here.

runloop.run(main())

In the body of a coroutine, you can use the await keyword before calling an awaitable command. This pauses the coroutine until the command completes. Without the keyword, the program immediately continues to the next line of code in the coroutine. You can still use regular (not awaitable) code inside the coroutine. However, doing so will always pause or block the whole program until the command completes.

The program below defines the main() coroutine, which uses the await keyword before the two run_for_degrees() function calls. It uses the run() function from the runloop module to run the main() coroutine on the final line of code.

import motor

import runloop

from hub import port

async def main():

    # Run two motors on ports A and B for 360 degrees at 720 degrees per second.

    # The motors run after each other.

    await motor.run_for_degrees(port.A, 360, 720)

    await motor.run_for_degrees(port.B, 360, 720)

runloop.run(main())

Try the sample code. You should see that both motors run 360 degrees (one rotation) at 720 degrees per second, one at a time.

Challenge

Rewrite the code to have the motors run separately for 1000 degrees, then have them run together for 1200 degrees. Be sure to change and add comments according to what the program is doing. Place this code in your Engineering Notebook, Python Page-label it "Motors".

6. The Power of Random

Sometimes, the best program is an unpredictable one. When you don’t know what a program will do next, it seems more alive. To achieve this result, add some randomness.

The program below will set the Power Button light on the SPIKE Prime Hub to ten different colors, with a random delay between each color change.

import random

import time

from hub import light

for color in range(11):

    # Set the light to the current color.

    light.color(light.POWER, color)

    # Keep the light on for 0.5 to 1.5 seconds.

    sleep_time = random.randint(500, 1500)

    time.sleep_ms(sleep_time)

Each color is represented by a different number. The for loop iterates over range(11) and assigns the value to the color variable. It will be 0 (black) which turns the light off the first time the loop runs and 10 (white) in the last iteration. Notice that this program imports the random module, which contains several functions to add randomness.

This example uses the randint() function, with a start value of 500 and a stop value of 1500. With these arguments, the function returns a number between 500 and 1500 to add some variation to the sleep time. However, the colors will always light up in the same order even if you run the program several times. Luckily, the random module has some other functions to add even more randomness to the program.

Loop Forever

You can also use a while loop to repeat something forever instead of a specific number of times. In Python, the simplest way to create such a loop is to write while True: followed by the code you want to run forever. The next example uses a while True loop to run a little disco show forever or until you stop the program.

import random

import time

from hub import light

while True:

    # Generate a random number between 1 and 9.

    random_color = random.randint(1, 9)

    # Set the light to the random color.

    light.color(light.POWER, random_color)

    # Keep the light on for 0.5 to 1.5 seconds.

    sleep_time = random.randint(500, 1500)

    time.sleep_ms(sleep_time)

Notice that the Power Button lights up in random colors, with a random delay between each color change. The example uses the randint() function again to generate a number between 1 and 9 (both included), which corresponds to the different color numbers excluding black (0) and white (10).

Lists and Constants

If you want the light show to only include certain colors, you can put them in a list and then choose a random color from it. You create a new list like a variable, first writing the list name, then the = sign, and finally the values inside square brackets, separated with commas. For a simple list with at least two items, write my_list = [1, 2]. You can add as many values as you want.

As you’ve seen in the previous examples, each color is represented by a different number. You use this number to set the light to that color, for example, number 9 will set the light to red. However, using numbers for colors can make it harder for other readers to know what your code will do. You could add comments to describe each value, but a better way is to make variables for each color. The color module has a variable RED so you can write color.RED instead of the number 9 in your code. (A variable listed with all capital letters is a constant, which means you shouldn’t change it.)

The example below imports the color module and uses some of the color constants to create the list colors. This time, the randint() function determines how many times the for loop runs, and the light turns white at the end of this little random light show.

import random

import time

import color

from hub import light

# Create a list with some different light colors.

colors = [color.RED, color.GREEN, color.BLUE, color.YELLOW]

# Change the light five to ten times.

times = random.randint(5, 10)

for i in range(times):

    # Choose a random color from the list of colors.

    random_color = random.choice(colors)

    # Set the light to the random color.

    light.color(light.POWER, random_color)

    # Keep the light on for 0.5 to 1.5 seconds.

    sleep_time = random.randint(500, 1500)

    time.sleep_ms(sleep_time)

# Set the light to white.

light.color(light.POWER, color.WHITE)

You’ll see the Power Button light change to a random color from the list, for a random number of times, with a random delay between each color change. The example uses the choice() function to pick a random color from the colors list.

Challenge

Rewrite the code to have four different colors blink continuously until the program is stopped, Also have the following phrase scroll on the hub "I like to Disco". Also, have the robot do a little dance for 20 seconds. Be sure to change and add comments according to what the program is doing. Place this code in your Engineering Notebook, Python Page-label it "Disco".

8. Sensor Conditions

You’ve used the sensor value to control a motor directly, but it’s also possible to change the flow of the program using sensor conditions and an ifstatement. The if statement is an essential part of programming and the simplest way to control the flow of your program.

You create an if statement by writing if followed by a logical expression and a colon. Logical expressions are basically yes / no questions, such as “Is the color red?” or “Is the button pressed?” If the answer to the question is “yes,” the expression is evaluated to be True and otherwise it is False. These are the two Boolean values used in Python, and are of type bool. All the lines of code with the same indentation level after the if statement are part of the code block that runs if the expression is True.

For an example, connect a Color Sensor to port A and run the program below.

from hub import port, sound

import color

import color_sensor

import runloop

async def main():

    while True:

        # Check if the red color is detected.

        if color_sensor.color(port.A) == color.RED:

            # If red is detected start a very long beep.

            sound.beep(440, 1000000, 100)

            # Pause the program while red is detected.

            while color_sensor.color(port.A) == color.RED:

                await runloop.sleep_ms(1)

            # Stop the sound when red is no longer detected.

            sound.stop()

runloop.run(main())

Wave a red LEGO® brick in front of the Color Sensor while the program is running. You’ll hear a beep when the red color is detected, which stops when the red color is no longer detected. The example uses an if statement to check if the color detected by the Color Sensor is red. It does this using the equality operator == with the Color Sensor color value on the left and the color.RED constant on the right. (Note that there are two = signs vs. the single = sign you used to assign values to variables.) If the Color Sensor color value is the same as the color.RED constant, the condition is True and the code block after the if statement runs.

It’s important to wrap the code in a while True loop. Otherwise, the Color Sensor only checks the color for a split second when the program starts. So far, you used the while loop with the True constant to repeat code forever. You can also use the while loop with a logical expression to repeat code only as long as that expression evaluates to True. The example above uses the same condition as the if statement in the inner while loop, to continue playing the beep while the red color is detected. When the condition is no longer True, the Hub exits the while loop and runs the next line of code to stop the sound.

Inside the inner while loop, notice the sleep_ms() function from the runloop module. This function pauses the main() coroutine for a number of milliseconds in a non-blocking way. Because it uses the await keyword, other tasks can run while that coroutine is paused. In the example, the pause is one millisecond. This may seem like very little time, but it’s enough for the Hub to run many coroutines concurrently. The sleep_ms() function from the time module, which you used in earlier chapters, pauses the program in a blocking way. This means that it pauses the entire program and not just the code block where you call it.

What Else?

You can add more than one condition by extending the if statement with an elif statement that checks another condition. You can add as many of these as you need, and they follow the same syntax as the if statement. The elif should be on the same indentation level as the first if statement, and the elif keyword is followed by a logical expression and a colon. Indent the next line(s) of code that should run when this condition is True.

Sometimes, none of the conditions in the if and elif statements are True. In this case, you can run some code by adding an else statement without any condition. This runs when all the previous conditions are False.

For example, the program below adds an elif and else statement to also beep if the left button is pressed.

from hub import button, port, sound

import color

import color_sensor

import runloop

# This function returns `True` if the Color Sensor detects red.

def red_detected():

    return color_sensor.color(port.A) == color.RED

# This function returns `True` if the left button is pressed.

def left_pressed():

    return button.pressed(button.LEFT) > 0

async def main():

    while True:

        if red_detected():

            # If red is detected start a very long beep.

            sound.beep(440, 1000000, 100)

            # Wait until red is no longer detected.

            while red_detected():

                await runloop.sleep_ms(1)

        elif left_pressed():

            # If the left button is pressed make a short beep.

            sound.beep(880, 200, 100)

            # Wait until the left button is released.

            while left_pressed():

                await runloop.sleep_ms(1)

        else:

            # Otherwise, stop the sound.

            sound.stop()

runloop.run(main())

Wave a red LEGO brick in front of the Color Sensor and press the left button on the Hub while the program is running. You’ll hear a beep for as long as the red color is detected, and a short beep each time the left button is pressed.

The example defines two functions to do the logic tests and return the result. The red_detected() function checks if the color detected by the Color Sensor is red and returns the result True or False. The left_pressed() function uses the pressed() function from the hub.button module and uses the > operator to check if the value is greater than 0 and returns the result.

The code in the if statement here is largely the same as the first example, but now it uses the red_detected() function in two places instead of repeating the condition for the if and while statements. The elif statement uses the left_pressed() function to check if the left button on the Hub is pressed for more than 0 milliseconds.

Note that the elif statement only runs when the condition of the first if statement is False. Therefore, pressing the button while the Color Sensor detects something red has no effect. You should carefully consider the order of your if and elif conditions and check the most important ones first. The else statement stops the sound if neither condition is True.

Multiple Conditions

When you use if/elif/else statements to test for multiple conditions, only one of the blocks will run. These conditions are mutually exclusive. You’ve seen that while the color red was detected, pressing the left button had no effect. To truly check multiple conditions, you must check them at the same time. Like adding several stacks of Word Blocks, in Python you can run multiple coroutines with the run() function from the runloop module. Until now, you’ve called it with the main() coroutine as its only argument, but it’s possible to pass multiple coroutines as comma-separated arguments.

For example, the program below divides the code that checks the detected color and the pressed button into two coroutines. The run() function on the final line of code starts both coroutines at the same time.

from hub import button, port, sound

import color

import color_sensor

import runloop

# This function returns `True` if the Color Sensor detects red.

def red_detected():

    return color_sensor.color(port.A) == color.RED

# This function returns `True` if the left button is pressed.

def left_pressed():

    return button.pressed(button.LEFT) > 0

# This coroutine continuously checks if the Color Sensor detects red.

async def check_color():

    while True:

        # Wait until red is detected.

        while not red_detected():

            await runloop.sleep_ms(1)

        # When it's detected start a very long beep.

        sound.beep(440, 1000000, 100)

        # Wait until red is no longer detected.

        while red_detected():

            await runloop.sleep_ms(1)

        # When red is no longer detected stop the sound.

        sound.stop()

# This coroutine continuously checks if the left button is pressed.

async def check_button():

    while True:

        # Wait until the left button is pressed.

        while not left_pressed():

            await runloop.sleep_ms(1)

        # When it's pressed make a short beep.

        sound.beep(880, 200, 100)

        # Wait until the left button is released.

        while left_pressed():

            await runloop.sleep_ms(1)

# Run both coroutines.

runloop.run(check_color(), check_button())

Wave a red LEGO brick in front of the Color Sensor and press the left button on the Hub while the program is running. Like before, you’ll hear a beep for as long as the red color is detected, and a short beep each time the left button is pressed. This time, it’s possible to press the left button and hear a beep while the red color is detected because both functions run at the same time.

When you create your own coroutines, remember that:

• Your coroutines should at least await one command.

• When you use a tight while loop, use await runloop.sleep_ms(1) inside the loop to give other coroutines a chance to start and run.

Challenge

Rewrite the code to have the Force Sensor control control a tone sound.beep(220, 1000, 100), The Left Button control a tone sound.beep(440, 1000, 100), and right Button control another tone sound.beep(660, 1000, 100). both motors. Play a little tune while pushing the three buttons. Be sure to change and add comments according to what the program is doing. Place this code in your Engineering Notebook, Python Page-label it "Tone".