Homepage Demos Overview Downloads Tutorials Reference
Credits

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

Tekkotsu v2.2
Generated Tue Oct 19 14:19:14 2004 by Doxygen 1.3.9.1