Introduction

Sequencing and pattern recognition are fundamental skills in computing, essential for solving problems and creating effective programs. From deciphering changing light sequences to following step-by-step instructions in daily tasks, such as cooking or personal hygiene, these skills are ubiquitous. In this chapter, we explore how sequencing and pattern recognition play vital roles in programming with the micro:bit, using LED lights to display images and developing programs with MicroPython. By understanding these concepts, we lay the foundation for mastering computational thinking.

Prototyping

In the software development process, a designer starts by creating a project plan and then develops a prototype. The prototype aims to include all elements of the final solution, helping to identify and fix errors in both functionality and user experience. It also allows for testing project requirements and gathering user feedback for improvements before the final product is created.

Different types of projects require different types of prototypes. For hardware products like cars, a physical prototype is necessary to determine materials, costs, and parts. In software development, the prototype is a working model of the software used to gather user feedback on its appearance and functionality.

Prototyping is crucial in software development to avoid releasing buggy software. Users expect a fully functional product upon release. There are two main types of software prototyping: evolutionary and throwaway.

Evolutionary Prototyping

This involves developing a complete prototype for user feedback. Based on the feedback, improvements are made and new prototypes are created until the final solution is reached. An example is a new game given to users for testing; feedback is used to improve and redevelop the game.

Throwaway Prototyping

This involves developing small sections of the final solution and gathering feedback. The small prototype is then discarded. This method reduces the risk of needing major changes in the final solution. An example is releasing a section of a game for user testing and then using the feedback to develop a new prototype.

Pattern Recognition

In programming, moving from block-based to text-based coding involves recognizing patterns. For example, the MakeCode block to show a heart icon translates to the MicroPython code display.show(Image.HEART). Similarities in terms like "show" and "heart" help in understanding both types of code.

Code Comparison

When comparing MakeCode and MicroPython for displaying a happy face when button A is pressed, similarities include:

• MakeCode: The outer block checks if button A is pressed.
• MicroPython: The first line of code does the same check (if button_a.is_pressed():).
• Both codes have similar terms like "button A pressed".

Pattern recognition within a single language, like MicroPython, allows you to modify code easily. For instance, to display a different icon when button B is pressed, you can copy and edit the existing code for button A, changing references from A to B and updating the image.

Flowcharts

Flowcharts for these programs also show patterns, with decision blocks checking button presses and corresponding outputs. Placing flowcharts side by side highlights these similarities and patterns.

Patterns between text-based programming languages

Patterns in Text-Based Programming

In the previous theme, patterns were identified between block-based programming in MakeCode and text-based programming in MicroPython. Similarly, patterns can be observed between text-based languages like MicroPython and Python. For example:

• In Python, the print() function is used to output text.
• In MicroPython, thedisplay.scroll() function is used to output text.

Both functions use brackets and quotation marks to define the text to be output, indicating that the content is a string.

Patterns in Flowcharts

Patterns can also be found in flowcharts. Flowcharts help predict outcomes by following the sequence from top to bottom and understanding the symbols used for processes and outputs.

Example

A flowchart example can be represented in both Python and MicroPython to output numbers 1, 2, 3 with a 1-second delay between each. Similarities include:

• The use of sleep to add a 1-second delay in both languages.
• The number to be output is written within brackets.

Overall, both flowcharts and written programs follow a sequential order from top to bottom, which is crucial for the expected program output.

The Logic of AND/OR/NOT

In programming, multiple inputs may be needed to trigger an output. For example, starting a light sequence might require both a button press and a sound sensor activation. Each input can be true or false.

Boolean Operators

Boolean operators (AND, OR, NOT) allow combining multiple inputs:

• AND: Both inputs must be true to activate the output. If both buttons A and B are pressed, a happy face is displayed; otherwise, a sad face is shown.
• OR: Either or both inputs must be true to activate the output. If either button A or B is pressed, a happy face is displayed; otherwise, a sad face is shown.
• NOT: Returns the opposite of the input. If button A is not pressed, a happy face is displayed; if pressed, a sad face is shown.

Flowcharts

Flowcharts help visualize these conditions. For instance, a flowchart can depict the logic of pressing buttons to display faces.

Sub-Routines

Sub-routines are sections of code used multiple times, placed separately from the main code, and called by their name in the main flowchart.

Example

If the A button is pressed OR movement is detected, a light sequence runs; otherwise, a sad face is displayed. The sub-routine "Light sequence" displays a large square, waits 1 second, displays a small square, waits 1 second.

Project Plans and Test Plans

Before creating a prototype program, a project plan is essential to outline what the program needs to achieve. This involves breaking down the program into smaller problems that need to be solved. For example, to create a program where an alarm activates upon pressing a button on the micro:bit, questions would include identifying the input button, defining the alarm sequence, and determining actions if the alarm isn't activated. A project plan ensures software development progresses smoothly, defining the expected functionality, required sections, inputs/outputs, and testing procedures to ensure the final product meets expectations.

Identifying errors and debugging

Debugging is essential for identifying and fixing errors in both the flowchart and program code. A sequence in programming is a set order of instructions, and an incorrect sequence can lead to errors or incorrect outputs. For example, identifying an error in a color sequence can be done using pattern recognition.

Pattern recognition can also be applied to debugging program code by checking the sequence in a flowchart. For instance, in a flowchart that alternates between displaying shapes and waiting, you can identify the next steps in the sequence by following the pattern.

In the example of MicroPython code corresponding to a flowchart, comparing the sequence in the flowchart with the code can reveal errors. Highlighted sections in the code that do not match the flowchart indicate where the sequence is incorrect. Rearranging these sections can fix the program.

When debugging, other potential errors to check include:

• Ensuring the program starts with from microbit import*
• Checking for matching brackets
• Verifying colons at the end of if statement lines
• Using proper capitalization, such as in display images (e.g., HAPPY)
• Ensuring strings have quotation marks around them
• Correctly spelling code words

If errors are present, the micro:bit will display a sad face and indicate the line of the error by scrolling it across the display.

Sequences and lights

The micro:bit can control 25 individual LED lights, allowing you to create specific light patterns. To turn on a single LED, such as the center LED, follow these steps:

1. Open the MicroPython online platform in your web browser.
2. Enter the appropriate program code in the correct MicroPython format.
3. Connect the micro:bit to your device using a USB cable.
4. Flash the program to the micro:bit to test the LED.

To turn on a different LED, like the top-left one, you would need to adjust the program code accordingly.

Creating a Pattern of Lights

You can create a specific pattern using the LED grid. Here's how:

1. Break down the pattern into on (9) and off (0) LED lights.
2. Use the grid to guide where to place 0s and 9s in the program code.
3. Check the pattern on the micro:bit to ensure it matches your grid.

For example, a pattern can be created by adding numbers to represent the LED states (9 for on, 0 for off). Adding colors to a grid can help visualize the pattern:

1. Open the MicroPython online platform in your web browser.
2. Type in the program code in the correct format.
3. Connect the micro:bit to your device using a USB cable.
4. Flash the program to the micro:bit to test the LED pattern.

Ensure the brackets are correctly opened and closed in the code related to the LED lights. Flash the program to check that the rows of LEDs turn on as expected.

Creating a Moving Sequence of Lights 

Summary of Creating a Moving Image on Micro:bit

In the previous theme, you learned to display a single image on the micro:bit's LED display using 9 to turn on LEDs and 0 to turn them off.

Creating a Moving Image

A moving image is created by combining multiple image outputs in a sequence. For example, to display LEDs on the left-hand side followed by LEDs on the right-hand side, you need to create two image outputs in the program:

1. Plan the sequence using a flowchart to identify the pattern for placing 9s and 0s.
2. Create a grid for each image output to map the LED pattern.
3. Write the program code for each grid:
4. 
   
   • First, code the LEDs for Image 1 using the grid to identify the correct LEDs to turn on with a 9.
   • Repeat the code for Image 1, then edit it for Image 2, adjusting the LEDs that turn on after the sleep command.
5. Connect the micro:bit to your device using a USB cable.
6. Flash the program to the micro:bit to test the moving image.

Extending a Light Sequence 

After programming two individual images of LED lights, you can extend this to create a sequence of multiple images.

Adding Images to a Sequence

1. Plan the program sequence using a flowchart. Identify the pattern of 9s and 0s.
2. Create a grid for each image output based on the flowchart. For example:

                   Image 2:                1 0 1 0 1                0 1 0 1 0                1 0 1 0 1            

3. Write the program code for each grid and edit it to include the new image:
   • Edit the program code to display the new image in sequence between the existing images.
   • Copy and paste the existing code for Image 1 and insert it before the code for Image 3, then edit the pasted code for Image 2.
4. Connect the micro:bit to your device using a USB cable.
5. Flash the program to the micro:bit to test the sequence. The lights will now appear to move from one side to the other.

Light Brightness 

The micro:bit can control the brightness of individual LED lights using numbers 0-9. Zero means the LED is off, nine means it is fully on, and the numbers in between represent different levels of brightness.

Programming Light Brightness

1. Plan the pattern using a grid, assigning numbers 1-9 to indicate the desired brightness of each LED.
2. Plan the program sequence using a flowchart to visualize the pattern and brightness levels.
3. Create a grid for each image, assigning numbers to represent the brightness levels. For example, use 4 for half brightness:

4.         4 4 4 4 4        4 0 0 0 4        4 0 9 0 4        4 0 0 0 4        4 4 4 4 4        

5. Write the program code for each grid, including a sleep command to delay the display of each image.
6. Repeat and edit the code to display each image in sequence, with appropriate delays for each step.
7. Connect the micro:bit to your device using a USB cable and flash the program to test it.