Module 5: Robotics Interlude - Reactive Control

In planned control:

• We have advance knowledge of the goal and everything in between.

• Given this, we can compute a sequence of steps to get from the "start" to the "goal"
            => This was the approach taken by planning algorithms

• Example: the arm control problem.

• Example: the car acceleration problem
  • In this case, we constructed an entire acceleration function.
  • The goal: the acceleration function was applied to take a vehicle from start to finish in as little time as possible.

Contrast this with reactive control:

• In the winch problem, the only information used was the distance to the goal.

• The algorithm
  • Used the difference as input to the control (voltage, in that example).
  • Used its own estimate of derivative/integral for PID control.

Can a reactive approach be used in a robot planning problem?

• Consider a robot navigation problem.

• Suppose we only know the goal's coordinates
            => We have no knowledge of obstacles.

• The robot has sensors and must react to input from the sensors.

We will consider simple range sensors:

• Here, a robot has N range sensors equally spaced in a circle.

• Thus, if N=8, the robot can sense distance in 8 directions (N,S,E,W, NE,NW,SE,SW) relative to its orientation.

  

• We will assume that the sensor returns the distance to the closest obstacle in each sense-direction.

• The most common (and least expensive) type of range sensor: sonar.

• Note: we will use the convention that North is the direction the vehicle is facing (and thus, changes all the time).

Next, we will try and follow the "wall" and wind our way around the obstacle:

• We will circumnavigate obstacles by going clockwise
            => turn left when close enough

• After turning so that we're parallel to the wall, we will move forward.

• In moving forward, we will:
  • Examine the NE and SE sensor readings.
  • Try to keep these the same.
  • Thus, if the NE distance is larger, turn right (slightly):

    

  • Thus, if the SE distance is larger, turn left (slightly).
  • If the distances are approximately the same, move forward:

    

  • If, when moving forward, we're too close to an obstacle, turn left.

• In pseudocode:

         1.   while true
         2.       if |dNE - dSE| < α    
         3.           if dN > δ       
         4.               move forward
         5.           else
         6.               stop and turn left
         7.           endif
         8.       else if dNE > dSE
         9.           stop and turn right
         10.      else
         11.          stop and turn left
         12.      endif
         13.  endwhile
         

• Which can be shortened to (and leaving out the loop):

         1.   if |dNE - dSE| < α and dN > δ
                  // Approximately parallel to wall, and no obstacle in front.
         2.       move forward
         3.   else if dNE > dSE
         4.       stop and turn right
         5.   else
         6.       stop and turn left
         7.   endif
         

To address the problem:

• We will include some forward motion:

         1.   if |dNE - dSE| < α and dN > δ
         2.       move forward
         3.   else if dNE > dSE
         4.       reduce speed and turn right
         5.   else
         6.       reduce speed and turn left
         7.   endif
         

• This way, we will not repeat a position and get stuck.

Next, let us use the PID approach:

• Notice that d_NE - d_SE determines our action:
  • If |d_NE - d_SE| is approx. zero,
              => No turn
  • If d_NE - d_SE > 0
              => right turn
  • If d_SE - d_NE > 0
              => left turn

• Thus, we can summarize this as
            amount of left turn = d_SE - d_NE

• Define
            e(t) = (d_SE-d_NE) = difference at time t.

• Then, proportional control (at any time t) can be described as:
            φ = k_P e(t)
  where φ is the left-turn steering angle.

• In pseudocode

         1.   if |dNE - dSE| < α and dN > δ
         2.       move forward
         3.   else
         4.       reduce speed 
         5.       set φ = kP e(t)
         6.   endif
         

To damp out the oscillations, let's use differential control:

• We will store the previous value of e(t) and estimate
            e'(t) = (e(t) - e(t') / (t - t')

• Then define the control
            φ = k_Pe(t) - k_De'(t)

Bounds on values:

• Sometimes, the difference or differential term in PD control can get very large.

• One simple solution is to bound sensor values, e.g.
            if d_NE > 2 d_SE, then set d_NE = 2 d_SE

An additional fix:

• We need to make sure we keep a safe distance from the wall.

• To do this, we could read the East-sensor
            => identify the distance looking rightwards

• Key idea: if it's too close (less than distance δ), turn left (away from wall).

• Pseudocode:

         1.   if dE < δ
         2.       reduce speed and turn left
         3.   else if |dNE - dSE| < α and dN > δ
         2.       move forward
         3.   else
         4.       reduce speed 
         5.       set φ = kP e(t) - kD e'(t)
         6.   endif
         

Goal seeking