Module 5: Robotics Interlude - Reactive Control

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
  (And 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
            \(\Rightarrow\) 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}| \approx 0\)
              \(\Rightarrow\) No turn (\(\phi=0\))
  • If \(d_{NE} - d_{SE} \gt 0\)
              \(\Rightarrow\) right turn (\(\phi\lt 0\)
  • If \(d_{SE} - d_{NE} \gt 0\)
              \(\Rightarrow\) left turn (\(\phi\gt 0\))

• Thus, we can summarize this as
            amount of left turn = \(d_{SE} - d_{NE}\)

• Define $$\eqb{ e(t) & \eql & (d_{SE} -d_{NE}) \\ & \eql & \mbox{ difference at time } t }$$

• Then, proportional control (at any time \(t\)) can be described as: $$ \phi \eql k_P e(t) $$ where \(\phi\) 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)\) (at time \(t'\)) and estimate $$ e'(t) \eql \frac{e(t) - e(t')}{t - t'} $$

• Then define the control $$ \phi \eql 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} \gt 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
            \(\Rightarrow\) identify the distance looking rightwards

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

• Pseudocode:

         Algorithm: follow-wall
         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
         

5.3   State-based control

Now let's return to our original problem of getting the vehicle to a desired destination:

• Assumptions:
  • Destination coordinates are known.
  • Nothing is known about obstacles.
  • We will have readings from the 8 range sensors at any time.
• A simple algorithm:

  

  • Head towards goal
              \(\Rightarrow\) We can do this because we can compute the angle towards the goal
  • If an obstacle is encountered, use wall-following to go around the obstacle

• Some notation:
            \(\theta \) = current orientation (heading)
            \(\gamma \) = direction to goal

• Pseudocode:

        Algorithm: goal-seek
        1.   if dN > δ and |θ-γ| > ε
                 // There's no obstacle, but we're not in the right direction.
        2.       turn towards goal
        3.   else if dN > δ and |θ-γ| < ε
                 // We're in the right direction, and there's no obstacle.
        4.       move forward
        5.   else
        6.       follow-wall        // As in previous section.
        7.   endif