Scribbler 2 Sensors and Motion

The Scribbler 2 robot includes equipment for a wide range of operations:

• a tone generator synthesizes musical tones

• lights blink

• several sets of sensors provide information about the robot's environment

• motors turn wheels, allowing the robot to move

This reading introduces several MyroC capabilities for utilizing Scribbler 2 sensors and motion.

Scribbler 2 Sensors

The Scribbler 2 and Fluke each contain several sensors:

• Sensors on the Scribbler 2

  • Left, middle, and right light sensors, indicating the light intensity encountered near parts of the robot. (Values range from near 0 for bright light to near 65535 for very dark environments.)

  • IR sensors, with emitters on the left and right and a receiver in the middle, help determine the presence of obstacles nearby. The IR light from the emitters bounces off obstacles and can be detected the IR detector. (A sensor reading of 0 indicates no obstacle, whereas a reading of 1 indicates an obstacle has been detected.)

• Sensors on the Fluke

  • IR emitters and a corresponding receiver on the Fluke report the amount of light that bounces off a nearby object. (Values near 0 indicate no obstacle (no reflected light) and values near 6000 indicate an obstacle (much detected light).)

  • Left and right virtual light sensors utilize parts of camera images to infer the amount of light in a region. (Values near 0 represent bright light, whereas values near 65535 represent a very dark region.)

Accuracy: A Technical Issue

Since each sensor is an electro-mechanical device, values reported by a sensor can vary — sometimes substantially. Further, values may be influenced by such factors as the strength of the batteries or the amount of ambient light within a room.

To mitigate variability, use of the sensors typically involves a parameter, called sampleSize.

• If sampleSize is 1, only one reading is obtained, and that value returned.

• If sampleSize > 1, the robot takes this prescribed number of readings and returns the average.

Using Sensor Data

Although obtaining sensor data may be of some interest by itself, the most common usage of this information involves controlling a robot's behavior.

To illustrate, the following program sensor-use.c beeps twice if the program detects no obstacle on the left of the Scribbler 2, but turns on a light for 3 seconds if an obstacle is present.

/* A program that responds to the presence of an obstacle.
   If an obstacle is not detected, the robot beeps twice.
   If an obstacle is detected, the robot turns on a light for 3 seconds. */

#include <stdio.h>
#include <MyroC.h>

int main ()
{
   printf ("Program to respond to a detected obstacle\n");
   rConnect ("/dev/rfcomm0");

   /* Obtain sensor data for obstacles on the left of the Scribbler 2 robot */
   int sensorReading = rGetIRTxt ("left", 5);

   /* Check if obstacle present */
   if (sensorReading)

     {
       printf ("obstacle detected\n");
       /* turn on light */
       rSetLEDFront (1);
       /* wait 3 seconds by beeping with zero frequency */
       rBeep (3.0, 0);
       /* turn off light */
       rSetLEDFront (0);
     }

   else
     {
       printf ("no obstacle found\n");
       rBeep (1.5, 880);
       rBeep (1.5, 1760);
     }

  printf ("Processing completed\n");
  return 0;
}

Robot Motion

Turning to the possibilities for robot motion, the Scribbler 2 robot has three wheels. The small wheel below the fluke dongle is purely for balance. The two large wheels each have their own motor, which can be adjusted to move at separate speeds to turn the robot to the left or right. The speed of the motors ranges from -1 (backwards at full speed) to 1 (forwards at full speed). It is important to note that there is no built-in time limit for how long the motor can run, so if you call a command to move without specifying a time limit or commanding the robot to stop, the motors will keep running until the Scribbler 2 battery dies.

A second important feature of the Scribbler 2 robot is that it can have the "front" set as either direction. When the robot has its forwardness set as "scribbler-forward", the front of the robot is the direction without a wheel. When the forwardness is "fluke-forward", the front is the direction with the small wheel (below the green card-like fluke dongle). The command to change the forwardness of the robot is:

   rSetForwardness (char * direction);

The options are "scribbler-forward" or "fluke-forward". By default, forwardness is set to "scribbler-forward" by rConnect.

That is, when the Scribbler 2 is turned on, the robot will consider "forward" so that the small wheel is at the back (under the fluke). Then the command

   rSetForwardness ("fluke-forward");

will change forwardness, so that forward now means the end with the fluke. To change forwardness back, away from the fluke, use the command

   rSetForwardness ("scribbler-forward");

Robot Commands

Scribbler robots respond to several motion commands that include moving forward, backward, or turning. These commands can be classified as blocking or non-blocking. Most motion commands can fall into either category, depending on the given parameters.

Blocking and non-blocking commands

A blocking command means that while the robot is executing this command, the program will not proceed until the command is completed. That is, while the Scribbler 2 is performing these commands, it cannot perform other actions (such as beeping). A non-blocking command is one that allows the robot to multi-task. For example, you could issue a non-blocking forward command and have the robot beep several times as it moves forward.

Motion Commands with Time and/or Speed Parameters

Many motion commands take two parameters:

• A speed parameter specifies a real number between -1.0 and 1.0:

  • The value -1.0 specifies full speed backward
  • The value -0.5 specifies half speed backward
  • The value 0.0 specifies no motion either forward or backward
  • The value 0.5 specifies half speed forward
  • The value 1.0 specifies full speed forward

• A duration parameter specifies the amount of time for the action.

  • The magnitude of the duration specifies the time for the action, in seconds. That is, durations of both -1.5 and 1.5 indicate that the action will continue for 1.5 seconds.
  • If the duration is non-negative, the action is blocking. Once the action is started, the Scribbler 2 will not continue with another activity until the action is completed.
  • If the duration is negative, the action is non-blocking. Once the action is started, the Scribbler 2 will continue with other actions while the action continues for the specified duration.

The following table identifies the available motion commands, together with examples and notes:

Summary: Most motion commands (i.e., commands with a time parameter) perform as blocking or non-blocking depending on their parameters. If the time given is greater than 0, the robot will move for that amount of time while blocking other commands. If the time parameter is negative, then it will be a non-blocking command that will continue until it is stopped, allowing subsequent commands to be processed in the meantime. A time of 0 will result in no motion. Also, remember that speed ranges from 0 (no movement) to 1 (full speed), and the unit of time is seconds.

A Command without a Time parameter

Continuous commands are commands that do not include time as a variable. Such commands are always non-blocking; that is, while the Scribbler 2 is performing these commands, it can perform other actions (such as beeping). The current MyroC.h specification includes only one continuous command:

  rMotors (double leftSpeed, double rightSpeed);
 

For example, the command

   rMotors (0.3, 0.7);

moves with the left wheel at 30% of full speed, and the right wheel at 70% of full speed, so the robot moves in a circular motion.

Stop Commands

These commands stop the continuous commands after they have been issued.

• rStop();
• rHardStop();