People have asked me to provide more information about my video on the Mindsensors site about testing the Line Leader sensor. How can the robot make a choice at a fork in the road (line)?
My Video: http://www.youtube.com/watch?v=isf2Kz_jdrA
First, let’s expand on the problem. I found an interesting video a while back on YouTube.com for a Robocup Jr – Rescue competition that outlined some fairly complex rules for following a line to a destination. In short, there are 10+ line configurations that a robot must be able to navigate in order to complete the mission. There is much more to this mission, but the focus here is on following the lines…
Robocup Jr Video: http://www.youtube.com/watch?v=LUvBfAmUm48

Here is a sample line configuration for the robot to navigate.

 
One configuration is shown above where the robot must follow the line to a circle, and determine which direction to travel to complete it. Markers are provided indicating the correct (suggested) route to follow. Markers on various configuration sheets can be left or right.
I am sure there is some smart robot programmer out there who is saying… “It’s easy with a light sensor or two…” (contact me so I can learn!). The robot somehow needs to determine that it is over a green marker, and turn the robot that direction to continue following the line around the circle to the other side. Sounds easy.
I tried to sense color (light intensity) differences with two NXT light sensors initially, and that works, but light intensity also changes as the robot moves from black line to white surface. To the light sensor, the world is gray-scale and there are no sharp lines. A black line on a white surface looks like this.

It is difficult to find "green" or the gray-scale equivilent in this mess. Here is a crude drawing of what the marker section might look like to a light sensor.

The problem is: How can I distinguish green from the edge of the line? Like I said, I am sure someone out there solved this problem with a light sensor or two, but not me. I implemented the Line Leader sensor to solve the problem. Because I have an array of 8 light sensors, and the Line Leader is great at keeping me on the line, I decided that might be able to use the width of the line as an indicator that I am over a marker.
Knowing the line width should be 2 or 3 detectors wide, I figured there must be a way to determine If the line became wider (over a line and marker). Since the green marker may or may not be detected as part of the line, I implemented custom code to read the raw values from each detector in the Line Leader to compare and calculate my own conclusions.
 

During initialization, I read the WHITE THRESHOLD values into memory. As the robot follows the line, it also compares the raw values to the white threshold values. If more four or more detectors of the eight are dark, the robot must be over a marker. A little more math is used to determine which side of the line leader has encountered the marker and the robot turns that direction.

Code: Select all

void BEH_LineMarker() {
  byte i;
  byte tL = 0;
  byte tR = 0;
      LLReadSensorRaw(LineLeaderPort, llRaw);
     for (i=0; i<4; i++) {   //COMPARE THE LEFT SIDE OF THE LINE LEADER
         if (llRaw.arr[i] < llWhite.arr[i]){
            tL++;
         }
      }
      for (i=4; i<8; i++) {  //COMPARE THE RIGHT SIDE OF THE LINE LEADER
         if (llRaw.arr[i] < llWhite.arr[i]){
            tR++;
         }
      }
      if (tL+tR >= 4) {  //ARE THERE ENOUGH DETECTORS TRIGGERED TO MEAN WE FOUND A MARKER?
         DriveCommand(MARKER_SPEED,sgn(tR-tL)*90,BEHAVIOR_LINE_MARKER);  //RIGHT (POSITIVE), LEFT (NEGITIVE)
         RequestControl(BEHAVIOR_LINE_MARKER);
      }
      else
         DeclineControl(BEHAVIOR_LINE_MARKER);
}


When called, this code reads the raw values into llRaw.arr for each of the 8 detectors in the Line Leader. As it compares to the white threshold values, it updates the left or right counters. At the end of comparison, if more than 4 detectors see dark, we must be over a marker, so… If most of the detections where on the right, turn right. If most of the detections were on the left, turn left.
RequestControl() and DeclineControl() are behavior-based fucntions that determine if this behavior wants to control the motors or not. More in another post….

There are many ways (and sensors) available that can allow a robot to follow a line. I have experimented a few that are of interest.

• Single Light Sensor
• Two Light Sensors
• Mindsensors LineLeader Sensor (Intelligent array of 8 light sensors in one I2C package)

In this article I review a couple of standard ways of staying on track, and then review the new Mindsensors – Line Leader sensor.  I was part of a beta-testing group for this great sensor.

Single Light Sensor

Using on NXT light sensor, there

are a couple of possibilities for following a line that can be effective. The programmer can either code to follow the line itself, or the edge of the line.

Following inside the line offers the advantage of knowing the robot is on the line, but what direct do we turn of we fall off? If the robot falls off of the line, which direction should it turn to return to it? As the robot drifts back and forth on the line, the programmer must try to correct its course to stay on the line. This method is mostly impractical.

Edge following offers the advantage of knowing the direction to turn in order to stay on the line. It is generally a faster, more accurate method for following a line. You select the right or left side of the line to follow, and code the robot to turn left if the light sensor reports BLACK and right if WHITE. This method allows a robot to follow the edge of the line through straight sections and curves. Is there a better method to follow a line?

Two Light Sensors

Using two NXT light sensors, there are also a couple of useful configurations to review. Sensors are generally set side by side on the front of the robot with either both inside, or both outside the line. With two sensors (left and right), more accurate line following can be achieved because as a line is lost on one side or the other, recovery is possible because we know which side lost the line.

Placement of the light sensors is very important so that only one sensor at a time could be on the line. As can be seen in the illustration, as the robot drifts from one side to the other, one sensor contacts the line and the robot can react accordingly.

Coding is similar to using one light sensor following the edge of a line, but you can let the robot run straight if both report WHITE or both report BLACK (depending on the configuration). This allows the robot to gain speed instead of oscillating back and forth (as much) as it must with one light sensor.

Mindsensors Line Leader Sensor

A more advanced method for following a line is to utilize three or more light sensors to follow a line. Many people have custom built line following sensor arrays, but Mindsensors has just released the Line Leader sensor for the rest of us. Not only does it contain eight (8) sensors in its array, the intelligent sensor also implements some very nice internal coding and a robust I2C interface to communicate with the robot.

Because there are 8 light detectors under the sensor, it is very easy to determine how to follow a line. The goal is to keep the line centered under the sensor. As the line moves left or right under the robot, it can compensate to center the line under the sensor. How is this done? Mindsensors has a good explanation in the Line Leader user guide.

Mindsensors took all of the hard work and math out of determining how to follow the line. There is a register for retrieving the STEERING value from the sensor. I have used the STEERING value successfully by supplying speed values to two motors. The following example code shows how to read the STEERING value from the sensor, and apply it to two drive motors.

int clip(int x, int min, int max) {
  if (x<min)
    return min;
  else if (x>max)
    return max;
  else
    return x;
}

While(true) {
//TWO MOTORS – DIFFERENTIAL DRIVE STEERING FROM LINE LEADER 
//GET STEERING FEEDBACK FROM THE SENSOR TO KEEP ROBOT ON THE LINE

  steering = (int) LL_Read(SensorPort, LineLeaderAddr, LL_READ_STEERING);
  motor[RIGHTMOTOR] = clip(70 + steering, -100, 100); //RIGHT MOTOR
  motor[LEFTMOTOR] = clip(70 - steering, -100, 100); //LEFT MOTOR
}

The clip function is a simple utility function that should be in everyone’s toolbox. It takes value returns it if it is between min and max. If outside the range, it returns min or max.

Mindsensors supplies a simple driver file that makes reading the STEERING value easier. We call LL_Read() with the LL_READ_STEERING constant to return the STEERING value suggested by the sensor based on where the line is. The last step is to determine speed value for the left and right motors. We ideally (in this case) want to travel straight at speed = 70. We add the steering value to the right motor, and subtract it from the left motor (within the range motors accept – [-100 to 100]). That’s it.

As the line drifts to the right (or robot to the left), steering becomes a negative number. The further it moves to the right, the bigger the number becomes to allow for correction of the robot.

If the STEERING value returned is -20, we set the motors to use the value to correct the robot’s steering.

RIGHTMOTOR power = 70 + (-20) = 50

LEFTMOTOR power = 70 – (-20) = 90

This causes the right motor to spin faster than the left turning the robot left to re-center the sensor over the line.

Your program would continue to loop, finding the next steering value and correcting the motors accordingly. The robot uses this feedback control to follow a line.

What if the robot takes advantage of the NXTs motor implementation and links the RIGHTMOTOR and LEFTMOTOR together? NXT firmware allows the motors to take advantage of the internal encoding for each motor to keep them running at the same speed (It can move in a straight line!). I often implement my drive motors with this configuration so the robot can easily move straight. Here is a quick code sample of implementing sync’d motors.

void _DriveRobot(int power, int steering) {
  if (steering >= 0) { //RIGHT TURN or STRAIGHT
    if (lastPower!=power || lastSteering != steering){
      nSyncedMotors = synchBA;
      nSyncedTurnRatio = (100 - (2*abs(steering)));
      motor[LEFTMOTOR]=power;
      lastPower=power;
      lastSteering=steering;
    }
  }
  else { //LEFT TURN
    if (lastPower!=power || lastSteering != steering){
      nSyncedMotors = synchAB;
      nSyncedTurnRatio = (100 - (2*abs(steering)));
      motor[RIGHTMOTOR]=power;
      lastPower=power;
      lastSteering=steering;
    }
  }
}

In this case, I have directly passed the STEERING value returned from the Line Leader to this routine with excellent success. Robot speed is determined by the POWER parameter (-100 to 100) to implement reverse, stop, or forward. The STEERING parameter (-100 to 100) determines left, straight, or right turns.