The Smart Robot Car Kit has already served as the basis for some blog posts. I had in this Post modified a toy car and equipped the Robot Car with sensors. With the front ultrasonic sensor, he can recognize obstacles and avoid them Door changing its direction of movement. Since the car is modular, it offers us options for modification. In this project we will add a four -fold line, so that it follows one black line painted on the floor. To do this, a four infrared sensors are added and a new sketch is programmed.

The black color of the line Weiger the light, the white color reflects. The reflected proportion is detected Door the sensor. These properties are used to follow the line. The sketch then only has to be programmed so that the Robot Car drives along the line.

Required hardware and materials

                                                

Required software and sketches

• Arduino IDE
• line_follower_smart_car_robot.ino sketch
• sensor_adjust.ino sketch

Circuit and description of the modules used

Download the circuit

We use a microcontroller, a Sensor Shield module, to connect the components and modules and with the AZ-L298N controller module, we control the speed and the direction of rotation of the engines. All of these components are included in the Smart Robot Car Kit. To follow the line, a 4-channel infrared sensor module is added. The necessary voltage to supply the infrared module must be 5V, while the supply voltage of the microcontroller and the AZ-L298N module is 10 V. As you can see in the circuit, I use two 5-volt battery packs and switch them into series. So I get the 10 VDC (red line) for the power supply of the microcontroller and the AZ-L298N module and the 5 VDC for the infrared form module (green line).

Setting the infrared sensor

I modified the Robot Car from Balsa wood so that the battery packs can be accommodated. I also built a bracket to attach the sensor module. It is attached to a height of 10 mm above the ground. The maximum distance where it works satisfactorily is 15 mm.

After we have assembled all modules and components of the Smart Robot Car, we first have to set the detection of the color change from black to white. To do this, we position the Smart Robot Car on a black line that is supposed to follow it and load the sketch sensor_adjust.ino on the microcontroller. The engines are not controlled. We use this sketch to read the sensors and Weergegeven the status in the serial monitor. For the adjustment we take the following steps:

• We place the Smart Robot Car with the four sensors on the black line. Each sensor must display a high value on the serial monitor and the LEDs D1, D2, D3 and D4 on the sensor module must be off. We use the potentiometers R9, R10, R11 and R12 to set the sensor values ​​until the LEDs on the board are off.
• We move the car on the side until the first set of transmitter and recipient sensors comes out of the black area of ​​the line. At this moment, the measurement value in the serial monitor of this sensor should be low and light up the corresponding LED of the adjustment module. If the measured value does not change and the LED does not go out, we set the corresponding potentiometer until the value changes. To make sure we repeat this step.
• The other three sensors are set in the same way. This should be recognized that the Robot Car leaves the line.

As you can see, it works in this case that all sensors are completely over a black line. Alternatively, it could also be programmed in such a way that the inner sensors stand above a thinner line and the outer sensors outside the line.

Description of the program flow and sketch

Our modified intelligent robot car must follow the black line on the floor and change the direction. The infrared sensors recognize when the robot deviates and leaves the path of the black line that we painted on a white background, so that the microcontroller makes the necessary changes to the speed of the two wheel engines so that the car returns to the path of the line.

If the Smart Robot Car deviates from the black line and the outer sensors recognize this, the microcontroller gives the command to turn the engine on the side that has left the line a little faster. If the two sensors go out on the same side, this means that the car has deviated far enough from the line. We have the normal speed of the engines car_advances () for normal progress and two somewhat faster speeds Slight_urn_Motor () and Sharp_motor_urn ()to adapt the position of the car.

Let's start with the analysis of the sketch line_follower_smart_car_robot.ino. Since the sensors each offer a digital outcome, we do not need to be a library. We will only record a high or low level signal at your outcome.

First we define the microcontroller pins, to which we will connect the signal outputs of the infrared sensors. Sensor 1 is the right external sensor of the vehicle, it is the in1 pin of the sensor sensitivity adjustment board. We connect it to port 9 of the Shield, during which in4-pin is the left outer sensor and is connected to port 12 of the Shield.

#define Ir_sensor_1 9
#define Ir_sensor_2 10
#define Ir_sensor_3 11
#define Ir_sensor_4 12

So that the microcontroller can send the correct commands to the engines, we must query the status of the sensor signals. For this we define four variables, one for every sensor of the Module.

intimately value_ir_sensor_1;
intimately value_ir_sensor_2;
intimately value_ir_sensor_3;
intimately value_ir_sensor_4;

We will now define the microcontroller pins for the engines. We need three pins for each engine. Two of the digital pins are used for the direction of rotation of the engine. You will be configured later as an outcome. The third digital PIN each must be PWM-capable (Pulse Width modulation). We use the function Analogwrite (Name_Motor, Value), to control the speed of the engine rotation.

#define enable_left_motor 5
#define Connection_1_motor_Left 2
#define Connection_2_motor_Left 4

#define enable_right_motor 6
#define Connection_1_motor_Right 7
#define Connection_2_motor_Right 8

Next will be in the set up()-Method configured the pins. With Pinmode (Pin_number, output) the motor pins are set as outputs.

pin mode(enable_right_motor,OUTPUT); 
pin mode(Connection_2_motor_Right, OUTPUT);
pin mode(enable_left_motor,OUTPUT);
pin mode(Connection_1_motor_Left, OUTPUT); 
pin mode(Connection_2_motor_Left, OUTPUT);

The sensor pins are with Pinmode (ir_sensor_1, input) configured as inputs.

pin mode(Ir_sensor_1, Input);
pin mode(Ir_sensor_2, Input);
pin mode(Ir_sensor_3, Input);
pin mode(Ir_sensor_4, Input);

That was it too. Now the following follows Loop ()-method, the one who is continuously executed. It contains the calls of the methods to read the conditions of the infrared sensor signals.

state_ir_1();
state_ir_2();
state_ir_3();
state_ir_4();

The condition of the sensors can be high or low. The reading is done with the instruction DigitalRead (ir_sensor_number)then the value obtained in the corresponding variable (value_ir_sensor_number) to save. The measured values ​​are then displayed in the serial monitor. The methods of the four sensors are the same, we only change the number of the infrared sensor.

void state_ir_1() {
        value_ir_sensor_1 = digital read(Ir_sensor_1);
        Serial.print("State ir sensor 1");
        Serial.print(value_ir_sensor_1);
}

The sensor values ​​are now used for an IF statement and thus car_advances () executor if the condition is true. This corresponds to the condition in which all sensor signals are high.

IF (value_ir_sensor_1 == HIGH && value_ir_sensor_2 == HIGH && 
    value_ir_sensor_3 == HIGH && value_ir_sensor_4 == HIGH) { 
  car_advances();
}

We could also have written the code of the method directly in the instruction. But that's a little tidy.

We spend the current position in the code in the serial monitor. With the code line Analogwrite (enable_right_motor, 71) Let us set the speed of the right motor to a value of 71 of 244, because we use the PWM property of this digital port. This means that the engine rotates at around 29 % of its speed when 5 VDC is created. With the next two code lines DigitalWrite (Connection_1_motor_Right, High) and DigitalWrite (Connection_2_Motor_Right, low), we define the direction of rotation of the right motor in the forward direction of the Smart Car Robot. The last three lines of the method do the same for the left engine.

void car_advances() {
  Serial.print("Car Advance");
  Analogwrite(enable_right_motor, 71);
  digital(Connection_1_motor_Right, HIGH);
  digital(Connection_2_motor_Right, Low);
  Analogwrite(enable_left_motor, 71);
  digital(Connection_1_motor_Left,HIGH);
  digital(Connection_2_motor_Left,Low);
}

If there is no high value in one of the four sensors, the previous code is not carried out and the program is transferred to the next IF statement that the method Slight_urn_Left () Call when sensor 1 deliver a low and the other sensors a high signal.

IF (value_ir_sensor_1 == Low && value_ir_sensor_2 == HIGH && 
    value_ir_sensor_3 == HIGH && value_ir_sensor_4 == HIGH) { 
  Slight_urn_Left();
}

The right external infrared sensor indicates that the Smart Robot Car has deviated a little to the right of the black line.

void Slight_urn_Left() {
  Serial.print("Car Turn Right");
  Analogwrite(enable_right_motor, 72);
  digital(Connection_1_motor_Right, Low);
  digital(Connection_2_motor_Right, HIGH);
  Analogwrite(enable_left_motor, 71);
  digital(Connection_1_motor_Left,HIGH);
  digital(Connection_2_motor_Left,Low);
}

The rotation speed of the right motor changes, so that our smart robot car turns slightly to the left and returns to the line.

If the above condition is not fulfilled, the next instruction follows the method Sharp_Left_urn () calls.

IF (value_ir_sensor_1 == Low && value_ir_sensor_2 == Low &&
    value_ir_sensor_3 == HIGH && value_ir_sensor_4 == HIGH) { 
  Sharp_Left_turn();
}

The condition is met if the sensors 1 and 2 provide a low signal and the other two provide a high signal. This means that the Robot Car has strayed so far from the line that the two right sensors are outside the line.

void Sharp_Left_turn() {
  Serial.print("Car Turn Right");
  Analogwrite(enable_right_motor, 73);
  digital(Connection_1_motor_Right, Low);
  digital(Connection_2_motor_Right, HIGH);
  Analogwrite(enable_left_motor, 71);
  digital(Connection_1_motor_Left,HIGH);
  digital(Connection_2_motor_Left,Low);
}

In contrast to the previous method, the rotation speed of the right motor is increased even further because the car has to drive a closer curve to get back on the line.

In order to identify leaving the line on the other side and carry out a directional core, the following methods are called up with three other IF instructions. The code is almost the same. The conditions refer to the other two sensors and the speed of the left engine is changed to make a correction to the left.

/* If sensor number 4 is not on the black line, a call is made to the smooth right turn method. */
IF (value_ir_sensor_1 == HIGH && value_ir_sensor_2 == HIGH && 
    value_ir_sensor_3 == HIGH && value_ir_sensor_4 == Low) { 
  Slight_urn_right();
}

/* If sensors 3 and 4 are not on the black line, a call is made to the hard right turn method. */
IF (value_ir_sensor_1 == HIGH && value_ir_sensor_2 == HIGH && 
    value_ir_sensor_3 == Low && value_ir_sensor_4 == Low) { 
  Sharp_Right_urn();
}

/* If all sensors are not above the black line, a call is made to the hard left turn method. */
IF (value_ir_sensor_1 == Low && value_ir_sensor_2 == Low && 
    value_ir_sensor_3 == Low && value_ir_sensor_4 == Low) { 
  Sharp_Left_turn();
}

I have commented on two methods in the code. To use them, the comment must be removed and these methods are called up. They serve to include the Smart Robot Car stop() to stop completely and with Go_Back () to let backwards.

In the video below you can see that the Smart Robot Car is constantly moving sideways. This is because it is practically impossible that the two engines turn at the same speed, even though we put the same voltage on the two engines. The speed could be measured and regulated with appropriate modifications.

You can also optimize or adapt the code yourself. We hope you enjoy this function of the AZ Smart Robot Car.