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

Tekkotsu v5.1CVS
Generated Mon May 9 04:58:38 2016 by Doxygen 1.6.3