Homepage
Demos
Overview
Downloads
Dev. Resources
Reference
Credits

ERS2xxInfo.h

Go to the documentation of this file.
00001 //-*-c++-*-
00002 
00003 // Mad props to Daishi MORI, the 220 master chief, for porting to the 220 ;)
00004 
00005 #ifndef INCLUDED_ERS2xxInfo_h
00006 #define INCLUDED_ERS2xxInfo_h
00007 
00008 #include <math.h>
00009 #ifndef PLATFORM_APERIOS
00010 typedef unsigned short word; //!< otherwise defined in Types.h
00011 #else
00012 #include <Types.h>
00013 #endif
00014 
00015 #include "CommonInfo.h"
00016 using namespace RobotInfo;
00017 
00018 //! Contains information about the ERS-2xx series of robot, such as number of joints, PID defaults, timing information, etc.
00019 /*! This is a compatability mode, which allows dual-booting
00020  *  of the same memory stick on both models without needing
00021  *  to recompile, at the expense of (a little) runtime speed. */
00022 namespace ERS2xxInfo {
00023 
00024   // *******************************
00025   //       ROBOT CONFIGURATION
00026   // *******************************
00027 
00028 
00029   const unsigned int FrameTime=8;        //!< time between frames in the motion system (milliseconds)
00030   const unsigned int NumFrames=4;        //!< the number of frames per buffer (don't forget also double buffered)
00031   const unsigned int SlowFrameTime=128;  //!< time between frames for the ears (which move slower for some reason, don't want to mix with other outputs) (milliseconds)
00032   const unsigned int NumSlowFrames=1;    //!< the number of frames per buffer being sent to ears (double buffered as well)
00033   const unsigned int SoundBufferTime=32; //!< the number of milliseconds per sound buffer... I'm not sure if this can be changed
00034   
00035   //!Corresponds to entries in ERS2xxInfo::PrimitiveName, defined at the end of this file, these are the primary grouping
00036   /*!Right now all binary joints are slow, but perhaps this won't always be the case... hence the IsFast/Slow bitmasks to select which type, in order to be more general */
00037   //!@name Output Types Information
00038   const unsigned JointsPerLeg   =  3; //!< The number of joints per leg
00039   const unsigned NumLegs        =  4; //!< The number of legs
00040   const unsigned NumLegJoints   =  JointsPerLeg*NumLegs; //!< the TOTAL number of joints on ALL legs
00041   const unsigned NumHeadJoints  =  3; //!< The number of joints in the neck
00042   const unsigned NumTailJoints  =  2; //!< The number of joints assigned to the tail
00043   const unsigned NumMouthJoints =  1; //!< the number of joints that control the mouth
00044   const unsigned NumEarJoints   =  2; //!< The number of joints which control the ears (NOT per ear, is total)
00045   const unsigned NumButtons     =  11; //!< the number of buttons that are available, see ERS2xxInfo::ButtonOffset_t
00046   const unsigned NumSensors     =  1+3+1+5;  //!< 1 dist, 3 accel, 1 thermo, 5 from power, see ERS2xxInfo::SensorOffset_t
00047   const unsigned NumLEDs        =  22; //!< The number of LEDs which can be controlled
00048   
00049   const unsigned NumPIDJoints   = NumLegJoints+NumHeadJoints+NumTailJoints+NumMouthJoints; //!< The number of joints which use PID motion - everything except ears
00050   const unsigned NumBinJoints   = NumEarJoints; //!< The number of binary joints - just the ears
00051   const unsigned NumOutputs     = NumPIDJoints + NumBinJoints + NumLEDs; //!< the total number of outputs
00052   const unsigned NumReferenceFrames = NumOutputs + 1 + NumLegs + 1 + 1; //!< for the base, paw, camera, and IR sensor reference frames
00053 
00054   const float CameraHorizFOV=57.6/180*M_PI; //!< horizontal field of view (radians)
00055   const float CameraVertFOV=47.8/180*M_PI; //!< vertical field of view (radians)
00056   const float CameraFOV=CameraHorizFOV; //!< should be set to maximum of #CameraHorizFOV or #CameraVertFOV
00057   const unsigned int CameraResolutionX=176; //!< the number of pixels available in the 'full' layer
00058   const unsigned int CameraResolutionY=144; //!< the number of pixels available in the 'full' layer
00059 
00060   const bool IsFastOutput[NumOutputs] = {
00061     // for PID joints
00062     true, true, true, //legs
00063     true, true, true,
00064     true, true, true,
00065     true, true, true,
00066     true, true, true, //head
00067     true, true,       //tail
00068     true,             //mouth
00069     // for LEDs
00070     true, true, true,           // face left side LEDs x3
00071     true, true, true,           // face right side LEDs x3
00072     true,                       // head mode LED x1
00073     true, true, true,           // back left multi LEDs x3
00074     true, true, true,           // back right multi LEDs x3
00075     true, true, true,           // tail LEDs x3
00076     true, true, true,           // face front LEDs x3
00077     true,                       // retractable head light x1
00078     true, true,                 // tail red/blue from 210
00079     // for binary joints
00080     false, false
00081   }; //!< true for joints which can be updated every 32 ms (all but the ears on a 210)
00082 
00083   //! we need this so you can tell programmatically which joints are "real" and which are "fake" in compatability mode
00084   const bool IsRealERS210[NumOutputs] = {
00085     // for PID joints
00086     true, true, true, //legs
00087     true, true, true,
00088     true, true, true,
00089     true, true, true,
00090     true, true, true, //head
00091     true, true,       //tail
00092     true,             //mouth
00093     // for LEDs
00094     true, true, true,           // face left side LEDs x3
00095     true, true, true,           // face right side LEDs x3
00096     true,                       // head mode LED x1
00097     false, false, false,        // back left multi LEDs x3
00098     false, false, false,        // back right multi LEDs x3
00099     false, false, false,        // tail LEDs x3
00100     false, false, false,        // face front LEDs x3
00101     false,                      // retractable head light x1
00102     true, true,                 // tail red/blue from 210
00103     // for binary joints
00104     true, true
00105   }; //!< true for joints which can be updated every 32 ms (all but the ears on a 210)
00106 
00107   //! we need this so you can tell programmatically which joints are "real" and which are "fake" in compatability mode
00108   const bool IsRealERS220[NumOutputs] = {
00109     // for PID joints
00110     true, true, true, //legs
00111     true, true, true,
00112     true, true, true,
00113     true, true, true,
00114     true, true, true, //head
00115     false, false,     //tail
00116     false,            //mouth
00117     // for LEDs
00118     true, true, true,           // face left side LEDs x3
00119     true, true, true,           // face right side LEDs x3
00120     true,                       // head mode LED x1
00121     true, true, true,           // back left multi LEDs x3
00122     true, true, true,           // back right multi LEDs x3
00123     true, true, true,           // tail LEDs x3
00124     true, true, true,           // face front LEDs x3
00125     true,                       // retractable head light x1
00126     false, false,               // tail red/blue from 210
00127     // for binary joints
00128     false, false
00129   }; //!< true for joints which can be updated every 32 ms (all but the ears on a 210)
00130 
00131 
00132   // *******************************
00133   //         OUTPUT OFFSETS
00134   // *******************************
00135 
00136 
00137   //!Corresponds to entries in ERS2xxInfo::PrimitiveName, defined at the end of this file
00138   //!@name Output Offsets
00139   const unsigned PIDJointOffset = 0; //!< The beginning of the PID Joints
00140   const unsigned LegOffset   = PIDJointOffset;           //!< the offset of the beginning of the leg joints
00141   const unsigned HeadOffset  = LegOffset+NumLegJoints;   //!< the offset of the beginning of the head joints
00142   const unsigned TailOffset  = HeadOffset+NumHeadJoints; //!< the offset of the beginning of the tail joints
00143   const unsigned MouthOffset = TailOffset+NumTailJoints; //!< the offset of the beginning of the mouth joint
00144 
00145   const unsigned LEDOffset   = PIDJointOffset + NumPIDJoints; //!< the offset of LEDs in WorldState::outputs and MotionCommand functions
00146 
00147   const unsigned BinJointOffset = LEDOffset+NumLEDs; //!< The beginning of the binary joints
00148   const unsigned EarOffset   = BinJointOffset;           //!< the offset of the beginning of the ear joints - note that ears aren't sensed.  They can be flicked by the environment and you won't know.  Nor will they be flicked back
00149 
00150   const unsigned BaseFrameOffset   = NumOutputs; //!< Use with kinematics to refer to base reference frame
00151   const unsigned PawFrameOffset    = BaseFrameOffset+1; //!< Use with kinematics to refer to paw reference frames (add appropriate LegOrder_t to specify which paw)
00152   const unsigned CameraFrameOffset = PawFrameOffset+NumLegs; //!< Use with kinematics to refer to camera reference frame
00153   const unsigned IRFrameOffset = CameraFrameOffset+1; //!< Use with kinematics to refer to infrared (distance) sensor reference frame
00154 
00155   //! The offsets of the individual legs
00156   enum LegOffset_t {
00157     LFrLegOffset = LegOffset+LFrLegOrder*JointsPerLeg, //!< beginning of left front leg
00158     RFrLegOffset = LegOffset+RFrLegOrder*JointsPerLeg, //!< beginning of right front leg
00159     LBkLegOffset = LegOffset+LBkLegOrder*JointsPerLeg, //!< beginning of left back leg
00160     RBkLegOffset = LegOffset+RBkLegOrder*JointsPerLeg  //!< beginning of right back leg
00161   };
00162   
00163   //@}
00164   
00165   //! The offsets of the individual LEDs on the head and tail.  Note that left/right are robot's point of view.  See also LEDBitMask_t
00166   enum LEDOffset_t {
00167     FaceFrontLeftLEDOffset = LEDOffset, //!< head face side light (front left - blue) (ERS-220)
00168     FaceFrontRightLEDOffset,    //!< head face side light (front right - blue) (ERS-220)
00169     FaceCenterLeftLEDOffset,    //!< head face side light (center left - blue) (ERS-220)
00170     FaceCenterRightLEDOffset,   //!< head face side light (center right - blue) (ERS-220)
00171     FaceBackLeftLEDOffset,      //!< head face side light (back left - red) (ERS-220)
00172     FaceBackRightLEDOffset,     //!< head face side light (back right - red) (ERS-220)
00173     ModeLEDOffset,              //!< mode indicator (back of the head - orange) (ERS-220)
00174     BackLeft1LEDOffset,         //!< back multi-indicator (left #1 - blue) (ERS-220)
00175     BackLeft2LEDOffset,         //!< back multi-indicator (left #2 - blue) (ERS-220)
00176     BackLeft3LEDOffset,         //!< back multi-indicator (left #3 - blue) (ERS-220)
00177     BackRight3LEDOffset,        //!< back multi-indicator (right #3 - blue) (ERS-220)
00178     BackRight2LEDOffset,        //!< back multi-indicator (right #2 - blue) (ERS-220)
00179     BackRight1LEDOffset,        //!< back multi-indicator (right #1 - blue) (ERS-220)
00180     TailLeftLEDOffset,          //!< tail light (left - blue) (ERS-220)
00181     TailCenterLEDOffset,        //!< tail light (center - red) (ERS-220)
00182     TailRightLEDOffset,         //!< tail light (right - blue) (ERS-220)
00183     FaceFrontBLEDOffset,        //!< face front light B (blue) (ERS-220)
00184     FaceFrontALEDOffset,        //!< face front light A (blue) (ERS-220)
00185     FaceFrontCLEDOffset,        //!< face front light C (red) (ERS-220)
00186     RetractableHeadLEDOffset,   //!< retractable head light (ERS-220)
00187  
00188     TlBluLEDOffset,             //!< blue tail light (ERS-210)
00189     TlRedLEDOffset,             //!< red tail light (ERS-210)
00190 
00191     // aliases for backward compatibility
00192     BotLLEDOffset = FaceFrontLeftLEDOffset,   //!< bottom left (red - sad) (ERS-210)
00193     BotRLEDOffset = FaceFrontRightLEDOffset,  //!< bottom right (red - sad) (ERS-210)
00194     MidLLEDOffset = FaceCenterLeftLEDOffset,  //!< middle left (green - happy) (ERS-210)
00195     MidRLEDOffset = FaceCenterRightLEDOffset, //!< middle right (green - happy) (ERS-210)
00196     TopLLEDOffset = FaceBackLeftLEDOffset,    //!< top left (red - angry) (ERS-210)
00197     TopRLEDOffset = FaceBackRightLEDOffset,   //!< top right (red - angry) (ERS-210)
00198     TopBrLEDOffset = ModeLEDOffset,           //!< top bar (green) (ERS-210)
00199   };
00200   
00201   //! Bitmasks for use when specifying combinations of LEDs (see LEDEngine ) Note that left/right are robot's point of view
00202   //!@name LED Bitmasks
00203   typedef unsigned int LEDBitMask_t; //!< So you can be clear when you're refering to a LED bitmask
00204   const LEDBitMask_t FaceFrontLeftLEDMask   = 1<<(FaceFrontLeftLEDOffset-LEDOffset);
00205   const LEDBitMask_t FaceFrontRightLEDMask  = 1<<(FaceFrontRightLEDOffset-LEDOffset);
00206   const LEDBitMask_t FaceCenterLeftLEDMask  = 1<<(FaceCenterLeftLEDOffset-LEDOffset);
00207   const LEDBitMask_t FaceCenterRightLEDMask = 1<<(FaceCenterRightLEDOffset-LEDOffset);
00208   const LEDBitMask_t FaceBackLeftLEDMask    = 1<<(FaceBackLeftLEDOffset-LEDOffset);
00209   const LEDBitMask_t FaceBackRightLEDMask   = 1<<(FaceBackRightLEDOffset-LEDOffset);
00210   const LEDBitMask_t ModeLEDMask            = 1<<(ModeLEDOffset-LEDOffset);
00211   const LEDBitMask_t BackLeft1LEDMask       = 1<<(BackLeft1LEDOffset-LEDOffset);
00212   const LEDBitMask_t BackLeft2LEDMask       = 1<<(BackLeft2LEDOffset-LEDOffset);
00213   const LEDBitMask_t BackLeft3LEDMask       = 1<<(BackLeft3LEDOffset-LEDOffset);
00214   const LEDBitMask_t BackRight3LEDMask      = 1<<(BackRight3LEDOffset-LEDOffset);
00215   const LEDBitMask_t BackRight2LEDMask      = 1<<(BackRight2LEDOffset-LEDOffset);
00216   const LEDBitMask_t BackRight1LEDMask      = 1<<(BackRight1LEDOffset-LEDOffset);
00217   const LEDBitMask_t TailLeftLEDMask        = 1<<(TailLeftLEDOffset-LEDOffset);
00218   const LEDBitMask_t TailCenterLEDMask      = 1<<(TailCenterLEDOffset-LEDOffset);
00219   const LEDBitMask_t TailRightLEDMask       = 1<<(TailRightLEDOffset-LEDOffset);
00220   const LEDBitMask_t FaceFrontBLEDMask      = 1<<(FaceFrontBLEDOffset-LEDOffset);
00221   const LEDBitMask_t FaceFrontALEDMask      = 1<<(FaceFrontALEDOffset-LEDOffset);
00222   const LEDBitMask_t FaceFrontCLEDMask      = 1<<(FaceFrontCLEDOffset-LEDOffset);
00223   const LEDBitMask_t RetractableHeadLEDMask = 1<<(RetractableHeadLEDOffset-LEDOffset);
00224   
00225   const LEDBitMask_t TlRedLEDMask= 1<<(TlRedLEDOffset-LEDOffset); //!< red tail light
00226   const LEDBitMask_t TlBluLEDMask= 1<<(TlBluLEDOffset-LEDOffset); //!< blue tail light
00227 
00228   // aliases for backward compatibility
00229   const LEDBitMask_t BotLLEDMask = 1<<(BotLLEDOffset-LEDOffset); //!< bottom left (red - sad)
00230   const LEDBitMask_t BotRLEDMask = 1<<(BotRLEDOffset-LEDOffset); //!< bottom right (red - sad)
00231   const LEDBitMask_t MidLLEDMask = 1<<(MidLLEDOffset-LEDOffset); //!< middle left (green - happy)
00232   const LEDBitMask_t MidRLEDMask = 1<<(MidRLEDOffset-LEDOffset); //!< middle right (green - happy)
00233   const LEDBitMask_t TopLLEDMask = 1<<(TopLLEDOffset-LEDOffset); //!< top left (red - angry)
00234   const LEDBitMask_t TopRLEDMask = 1<<(TopRLEDOffset-LEDOffset); //!< top right (red - angry)
00235   const LEDBitMask_t TopBrLEDMask= 1<<(TopBrLEDOffset-LEDOffset); //!< top bar (green)
00236 
00237   const LEDBitMask_t FaceLEDMask
00238   = FaceFrontLeftLEDMask
00239   | FaceFrontRightLEDMask
00240   | FaceCenterLeftLEDMask
00241   | FaceCenterRightLEDMask
00242   | FaceBackLeftLEDMask
00243   | FaceBackRightLEDMask
00244   | FaceFrontALEDMask
00245   | FaceFrontBLEDMask
00246   | FaceFrontCLEDMask
00247   | ModeLEDMask;              //!< LEDs for face
00248  
00249   const LEDBitMask_t HeadLEDMask
00250   = FaceLEDMask
00251   | RetractableHeadLEDMask;   //!< LEDs on head (face plus retractable light)
00252  
00253   const LEDBitMask_t BackLEDMask
00254   = BackLeft1LEDMask
00255   | BackLeft2LEDMask
00256   | BackLeft3LEDMask
00257   | BackRight1LEDMask
00258   | BackRight2LEDMask
00259   | BackRight3LEDMask; //!< LEDs on back
00260  
00261   const LEDBitMask_t TailLEDMask
00262   = TailLeftLEDMask
00263   | TailCenterLEDMask
00264   | TailRightLEDMask
00265   | TlRedLEDMask
00266   | TlBluLEDMask;  //!< LEDs for tail
00267  
00268   const LEDBitMask_t AllLEDMask  = (LEDBitMask_t)~0; //!< selects all of the leds
00269   //@}
00270 
00271 
00272   // *******************************
00273   //          INPUT OFFSETS
00274   // *******************************
00275 
00276 
00277   //! The order in which inputs should be stored
00278   //!@name Input Offsets
00279 
00280   //! holds offsets to different buttons in WorldState::buttons[]
00281   /*! Should be a straight mapping to the ButtonSourceIDs
00282    *
00283    *  Note that the chest (power) button is not a normal button.  It kills
00284    *  power to the motors at a hardware level, and isn't sensed in the
00285    *  normal way.  If you want to know when it is pressed (and you are
00286    *  about to shut down) see PowerSourceID::PauseSID.
00287    *
00288    *  @see WorldState::buttons @see ButtonSourceID_t */
00289   enum ButtonOffset_t {
00290     LFrPawOffset = LFrLegOrder,
00291     RFrPawOffset = RFrLegOrder,
00292     LBkPawOffset = LBkLegOrder,
00293     RBkPawOffset = RBkLegOrder,
00294     ChinButOffset= 4,
00295     BackButOffset,
00296     HeadFrButOffset, //!< see ERS210Info::HeadFrButOffset, ERS220Info::HeadFrButOffset
00297     HeadBkButOffset, //!< see ERS210Info::HeadBkButOffset, ERS220Info::HeadBkButOffset
00298     TailLeftButOffset,
00299     TailCenterButOffset,
00300     TailRightButOffset,
00301   };
00302 
00303   //! Provides a string name for each button
00304   const char* const buttonNames[NumButtons] = {
00305     "LFrPaw","RFrPaw","LBkPaw","RBkPaw",
00306     "ChinBut","BackBut","HeadFrBut","HeadBkBut",
00307     "TailLeftBut","TailCenterBut","TailRightBut"
00308   };
00309 
00310   //! holds offset to different sensor values in WorldState::sensors[]
00311   /*! @see WorldState::sensors[] */
00312   enum SensorOffset_t {
00313     IRDistOffset = 0,  //!< in millimeters
00314     BAccelOffset, //!< backward acceleration, in @f$m/s^2@f$, negative if sitting on butt (positive for faceplant)
00315     LAccelOffset, //!< acceleration to the robot's left, in @f$m/s^2@f$, negative if lying on robot's left side
00316     DAccelOffset, //!< downward acceleration, in @f$m/s^2@f$, negative if standing up... be careful about the signs on all of these...
00317     ThermoOffset, //!< in degrees Celcius
00318     PowerRemainOffset, //!< percentage, 0-1
00319     PowerThermoOffset, //!<  degrees Celcius
00320     PowerCapacityOffset, //!< milli-amp hours
00321     PowerVoltageOffset, //!< volts
00322     PowerCurrentOffset //!< milli-amp negative values (maybe positive while charging?)
00323   };
00324 
00325   //! Provides a string name for each sensor
00326   const char* const sensorNames[NumSensors] = {
00327     "IRDist",
00328     "BAccel","LAccel","DAccel",
00329     "Thermo",
00330     "PowerRemain","PowerThermo","PowerCapacity","PowerVoltage","PowerCurrent"
00331   };
00332 
00333   //@}
00334 
00335 
00336   //! The length of the strings used for each of the outputs in outputNames (doesn't include null term)
00337   const unsigned outputNameLen = 9;
00338   //! A name of uniform length for referring to joints - handy for posture files, etc.
00339   const char* const outputNames[NumOutputs] = {
00340     "LFr:rotor",
00341     "LFr:elvtr",
00342     "LFr:knee~",
00343     "RFr:rotor",
00344     "RFr:elvtr",
00345     "RFr:knee~",
00346     "LBk:rotor",
00347     "LBk:elvtr",
00348     "LBk:knee~",
00349     "RBk:rotor",
00350     "RBk:elvtr",
00351     "RBk:knee~",
00352     
00353     "NECK:tilt",
00354     "NECK:pan~",
00355     "NECK:roll",
00356     
00357     "TAIL:tilt",
00358     "TAIL:pan~",
00359     
00360     "MOUTH~~~~",
00361     
00362     "LED:botL~",
00363     "LED:botR~",
00364     "LED:midL~",
00365     "LED:midR~",
00366     "LED:topL~",
00367     "LED:topR~",
00368     "LED:topBr",
00369     
00370     "LED:bkL1~",                // "LED:tlBlu" of ERS-210
00371     "LED:bkL2~",                // "LED:tlRed" of ERS-210
00372     "LED:bkL3~",
00373     "LED:bkR3~",
00374     "LED:bkR2~",
00375     "LED:bkR1~",
00376     "LED:tailL",
00377     "LED:tailC",
00378     "LED:tailR",
00379     "LED:faceB",
00380     "LED:faceA",
00381     "LED:faceC",
00382     "LED:light",                 // retractable head light
00383     
00384     "LED:tlRed",
00385     "LED:tlBlu",
00386     
00387     "EAR:left~",
00388     "EAR:right"
00389   };
00390   
00391 
00392   //! the joint identifier strings used to refer to specific joints in OPEN-R (but not needed for others)
00393   /*!@showinitializer 
00394    * @warning IMPORTANT!!!!  DO NOT CHANGE THE ORDER OF ITEMS IN THIS TABLE!!!\n
00395    *
00396    * The offset consts defined in this file correspond to this table and will make life easier
00397    * if you feel the need to reorder things, but they aren't used perfect @e everywhere \n
00398    * In particular, assumptions are made that the pid joints will be in slots 0-numPIDJoints
00399    * and that the fast outputs (ie NOT ears) will be in slots 0-NumFastOutputs\n
00400    * There may be other assumptions not noted here!!!
00401    * @note These entries DON'T correspond to the CPC index numbers defined in WorldState (this only lists joints, and in a different order defined by OPEN-R, that one has sensors as well*/
00402   const char* const PrimitiveName [NumOutputs] = {
00403     "PRM:/r2/c1-Joint2:j1",       //!< the left front leg   the rotator
00404     "PRM:/r2/c1/c2-Joint2:j2",    //!< the left front leg   the elevator 
00405     "PRM:/r2/c1/c2/c3-Joint2:j3", //!< the left front leg   the knee 
00406     "PRM:/r4/c1-Joint2:j1",       //!< the right front leg   the rotator
00407     "PRM:/r4/c1/c2-Joint2:j2",    //!< the right front leg    the elevator 
00408     "PRM:/r4/c1/c2/c3-Joint2:j3", //!< the right front leg   the knee 
00409     
00410     "PRM:/r3/c1-Joint2:j1",       //!< the left hind leg   the rotator
00411     "PRM:/r3/c1/c2-Joint2:j2",    //!< the left hind leg   the elevator 
00412     "PRM:/r3/c1/c2/c3-Joint2:j3", //!< the left hind leg   the knee
00413     "PRM:/r5/c1-Joint2:j1",       //!< the right hind leg   the rotator
00414     "PRM:/r5/c1/c2-Joint2:j2",    //!< the right hind leg   the elevator 
00415     "PRM:/r5/c1/c2/c3-Joint2:j3", //!< the right hind leg   the knee 
00416 
00417     "PRM:/r1/c1-Joint2:j1",       //!< the neck  tilt (12)
00418     "PRM:/r1/c1/c2-Joint2:j2",    //!< the neck   pan 
00419     "PRM:/r1/c1/c2/c3-Joint2:j3", //!< the neck   roll 
00420         
00421     "PRM:/r6/c2-Joint2:j2",       //!< the tail tilt (15)       // *** NOTE ***
00422     "PRM:/r6/c1-Joint2:j1",       //!< the tail pan             // CHANGE_ET 12/16/01 matches neck order
00423     
00424     "PRM:/r1/c1/c2/c3/c4-Joint2:j4", //!< the mouth (17)
00425     
00426     "PRM:/r1/c1/c2/c3/l1-LED2:l1", //!< lower  left  LED (18)
00427     "PRM:/r1/c1/c2/c3/l4-LED2:l4", //!< lower  right LED
00428     "PRM:/r1/c1/c2/c3/l2-LED2:l2", //!< middle left  LED
00429     "PRM:/r1/c1/c2/c3/l5-LED2:l5", //!< middle right LED
00430     "PRM:/r1/c1/c2/c3/l3-LED2:l3", //!< upper  left  LED
00431     "PRM:/r1/c1/c2/c3/l6-LED2:l6", //!< upper  right LED
00432     "PRM:/r1/c1/c2/c3/l7-LED2:l7", //!< top          LED
00433     
00434     "PRM:/r6/l1-LED2:l1", //!< back 1st left LED (corresponds to tail blue LED of ERS-210) (25)
00435     "PRM:/r6/l2-LED2:l2", //!< back 2nd left LED (corresponds to tail red  LED of ERS-210)
00436     "PRM:/r6/l3-LED2:l3", //!< back 3rd left LED
00437     "PRM:/r6/l4-LED2:l4", //!< back 3rd right LED
00438     "PRM:/r6/l5-LED2:l5", //!< back 2nd right LED
00439     "PRM:/r6/l6-LED2:l6", //!< back 1st right LED
00440  
00441     "PRM:/r6/l9-LED2:l9", //!< tail left LED   (31)
00442     "PRM:/r6/l7-LED2:l7", //!< tail center LED
00443     "PRM:/r6/l8-LED2:l8", //!< tail right LED
00444  
00445     "PRM:/r1/c1/c2/c3/l8-LED2:l8", //!< face front LED B
00446     "PRM:/r1/c1/c2/c3/l9-LED2:l9", //!< face front LED A
00447     "PRM:/r1/c1/c2/c3/la-LED2:la", //!< face front LED C
00448     "PRM:/r1/c1/c2/c3/lb-LED2:lb", //!< retractable head light
00449 
00450     "PRM:/r6/l2-LED2:l2", //!< tail red LED (corresponds to back 2nd left LED of ERS-220)  (38)
00451     "PRM:/r6/l1-LED2:l1", //!< tail blue LED  (corresponds to back 1st left LED of ERS-220)
00452 
00453     "PRM:/r1/c1/c2/c3/e1-Joint3:j5", //!< left ear (40)
00454     "PRM:/r1/c1/c2/c3/e2-Joint3:j6" //!< right ear
00455   };
00456 
00457   //! use to open speaker connectio with the system
00458   const char* const SpeakerLocator="PRM:/r1/c1/c2/c3/s1-Speaker:S1";
00459 
00460   //! use to open camera connection with the system
00461   const char* const CameraLocator="PRM:/r1/c1/c2/c3/i1-FbkImageSensor:F1";
00462 
00463   //Old PID table:
00464   /*const word Pid[NumPIDJoints][6] = {
00465     { 0x16, 0x04, 0x08, 0x0E, 0x02, 0x0F },
00466     { 0x14, 0x04, 0x06, 0x0E, 0x02, 0x0F },
00467     { 0x23, 0x04, 0x05, 0x0E, 0x02, 0x0F },
00468     { 0x16, 0x04, 0x08, 0x0E, 0x02, 0x0F },
00469     { 0x14, 0x04, 0x06, 0x0E, 0x02, 0x0F },
00470     { 0x23, 0x04, 0x05, 0x0E, 0x02, 0x0F },
00471     { 0x16, 0x04, 0x08, 0x0E, 0x02, 0x0F },
00472     { 0x14, 0x04, 0x06, 0x0E, 0x02, 0x0F },
00473     { 0x23, 0x04, 0x05, 0x0E, 0x02, 0x0F },
00474     { 0x16, 0x04, 0x08, 0x0E, 0x02, 0x0F },
00475     { 0x14, 0x04, 0x06, 0x0E, 0x02, 0x0F },
00476     { 0x23, 0x04, 0x05, 0x0E, 0x02, 0x0F },
00477     
00478     { 0x0A, 0x08, 0x0C, 0x0E, 0x02, 0x0F },
00479     { 0x0D, 0x08, 0x0B, 0x0E, 0x02, 0x0F },
00480     { 0x10, 0x08, 0x0C, 0x0E, 0x02, 0x0F }, // P was 0x0C, updated as seen on https://www.openr.org/page1_2001/gain.html 8/13/2002
00481     
00482     { 0x0A, 0x00, 0x18, 0x0E, 0x02, 0x0F },
00483     { 0x07, 0x00, 0x11, 0x0E, 0x02, 0x0F },
00484     
00485     { 0x0E, 0x08, 0x10, 0x0E, 0x02, 0x0F }, //  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
00486   };*/
00487       
00488   //! This table holds the default PID values for each joint.  see PIDMC
00489   const float DefaultPIDs[NumPIDJoints][3] =
00490     {
00491       { 0x16/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x08/(double)(1<<(16-0xF)) },
00492       { 0x14/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x06/(double)(1<<(16-0xF)) },
00493       { 0x23/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x05/(double)(1<<(16-0xF)) },
00494       { 0x16/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x08/(double)(1<<(16-0xF)) },
00495       { 0x14/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x06/(double)(1<<(16-0xF)) },
00496       { 0x23/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x05/(double)(1<<(16-0xF)) },
00497       { 0x16/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x08/(double)(1<<(16-0xF)) },
00498       { 0x14/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x06/(double)(1<<(16-0xF)) },
00499       { 0x23/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x05/(double)(1<<(16-0xF)) },
00500       { 0x16/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x08/(double)(1<<(16-0xF)) },
00501       { 0x14/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x06/(double)(1<<(16-0xF)) },
00502       { 0x23/(double)(1<<(16-0xE)), 0x04/(double)(1<<(16-0x2)), 0x05/(double)(1<<(16-0xF)) },
00503 
00504       { 0x0A/(double)(1<<(16-0xE)), 0x08/(double)(1<<(16-0x2)), 0x0C/(double)(1<<(16-0xF)) },
00505       { 0x0D/(double)(1<<(16-0xE)), 0x08/(double)(1<<(16-0x2)), 0x0B/(double)(1<<(16-0xF)) },
00506       { 0x0A/(double)(1<<(16-0xE)), 0x08/(double)(1<<(16-0x2)), 0x0C/(double)(1<<(16-0xF)) },
00507 
00508       { 0x0A/(double)(1<<(16-0xE)), 0x00/(double)(1<<(16-0x2)), 0x18/(double)(1<<(16-0xF)) },
00509       { 0x07/(double)(1<<(16-0xE)), 0x00/(double)(1<<(16-0x2)), 0x11/(double)(1<<(16-0xF)) },
00510 
00511       { 0x0E/(double)(1<<(16-0xE)), 0x08/(double)(1<<(16-0x2)), 0x10/(double)(1<<(16-0xF)) }
00512     };
00513   
00514   //! These will control the shift values given to the system.  see PIDMC
00515   const unsigned char DefaultPIDShifts[3] = {0x0E, 0x02, 0x0F};
00516     
00517   //!These values are Sony's recommended maximum joint velocities, in rad/ms
00518   /*! a value <= 0 means infinite speed (e.g. LEDs)
00519    *  
00520    *  These limits are <b>not</b> enforced by the framework.  They are simply available for you to use as you see fit.
00521    *  HeadPointerMC is (as of v1.6) the only included MotionCommand to actually use these values. */
00522   const float MaxOutputSpeed[NumOutputs] = {
00523     2.8143434e-03,     //Legs LR,FB,REK
00524     2.4980025e-03,
00525     2.8361600e-03,
00526     2.8143434e-03,
00527     2.4980025e-03,
00528     2.8361600e-03,
00529     2.8143434e-03,
00530     2.4980025e-03,
00531     2.8361600e-03,
00532     2.8143434e-03,
00533     2.4980025e-03,
00534     2.8361600e-03,
00535   
00536     2.1053034e-03,     //Head TPR
00537     3.0106930e-03,
00538     3.0106930e-03,
00539   
00540     4.4724062e-03,     //Tail
00541     4.4724062e-03,
00542   
00543     4.3742314e-03,     //Mouth
00544     
00545     0,0,0,//LEDs
00546     0,0,0,
00547     0,
00548     0,0,0, 
00549     0,0,0, 
00550     0,0,0, 
00551     0,0,0, 
00552     0,
00553     0,0,
00554 
00555     0,0                //Ears
00556   };
00557 
00558 #ifndef RAD
00559   //!Just a little macro for converting degrees to radians
00560 #define RAD(deg) (((deg) * M_PI ) / 180.0)
00561   //!a flag so we undef these after we're done - do you have a cleaner solution?
00562 #define __RI_RAD_FLAG
00563 #endif
00564 
00565   //! Defines the indexes to use to access the min and max entries of ERS2xxInfo::outputRanges and ERS2xxInfo::mechanicalLimits
00566   enum MinMaxRange_t { MinRange,MaxRange };
00567 
00568   //! This table holds the software limits of each of the outputs
00569   const double outputRanges[NumOutputs][2] =
00570     {
00571       { RAD(-117),RAD(117) },{ RAD(-11),RAD(89) },{ RAD(-27),RAD(147) }, //left front REK
00572       { RAD(-117),RAD(117) },{ RAD(-11),RAD(89) },{ RAD(-27),RAD(147) }, //right front REK
00573       { RAD(-117),RAD(117) },{ RAD(-11),RAD(89) },{ RAD(-27),RAD(147) }, //left back REK
00574       { RAD(-117),RAD(117) },{ RAD(-11),RAD(89) },{ RAD(-27),RAD(147) }, //right back REK
00575 
00576       { RAD(-82),RAD(43) },{ RAD(-89.6),RAD(89.6) },{ RAD(-29),RAD(29) }, //neck TPR
00577         
00578       { RAD(-22),RAD(22) },{ RAD(-22),RAD(22) }, // tail tp
00579 
00580       { RAD(-47),RAD(-3) }, //mouth
00581 
00582       {0,1},{0,1},{0,1},        // face left side LEDs x3
00583       {0,1},{0,1},{0,1},        // face right side LEDs x3
00584       {0,1},                    // head mode LED x1
00585       {0,1},{0,1},{0,1},        // back left multi LEDs x3
00586       {0,1},{0,1},{0,1},        // back right multi LEDs x3
00587       {0,1},{0,1},{0,1},        // tail LEDs x3
00588       {0,1},{0,1},{0,1},        // face front LEDs x3
00589       {0,1},                    // retractable head light x1
00590       {0,1},{0,1},              // 210 red/blue tail light
00591 
00592       {0,1},{0,1} //ears
00593     };
00594 
00595   //! This table holds the mechanical limits of each of the outputs
00596   const double mechanicalLimits[NumOutputs][2] =
00597     {
00598       { RAD(-120),RAD(120) },{ RAD(-14),RAD(92) },{ RAD(-30),RAD(150) }, //left front jsk
00599       { RAD(-120),RAD(120) },{ RAD(-14),RAD(92) },{ RAD(-30),RAD(150) }, //right front jsk
00600       { RAD(-120),RAD(120) },{ RAD(-14),RAD(92) },{ RAD(-30),RAD(150) }, //left back jsk
00601       { RAD(-120),RAD(120) },{ RAD(-14),RAD(92) },{ RAD(-30),RAD(150) }, //right back jsk
00602 
00603       { RAD(-85),RAD(46) },{ RAD(-92.6),RAD(92.6) },{ RAD(-32),RAD(32) }, //neck tpr
00604         
00605       { RAD(-25),RAD(25) },{ RAD(-25),RAD(25) }, // tail tp
00606 
00607       { RAD(-50),RAD(0) }, //mouth
00608         
00609       {0,1},{0,1},{0,1},        // face left side LEDs x3
00610       {0,1},{0,1},{0,1},        // face right side LEDs x3
00611       {0,1},                    // head mode LED x1
00612       {0,1},{0,1},{0,1},        // back left multi LEDs x3
00613       {0,1},{0,1},{0,1},        // back right multi LEDs x3
00614       {0,1},{0,1},{0,1},        // tail LEDs x3
00615       {0,1},{0,1},{0,1},        // face front LEDs x3
00616       {0,1},                     // retractable head light x1
00617       {0,1},{0,1},              // 210 red/blue tail light
00618 
00619       {0,1},{0,1} //ears
00620     };
00621 
00622 #ifdef __RI_RAD_FLAG
00623 #undef RAD
00624 #undef __RI_RAD_FLAG
00625 #endif
00626 
00627 }
00628 
00629 /*! @file
00630  * @brief Defines RobotInfo namespace for ERS-2xx series of robots, such as joint counts, offsets, names and PID values
00631  * @author Daishi MORI (Creator)
00632  *
00633  * $Author: ejt $
00634  * $Name: tekkotsu-2_4_1 $
00635  * $Revision: 1.15 $
00636  * $State: Exp $
00637  * $Date: 2005/06/01 05:47:49 $
00638  */
00639 
00640 #endif

Tekkotsu v2.4.1
Generated Tue Aug 16 16:32:46 2005 by Doxygen 1.4.4