MyroC.h

Go to the documentation of this file.

/*
 ********************** implementation overview *************************
 *  MyroC implementation files organized by user function as follows:

 1. GENERAL                          2. SENSORS
    rConnect                          a.Scribbler Sensors
    rDisconnect                         rGetLightsAll
    rSetConnection                      rGetLightTxt
    rFinishProcessing                   rGetIRAll
    rSetVolume                          rGetIRTxt
    rBeep                               rGetLine
    rBeep2                        
    rSetName                          b.Fluke Sensors
    rGetName                            rGetObstacleAll
    rSetForwardness                     rGetObstacleTxt
    rGetForwardness                     rGetBrightAll
    rSetLEDFront                        rGetBrightTxt
    rSetLEDBack                         rSetIRPower
    rGetBattery    
    rGetStall

3.  MOVEMENT                         4.  PICTURES
    rTurnLeft                            rGetCameraSize
    rTurnRight                           rTakePicture
    rTurnSpeed                           rDisplayPicture
    rForward                             rWaitTimedImageDisplay
    rFastForward                         rSavePicture
    rBackward                            rLoadPicture
    rMotors                              
    rStop
    rHardStop   
*/

#ifndef _MyroC
#define _MyroC

typedef struct
{
  unsigned char R; 
  unsigned char G; 
  unsigned char B; 
} Pixel;

typedef struct 
{
  int height; 
  int width;  
  Pixel pix_array[266][427]; 
} Picture;

/* ***************************************************************/
/* 1. GENERAL - GENERAL - GENERAL - GENERAL - GENERAL - GENERAL  */
/* ***************************************************************/

int rConnect (const char * address);

void rDisconnect();

void rSetConnection (int new_socket_num);

void rFinishProcessing ();

void rSetVolume (char highMute);

void rBeep(double duration, int frequency);

void rBeep2(double duration, int freq1, int freq2);

void rSetName (const char * name);

const char * rGetName();

void rSetForwardness(char * direction);

void rSetForwardnessTxt (char * direction);

char * rGetForwardness ();

void rSetLEDFront(int led);

void rSetLEDBack(double led);

double rGetBattery();

int rGetStall (int sampleSize);

void rSetBluetoothEcho (char onOff);


/* ************************************************************************/
/* 2. SENSORS - SENSORS - SENSORS - SENSORS - SENSORS - SENSORS - SENSORS */
/* ************************************************************************/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*  Group a:  Scribbler Sensors                                          */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void rGetLightsAll (int lightSensors[3], int sampleSize);

int rGetLightTxt (const char * sensorName, int sampleSize);

void rGetIRAll (int irSensors[2], int sampleSize);


int rGetIRTxt (const char * sensorName, int sampleSize);

void rGetLine (int lineSensors[2], int sampleSize);

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*  Group b:  Fluke Sensors                                              */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void rSetIRPower (int power);

void rGetObstacleAll (int obstSensors[3], int sampleSize);

int rGetObstacleTxt (const char * sensorName, int sampleSize);

void rGetBrightAll (int brightSensors[3], int sampleSize);

int rGetBrightTxt (char * sensorName, int sampleSize);

void rGetInfo (char * infoBuffer);


/* *********************************************************************/
/* 3. MOVEMENT - MOVEMENT - MOVEMENT - MOVEMENT - MOVEMENT - MOVEMENT  */
/* *********************************************************************/

/* Procedures in this section, except rMotors, include a "time" parameter.
 *
 * Throughout, "time" is interpreted as follows:
 *     if time > 0, the call to the procedure is "blocking:
 *            That is, a call to the procedure starts a motion, and
 *            all other processing stops for the specified time (in seconds).
 *            After the specified time interval, the motion stops,
 *            and processing in the main program continues.             \n
 *     If time == 0, the procedure is "non-blocking":
 *            That is, the procedure starts a motion, 
 *            and that motion continues until another motion command is issued.
 *            Once the motion starts, other processing in the main
 *            program continues.                                        \n
 *     If time < 0, the procedure is "non-blocking": 
 *            That is, a call to the procedure starts a motion,
 *            and a timer is started for the abs("time").               \n
 *            Once the time interval is completed,                      \n
 *               if no other motion command has been issued,
 *                  a command to stop robot motion is given             \n
 *               if another motion command has been issued (before the
 *                  specified time), the new command is executed immediately,
 *                  and the timer is ignored.                           \n
 *           For example, suppose rForward is called with a time of -5 seconds:
 *               subsequent processing in the main program continues    \n
 *               if numerous beeps are issued or the camera is used or
 *                  a series of non-motion commands are issued, then
 *                  the rForward action stops in 5 seconds.             \n
 *               if an rRightTurn command is issued after 2 seconds,
 *                  then the rForward command is overridden by rRightTurn
 *                  and the timer for rForward (after another 3 seconds)
 *                  is ignored.
 *
 * Program termination with timed, non-blocking commands:
 *    When a non-blocking time is specified (i.e., time < 0), processing within 
 *    the controlling program continues.  However, the robot's Bluetooth connection
 *    (established with rConnect) is not severed until the non-blocking timer has
 *    expired and the motion stopped.  In particular, rDisconnect blocks until
 *    the specified non-blocking time is completed and the program tells the
 *    robot to stop.
 */

void rTurnLeft (double speed, double time);

void rTurnRight (double speed, double time);

void rTurnSpeed (char * direction, double speed, double time);

void rForward (double speed, double time);

void rFastForward (double time);
 
void rBackward (double speed, double time);

void rMotors (double leftSpeed, double rightSpeed);

void rStop();

void rHardStop();

/* *********************************************************************/
/* 4. PICTURES PICTURES PICTURES PICTURES PICTURES PICTURES PICTURES   */
/* *********************************************************************/
Picture rTakePicture();

void rSavePicture(Picture * pic, char * filename);

Picture rLoadPicture(char * filename);


void rDisplayPicture(Picture * pic, double duration, const char * windowTitle);

void rWaitTimedImageDisplay ();

#endif