XOD powered line follower mBot

In the previous article, we learned how to use a PID-controller in the XOD visual programming environment. Also, we turned the mBot platform by Makeblock into a simple hand follower robot. If you want to recall the topic or you know nothing about what is a PID-controller, I advise you to read the first article in the series.

In this article, we continue the PID-controller experiment. We’re going to use the mBot platform from Makeblock as we did before. The next more challenging task for us is to create a line follower robot. To make this possible, we should extend the mBot capabilities. We add a “Me Line Follower’ sensor. Since this sensor is made by the same manufacturer, it perfectly fits our robot and is ideal for our task.

There is a XOD library to repeat described examples. Check out the overview at the XOD website and add it to your XOD project by hitting File → Add Library in the menu and typing gabbapeople/mbot-lib. The library has improved since the last release, so if you have it already make sure to add it again to get the latest version.

Take a look at our improved mBot.

mBot with a line sensor.

Making patch

Let’s begin robot programming by reading incoming values from the line sensor. The first node to place into the patch is mbot-line-sensor

mbot-line-sensor node.

This node communicates with the sensor through the S1 and S2 input pins. It has two output pins L and R according to the left and right infrared sensor on the board. True value on an output pin means that there is a white or bright color in front of the infrared sensor. In turn, false value means that the color is black or dark.

“Me Line Follower” has a blue label. Physically we connect it to a suitable blue labeled “port 1” on the controller board. In the program we put a corresponding node rj25-port1-blue into the patch and create necessary links.

mbot-line-sensor node connected to the RJ25 port 1.

What are the possible states of the line sensor? Look at the sketch.

Possible sensor states. Top view.
  • Situation 1. Both IR LEDs are on the line. mbot-line-sensor node puts false to the L and R pins. mBot should move forward.
  • Situation 2. The left IR LED is on the line while the right deviates to the right. mbot-line-sensor node puts false to the L pin, and true to the R. mBot should turn to the left.
  • Situation 3. The right IR LED is on the line while the left deviates to the left. mbot-line-sensor node puts true to the L pin, and false to the R. mBot should turn to the right.
  • Situation 4. Both IR LEDs are out of the line. mbot-line-sensor node outputs two true values. mBot should turn around to find the missing line.

However, it is better to use analog sensors instead of digital. At the same time a line follower sensor array is better than a couple of IR LEDs but it is ok to use this sensor for our example.

For a PID-controller an input should be a single variable while the mbot-line-sensor outputs a couple. To solve this problem, we add the subtract node. This node makes a subtraction of two boolean variables and produces a number.

Logical subtraction.

In this way, the subtract node can output the values:

  • 0 for the first situation;
  • -1 for the second situation;
  • 1 for the third situation;
  • 0 for the fourth situation.

The input is ready and it’s time to link it with the pid-controller.

pid-controller node.

We use those four situations to form the “error” concept for the PID-controller. The situation when the incoming value is 0 and both IR LEDs are in line is ideal for us. That’s why we should set up the the TARG pin to 0.

But this patch in its form can work correctly only with the second and third situations. When mBot completely loses the line the incoming value for the pid-controller node will be 0 too. For this case we have to introduce a special condition.

We place three additional nodes and, if-else, and multiply to the patch and make links as shown on the picture below. Take a look.

The situation 4 solution.

The and node makes a condition for the situation 4. The if-else node is used to define an amplification factor coefficient. Assign the T pin to a value of 25 and F pin to a value of 1. Finally, the multiply node multiplies the output of the pid-controller by the coefficient and passes it further.

If it is not the situation 4, then the coefficient is 1, and the output of the pid-controller remains unchanged. If it is then the coefficient is 25, and the output increases significantly.

The value at the F pin shows how rapid mBot turns around looking for the line. We choose the 25 value empirically. Adjust it in your project to find what works best for you.

Now the second, third, and forth situations are described, and only the first is left untouched. To fix this, we need to place the only one node nor and link it as shown in the picture below.

The situation 1 solution.

In the first situation, both L and R pin values are false, and the mBot moves forward. There is no error. We link the nor node with the RST pin of the pid-controller node to wait for a new incoming deviation.

The last step of making the patch is to pass the multiplied value to the motors. We put three nodes mbot-motors, subtract and add to the patch. Also, we set up a constant to store the base speed value of the mBot and make links. The finished patch is shown below.

The finished patch.

The mbot-motors node controls the engines. A positive value makes the wheel move backward while negative makes it move forward. The SPD constant node stores the basic mBot speed. It ranges from -1 to 0 and we set it up to -0.8. The subtract and add nodes calculate the motor speed by the multiplied pid-controller output and the set up constant. The patch is ready for tests. Now it is time to tune the PID-controller.

PID-controller

As you remember, a PID-controller adjusts the output operating three factors. They are the proportional, integral, and derivative. Leaving all the coefficients equal to zero makes the mbot just wander around without any behavior at all. As we did in the previous examples, we need to choose the coefficient values experimentally.

Kp factor

Let’s put the value 3 into the Kp pin, leave other coefficients equal 0, and upload the patch. To test the behavior of the robot we make a small track part on the floor.

The 3 value of the Kp.

As you see, with this coefficient oscillation is too high. mBot is trying to follow the line, but it twitches and finally leaves the track. Let’s set the 0,1 Kp coefficient.

The 0.1 value of the Kp.

Now, when the robot loses the line it returns back too long. That happens because the error has too little effect on the motor speed change. By trial and error we select a proper value 0,7.

The 0.7 value of the Kp.

Take a look at the graphical explanation of the mBot behavior. It shows how the Kp value changes the robot movement.

The influence of Kp on the trajectory.

Kd factor

Adjusting the Kp coefficient, we make the movement smoother. However, still, the robot can’t finish the track. Apparently, the second turn on his path is too steep, and the pid-controller node reacts to slow. To solve this problem, we should set a non-zero Kd coefficient.

The first time we put the 3 value of the Kd. It turned out that the 3 value is far away from the correct. We make lots of tests to find the proper value. We choose the 1 value as the best one.

The 1 value of the Kd.

The mBot finishes the track. Take a look at the sketch below. Increasing the Kd value, we increase the time period for the robot to be on line and reduce the time period to return to the line in case of loss.

The influence of Kp on the trajectory.

Ki factor

The selected Kp and Kd coefficients are quite suitable for our robot. But what about the Ki?

In fact, we do not need to set it up. For a line follower robot, the Ki can be useful in very particular cases.

For example. The track on the floor is endlessly straight. The robot moves strictly along the line, but there is tiny manufacturing disagreement of the motors. After a considerable period, this small issue will turn into an uncontrolled twitch. The Ki factor eliminates such problems.

We will try to use Ki in a very unusual way.

When the robot is out of the line, the input for the pid-controller is 0. If the the Ki is 0 the multiplied value to the motors is 0 too (25 * 0 = 0).

The thing is that the robot does not move in ideal conditions. The IR sensors always touch bad pieces of the track line or interfere with dark spots on the floor. So while the robot is off the line the input of the pid-controller isn’t constantly 0. By adding the Ki, we get rid of the zero multiplied value. The 25 coefficient at the T pin of the if-else node makes the robot rotate very fast if it loses the line. For the test, we put the 2 Ki value.

The 2 value of the Ki.

Conclusion

We made a cool line follower robot with a simple XOD program. Thanks to the PID controller it was so easy.

Be sure to follow new articles cause we will do new instructive projects!