MyroC.h

Go to the documentation of this file.

 /*
     Index of all functions

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

3.  MOVEMENT                         4.  PICTURES
    rTurnLeft                            rTakePicture
    rTurnRight                           rSavePicture
    rTurnSpeed                           rLoadPicture
    rForward                             rDisplayPicture
    rFastForward
    rBackward
    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[192][256]; 
} Picture;
/* ***************************************************************/
/* 1. GENERAL - GENERAL - GENERAL - GENERAL - GENERAL - GENERAL  */
/*****************************************************************/

int rConnect (const char * address);

void rDisconnect();

void rSetConnection (int new_socket_num);

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  */
/***********************************************************************/

/* In this section, "non-blocking" refers to commands that do not prevent
   the robot from executing other non-movement commands at the same time.
   For example, a call to rForward in the non-blocking mode with a
   consecutive call to rBeep will result in the Scribbler moving forward
   while beeping.
*/
   

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  */
/***********************************************************************/
/* In this section we deal with taking and manipulating pictures produced 
   from the Scribbler 2 camera. These pictures will always be 192x256 
   (192 rows by 256 columns) and internally are defined as type Picture, 
   which hold a 2D array of type of Pixel. These can be saved and loaded 
   as .jpeg files.

   Following standard mathematical convention for a 2D matrix, 
   all references to a pixel are given within an array as [row][col]
 */

Picture rTakePicture();

void rSavePicture(Picture pic, char * filename);

Picture rLoadPicture(char * filename);


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


#endif