mBot2 Basics

Code block:

This code block allows you to move the mBot2 forward, backward, left and right at a specific rotational speed of the wheels and for a number of seconds.

The example below shows how you can make the mBot2 move for two seconds at a speed of 50 rotations per minute. This is useful, for example, when the mBot2 needs to push a load forward.

Code block:

This code block allows you to make your robot stop moving. This can be a useful block during a testing phase. If a program does not work as expected you can use this block to make the robot stop immediately.

For example, you can make the robot stop when the A button of the CyberPi is pressed. To do this, use the programming example below.

Code block:

With this code block you can make the mBot2 rotate by a number of degrees, and you can choose whether the rotation should be to the left or to the right.

When the programming example below is set, the mBot2 can be controlled by using the arrow keys. When pressing the right arrow, the mBot2 will turn 90 degrees to the right, when pressing the left arrow, it will turn 90 degrees to the left.

Code block:

With this code block you can make the mBot2 move forward or backward a certain distance.

When you use the programming example below, the mBot2 will move 100 cm forward. To start this, move the joystick of the CyberPi upwards.

Code block:

You can also control the motors of the mBot2 independently, and this is one of the blocks which you can use for that.

In the example below, the mBot2 will move in a curve for 3 seconds before it stops. Notice that the value for one of the motors is negative; this is because the motors are mounted in opposite directions, so in order to move the robot in one direction, you need to make one of the motors rotate the opposite way. What would happen if both wheels rotate at 40 RPM?

Code block:

Because the motors of mBot2 can measure their speed and rotation, you can also read these values. The speed measured is the rotational speed in Rounds per Minute (360° = 1 round; in science, it is more common to use “degree per second” (1 RPM = 6° per second)). In mBlock 5, if you tick the box next to this block, you can read the values on the stage above the panda. The programming example below changes the values of the rotation back to zero, and then orders the mBot2 to move forward for one second. What value do you read on the stage after the robot moved?

Option 1

Option 2

1

2

3

Step 1: What do you want to do?

• What route do you want the mBot2 to drive?
• What parts does the maze consist of?
• How long are the distances the robot needs to travel?
• Does the robot also need to make turns? Which way and by how many degrees?

Step 2: What do you need?

• What do you need in addition to the mBot2?

Step 3: What code blocks do you need to make the mBot2 drive?

• How are you going to make the mBot2 drive?
• What code blocks will you use?
• Make a brief description on how your program works (pseudocode/natural language, flowchart or UML)
• If you need further explanation, you can discuss with your fellow students, the teacher, or do a research on the topic. There is help available for every code block in mBlock as well.

Step 4: Testing and implementation

• Is the first version ready? Test it! During the testing round, write down areas of improvement.
• Work on the improvement points until your mBot2 drives through your maze without errors.

Step 1: Warming up

This step consists of two parts:

• Sensors and data in everyday life
• What is the CyberPi?

1. Sensors and data in everyday life

Sensors that collect data are found in many different places in everyday life. Much more than you probably think at first. For example, with the help of sensors the exterior lighting of your house is turned on automatically when it gets dark outside. Or the heating is automatically turned off when it gets too hot in the classroom. The amount of outdoor light and the heat in the classroom is all recorded using sensors. Can you and your classmates think of any other examples?

2. What is the CyberPi?

To get the mBot2 to work, you need to write a computer program. You do that in the code editor mBlock. The computer program you write consists of a series of commands that the mBot2 has to execute.

Mounted on the mBot2 there is a CyberPi. A CyberPi is a small, programmable microcomputer. You give the CyberPi commands using the code blocks in mBlock. The CyberPi passes these commands back to the mBot2. You can remove the CyberPi from the mBot2.

The CyberPi has many different functions, such as a microphone, a speaker and a joystick. There are also many sensors on the CyberPi. Take a look at the image below.

Step 2: Hands-on

This step consists of four parts:

• Getting acquainted with the sensors of the mBot2.
• Extend and test some programming examples of the sensors.
• Display the data from the sensors.
• Difference between live mode and download mode.

1. Getting to know the mBot2 sensors

Every robot works with sensors. Sensors can be compared with your senses (=taste, touch, smell, hearing, sight). Through these sensors the mBot2 'sees' its environment. There are different types of sensors that can make the mBot2 'see', such as:

• Light sensor
• Sound sensor
• Gyroscope accelerometer
• Quad RGB sensor
• Timer

Below lists the sensors of the mBot2. Each sensor is accompanied by a brief explanation and programming example.

2. Testing and extending programming examples for the sensors

In the table above, there is a programming example for each sensor. You are going to recreate these programming examples in mBlock and test them. Think of an extension for two of the programming examples. The table above already mentions an extension suggestion for every programming example. Maybe you know a much nicer extension!

While writing a computer program, you can immediately test what you are creating. You do this by using live mode. You select live mode by moving the Mode switch to the right. Take a look at the image below.

3. Displaying the data from the sensors

In testing the programming examples, you have seen that each sensor shows something on the CyberPi's display. For example, the light sensor records the light intensity of the environment. The timer registers the time, and the gyro sensor keeps track of which way the mBot2 tilts. Everything that a sensor registers is called data.

You can show the data from a sensor on the display of the mBot2. In the programming examples you have seen that you can display the data with, for instance, a number or a text.

You can display the data from the sensors in different ways on the display of the mBot2. You can use different code blocks for this. These code blocks can be found in mBlock under the category 'Display'.

In the diagram below you see three examples of how to show data on the CyberPi's display. Reproduce the programming examples and test in live mode. See what happens on the display of the mBot2.

4. Live mode and upload mode

You need to transfer the computer program you build in mBlock to the CyberPi.

The CyberPi puts the mBot2 to work according to the commands you wrote in mBlock. While writing a computer program, you can directly test what you are making. You do that by using live mode. You select live mode by moving the Mode switch to the right. You must not disconnect the CyberPi from the computer while testing in live mode!

The CyberPi also has an upload mode. In upload mode, the computer program is transferred to the CyberPi. The program is stored on the CyberPi until you replace it with another program. You can simply unplug the CyberPi.

In the diagram below you can see the differences between live mode and upload mode.

Step 3: Trying it out

You have already learned a lot about the sensors of the mBot2 and how to show the data from the sensors on the display of the CyberPi. You are now going to collect data yourself using the sensors of the mBot2 and show it on the CyberPi's display. You will do this while driving the mBot2 around the classroom or school. What data you collect and how you show it on the CyberPi's display is up to you.

Use the knowledge you gained in 'Step 2' of this lesson. Of course, you can do plenty of experimenting yourself with the different programming possibilities in mBlock.

When thinking about this assignment, it is helpful to use the following step-by-step plan. Do you have an idea of what you want to make? If so, first discuss with your teacher whether this is feasible.

Step 4: Wrap-up

What data did your mBot2 collect? Did it go well? Did you get to see all the data on the display of the CyberPi?

In this lesson, you learned about the different sensors on the mBot2 and where you might encounter them in everyday life. You know how to program these sensors and how to show the data on the display. You also learned about the difference between the upload and live modes of mBlock.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think worked out well?
• What could be better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Code block:

When recording and playing back a sound, you actually always use three code blocks. With the code block 'Start recording' you let CyberPi start recording a sound. The electrical signal from the microphone is stored in the memory of the CyberPi, and the recording automatically stops after 10 seconds. You can also indicate when the recording should stop. This is done with the code block 'Stop recording'. The recorded sound is temporarily stored in the memory of the CyberPi. Do you switch off the mBot2? Then the recorded sound is lost. Playback of the recorded sound is controlled by the 'Play recording' code block.

In the programming example below, when you press button A, CyberPi starts recording. After 3 seconds the recording stops. When you press button B, you hear what was recorded. By using two event blocks, two programming tasks can run independently from each other without the need for a main loop.

Code block:

You just learned how to playback a recorded sound. With this code block you make sure that the sound recorded by the microphone is played all the way through.  This means that the execution of further blocks is blocked until this one is finished. After the sound is finished you can make the mBot2 do something else. For example, make a certain sound so you know the recording is finished.

In the programming example to the right, the CyberPi starts recording when you press button A. If you press button B, the recording stops. If you move the joystick down, you will hear what the mBot2 recorded. After the entire recording ends, you will hear a "prompt" sound. The code blocks in this example are placed in a so-called loop structure. This ensures that the input from the buttons and joystick are continuously monitored.

Example 1:

The mBot2 makes a sound when it approaches an obstacle and turns around. You recorded the sound yourself earlier.

Example 2:

The mBot2 drives around and plays a sound you recorded when the ambient light is low. When the mBot2 comes near an obstacle, it lets out a warning sound and turns around.

Step 1: What do you want to do?

• When should the mBot2 turn around?
• What sound should the mBot2 make when it gets near an obstacle?

Step 2: What do you need?

• What do you need in addition to the mBot2?

Step 3: What code blocks do you need to make the mBot2 drive?

• How are you going to make the mBot2 drive?
• What code blocks will you use?
• Make a brief description on how your program works (pseudocode/natural language, flowchart or UML)
• If you need further explanation, you can discuss with your fellow students, the teacher, or do a research on the topic. There is help available for every coding block in mBlock as well.

Step 4: In what way do you want to show the data from the sensors on the display?

• What sound should the mBot2 make?
• What code blocks will you use?
• Make a brief description on how your program works (pseudocode/natural language, flowchart or UML)
• If you need further explanation, you can discuss with your fellow students, the teacher, or do a research on the topic. There is help available for every coding block in mBlock as well.

Step 5: Testing and implementation

• Is the first version ready? Test it! During the testing round, write down areas of improvement.
• Work on the improvement points until your mBot2 does exactly what you had in mind.
• Successful? Film the end result and ask your teacher if you can post it on social media with the hashtag #mBot2

Step 1: Warming up

This step consists of two parts:

• Ultrasonic sensors in everyday life
• How does the ultrasonic sensor work?

1. Ultrasonic sensors in everyday life

Ultrasound is sound with a very high frequency. So high, that people cannot hear it. With special microphones this sound can be recorded and displayed on a computer: it seems like vibrations in the form of a wave. Since ultrasound has a very high frequency, the waveform shows valleys and peaks very close together. Ultrasound can be a useful thing. For example, you can use the vibrations of the ultrasound to clean objects, or you can also use it to detect objects.

Figure 2. Example of bat and dolphin

2. How does the ultrasonic sensor work?

The mBot2 has an ultrasonic transmitter and a receiver. These are located on the front of the mBot2 in the little cylinders that can be considered as “eyes”. This sensor sends out short bursts of ultrasonic sounds and listens for any echo. Does the mBot2 come close to an obstacle? Then the ultrasonic sound is reflected back to the mBot2. Based on the time it takes for the sound to return to the sensor, the mBot2 internally calculates the distance to it.

This data can be used to decide how the robot should react: you tell it to the robot by programming it. Such an action could be, for example, that the mBot2 should stop driving or make a turn.

Step 2: Hands-on

This step consists of two parts:

• Getting acquainted with the different code blocks of the ultrasonic sensor
• Recreating and testing some programming examples of the ultrasonic sensor.

1. Getting acquainted with the different code blocks of the ultrasonic sensor

In mBlock, there are several code blocks for the ultrasonic sensor you can use in your programs. For this, you need to add the extension 'Ultrasonic Sensor 2' from the extension library. Then you will find the code blocks in the 'Ultrasonic Sensor' category of the blocks field in mBlock. These code blocks are green.

In the table below, you can see some examples of the code blocks to program the ultrasonic sensor.

2. Recreating and testing some programming examples of the ultrasonic sensor

In the table above, each code block of the ultrasonic sensor has a programming example. You are going to recreate these programming examples in mBlock and test them. For one programming example, come up with your own ideas on how to extend the application.

Step 3: Trying it out

You have already learned a lot about the ultrasonic sensor on the mBot2. You are now going to create your own computer program in mBlock using the ultrasonic sensor.

In this assignment you are going to make the mBot2 drive in infinite 'rounds'. You do this by placing an object at each vertex. You program the mBot2 in such a way that it makes a turn at each object and eventually returns to the starting point. Take a look at the image below.

Use the knowledge you gained in 'Step 2' of this lesson. Of course, you can also experiment with the different programming possibilities in mBlock.

In working out this assignment, it is helpful to use the following step-by-step plan. Do you have an idea of what you want to make? If so, first discuss with your teacher whether this is feasible.

Step 4: Wrap-up

Did you manage to get the mBot2 to drive one round?

In this lesson, you learned about ultrasonic sensors and where you might encounter them in everyday life. You know how to program the ultrasonic sensor of the mBot2, for example, to prevent the mBot2 from driving into obstacles. You also know how to use the LED lights in the Ultrasonic sensor to make the mBot2 show a certain emotion.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think turned out well?
• What could be better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Step 1: Warming up

This step consists of two parts:

• Color sensors in everyday life
• How do color sensors work? What is specific about the mBot2’s color sensor?

1. Color sensors in everyday life

Color sensors can detect light intensity and colors. You will encounter this type of sensor in many different places in everyday life.

For example, a warehouse robot can find the correct route through a warehouse based on different colors on the floor. This kind of sensor is also used if precise color-matching is required, e.g., in vehicle coloring. A measuring device with a color sensor, the color meter, can check if the right color is used in spray-painting a vehicle. Can you and the classmates from your group think of any other examples?

2. How do color sensors work? What is specific about the mBot2’s color sensor?

A color sensor consists of three different (internal) sensors that measure the light reflected by an object based on the intensity of the Red, Green and Blue color values. Color sensors are therefore called “RGB-sensors” as well. Any color is decoded into three values by the sensor – so a specific “mix” of these values represents a color.

The mBot2 has four of these RGB-sensors integrated into a single sensor. Take a look at the image below.

This is the Quad RGB sensor that is on the mBot2. The RGB-sensors are named L1, L2, R1, and R2 (L for left side, R for right side). They automatically detect the RGB values of the reflected color and compare the mix of values internally with different pre-sets for colors. This will make coding much easier, because the sensor can then report the color and you don’t have to check the RGB-codes yourself. The sensor can detect 6 different colors plus black and white. Instead of color it can report on shades of grey or lines and junctions.

The Quad-RGB-sensors allows the mBot2 to follow a line on the floor and react to different color markers. The Quad RGB sensor is placed on the front of the mBot2. At the bottom face you will see the four sensors. At the top you can find the names of each one, so you can identify and program the sensors in a specific way. Take a look at the images below.

The little button on the top side of the sensor is used for calibration. If you double-click it, the LEDs will start flashing and you can “swipe” the mBot2 with the sensor across the line to be followed. This will calibrate the sensor to differentiate the line from the background. If you are using a black line on a white surface, this is normally not needed.

The map provided with the mBot2 has colors marked inside the track itself to react to the color codes. This might cause the sensor to misunderstand a bright color (like yellow) for the background instead of the track. So as a first exercise, please calibrate the sensor to the yellow color code, it will then automatically recognize reliably this and all “darker” colors as the line.

When you program the mBot2, you will use one or more of these four sensors to check for certain colors on the floor along the way. You can have the mBot2 perform a command when a color is spotted. For example, 'stop' when red and “go left” when green.

Step 2: Hands-on

This step consists of three parts:

• Getting acquainted with the different code blocks of the Quad RGB sensor
• Reproducing and testing some programming examples of the Quad RGB sensor
• How can the mBot2 follow a line?

1. Getting acquainted with the different code blocks of the Quad RGB sensor

In mBlock, there are several code blocks that you can use to program the Quad RGB sensor. You can find these code blocks in the 'Quad RGB' category of the block field in mBlock. These code blocks are green.

In the table below, you can see some of the code blocks you can use in your program with the Quad RGB sensor. The first four code blocks are for (simple) line-identification. They can be used for simple and advanced line following, but also for detecting crossings and sharp (90°) turns. The calibration of the sensor to different color tracks is briefly mentioned in the section above. The blue LEDs on the top side of the sensor indicate the line/background detection: if they are off, they sense dark color (line), if they are shining blue, they indicate bright (background) color. The status of the LED therefore indicates the reflectivity of the floor or map.

2. Reproducing and testing some programming examples of the Quad RGB sensor

In the diagram above, each code block of the Quad RGB sensor has a programming example. You are going to recreate these programming examples in mBlock and test them. For one programming example, come up with your own modification to the code.

3. How can the mBot2 follow a line?

The basis of the assignment in 'Step 3' of this lesson is that the mBot2 is going to follow the track on a map, being a touring coach. For this purpose, you will need to use the code examples explained and tested so far and modify them accordingly.

First use this coding block:

If the robot is on the track (both L1 and R1 detect a line, code value3), the robot should drive straight. If only one of the two inner sensors identifies a line, then it should turn left or right accordingly.

Use these driving blocks (only turning right is shown):

They just start the motors as needed, and the next code block will be executed immediately. Since you don’t know how far the robot is off or when a next curve will occur, the driving commands cannot contain any driving time or distance (same for turning). The next iteration of a program loop will check the new sensor data and select the driving accordingly.

If you are using the provided map, make sure to calibrate the sensor as described to the brightest color (yellow section on the track).

Step 3: Trying it out

You have already learned a lot about the Quad RGB sensor on the mBot2. You are now going to create your own computer program in mBlock using the Quad RGB sensor.

In this assignment you will turn the mBot2 into a touring car. The tour coach takes a tour of landmarks in a city. In the box of the mBot2 there is a map with a track. The coach follows the black line on the map. In the previous part you should have already programmed a simple line following robot, now it is time to add more enhancements.

To make the program easier to understand, you can “build” your own coding blocks. The entire line-following part of the program can be added up to one simple command, e.g., “simple_line”. The red/pink “My Blocks” in the code menu allows to define a custom block and structure your code in a nice way. The example program below makes use of custom blocks.

In addition to following the track, the coach performs an action at some of the sights. The sights are indicated by a colored area (red, yellow, green, and blue).

You can think up the actions that the coach should perform. Are you going to have the coach drive around Paris? Then it might be fun to play the French national anthem. Or the bells of Big Ben if the coach is driving through London.

Of course, you can also keep it a little simpler. In the example below, you have the coach turn around at the red marker and do different activities at other colored markers.

Use the knowledge you gained in 'Step 2' of this lesson. Of course, you can do plenty of experimenting yourself with the different programming possibilities in mBlock. Do you get stuck? Then you can use the programming examples below. You can copy it and adapt it to your own wishes and preferences.

This program starts if you press B and it stops with pressing A. It performs a simple line following using custom “My Blocks”-code and then checks if the R1 sensor detects either blue (drive very slowly) red (turn around), or green (look to each side). To make sure the color does not get recognized again after the activities were done, the robot drives 4cm forward each time.

The “simple_line” block is defined as follows:

Advanced version:

In the previous step, the deviation from the line was introduced. This block reports how far the robot is off track (-100 to +100; 0 for perfect in center) and it can be used to calculate the steering of the robot. This is a proportional line following – the more the robot is off track, the more it needs to steer against this. If the robot is right off track, the deviation is positive (robots needs to drive to the left); for negative values, the robot is left to the track (needs driving right).

For implementing this, you need a basic speed – that is the speed for moving forward on a straight track. For steering left or right, one of the wheels needs to turn faster than the other – the greater the difference, the greater the steering.

To calculate the steering, we need to add the deviation to one motor’s basic speed and subtract it from the other. To allow for a finder adjustment, a factor will be used to adjust how strong the deviation affects the steering, since the range for deviation itself is too big to be used directly for controlling the motors.

But to which motor must the calculated value be added or subtracted? A positive deviation means the robot is off track on the right side and must turn left. This means that the right wheel must run faster – we add the scaled deviation to the right wheel and subtract it from the left therefore.

When setting up the “My Blocks”, you can add inputs and rename them to a meaningful name:

The only thing left to take care of, is that the movement block (shown below) requires negative values for the right motor and positive for the left one to drive forward (this is because they are mounted facing each other).

To finalize the calculation, the values for the right motor need to be multiplied by -1. This is the definition of the proportional line following block:

In the main loop of a program, you simply use this block with one command:

This calls the sub-program with a basic speed of 50 and a steering factor of 0.6 and sends the current deviation from the sensor reading as well. You can experiment with the values a bit – if the robot “oscillates” (rapidly switching from left to right turning etc.) the steering factor is too high; if it goes off track even on weak curves, it is too low.

When working on this assignment, it is helpful to use the following step-by-step plan. Do you have an idea of what you want to make? If so, first discuss with your teacher whether this is feasible.

Step 4: Wrap-up

Did you manage to program the mBot2 as a touring car around the track?

In this lesson, you learned about the Quad RGB sensor and where you might encounter it in everyday life. You know how to program the mBot2's Quad RGB sensor to make the robot follow a line. You also learned how to program the mBot2 to drive a route based on different colors.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think turned out well?
• What could be better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Step 1: Warming up

This step consists of two parts:

• Gyroscopes and accelerometers in everyday life
• Which tilt movements can the mBot2 detect?

1. Gyroscopes and accelerometers in everyday life

How do devices like smartphones identify their position (hold upright, display facing up/down)? How to determine if a crash is severe enough to ignite airbags? Estimating the current position without an external precise reference has been a challenge at sea with cloudy skies for centuries – and it is still a very important task for household items, robots and even space probes.

They all use at least two different sensors, gyroscopes, and accelerometers. A gyroscope works with a crystal that is under electric tension. This converts the direction of the force of the tipping motion into an electrical signal. Gyroscopes measure the rotational speed in degrees per second and with the help of math, they can estimate the rotated angle as well – but the latter is not that accurate: gyroscopes “drift” over time. Accelerometers report the change of position (like in- or decrease of speed) – and regarding the earth’s gravity, they report the gravitational acceleration (as compared to free fall). Both types of sensors can measure on each spatial axis, reporting either rotational speed or acceleration on X-, Y- and Z-axis.

Combining data from both gyroscope and accelerometer, the direction and strength of movements can be calculated (in reality this is not super precise, so it is more a very good estimation). In Robotics these sensors are used to stabilize vehicles in uneven ground (or in flight) and help them maintain their programmed path. For the mBot2, these sensors are integrated into a small chip on the CyberPi.

Therefore, we will address the combined sensor as “motion sensor”.

2. Which tilt movements can the mBot2 detect?

Before you learn to program in mBlock5 with the motion sensor, it is useful to know which tilt motions the mBot2 can measure. You can show the measurements of the tilting movements on the CyberPi display. In lesson 2 you have already learned about how to do this.

The mBot2 can detect the following tilt movements:

Step 2: Hands-on

This step consists of two parts:

• Getting acquainted with the different programming blocks of the motion sensor
• Recreating and testing some programming examples of the motion sensor

1. Getting acquainted with the different programming blocks of the motion sensor

In mBlock there are several code blocks for the motion sensor you can use in your own programs. These code blocks can be found in the 'Motion Sensing' category of the block field in mBlock. These code blocks are orange.

The table below gives a detailed explanation on the code blocks together with some sample program code to test it.

2. Recreating and testing some programming examples of the motion sensor

In the table above each code block of the motion sensor has a programming example. You are going to recreate these programming examples in mBlock and test them.

The motion sensor on the CyberPi registers the tilting movements of the mBot2. When testing the above programming examples; therefore, you actually only need the CyberPi. If it is more convenient, remove the CyberPi from the mBot2 and make the tilting movements with the CyberPi yourself during testing. You can test the programming examples in live mode. Since the battery is in the mBot2 shield, you will need to connect the CyberPi to the computer via the USB-C cable to run the programs.

Step 3: Trying out

You have already learned a lot about the motion sensor on the mBot2. You are now going to create your own computer program in mBlock using this sensor.

In this assignment you are going to create a bumpy track for the mBot2. You can make this track from, for example, (small) stones or plasticine on cardboard. The idea is for the mBot2 to drive over the course. If the mBot2 is shaken (hard), it must drive slower. You can also put an object on the mBot2 that must not fall while driving.

Tricky task, isn't it? Fortunately, you don't have to invent everything yourself! Below you can see a programming example that you can extend. In this programming example, the mBot2 will slow down if it makes too large tipping movements.

Use the knowledge you gained in 'Step 2' of this lesson. Of course, you can do plenty of experimenting yourself with the different programming possibilities in mBlock.

When thinking about this assignment, it is helpful to use the following step-by-step plan.

Step 4: Wrap up

How did this task go? Did the object stay neatly on the mBot2 while driving?

In this lesson, you learned about sensors for measuring movement around axes and acceleration, the gyroscope and the accelerometer. They are integrated into a single little component placed on the CyberPi. These combined sensors are used to determine the position of a robot in 3D-space. They are called inertial measurement units, IMU. You have learned where to encounter them in everyday life. You know what tilt-movements and movement-changes the mBot2 can measure and how you can use different code blocks to take advantage of these measurements in your programs with mBot2.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think turned out well?
• What could be even better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Step 1: Warming up

This step consists of two parts:

• A LAN connection in everyday life
• How to set up a LAN connection with mBot2 and CyberPi

1. A LAN connection in everyday life

LAN stands for Local Area Network, and it describes a network of computers and peripherals with a certain spatial extent, usually within a building. The network enables the computers to exchange data with each other inside this network, and (not mandatory) with other networks like the internet. Therefore, they need some kind of connection (wired by cable or by wirelessly/WIFI by radio waves) and a common “language” (called protocol). Normally, the individual computers connect to a managing device that switches and routes the traffic of data (“router”). On a WIFI network this is a dedicated access point or the Internet router offers a built-in n access point.

Can you think of some examples where a LAN network is used? In this lesson, the mBot2 and the CyberPi are the different devices that communicate with each other over a LAN connection.

2. How do you set up a LAN connection with mBot2 and CyberPi

To set up a LAN connection between mBot2 and CyberPi you don't need much. The mBot2 and the CyberPi (or mBot2 among themselves) will automatically be able to communicate with each other wirelessly, there is no need to connect to a Wi-Fi Access point or router for this.

Is a router used? Then all the mBot2 and CyberPi must be put on the same channel of the router. This needs to be set in the router’s settings.

Step 2: Hands-on

This step consists of two parts:

• Getting acquainted with the different code blocks for the LAN communication
• Reproduce and test programming some examples of the LAN communication

1. Getting acquainted with the different code blocks for the LAN communication

In mBlock, there are several code blocks that you can use to set up a LAN connection. You will find these code blocks in the 'LAN' category of the block field in mBlock. These code blocks are green.

Below shows an example of these code blocks to set up a LAN connection.

2. Reproducing and testing programming some examples of the LAN communication

In the table above, each code block of the LAN connection is accompanied by a programming example. You are going to recreate these programming examples in mBlock and test them. For one programming example, come up with your own extension.

Step 3: Trying it out

You have already learned a lot about the LAN connection of the mBot2. You are now going to create your own computer program in mBlock using the LAN communication.

In this assignment you are going to program a game by yourself. It is called 'Looking for ... the color blue'. In this game, a group of mBot2 searches for the color blue on the floor. If one of the mBot2 finds the color, it will inform the others via a LAN message and win the game.

Sounds quite complicated! Fortunately, you don't have to program everything yourself. Below you can see a programming example. The same program should be uploaded to all mBot2 so they all follow the same instructions.

To make the mBot2 drive randomly, you can use the following code block:

This code block is used to randomly select a value within a certain range. A particular instruction can be assigned to each value of the range. In this way, the mBot2 can choose in a non-linear way from a number of instructions. To make your program easier to understand, you can separate the blocks for this instruction and place them under a custom block, which you can then use in your main program:

You only have one mBot2? Then you can simulate the communication between two devices by including a sprite in the mBlock stage. The stage is the area on the upper left corner of the mBlock's screen.

You need to add a new extension to the code blocks for the sprite and the mBot2, called “Upload Mode Broadcast”. It allows you to send and receive messages between the sprite and the robot while the robot is in Upload mode, similar to the messages sent via LAN communication.

	Extension	Add
For the Sprite		Click on 'Sprites' Click on 'Extensions' Click on 'Sprite extensions' Find the extension labelled “Upload Mode Broadcast” and add it
For mBot2		Click on 'Devices' Click on 'Extensions' Click on 'Device extensions' Find the extension labelled “Upload Mode Broadcast” and add it (might not be on the first page of the Extensions library)

In this programming example, when mBot2 has found the color, it will send a message to the panda sprite in the stage of mBlock, and the panda will say that the mBot2 has found the color.

You can copy the above programming examples, but you can also come up with your own extension. It is then useful to use the following step-by-step plan. Do you have any idea of what you want to make? If so, first discuss with your teacher whether this is feasible.

Step 4: Wrap up

Did you succeed in programming the game?

In this lesson, you learned what a LAN connection is and where you might encounter it in everyday life. You know how to set up a LAN connection between different devices. You also learned how to create your own LAN network using the mBot2 and the CyberPi. In addition, you know how to add a random selection to a computer program.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think worked out well?
• What could be better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Step 1: Warming up

This step consists of two parts:

• Speech recognition in everyday life
• Getting to know speech recognition with the mBot2

1. Speech recognition in everyday life

Speech recognition is the technology that can identify words and sentences in the sound of the human voice and translates this back to text. This is a very computational task, since what all the algorithms can look at is a change of frequency over time. But even this differs from person to person – just think of low or high voice, speaking fast or in a dialect. Even the mood can change the “tone” which the same sentence sounds like. The research of decades in computer science and linguistics allows these complex tasks to be incorporated more and more in everyday life.

Some recognition systems require a form of “training”, where the user reads specific texts known to the detecting algorithm – adapting a computer model to the individual tone of voice. Other only identify very specific words – they are used in user dialog systems mostly. Some systems can recognize and translate texts regardless of the context.

The CyberPi and the mBot2 can use voice recognition without the need for complex coding. However, since the output is “just” text, the program must analyse it and process further.

Speech recognition is used in consumer electronics like TVs, smartphones or smart homes to give extra comfort for the user – asking for a connection, putting an appointment into the calendar, or having the room temperature and light changed just by telling.

Next to comfort only, speech recognition can be a great help for disabled people or provide extra safety, e.g., a driver in a car can approve a navigation change due to upcoming traffic jams just by voice, instead of interacting with knobs or a screen-based interface.

In this activity, you will make use of some of the features of voice recognition.

2. Get to know speech recognition with the mBot2

The mBot2 offers a speech recognition based on block coding – it is as simple as starting the recognition for a certain time (like 2, 3 or 5 seconds) using a single block and retrieving the recognized text as a string by another block. The coding blocks will be explained below.

This voice recognition can understand many different languages and is not restricted to a small set of predefined words. Therefore, it is a very computational task - it is so demanding, that the mBot2 or the CyberPi can’t handle it themselves… they need to call for support using the internet. That’s why first of all, an Internet connection must be established, and a user account is required as well. Setting up a user account generates a “key” to sign in into the services used (for data usage and privacy see below)

The speech recognition records the audio like you did this in the 3rd activity, and then sends this recording to a very powerful network of computers for processing. They take care of the translation back to text and send the text back to the CyberPi/mBot2. The network of computers is usually referred to as “the cloud”. It is not a specific computer anymore but rather a huge cluster of them shifting the computational tasks between them.

You can use the Internet for transmitting data between multiple CyberPi’s in different networks and locations as well (like in school and at home). This digital service is processed in the cloud as well.

Data usage and privacy note:

Speech recognition requires an internet connection for transferring the recorded audio and sending back the transcribed text. The recorded audio is processed on servers in Europe, the Microsoft Azure cloud, but it will not be stored permanently. For using the services, a “key” is required, that will automatically be generated by creating a user account on Makeblock.com and used internally by the coding blocks. There is no need to manually enter this key anywhere.

Apart from an Email and a self-chosen password, no further personal information (like names, pictures, gender…) is mandatory.

The internet connection requires a WIFI access via SSID (that is the name of the wireless network) and password – certificate-based logins are not supported. The SSID and password are stored with the program in plain text, so using a temporary hotspot might be a good idea. Ideally, you can use a smartphone with a flat-rate data plan.

Step 2: Hands-on:

• In this step you will get acquainted with the different code blocks of the AI and IoT functions. This step consists of three parts:
• Setting up a WIFI connection
• Programming and applying speech recognition
• Messaging and Communication in LAN and Cloud

1. Setting up a WIFI connection

Open mBlock and connect the CyberPi in the 'Devices' tab. Switch to upload mode. Once connected look for the AI (Artificial Intelligence) block category  in the code blocks and click on it. You will now see the available functions including speech recognition (if the blocks are greyed out, you forgot to switch to upload mode…).

To use speech recognition, you need to connect the CyberPi to the Internet. Below you will see the programming example that you will use in order to have the CyberPi connect to the Internet. As soon as the CyberPi is connected to the Internet you will see this on the display and the LEDs will turn green.

These examples use an event-based approach, so one thread in the program tries to enable the internet connection on start-up. The other threads start the recognition. But for now, it does not check if the Internet connection ban be established before continuing – nor does it give any indication to the user about what is happening except if it was successful. You might want to change this at a later stage when trying out own ideas…

Make sure that you put in the name (SSID) and password for the WIFI network correctly (the picture shows an example!). These are both case sensitive. Connect the mBot2 to your computer with a USB cable and switch on the upload mode. Recreate the programming code from above and try if the code works. A tip is to do this with a hotspot from your cell phone, as a school network often only allows known devices to connect (white-listed MAC addresses). Make sure that the data plan covers the internet usage! Now connect the CyberPi to your computer.

You have now connected the mBot2 to the Internet. You can now communicate with the mBot2 via the cloud. This is what you call Internet of Things (IoT).

If you are using a separate CyberPi to show the status (like the order sent to the kitchen or the delivery process), it must connect to the same WIFI network. This is to make sure that both devices (mBot2-Cyberpi and stand-alone CyberPi) are using the same channel in the WIFI network. The router/access point decides on the channels. This ensures that all devices are on the same channel for data exchange. You can also refer to LAN communication in lesson 7.

2. Programming and applying speech recognition

You are now going to program and test the speech recognition. You are going to supplement the programming code in which you let the mBot2 connect to the WIFI with a code for speech recognition.

In the programming example below, the mBot2 is programmed so that when you press button B, the mBot2 recognizes speech for 3 seconds. The result is shown on the CyberPi display and the recognition is spoken. Recreate the programming code below and test it out. Check what you said and what was “understood” and translated back.

Does it work? Then see what else you can do with speech recognition!

You can also use speech recognition to voice-control mBot2. You can assign certain instructions to certain speech recognition results, but be aware of how specific you are with the results. For example, you could build the instruction to only recognise “yes” when the button B is pressed. But what happens if you say “definitely yes” or “yes of course”? Then a direct matching with…

… would not work… the recognition result would be different (string “yes” is not equal to string “definitely yes”).  In order to allow a broader set of answers all meaning “yes”, you can simply check if the answer-string contains the word “yes”:

3. Messaging and Communicating in LAN and Cloud

You can also use the result of the speech recognition to interact with multiple mBot2 or CyberPi. In lesson 7 you have already learned about the LAN connection and how to set it up.

Next to sending a message on the LAN, which requires the devices to be “local” to each other, you can use another cloud service to send messages to devices on remote locations – as long as they have an Internet connection. These blocks are located in the IoT (Internet of Things) block category.

These blocks work identical to the ones handling the LAN communication:

To make sure the remote side can communicate only with the devices you intend to, you need to have a Makeblock user account. This will create a “key” for the cloud communication – this key is hidden within the coding blocks and unique to a user. To make 2 remote devices communicate over the Internet, both need to be programmed from the same user account.

The cloud broadcast blocks have the advantage of being able to communicate worldwide, but they are not useful for speedy communication – it might take a few seconds for the message to arrive. The LAN-broadcasts on the other hand are fast but work only locally.

Below you see a programming example that summarizes the above. Recreate the program first and try if everything is working with the recognition and communicating between the CyberPi and another mBot2. For this exercise, you need to upload the same program code in Upload-mode to both devices.

After you made sure everything works fine, you can modify and extend the example – maybe directional commands? Think of lesson1 and the exercise to navigate the mBot2 manually through a maze… can you do the same with voice-commands?

Step 3: Trying out

Now you know how to make a WIFI connection, program speech recognition and deploy Cloud or LAN messaging. It is now time to get started yourself. You are going to program a polite service robot – a robot waiter. There are already restaurants in some countries where a robot comes to take the order and brings the food from the kitchen. Take a look at the following video: https://www.youtube.com/watch?v=FFCPKmLAZb4

The robot waiter you are going to make must be able to do a number of things:

• Drive along a straight line
• Stop at a red area (your table), take an order and send the order to the kitchen
• Additional option: if a second mBot2 or CyberPi is available, then display the orders to the kitchen (so they can start preparing the food already)
• Continue driving until the mBot2 encounters a green surface (the kitchen) and stops to pick up the food from the kitchen
• Optional: if a second mBot2 or CyberPi is available, then give a notification that the food is being delivered

The start-up sequence is nearly identical to the previous examples – remember to put in the correct SSID and password:

The next code block is programmed in the same script field under the previous example. In this code block, you instruct the mBot2 to start driving and then stop at a red marker to take the order. After that, the mBot2 drives on to a green mark. The colour markers indicate the table and the kitchen. To start easier, we assume they are in a straight line. If you have everything working, you can extend this further and include the knowledge you gained from previous lessons and make the robot follow a line to the table (the provided map has red and green markers on the track that can be used for this purpose). Lesson 5 explains all about line following…

As an extra addition to voice recognition, staying with the straight line between table and kitchen, you can use cloud or LAN messaging to send the order to another mBot2 or CyberPi to display.

You have to create yourself the block 'get_order' in 'My blocks'. This helps keeping an overview of the main program – so it’s just driving to coloured markers with getting the order in between.

To actually define what “get_order” means, let’s first think about an order process:

1. Ask for the order
2. Recognize the answer
3. Check back that the understood order is correct
4. If yes, proceed (send order to kitchen and end the order sequence)
   If no, ask again.

Checking is a sensible thing to prevent wrong orders. To translate these steps in a structured way, you can use a flow diagram like the following one:

From here, it is much easier to create the necessary coding blocks: you start with the code block 'get order'. You create this code block again in 'My blocks'.

In addition, you need to create two variables. In one variable we will store the recognition result from the order, so if everything was understood correctly, this can be sent to the kitchen (attention: checking back with yes/no – the answer to this would override the previous recognition result in the report block; that’s why we need to store the recognized order in a variable).

The second variable keeps track of the entire process: is the order complete (meaning, understood correctly)? If not, the ordering process will start all over again. This second use of the variable reports on process data (stage).

You can use the knowledge from previous lessons to help with the program, e.g. light up LEDs to make the user understand that the robot is about to speak (green) or listen (red), or you can use the screen on the waiter-mBot2 to display data. Use this at checkpoints in your program, so evaluate if your code works and give feedback to the users.

As an extra addition, you can use cloud or LAN messaging to send data to another mBot2. For a better learning experience, there are examples on how to solve specific tasks in this lesson. You can refer to them in case you have problems with your own code or get ideas on how to deal with a specific situation. In general, it is better to get a draft working and refine the code in iterations rather than trying to have everything done and programmed perfectly at once. Start with the driving sequence and instead of having the ’get_order’ block ready, just make a beep there to show that everything is working so far. Then work on the order process but keep the driving out. This way you can iterate faster without the robot having to drive between the markers every time you want to try your code. as final stages, combine them to solve the given task.

In the programming examples above, you also sent a message to a second mBot2 as an additional option. For example, in the 'order process' you have said that once the customer confirms the order the mBot2 sends a message via cloud or LAN messaging to a second mBot2 or CyberPi (for displaying the incoming orders in the kitchen). Now you have to program the second mBot2 to receive the message.

In the programming example below, the kitchen receives the order and displays it. Create the programming example below in the same script. Place this next to the first programming example. This way you keep the script clear.

In the programming example 'controlling a robot' you have programmed that after detecting the green area a cloud message is sent to the customer to inform him that their order is coming. This is also programmed in the same script field next to the other blocks – you could use another CyberPi (as a smart device on the customer’s table) to inform about the order status:

When you have programmed everything, your script area will look like this:

You need to upload this code to all the mBot2s and/or CyberPi’s you want to use. It can be the same code because they are automatically connected via the LAN or Cloud connection – and the one sending the message won’t react upon it.

Create a straight line for the mBot2 to drive along and make sure there is a wide red and green marker. Upload the code and try whether the robot waiter is processing the customers' orders.

Of course, there is always room for improvement. Adjust the code where you think it could be better or prettier. Maybe you start with a line-follower that can take the orders? Or you extend this exercise further and have a dedicated waiter mBot2 taking the orders and a delivery mBot2 that will bring the food? You can cooperate with other teams in your class and integrate their robots…

Discuss possible extensions like these in the class when reviewing the progress so far and elaborate a use case with multiple robots – it doesn’t need to be a restaurant…

Step 4: Wrap up

Did you succeed in programming the waiter-bot?

In this lesson, you learned about speech recognition and speech synthesis and how to apply it via a cloud service. You managed to connect the mBot2 to the Internet and so send data locally or even remotely.
Creating a dialog (like for ordering a meal) was part of the exercise, and you learned to filter the text answer for specific trigger words to have a more ‘natural’ conversation (not expecting the user to answer with specific responses only).

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think worked out well?
• What could be better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?

Step 1: Warming up

This step consists of three parts:

• Machine Learning in everyday life
• Getting to know the Machine Learning extension in mBlock
• Applying Machine Learning

1. Machine Learning in everyday life

Machine Learning works on a statistical basis: training data is provided to the algorithm, like pictures of different objects plus their descriptions. The learning phase then tries to distinguish best between these pictures and match each picture to the correct category. After this phase, the learned patterns are tested against new sets, and the learning can be reinforced. The difference to “classical” sorting programs is that there is no clear indication beforehand on how to decide between the different categories, like you can differentiate between colors.

By “learning from past data” the computer program can better adjust to changing situations. Think about facial recognition on your phone: the first times after setting this up, it is harder for the phone to correctly identify you, but over time, the algorithm “learns” to identify your face in different environments as well. Machine Learning is broadly used in image classification (e.g., on social media) to automatically analyze what pictures uploaded show: a cat, a dog, furniture, people etc.

Machine Learning is considered as “weak Artificial Intelligence”, since the computer program is not aware of itself nor can “think” like we do – but its current behavior is influenced by data collected and analyzed.

2. Getting to know the Machine Learning extension in mBlock

In mBlock there is a Machine Learning tool. You need to add this tool from the extension library. Proceed as follows:

• Click on 'Sprites'.
• Click on 'extensions' (at the bottom in the middle of the screen).
• You will now enter the extension library. At the top of the screen, click 'Sprite Extensions'.
• Find the extension 'Teachable Machine' and add it.

• The extension will now be added to the code blocks. You can recognize the extension by the abbreviation TM in green.
• Make sure you have a working webcam.
• Click on the 'Training model' button.

The extension consists of a training model in which you can ‘teach’ to differentiate between sets of pictures taken with a webcam. The basic model you see consists of 3 categories. If you want more, click on “build a new model” and choose the number of categories.

Some advice:

• Think about the number of categories and the recognition beforehand. You cannot add a category later, you would need to start all over again.
• Choose 1 extra category to be used as “background”. So, if you want to recognize 2 different animals by pictures you hold in front of the webcam, choose 3 categories: The third one will be the one where there is no picture of an animal shown. Otherwise, you “force” the model to decide e.g., between cat and dog, even if the webcam shows the empty background.
• Background should generally be simple and static (not: classroom with pupils, webcam looking at the pupils etc.) with a clear contrast to the objects to be recognized.

The images will be analyzed just on the computer and the result can be stored. The pictures themselves will not be kept! So, if you save the program file in mBlock and reopen it later, you won’t see the original pictures the model was trained on. You can always add new pictures to existing categories, but not delete single ones (only all pictures and learnings from a category).

You can directly ‘teach’ the categories using images taken with the camera. You will use the standard 3 categories for this exercise:

• You can start with the mBot2. Place it on the desk and align the camera to get a good view – or hold it steady in your hand if you use a laptop with a built-in camera. Then click the 'Learn' button. Hold the button until the camera has recorded at least 20 samples. Above the mosaic of samples, you can see the number of samples stored for this category. Give this category a name, for example 'mBot2'.
• Now choose something else, e.g., a notebook, hold it in front of the camera and click on the 'Learn' button. Hold the button until the camera has recorded at least 20 samples. Give this category a different name, for example "notebook".
• Now record the “background”. This should be used whenever none of the other objects are presented to the camera. Click and hold the 'Learn' button until the camera has recorded at least 20 samples. Give this category a different name, for example "background".

You have now ‘trained’ the Machine Learning different objects (mBot2, notebook and background) that the algorithm will now recognize in the camera picture. For every category you can see a bar measuring a percentage. This represents the confidence that the algorithm has in the recognition result. You can increase the percentage of confidence by increasing the number of samples and doing some slight variations like changing the angle of the object. This will help the camera recognize the objects even better and faster.

You can test the recognition live without the need for any coding at this stage. Add pictures until the recognition is fast and accurate (not switching between results and showing a high percentage >90%). Are you satisfied? Then click on 'Use the model'. You will now return to the screen for coding on sprite level.

There are three new code blocks now. One block will report the recognition result (as you typed it), the second one is the confidence for a given category and the third one is the Boolean block for conditional statements. It lets you choose the category by a drop-down menu. If you click on one of the code blocks, a new window will appear. This is the recognition window, which displays the camera image and the recognition result. Now your webcam functions as a smart sensor, identifying different objects or pictures.

Step 2: Hands-on

This step consists of three parts:

• Applying Machine Learning
• Machine Learning in combination with the mBot2
• Establishing a LAN connection

1. Applying Machine Learning

You have ‘taught’ two different objects, the mBot2 and a notebook, plus the background to the Machine Learning model. Now you can use the output of the recognition like any other sensor blocks in your program code. You can use conditional statements to differentiate between the objects and assign a certain action separately to each result.

You are now going to try to make the sprite (in this case the panda) talk when the webcam recognizes a learned object.

On the right you see a programming example. Reproduce the programming example and see what the panda does when the webcam recognizes your learned objects.

Was it successful? Then investigate what other possibilities there are. Can you make the panda jump or walk?

2. Machine Learning in combination with the mBot2

Now you know how to make use of the Machine Learning extension for image recognition and control a sprite with it, for example the panda. You are now going to learn how to communicate from the computer to the mBot2 running its own program. For this the mBot2 needs to stay “connected” to the computer – this is done via USB cable or the Makeblock Bluetooth Dongle. The dongle allows the robot to move independently from the computer; if you use a USB-cable, make sure you only perform slight movements of the mBot2, like small turns and distances.

With this connection in place, the sprite (in this case the panda) can send data to the mBot2. The mBot2 receives this data and the program running on the robot can react to it.

You need to add a new extension to the code blocks for the sprite and the mBot2, called “Upload Mode Broadcast”.

In this way, the extension will be added both for the mBot2 and the sprite. In mBlock it appears in dark blue. Click on the new extension and see the different code blocks associated with it. Basically, the extension adds a communication protocol. It allows you to send and receive messages between the sprite and the robot while the robot is in Upload mode.

3. Establishing the connection with the mBot2

You have now installed all the necessary extensions for the hardware and software to be able to communicate with each other. Now you will program the mBot2 to be controlled by Machine Learning. The idea is that the mBot2 will perform actions based on recognition results. You programmed a similar task earlier just for the sprite (mBot2, notebook, and background).

Now, the recognition results must be sent and received over the connection between the Bot2 and the computer (either cable or wirelessly via Bluetooth Dongle). The receiving code uses events, so the corresponding code is executed, once the message is received. With events there is no need to check for a sensor or message in a loop, making the code more efficient and easier to understand.

You need to create two computer programs – one for the device (mBot2) and one for the Sprite that uses the Machine Learning add-on:

Sprite program

Sprite program

mBot2 program

After reprogramming the above code blocks, make sure your computer stays connected to the mBot2 if you use a cable (don’t disconnect the cable). Ideally, they would be connected via Bluetooth using the Makeblock Bluetooth Dongle, because this gives the mBot2 more flexibility in driving around.

The Makeblock Bluetooth Dongle will remember the last paired device and instantly reconnects.

In case you don’t have the Bluetooth dongle from Makeblock, you can verify the compatibility of the Bluetooth in your computer via the following link: https://www.yuque.com/makeblock-help-center-en/cyberpi/bluetooth-compatibility

Now switch mBlock to Upload Mode and connect the mBot2 to mBlock. Click the ‘Connect’ button and upload the computer program. You can now start testing!

Step 3: Trying out

You have all the knowledge and skills to use the mBot2 in any situation. Now you are going to work with the ecosystem of a little mouse. A mouse lives in nature where it must look for food and water. There are also many dangers, such as predators who feed on mice.

In this assignment, you will program the mBot2 to act as a little mouse that searches for food and flees from predators.

Find a picture of a flying eagle and some corn. The corn is the food of the little mouse. The eagle is the hunter. You can print these images or use your smartphone to display them to the webcam. You can also hand-draw pictures for food and predator if you like. Just use the same method you decided for ‘teaching’ them to your algorithm using the Machine Learning extension and for testing the program.

Program the mBot2 so that if you show the corn to the camera, the mBot2 will move forward (if you use the cable, make a small movement), but if you show the image of the eagle, it moves backwards.

You can also add more code: if the little mouse sees the food, it says "yummy" and when it sees the eagle, we can hear its heartbeat.

When creating the computer program for this assignment, it is helpful to use the following step-by-step plan.

Step 4: Wrap-up

Were you able to recreate the mouse ecosystem?

In this lesson, you learned about Machine Learning and how to apply it. You also know how to use a communication (and why preferably wireless) between a sprite and the mBot2, and to make use of it to exchange data between the two. In addition, you have made various technical features of the mBot2 work together.

It is now time for a brief reflection. Think on your own and discuss with the group:

• What do you think turned out well?
• What could be even better?
• Which parts of the lesson did you find easy and which did you find more difficult?
• What would you like more explanation about?
• Who could help you with that?