View source for MRC/Tutorials/Obtaining laser, odometry, and control effort data

= Introduction =

This page provides a short description of the laser data, odometry data, and control effort data that can be obtained throught the ''IO'' object introduced earlier.

= Laser Data =

To obtain the laser data, do the following:

<pre>
emc::LaserData scan;
if (io.readLaserData(scan))
{
    // ... We got the laser data, now do something useful with it!
}
</pre>

The ''LaserData'' struct is defined as follows:

<pre>
struct LaserData
{
    double range_min;
    double range_max;
    
    double angle_min;
    double angle_max;
    double angle_increment;

    std::vector<float> ranges;

    double timestamp;
};
</pre>

The ''range_min'' and ''range_max'' values define what the smallest and largest measurable distances are. If a distance reading is below ''range_min'' or above ''range_max'', that reading is invalid. The values ''angle_min'' and ''angle_max'' determine the angle of the first and last beam in the measurement. The value ''angle_increment'' is the angle difference between two beams. Note that it is actually superfluous, as it can be derived from ''angle_min'', ''angle_max'' and the number of beams.

The actual sensor readings are stored in ''ranges''. It is an ''std::vector'', a vector of values which, in this case, stores ''floats''. Each vector element corresponds to one measured distance in ''meters'' at a particular angle. That angle can be calculated from ''angle_min'', ''angle_increment'' and the index of the element in the vector.

Finally, the ''timestamp'' specifies at which point in time the data was measured. The timestamp is in [http://en.wikipedia.org/wiki/Unix_time Unix time], ''i.e.'', the number of seconds since 1 January 1970. Note that the absolute value is not necessarily important, but that the timestamp ''can'' be handy to keep track of laser data over time, or to synchronize it with other input data (''e.g.'', the odometry data).

= Odometry Data =

The PICO robot has a holonomic wheel base which consists of three so-called omni-wheels. The specific configuration of the wheels allows the robot to move both forwards and sideways, and enables it to rotate around its axis. Each wheel has an encoder which keeps track of the rotations of that wheel. By using all three encoders and knowing the wheel configuration, the displacement and rotation of the robot can be calculated. In other words: we can calculate how far the robot drove and how far it rotated since it's initial position. This translation and rotation based on the wheel encoders is called ''odometry''. However, note that this information is highly sensitive to noise: small errors caused by measurement errors and wheel slip are accumalate over time. Therefore, relying on odometry data alone over longer periods of time is not recommended!

To obtain the odometry information, do the following:

<pre>
emc::OdometryData odom;
if (io.readOdometryData(odom))
{
    // ... We got the odom data, now do something useful with it!
}
</pre>

The ''OdometryData'' struct is defined as follows:

<pre>
struct OdometryData
{
    double x;
    double y;
    double a;
    double timestamp;
};
</pre>

Here ''x'', ''y'' and ''a'' define the displacement and rotation of the robot since its start, ''according to the wheel rotations''. The translation ''(x, y)'' is in meters. The rotation, ''a'' is in radians between -pi and pi. Like the laser data, the odometry data also contains a timestamp which is in seconds (Unix time).

= Control Effort =

'''remark: The control effort data will not give any output in the simulator and will only give outputs when testing on the real pico.'''<br>
To obtain the control effort information, do the following:

<pre>
emc::ControlEffort ce;
if (io.readControlEffort(ce))
{
    // ... We got the control effort data, now do something useful with it!
}
</pre>

The ''ControlEffort'' struct is defined as follows:

<pre>
struct ControlEffort
{
    double x;
    double y;
    double th;
    double timestamp;
};
</pre>

Here, the 'x','y', and 'th' correspond to, respectively, the control effort in the x, y, and theta direction. Similar to all the data structures above, the timestamp is defined in Unix time.

= Lazy Boolean Evaluation =
The functions shown above are boolean function, i.e., they return True or False to indicate whether a new measurement of the sensor is available. If you want something to happen when either laser or odometer data is found you may be tempted to use something like:

<pre>
emc::LaserData scan;
emc::OdometryData odom;
if (io.readLaserData(scan) || io.readOdometryData(odom))
{
    // ... We got sensor data, now do something useful with it!
}
</pre>

However c++ uses lazy boolean evaluation. Meaning it won't evaluate the second argument in an OR statement if the first is already True. Similarly it won't evaluate the second argument in an AND statement if the first is False. In this example the laser data will be read but the odom struct remains empty!