While Loop on mBot

In this lesson, you will learn how to use a loop to accelerate and decelerate. Loops are an important part of developing autonomous programs. The purpose of a robot is to perform a series of tasks. Most tasks are specific to a particular objective. Many tasks include repetitive operations. Robots can perform repetitive tasks all day long.

This lesson will cover a simple task. The robot will gradually accelerate to its top speed; it will then reduce speed to a full stop.

We will be using the remote to start and control the process.

The link to the finished code is available below.

https://planet.mblock.cc/project/502092

We are building the program with the basic building blocks that are particular to this task. The aim is to show you how programmers develop programs. Programmers build and test parts of the program as they go. The program evolves to become the completed product. Testing is important during the development process.

The online version of the mBlock coding environment is at https://ide.mblock.cc

Building the program

Open the mBlock application. Click inside the project name field and set the name to accelerate-decelerate. Click the Save button.

Go to the Devices section and click the Add button.

Select the mBot library; click the OK button.

We can set the mBot library to be loaded each time we create a new project. Click the Star icon. The mBot library will load each time a new project is created.

Delete other Device libraries. This prevents us from accidentally selecting code blocks that don’t work with the mBot.

We want the robot to move forward and accelerate. The process begins when the Up button on the remote is pressed.

Go to the Control functions section and place an **if…then** code block on the canvas.

Go to the Sensing section and get the **IR remote pressed** code. Place it into the **if…then** parameter.

Choose the **Up** option from the button selector.

We want the robot to slowly accelerate when the Up button is pressed. To perform the acceleration process we need to use a loop. We want the loop to repeat until it reaches the maximum velocity.

We don't know the robot's velocity. We only know the amount of energy applied to the robot motors. The energy is supplied by the batteries. The batteries supply current to the robot's controller and the motors.

The energy we supply to the robot's motors is like the gas pedal on a car. We supply fuel to the engine and the engine, in turn, uses the fuel to propel the car forward. A speedometer in the car lets us know how fast we are going.

The robot does not have a speedometer, so it's like driving a car without a speedometer. We don't know how fast the robot is traveling. We can take some measurements and perform a bit of math to know the robot's acceleration and velocity.

There are three loop options we could use. We are using the repeat **until loop**. We are using this loop because we want the robot to accelerate **until** it receives the maximum amount of energy available.

Go to the Control section. Place a **repeat until** loop within the **if…then** condition.

Go to the Action section. Place the **move forward at power** code block inside the loop.

We need a way to increase the power applied to the motors. The power applied to the motors is based on a percentage of the available battery power. The current value in the move forward code is constant. It doesn't change while the program is running. To update the percentage, we need a variable.

Go to the Variables section; click the **Make a Variable** button.

Use **Power** for the variable name. Select the option to use this variable for this sprite only. Click the OK button.

Grab the Power variable.

Place the variable into the Power parameter.

The variable accepts input from several sources. Attach the **set Power** code to the beginning; before the **if…then** code.

It is recommended to initialize variables before they are used. This block is not in the loop because it sets the initial value of the power before it is changed. The initial value is set to zero.

Place the Change Power code inside the loop and above the Move forward code. This code, increases, the value of the power applied to the motors. The value for the power ranges from 0 to 100 percent. The power can be increased by any increment we want. The increment determines the rate of acceleration. Small increments result in slow acceleration. Large increments result in a fast acceleration.

Let’s begin with an increment of 10 percent. Place 10 inside the parameter.

This will repeat until the robot reaches a maximum of 100 percent. The loop needs a condition. The condition informs the loop when it is time to stop looping.

Go to the Operators section. Look for the **Equal to** operator. This is an evaluation operator. It evaluates if something is equal to something else. This isn't like the equal sign in traditional math. This sign looks to see if two or more values are the same.

Place the evaluation operator inside the repeat parameter.

Go to the Variables section. Place the Power variable inside the left side of the evaluation.

Change the value from 50 to 100.

This is a good place to stop and test what we have done. The robot is going to be moving, so we need to make sure it stops at the end of the loop. Go to the Actions section; place the Stop moving code at the end of the if..then code.

Connect the robot to the computer and turn the robot On. Click the Connect button. Select the port for your robot and complete the connection.

Click the Upload button.

Go to the Events section. Attach the When mBot starts up code to the beginning.

Click the Upload button.

Disconnect the robot and place it on the ground. Please, don’t do this on a table or desk.

Press the Up arrow on the remote.

**Nothing is happening!**

Sorry, I set this up as our first bug in the code. I often make this mistake.

It also provides a teachable moment.

Code that is waiting for input from a user needs to be placed in a Loop. This forces the code to keep checking for input.

Connect the robot back to your computer. Detach the if…then code from the set power code.

Get the Forever loop from the Control section and attach it below the Set Power code.

Take the If…Then combined code blocks and place them within the Forever loop.

We can upload this code to the robot and the robot will receive the command from the remote. The robot will power up and move forward. You will see it move away at the fastest speed. It won’t perform a gradual acceleration. This introduces another bug.

The controller processes the instructions very fast. The processor on the controller is not as fast as the one on your typical computer. It is still fast. It processes information at 16 MHz. That is 16 Mega-Hertz or 16 million instructions per second!

The processor increases the speed so fast that it reaches 100 percent almost instantly. We need to slow things down.

Go to the Control section and place a Wait 1-second delay after the Move forward code. With the code, the robot will move forward at a certain Power for One Second. The Power will increase to the next level and the robot will move at that Power level for One Second. It will repeat this process until the power level reaches 100 percent.

The robot is set to accelerate until it reaches 100 percent of the available power. It will keep going unless we do something to slow it down or stop it. Give it a try. No bugs this time.

Not on the table or desk!

Let’s slow the robot and bring it back to a stop after accelerating. The next process is to decelerate the robot. The code to do this is almost identical to the code for acceleration.

Move your mouse pointer over the Repeat until code. Right-click on the code; select duplicate.

The duplicate code attaches itself to the mouse pointer. Move the pointer to the end of the **Repeat until** code. Wait for the code blocks to separate; release the code. The code must be right after the first repeat until code.

The second code will repeat the loop until the Power level is zero. Place the number 0 into the comparison operator for Power.

We need to decrease the power supplied to the robot through each cycle. Change the positive 10 increments with negative 10, -10.

That is all we need to do. The robot will accelerate up until it reaches 100 percent of the available power. It will then begin to decelerate until no more power is sent to the motors.

Some lights

I like to add some visuals to my robot code. It provides feedback, so I can see at what stage of the code the robot is operating.

Go to the Show section. Get the **LED all** code. Attach it to the first repeat until loop at the beginning.

Click the color selector and move the color slider; choose green. When the LEDs are green, I know the robot is in the acceleration loop.

Add an LED code block to the second repeat loop. Place it in the same position. Leave the color set to red. When the LEDs are red, I know the robot is in the deceleration loop.

Place one last LED code block outside the second repeat loop. Select the color picker; move the brightness slider to the left. This turns the LEDs off.

Upload the code to the robot. Place the robot on the floor and press the Up arrow on the remote.

The program is in a loop. Press the Up arrow when the robot stops to repeat the process.

Basic Navigation with mBot and the remote

The mBot robot from Makeblock is a good STEM tool. The robot is a motorized vehicle with basic motor controls and sensors. The controller has several sensors, LEDs, and a small speaker. There are plenty of things we can do with this robot. One fun option is to drive the robot around. The kit comes with a remote.

In this lesson, we are covering the fundamentals for controlling the mBot with the remote. We will cover the button options for driving the robot around.

Connect the mBot to your computer with a USB cable. Open the mBlock application or use the online version at https://ide.mblock.cc/#/. Click on the untitled name box.

Set the name to Drive with remote.

Click the Save button.

Login with your account information.

Go to the Devices section; click the Add button.

Select the mBot device library.

Return to the Devices section; remove any other device libraries. This avoids conflicts with other libraries that don’t work with the mBot.

Go to the Control functions section; place an if…then…else block onto the canvas. An if…then…else code block checks if something is true or false.

Go to the Sensing functions section; place the IR remote pressed block into the if…then parameter. This is the parameter used to check if it is True or False; if the button is pressed or not.

Use the button selector and choose the Up button.

Go to the Action functions section; place the move **forward at power** block into the Then space. If the button pressed is the Up button, True, then the robot will move forward at 50% power.

We need to provide instructions if another button is pressed. This requires another code block to evaluate the press of another button. Go to the Control functions. Place an **if…then…else** block inside the **Else** area of the other **if…then…else** block.

Place an **IR remote** block from the Sensing functions inside the if…then parameter.

Change the button pressed; select the down button.

Place a **Move forward at power** into the **If…then** section.

Click the Move forward selector and choose the move backward option.

Place and **if…then…else** code block into the else portion of the previous code block.

Place the IR remote code into the **if…then** parameter. Select the Left button option.

Place the **Move forward** code block into the **if…then** section of the code. Use the Turn left option for the motion.

Place an **if…then…else** code within the else portion of the previous code. Place an **IR remote** code in the if…then parameter and select Right for the button option. Place a **Move forward** code block into the if…then section of the code; choose right for the motion parameter.

We are done with all the basic motion options.

The Loop

The robot controller needs to keep checking for a button to be pressed on the remote. We need to place these condition statements inside a loop.

Go to the Control functions section; find the Forever loop code.

Move the Forever loop over the condition code blocks. Move it toward the beginning of the code. We want the code to wrap around all the condition code blocks. Look for a gray shadow of the Forever block to wrap itself around the condition code. Release the block when the shadow appears.

The Forever loop must be wrapped around all the condition code blocks.

We are done with the code. Make sure the robot is connected to the computer and turned On.

Click the Upload button.

Go to the Events functions. **When mBot starts up** block should be the only one available for selection.

Attach the **When mBot starts up** code to the beginning.

Click the Connect button.

Select the communication port for your robot and connect.

Click the Upload button.

Wait for the code to upload to the robot controller. Place the robot on the floor. Press the Up button to move forward. Press the Left or Right buttons. Press the Down button.

Go and play for a while. I'll be here when you are ready for the next part.

The robot moves in the direction the button is pressed until another button is pressed. This is fine but it may lead to some crashes. It also makes it difficult to place on a table when we need to update the code.

Turn the robot Off for now and connect it to your computer.

Go to the Action functions; add the Stop moving code to the Else portion of the last condition code block.

This code block will stop the robot from traveling endlessly. It will stop if none of the required buttons is pressed.

Hold the robot in one hand or have a partner hold the robot. You can also place the robot upside down if it has a protective case around the controller. Turn the robot On.

Click the Connect button. Select the communication port. Upload the updated code.

Place the robot back on the floor. Press and hold the Up button. Release the button and the robot will stop moving. Press and hold any of the direction buttons. The robot moves only while one of the required buttons is pressed.

This option makes it easier to navigate and control the robot’s movements.

Trigger mBot code with event inputs

Using the remote

In last week’s article, mBot Robot and Basic Motion, we used a simple code block to move our robot forward. This allowed us to use the robot to learn about motion, velocity, and acceleration. By adjusting the power applied to the motors we increased or decreased the velocity. The robot travels longer or shorter distances when we adjust the duration that power is applied to the motors.

I’m sure you adjusted the code and uploaded it several times. Each time you had to take care that the robot didn’t run off the desk or table. I’m sure this proved inconvenient on more than one occasion.

We are going to place a condition in our code so the robot doesn’t begin to move as soon as we upload our code. A condition is an event that must take place before segments of code are performed.

The robot comes with a remote. It doesn’t come with a battery though. You will need to insert one. I believe it is a CRC-2032 battery. This remote will serve as our event.

Open the mBlock software and create a new project. Title the project Remote Event. Load the mBot code library. Click the Add button in the devices panel.

Click on the mBot icon and click the Add button to load the libraries.

Go to the Control category. Find the Forever code block. This is a loop that will repeat the steps we place inside. It will repeat these steps until we turn the robot OFF.

Place the Forever block on the canvas.

Drag the “If…then” code block and place it within the Forever loop.

Go to the Actions category. Find the move forward code block. Place the block inside the “If…then” condition.

We need to set the condition to begin the Move code. Go to the Sensor category.

Look for the “IR remote A pressed?” code block.

Place the code block inside the condition parameter. The parameter will highlight when the piece is in the right position.

The remote code block has a parameter. This parameter waits for one of the buttons on the remote to be pressed. The “A” button is automatically selected. Click the triangle next to the letter to reveal more button options.

Select the “Up” button. I recommend each student uses a different button. This will prevent the robot from receiving a signal from a stray remote.

The code is complete. Upload the code to the robot. The robot will not move as soon as the program is uploaded. Disconnect the robot and place it on a flat surface. Press the Up button on the remote. The robot will move forward for 3 seconds. Press the Up button again and the robot will move forward again for 3 seconds.

The robot repeats the process because we placed the condition inside a forever loop. The condition does not need to be placed within the Forever loop. Placing the condition in the loop makes it convenient if we want to run the code blocks again and again. Without the Forever loop we would need to turn the robot OFF then On again to use the remote to trigger the event.

Use this code block for any future projects. Place all your code within the condition block.

Using the onboard button

You might not have a remote with the robot or a battery for the remote. There is a button on the robot we will use to trigger the event. The code for the onboard button is almost identical. Click and drag the IR remote code block out of the If…then parameter.

Drag the IR remote code over the Code panel. The panel will change to a light grey color. A trashcan will appear. Release the code block.

Look for the “When on-board button pressed” code block. It is in the Sensor category.

Place the code block in the parameter for the condition block. The code block has a parameter. The parameter is set to the button pressed. This is what we want.

The code is all set. Upload this to the robot. Press the button on the mBot. Using a button is a good option if you don’t want a remote from another robot to trigger the event on your robot.

Combine conditions

The IR remote and button can both be used. We will place both conditions in one code block. To use both conditions we need to use an operator. We are going to use a Boolean operator. There are three Boolean operators. They are AND, OR, and NOT. They are often used to connect and define relationships.

Remove the “When on-board button pressed” code and leave it on the canvas.

Go to the Operators category. Find the “or” operator.

Place the OR operator in the "If…Then" condition parameter. The OR operator has two parameters. The code for the button will be on one side. The code for the IR remote will be on the other. One condition or the other must be met for the move action to take place.

Place the “when on-board button pressed” code on the right side of the OR operator. It doesn’t make a difference on which side it is placed. The OR operator will work the same.

Find the IR remote code in the Sensor category. Place it on the left side of the OR operator. Choose a button to trigger the event.

Upload the program to the robot. Try the remote or the button. One of them will start the robot moving.

The mBot robot and basic motion

Basic math, science, and coding concepts

I like using the mBot in the classroom. It is useful when teaching math, science, and coding concepts. Once the robot is assembled we begin with the fundamentals. These fundamentals include coding the robot’s microcontroller to activate the motors so mBot begins to move around. Once the robot is moving we begin to learn about motion, velocity, and acceleration. This leads to lessons on Newton’s Laws of Motion.

Make sure the robot is not on a table where it can easily roll off and come crashing to the floor. I recommend placing the robot on the floor for the first few examples. You can also place the robot on a small paperback book so the wheels are free to spin.

The application to program the mBot is available online or as a download for your computer or device. Go to https://mblock.cc. Programming in the browser version of mBlock 5 requires an account. There is account integration with Google so students can easily create their accounts. This is useful if your school district uses Google account services.

Create a new project by clicking the new project button on the startup page. Provide a title for the project. Click the word Untitled next to the image of a diskette.

Name the project “Move forward and back”. Don’t include the quotation marks.

We need to load the robot into the development environment. Loading the robot loads the code library for the robot. This code library provides some specific code blocks for mBot.

Go to the Devices section under the Stage and click the Add button. The button is next to the Cody Device.

A Device selector window will open. Click the mBot device and click the OK button.

There are two devices in the Devices section. The mBot device is selected. A blue highlight appears around the selected device.

The codes panel updates with the categories and code blocks for the mBot. The first code block in the Action category is used to instruct the robot to move forward.

Using code blocks to build scripts is easy and intuitive. Click and drag the first code block onto the canvas area on the right. This code block has two number values. These values are inside small ovals.

The move forward code block is used to send instructions to the micro-controller on the mBot. The micro-controller sends instructions to all the components on the board. It also sends instructions to the components attached to the board.

The micro-controller interprets the instructions in the code block. The instructions in the current code block will send fifty-percent of the available energy to the motors. It will send this amount of energy for one second. That isn’t much time. We will change these values later.

STEM Integration

Let’s take a closer look. The code here relates to some basic concepts in science. The mBot has a battery pack. It uses four double-A batteries. Each battery is 1.5 volts. There are four of these batteries. That is a combined voltage of 6 volts. Volts are potential energy. Potential energy is a concept covered in physical science.

The code block instructs the micro-controller to send fifty-percent of this potential energy to the motors. The energy is released as current. Current is the flow of electrons from one end of a circuit to another. We can determine the current sent to the motors with a math formula. This formula is taken from

Ohm’s law. Ohm’s law is a formula used to calculate current, resistance, or voltage in a circuit. To determine the current sent through a circuit, we divide the voltage by the amount of resistance in a circuit.

We don’t need to know the exact amount of current sent to the motors. It is enough that we use this moment to apply classroom concepts to real-world applications. We must use the proper academic language.

Through the use of this model, we show students potential energy at work. They understand that the current is flowing through the motors to move the robot. They understand that one form of energy is being converted into another form.

There is another concept that we can teach with math and science. That concept is time. Using the code block, we send current to the motors for one second. We will change this value later to something more reasonable. It is important to note that the code does not have instructions for values that relate to miles per hour or even feet per minute. The values have nothing to do with the measurement of distance.

The values relate to energy and time. These two concepts are closely related to concepts taught in astronomy, physical science, and math. In space, distance is commonly measured in time. For example, the distance from the earth to the sun is 92.96 million miles or 146 million kilometers. Light takes 499 seconds to travel from the sun to the Earth. We call this One Astronomical unit. Light travels at 186,287 miles per second or 299,792 kilometers per second.

There are lots of numbers used to describe the distance from the Sun to the Earth. We can easily get confused when using miles or kilometers. How do we know the sun is that far away from the Earth? Did someone travel there to measure? Did we have a very long measuring tape? We used the constant speed of light to help find the distance. For the most part, light always travels at the same velocity. It is the same almost everywhere we measure. Light is constant. This makes the use of light a reliable measuring tool.

Light is measured in the amount of time it takes to travel from one place to another. The Sun is 499 light seconds from the Earth. The distance to the closest star system is 4.22 light-years. That is about 25 trillion miles or 40 trillion kilometers. A trillion is a number followed by 12 zeros. Time might be easier to understand.

We measure distance in time all the TIME! How long does it take to travel from your city or home town to another city? When children are fussing in the back seat they don’t ask, how many more kilometers ’til we get home? They as when are we getting there. They are already measuring distances in time.

Time is a central part of calculating velocity and acceleration. To determine velocity and acceleration we need a change in time and a change in position. The change in position is the distance traveled from one point to another. The calculation of force requires the calculation of acceleration. Acceleration is part of velocity.

We have strayed far away from the code for the robot. That is part of the point. We can extend and integrate a variety of concepts when using robots for STEM. Coding the robot is a means to an end.

Returning to the code

Let’s get back to the code block. This simple code instruction will help students learn and understand some principles of motion. Students will adjust the code parameters to learn and understand velocity and acceleration.

Update the code block so the mBot travels at half the potential energy for 3 seconds.

To upload the code we need to go through a few steps. Connect one end of the USB cable to the mBot. Connect the other end to the USB port on your computer. Turn the mBot ON. Make sure to hold the mBot. Sometimes the mBot wheels will begin to spin. My students often lay the mBot on its back. This leaves their hands free to work with the application and the upload process.

The mBot wheels will roll because it begins to process the instructions in any code uploaded to it from a previous session. The code is saved in the mCore memory. The code in this memory is executed each time the robot is turned on. This is common with devices that have Microcontrollers. The code is cleared out by new code uploaded or by updating the Firmware.

Click the Events category. The code blocks in this category are used to start our instructions. These are conditions that need to be met before the mBot will begin executing the instructions. Some of the conditions include the clicking of a green flag and the press of the space key. These conditions are often used with Scratch and the development of interactive stories and games. These conditions don’t work well with our robot.

The condition block we need is the first one. When mBot(more) starts up. This block is grey. This means the block cannot be selected. We cannot add it to the canvas while it is grey. How can we select it then?

We are currently in test mode. Test mode does not actively connect to the mBot. We need to exit Test mode.

Go to the bottom of the application and look for the Connect button. Above the button is an option for live or upload mode. Click the switch to change to upload mode.

The mBot condition block is now available. The condition blocks for the Scratch development environment are grey. This means they are not available for our robot.

Attach the mBot condition code block to the move code on the canvas.

We need to open a communication link to the mBot from the program. This will allow us to upload the code to the robot. Go to the bottom of the application and click the Connect button.

Uploading is when we send content from our computer to another. We download when we get content from another computer.

A connection configuration box will open. This configuration box is used to select the USB communication port connected to the robot. The port will be different on Windows and Mac computers. The image below shows the connection port on a Mac computer. The connection is being directed to one of the USB ports.

The connection port on Windows is usually Com3. It can also be Com1 or Com2. Com stands for Communication.

Click the port selector. The available communication ports will be listed. The communication port for the mBot on Mac has a special name. This port is /dev/tty.wchusbserial. The number after the name will depend on your Mac. The important part of the information is “wch”. This identifies the port that communicates with the mBot. Select this port.

Click the connect button.

A new button appears below the Test button. The connect button changes to Disconnect. Above the Disconnect button is a button to upload our code to the mBot. Click the button to begin the upload process. Make sure the robot will not roll off a table before doing this!

The mBlock software will compile our instructions. This means the program is checking our instructions for mistakes. It is also converting our instructions into instructions the mCore board understands. The compilation process is both a code checker and a translator.

The instructions are uploaded after the compilation process is complete. A progress bar will show the upload progress. The upload is usually quick. The mBot will run our instructions once the upload is complete.

Turn the robot off. Unplug the cable from the mBot. Leave the other end connected to the computer. We will be returning often to update the code. Each time we update the code it must be compiled and uploaded.

Set the robot on the floor and turn the power switch On. The robot will run the code again. It will do this every time we turn the mBot On.