irobotSensor.cpp

00001 #include "irobotSensor.h"
00002 #include <stdio.h>
00003 
00004 int32_t irobotReadBumps_Wheeldrops(
00005     xqueue_t * const queue,
00006     irobotBumps_WheelDrops_t * const bumps_wheelDrops
00007 ){
00008     uint8_t packedValues = 0;
00009 
00010     //check for NULL pointers
00011     if(!queue || !bumps_wheelDrops){
00012         return ERROR_INVALID_PARAMETER;
00013     }
00014     //verify packet size
00015     if(xqueue_count(queue) < SENSOR_BUMPS_WHEELDROPS_SIZE){
00016         return ERROR_INVALID_PARAMETER;
00017     }
00018 
00019     packedValues = xqueue_pop(queue);
00020 
00021     bumps_wheelDrops->bumpRight = !!(packedValues & (1 << 0));
00022     bumps_wheelDrops->bumpLeft = !!(packedValues & (1 << 1));
00023     bumps_wheelDrops->wheeldropRight = !!(packedValues & (1 << 2));
00024     bumps_wheelDrops->wheeldropLeft = !!(packedValues & (1 << 3));
00025     bumps_wheelDrops->wheeldropCaster = !!(packedValues & (1 << 4));
00026 
00027     return ERROR_SUCCESS;
00028 }
00029 
00030 int32_t irobotReadButtons(
00031     xqueue_t * const queue,
00032     irobotButtons_t * const buttons
00033 ){
00034     uint8_t packedValues = 0;
00035 
00036     //check for NULL pointers
00037     if(!queue || !buttons){
00038         return ERROR_INVALID_PARAMETER;
00039     }
00040     //verify packet size
00041     if(xqueue_count(queue) < SENSOR_BUTTONS_SIZE){
00042         return ERROR_INVALID_PARAMETER;
00043     }
00044 
00045     packedValues = xqueue_pop(queue);
00046 
00047     buttons->play = !!(packedValues & (1 << 0));
00048     buttons->advance = !!(packedValues & (1 << 2));
00049 
00050     return ERROR_SUCCESS;
00051 }
00052 
00053 int32_t irobotReadCargoBayDigitalInputs(
00054     xqueue_t * const queue,
00055     irobotCargoBayDigitalInputs_t * const digitalInputs
00056 ){
00057     uint8_t packedValues = 0;
00058 
00059     //check for NULL pointers
00060     if(!queue || !digitalInputs){
00061         return ERROR_INVALID_PARAMETER;
00062     }
00063     //verify packet size
00064     if(xqueue_count(queue) < SENSOR_CARGO_BAY_DIGITAL_INPUTS_SIZE){
00065         return ERROR_INVALID_PARAMETER;
00066     }
00067 
00068     packedValues = xqueue_pop(queue);
00069 
00070     digitalInputs->digitalInput0 = !!(packedValues & (1 << 0));
00071     digitalInputs->digitalInput1 = !!(packedValues & (1 << 1));
00072     digitalInputs->digitalInput2 = !!(packedValues & (1 << 2));
00073     digitalInputs->digitalInput3 = !!(packedValues & (1 << 3));
00074     digitalInputs->deviceDetect = !!(packedValues & (1 << 4));
00075 
00076     return ERROR_SUCCESS;
00077 }
00078 
00079 int32_t irobotReadChargingSourcesAvailable(
00080     xqueue_t * const queue,
00081     irobotChargingSourcesAvailable_t * const sources
00082 ){
00083     uint8_t packedValues = 0;
00084     //check for NULL pointers
00085     if(!queue || !sources){
00086         return ERROR_INVALID_PARAMETER;
00087     }
00088     //verify packet size
00089     if(xqueue_count(queue) < SENSOR_CHARGING_SOURCES_AVAILABLE_SIZE){
00090         return ERROR_INVALID_PARAMETER;
00091     }
00092 
00093     packedValues = xqueue_pop(queue);
00094 
00095     sources->internalCharger = !!(packedValues & (1 << 0));
00096     sources->homeBase = !!(packedValues & (1 << 1));
00097 
00098     return ERROR_SUCCESS;
00099 }
00100 
00101 int32_t irobotReadLowSideDriver_WheelOvercurrent(
00102     xqueue_t * const queue,
00103     irobotLowSideDriver_WheelOvercurrent_t * const lsd_wo
00104 ){
00105     uint8_t packedValues = 0;
00106 
00107     //check for NULL pointers
00108     if(!queue || !lsd_wo){
00109         return ERROR_INVALID_PARAMETER;
00110     }
00111     //verify packet size
00112     if(xqueue_count(queue) < SENSOR_LOW_SIDE_DRIVER_WHEEL_OVERDRIVE_SIZE){
00113         return ERROR_INVALID_PARAMETER;
00114     }
00115 
00116     packedValues = xqueue_pop(queue);
00117 
00118     lsd_wo->lowSideDriver1 = !!(packedValues & (1 << 0));
00119     lsd_wo->lowSideDriver0 = !!(packedValues & (1 << 1));
00120     lsd_wo->lowSideDriver2 = !!(packedValues & (1 << 2));
00121     lsd_wo->rightWheel = !!(packedValues & (1 << 3));
00122     lsd_wo->leftWheel = !!(packedValues & (1 << 4));
00123 
00124     return ERROR_SUCCESS;
00125 }
00126 
00127 int32_t irobotReadSensorGroup0(
00128     xqueue_t * const queue,
00129     irobotSensorGroup0_t * const sensorGroup0
00130 ){
00131     int32_t status = ERROR_SUCCESS;
00132 
00133     //0 = 1 + 2 + 3
00134     //at least in the binary field where 2:=1+1=0, 3:=2+1=1
00135     irobotSensorGroup1_t    sensorGroup1;
00136     irobotSensorGroup2_t    sensorGroup2;
00137     irobotSensorGroup3_t    sensorGroup3;
00138 
00139     //check for NULL pointers
00140     if(!queue || !sensorGroup0){
00141         return ERROR_INVALID_PARAMETER;
00142     }
00143     //verify packet size
00144     if(xqueue_count(queue) < SENSOR_GROUP0_SIZE){
00145         return ERROR_INVALID_PARAMETER;
00146     }
00147 
00148     if(!irobot_IsError(status)){
00149         irobot_StatusMerge(&status, irobotReadSensorGroup1(queue, &sensorGroup1));
00150     }
00151     if(!irobot_IsError(status)){
00152         irobot_StatusMerge(&status, irobotReadSensorGroup2(queue, &sensorGroup2));
00153     }
00154     if(!irobot_IsError(status)){
00155         irobot_StatusMerge(&status, irobotReadSensorGroup3(queue, &sensorGroup3));
00156     }
00157     if(!irobot_IsError(status)){
00158         sensorGroup0->bumps_wheelDrops = sensorGroup1.bumps_wheelDrops;
00159         sensorGroup0->wall = sensorGroup1.wall;
00160         sensorGroup0->cliffLeft = sensorGroup1.cliffLeft;
00161         sensorGroup0->cliffFrontLeft = sensorGroup1.cliffFrontLeft;
00162         sensorGroup0->cliffFrontRight = sensorGroup1.cliffFrontRight;
00163         sensorGroup0->cliffRight = sensorGroup1.cliffRight;
00164         sensorGroup0->virtualWall = sensorGroup1.virtualWall;
00165         sensorGroup0->lowSideDriver_WheelOvercurrent = sensorGroup1.lowSideDriver_wheelovercurrent;
00166 
00167         sensorGroup0->infrared = sensorGroup2.infrared;
00168         sensorGroup0->buttons = sensorGroup2.buttons;
00169         sensorGroup0->distance = sensorGroup2.distance;
00170         sensorGroup0->angle = sensorGroup2.angle;
00171 
00172         sensorGroup0->chargingState = sensorGroup3.chargingState;
00173         sensorGroup0->voltage = sensorGroup3.voltage;
00174         sensorGroup0->current = sensorGroup3.current;
00175         sensorGroup0->batteryTemperature = sensorGroup3.batteryTemperature;
00176         sensorGroup0->batteryCharge = sensorGroup3.batteryCharge;
00177         sensorGroup0->batteryCapacity = sensorGroup3.batteryCapacity;
00178     }
00179 
00180     return status;
00181 }
00182 
00183 int32_t irobotReadSensorGroup1(
00184     xqueue_t * const queue,
00185     irobotSensorGroup1_t * const sensorGroup1
00186 ){
00187     int32_t status = ERROR_SUCCESS;
00188     //check for NULL pointers
00189     if(!queue || !sensorGroup1){
00190         return ERROR_INVALID_PARAMETER;
00191     }
00192     //verify packet size
00193     if(xqueue_count(queue) < SENSOR_GROUP1_SIZE){
00194         return ERROR_INVALID_PARAMETER;
00195     }
00196 
00197     if(!irobot_IsError(status)){
00198         irobot_StatusMerge(&status, irobotReadBumps_Wheeldrops(queue, &sensorGroup1->bumps_wheelDrops));
00199     }
00200 
00201     if(!irobot_IsError(status)){
00202         sensorGroup1->wall              = (bool)xqueue_pop(queue);
00203         sensorGroup1->cliffLeft         = (bool)xqueue_pop(queue);
00204         sensorGroup1->cliffFrontLeft    = (bool)xqueue_pop(queue);
00205         sensorGroup1->cliffFrontRight   = (bool)xqueue_pop(queue);
00206         sensorGroup1->cliffRight        = (bool)xqueue_pop(queue);
00207         sensorGroup1->virtualWall       = (bool)xqueue_pop(queue);
00208     }
00209     
00210     if(!irobot_IsError(status)){
00211         irobot_StatusMerge(&status, irobotReadLowSideDriver_WheelOvercurrent(queue, &sensorGroup1->lowSideDriver_wheelovercurrent));
00212     }
00213 
00214     xqueue_drop_many(queue, 2); //unused
00215 
00216     return status;
00217 }
00218 
00219 int32_t irobotReadSensorGroup2(
00220     xqueue_t * const queue,
00221     irobotSensorGroup2_t * const sensorGroup2
00222 ){
00223     int32_t status = ERROR_SUCCESS;
00224 
00225     //check for NULL pointers
00226     if(!queue || !sensorGroup2){
00227         return ERROR_INVALID_PARAMETER;
00228     }
00229     //verify packet size
00230     if(xqueue_count(queue) < SENSOR_GROUP2_SIZE){
00231         return ERROR_INVALID_PARAMETER;
00232     }
00233 
00234     if(!irobot_IsError(status)){
00235         sensorGroup2->infrared = xqueue_pop(queue);
00236         irobot_StatusMerge(&status, irobotReadButtons(queue, &sensorGroup2->buttons));
00237     }
00238     if(!irobot_IsError(status)){
00239         sensorGroup2->distance = (int16_t)xqueue_pop16(queue);
00240         sensorGroup2->angle = (int16_t)xqueue_pop16(queue);
00241     }
00242 
00243     return status;
00244 }
00245 
00246 int32_t irobotReadSensorGroup3(
00247     xqueue_t * const queue,
00248     irobotSensorGroup3_t * const sensorGroup3
00249 ){
00250     //check for NULL pointers
00251     if(!queue || !sensorGroup3){
00252         return ERROR_INVALID_PARAMETER;
00253     }
00254     //verify packet size
00255     if(xqueue_count(queue) < SENSOR_GROUP3_SIZE){
00256         return ERROR_INVALID_PARAMETER;
00257     }
00258 
00259     sensorGroup3->chargingState     = (irobotChargingState_t)xqueue_pop(queue);
00260     sensorGroup3->voltage           = xqueue_pop16(queue);
00261     sensorGroup3->current           = (int16_t)xqueue_pop16(queue);
00262     sensorGroup3->batteryTemperature= (int8_t)xqueue_pop(queue);
00263     sensorGroup3->batteryCharge     = xqueue_pop16(queue);
00264     sensorGroup3->batteryCapacity   = xqueue_pop16(queue);
00265     
00266     return ERROR_SUCCESS;
00267 }
00268 
00269 int32_t irobotReadSensorGroup4(
00270     xqueue_t * const queue,
00271     irobotSensorGroup4_t * const sensorGroup4
00272 ){
00273     int32_t status = ERROR_SUCCESS;
00274     //check for NULL pointers
00275     if(!queue || !sensorGroup4){
00276         return ERROR_INVALID_PARAMETER;
00277     }
00278     //verify packet size
00279     if(xqueue_count(queue) < SENSOR_GROUP4_SIZE){
00280         return ERROR_INVALID_PARAMETER;
00281     }
00282 
00283     if(!irobot_IsError(status)){
00284         sensorGroup4->wallSignal            = xqueue_pop16(queue);
00285         sensorGroup4->cliffLeftSignal       = xqueue_pop16(queue);
00286         sensorGroup4->cliffFrontLeftSignal  = xqueue_pop16(queue);
00287         sensorGroup4->cliffFrontRightSignal = xqueue_pop16(queue);
00288         sensorGroup4->cliffRightSignal      = xqueue_pop16(queue);
00289 
00290         irobot_StatusMerge(&status, irobotReadCargoBayDigitalInputs(queue, &sensorGroup4->cargoBayDigitalInputs));
00291     }
00292     if(!irobot_IsError(status)){
00293         irobot_StatusMerge(&status, irobotReadChargingSourcesAvailable(queue, &sensorGroup4->chargingSourcesAvailable));
00294     }
00295     if(!irobot_IsError(status)){
00296         sensorGroup4->cargoBayAnalogSignal  = xqueue_pop16(queue);
00297     }
00298 
00299     return status;
00300 }
00301 
00302 int32_t irobotReadSensorGroup5(
00303     xqueue_t * const queue,
00304     irobotSensorGroup5_t * const sensorGroup5
00305 ){
00306     //check for NULL pointers
00307     if(!queue || !sensorGroup5){
00308         return ERROR_INVALID_PARAMETER;
00309     }
00310     //verify packet size
00311     if(xqueue_count(queue) < SENSOR_GROUP5_SIZE){
00312         return ERROR_INVALID_PARAMETER;
00313     }
00314 
00315     sensorGroup5->oiState                       = (irobotOIState_t)xqueue_pop(queue);
00316     sensorGroup5->songNumber                    = xqueue_pop(queue);
00317     sensorGroup5->songPlaying                   = (bool)xqueue_pop(queue);
00318     sensorGroup5->nStreamPackets                = xqueue_pop(queue);
00319     sensorGroup5->requestedVelocity             = (int16_t)xqueue_pop16(queue);
00320     sensorGroup5->requestedRadius               = (int16_t)xqueue_pop16(queue);
00321     sensorGroup5->requestedRightWheelVelocity   = (int16_t)xqueue_pop16(queue);
00322     sensorGroup5->requestedLeftWheelVelocity    = (int16_t)xqueue_pop16(queue);
00323 
00324     return ERROR_SUCCESS;
00325 }
00326 
00327 int32_t irobotReadSensorGroup6(
00328     xqueue_t * const queue,
00329     irobotSensorGroup6_t * const sensorGroup6
00330 ){
00331     int32_t status = ERROR_SUCCESS;
00332     
00333     //6 = 1 + 2 + 3 + 4 + 5  = 0 + 4 + 5
00334     irobotSensorGroup0_t    sensorGroup0;
00335     irobotSensorGroup4_t    sensorGroup4;
00336     irobotSensorGroup5_t    sensorGroup5;
00337 
00338     //check for NULL pointers
00339     if(!queue || !sensorGroup6){
00340         return ERROR_INVALID_PARAMETER;
00341     }
00342     //verify packet size
00343     if(xqueue_count(queue) < SENSOR_GROUP6_SIZE){
00344         return ERROR_INVALID_PARAMETER;
00345     }
00346 
00347     if(!irobot_IsError(status)){
00348         irobot_StatusMerge(&status, irobotReadSensorGroup0(queue, &sensorGroup0));
00349     }
00350     if(!irobot_IsError(status)){
00351         irobot_StatusMerge(&status, irobotReadSensorGroup4(queue, &sensorGroup4));
00352     }
00353     if(!irobot_IsError(status)){
00354         irobot_StatusMerge(&status, irobotReadSensorGroup5(queue, &sensorGroup5));
00355     }
00356     if(!irobot_IsError(status)){
00357         sensorGroup6->bumps_wheelDrops = sensorGroup0.bumps_wheelDrops;
00358         sensorGroup6->wall = sensorGroup0.wall;
00359         sensorGroup6->cliffLeft = sensorGroup0.cliffLeft;
00360         sensorGroup6->cliffFrontLeft = sensorGroup0.cliffFrontLeft;
00361         sensorGroup6->cliffFrontRight = sensorGroup0.cliffFrontRight;
00362         sensorGroup6->cliffRight = sensorGroup0.cliffRight;
00363         sensorGroup6->virtualWall = sensorGroup0.virtualWall;
00364         sensorGroup6->lowSideDriver_WheelOvercurrent = sensorGroup0.lowSideDriver_WheelOvercurrent;
00365 
00366         sensorGroup6->infrared = sensorGroup0.infrared;
00367         sensorGroup6->buttons = sensorGroup0.buttons;
00368         sensorGroup6->distance = sensorGroup0.distance;
00369         sensorGroup6->angle = sensorGroup0.angle;
00370 
00371         sensorGroup6->chargingState = sensorGroup0.chargingState;
00372         sensorGroup6->voltage = sensorGroup0.voltage;
00373         sensorGroup6->current = sensorGroup0.current;
00374         sensorGroup6->batteryTemperature = sensorGroup0.batteryTemperature;
00375         sensorGroup6->batteryCharge = sensorGroup0.batteryCharge;
00376         sensorGroup6->batteryCapacity = sensorGroup0.batteryCapacity;
00377 
00378         sensorGroup6->wallSignal = sensorGroup4.wallSignal;
00379         sensorGroup6->cliffLeftSignal = sensorGroup4.cliffLeftSignal;
00380         sensorGroup6->cliffFrontLeftSignal = sensorGroup4.cliffFrontLeftSignal;
00381         sensorGroup6->cliffFrontRightSignal = sensorGroup4.cliffFrontRightSignal;
00382         sensorGroup6->cliffRightSignal = sensorGroup4.cliffRightSignal;
00383         sensorGroup6->cargoBayDigitalInputs = sensorGroup4.cargoBayDigitalInputs;
00384         sensorGroup6->cargoBayAnalogSignal = sensorGroup4.cargoBayAnalogSignal;
00385         sensorGroup6->chargingSourcesAvailable = sensorGroup4.chargingSourcesAvailable;
00386 
00387         sensorGroup6->oiState = sensorGroup5.oiState;
00388         sensorGroup6->songNumber = sensorGroup5.songNumber;
00389         sensorGroup6->songPlaying = sensorGroup5.songPlaying;
00390         sensorGroup6->nStreamPackets = sensorGroup5.nStreamPackets;
00391         sensorGroup6->requestedVelocity = sensorGroup5.requestedVelocity;
00392         sensorGroup6->requestedRadius = sensorGroup5.requestedRadius;
00393         sensorGroup6->requestedRightWheelVelocity = sensorGroup5.requestedRightWheelVelocity;
00394         sensorGroup6->requestedLeftWheelVelocity = sensorGroup5.requestedLeftWheelVelocity;
00395     }
00396 
00397     return status;
00398 }
00399 
00400 int32_t irobotPrintSensorGroup6(
00401     const irobotSensorGroup6_t * const sensors
00402 ){  
00403     //catch NULL pointers
00404     if(!sensors){
00405         return ERROR_INVALID_PARAMETER;
00406     }
00407 
00408     printf("\n*********** iRobot Sensors ***********\n");
00409     printf(
00410         "Wheel Drops:\tCaster[%s] Left[%s] Right[%s]\n",
00411         sensors->bumps_wheelDrops.wheeldropCaster ? "X" : " ",
00412         sensors->bumps_wheelDrops.wheeldropLeft ? "X" : " ",
00413         sensors->bumps_wheelDrops.wheeldropRight ? "X" : " "
00414     );
00415 
00416     printf(
00417         "Bumps:\t\tLeft[%s] Right[%s]\n",
00418         sensors->bumps_wheelDrops.bumpLeft ? "X" : " ",
00419         sensors->bumps_wheelDrops.bumpRight ? "X" : " "
00420     );
00421 
00422     printf("Wall:\t\t[%s]\n", sensors->wall ? "X" : " ");
00423 
00424     printf(
00425         "Cliffs:\t\tLeft[%s] FrontLeft[%s] FrontRight[%s] Right[%s]\n",
00426         sensors->cliffLeft ? "X" : " ",
00427         sensors->cliffFrontLeft ? "X" : " ",
00428         sensors->cliffFrontRight ? "X" : " ",
00429         sensors->cliffRight ? "X" : " "
00430     );
00431 
00432     printf("Virtual Wall:\t[%s]\n", sensors->virtualWall ? "X" : " ");
00433 
00434     printf(
00435         "Overcurrent:\tLSD0[%s] LSD1[%s] LSD2[%s] LeftWheel[%s] RightWheel[%s]\n",
00436         sensors->lowSideDriver_WheelOvercurrent.lowSideDriver0 ? "X" : " ",
00437         sensors->lowSideDriver_WheelOvercurrent.lowSideDriver1 ? "X" : " ",
00438         sensors->lowSideDriver_WheelOvercurrent.lowSideDriver2 ? "X" : " ",
00439         sensors->lowSideDriver_WheelOvercurrent.leftWheel ? "X" : " ",
00440         sensors->lowSideDriver_WheelOvercurrent.rightWheel ? "X" : " "
00441     );
00442 
00443     printf("Infrared:\t0x%02X\n", sensors->infrared);
00444 
00445     printf(
00446         "Buttons:\tAdvance[%s] Play[%s]\n",
00447         sensors->buttons.advance ? "X" : " ",
00448         sensors->buttons.play ? "X" : " "
00449     );
00450 
00451     printf("Position:\tDistance[%d mm] Angle[%d deg]\n", sensors->distance, sensors->angle);
00452 
00453     printf("Charging State: ");
00454     switch(sensors->chargingState){
00455     case CHARGING_STATE_NOT_CHARGING:               printf("not charging\n");   break;
00456     case CHARGING_STATE_RECONDITION_CHARGING:       printf("reconditioning\n"); break;
00457     case CHARGING_STATE_FULL_CHARGING:              printf("full, charging\n"); break;
00458     case CHARGING_STATE_TRICKLE_CHARGING:           printf("trickle\n");        break;
00459     case CHARGING_STATE_WAITING:                    printf("waiting\n");        break;
00460     case CHARGING_STATE_CHARGING_FAULT_CONDITION:   printf("fault\n");          break;
00461     default:                                        printf("unknown\n");        break;
00462     }
00463 
00464     printf(
00465         "Battery:\tVoltage[%d mV] Current[%d mA]\n",
00466         sensors->voltage,
00467         sensors->current
00468     );
00469 
00470     printf(
00471         "Battery:\tCharge[%d mAh] Capacity[%d mAh] Temp[%d C]\n",
00472         sensors->batteryCharge,
00473         sensors->batteryCapacity,
00474         sensors->batteryTemperature
00475     );
00476 
00477     printf("Wall Signal:\t%d\n", sensors->wallSignal);
00478     printf(
00479         "Cliff Signals:\tLeft[%d] FrontLeft[%d] FrontRight[%d] Right[%d]\n",
00480         sensors->cliffLeftSignal,
00481         sensors->cliffFrontLeftSignal,
00482         sensors->cliffFrontRightSignal,
00483         sensors->cliffRightSignal
00484     );
00485 
00486     printf(
00487         "Cargo DI:\tDI0[%s] DI1[%s] DI2[%s] DI3[%s] DeviceDetect[%s]\n",
00488         sensors->cargoBayDigitalInputs.digitalInput0 ? "X" : " ",
00489         sensors->cargoBayDigitalInputs.digitalInput1 ? "X" : " ",
00490         sensors->cargoBayDigitalInputs.digitalInput2 ? "X" : " ",
00491         sensors->cargoBayDigitalInputs.digitalInput3 ? "X" : " ",
00492         sensors->cargoBayDigitalInputs.deviceDetect ? "X" : " "
00493     );
00494 
00495     printf("Cargo Analog:\t%d\n", sensors->cargoBayAnalogSignal);
00496 
00497     printf(
00498         "Charge Sources:\tInternal[%s] Base[%s]\n",
00499         sensors->chargingSourcesAvailable.internalCharger ? "X" : " ",
00500         sensors->chargingSourcesAvailable.homeBase ? "X" : " "
00501     );
00502 
00503     printf("OI State:\t");
00504     switch(sensors->oiState){
00505     case OISTATE_OFF:       printf("OFF\n");    break;
00506     case OISTATE_PASSIVE:   printf("PASSIVE\n");break;
00507     case OISTATE_SAFE:      printf("SAFE\n");   break;
00508     case OISTATE_FULL:      printf("FULL\n");   break;
00509     default:                printf("UNKNOWN\n");break;
00510     }
00511 
00512     printf("Song:\t\tNumber[%d] Playing[%s]\n", sensors->songNumber, sensors->songPlaying ? "X" : " ");
00513     printf("Stream Packets:\t%d\n", sensors->nStreamPackets);
00514     printf("Requested:\tVelocity [%d] Radius[%d]\n", sensors->requestedVelocity, sensors->requestedRadius);
00515     printf("Requested:\tRight[%d] Left[%d]\n", sensors->requestedRightWheelVelocity, sensors->requestedLeftWheelVelocity);
00516 
00517     printf("*********** iRobot Sensors ***********\n");
00518 
00519     return ERROR_SUCCESS;
00520 }