00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <interfaces/HumanoidMotionInterface.h>
00025
00026 #include <core/exceptions/software.h>
00027
00028 #include <cstring>
00029 #include <cstdlib>
00030
00031 namespace fawkes {
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 HumanoidMotionInterface::HumanoidMotionInterface() : Interface()
00045 {
00046 data_size = sizeof(HumanoidMotionInterface_data_t);
00047 data_ptr = malloc(data_size);
00048 data = (HumanoidMotionInterface_data_t *)data_ptr;
00049 data_ts = (interface_data_ts_t *)data_ptr;
00050 memset(data_ptr, 0, data_size);
00051 add_fieldinfo(IFT_BOOL, "moving", 1, &data->moving);
00052 add_fieldinfo(IFT_ENUM, "supporting_leg", 1, &data->supporting_leg, "LegEnum");
00053 add_fieldinfo(IFT_FLOAT, "max_step_length", 1, &data->max_step_length);
00054 add_fieldinfo(IFT_FLOAT, "max_step_height", 1, &data->max_step_height);
00055 add_fieldinfo(IFT_FLOAT, "max_step_side", 1, &data->max_step_side);
00056 add_fieldinfo(IFT_FLOAT, "max_step_turn", 1, &data->max_step_turn);
00057 add_fieldinfo(IFT_FLOAT, "zmp_offset_forward", 1, &data->zmp_offset_forward);
00058 add_fieldinfo(IFT_FLOAT, "zmp_offset_sideward", 1, &data->zmp_offset_sideward);
00059 add_fieldinfo(IFT_FLOAT, "l_hip_roll_compensation", 1, &data->l_hip_roll_compensation);
00060 add_fieldinfo(IFT_FLOAT, "r_hip_roll_compensation", 1, &data->r_hip_roll_compensation);
00061 add_fieldinfo(IFT_FLOAT, "hip_height", 1, &data->hip_height);
00062 add_fieldinfo(IFT_FLOAT, "torso_sideward_orientation", 1, &data->torso_sideward_orientation);
00063 add_fieldinfo(IFT_BOOL, "arms_enabled", 1, &data->arms_enabled);
00064 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_median", 1, &data->shoulder_pitch_median);
00065 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_amplitude", 1, &data->shoulder_pitch_amplitude);
00066 add_fieldinfo(IFT_FLOAT, "elbow_roll_median", 1, &data->elbow_roll_median);
00067 add_fieldinfo(IFT_FLOAT, "elbow_roll_amplitude", 1, &data->elbow_roll_amplitude);
00068 add_fieldinfo(IFT_UINT32, "msgid", 1, &data->msgid);
00069 add_messageinfo("SetWalkParamsMessage");
00070 add_messageinfo("SetWalkArmsParamsMessage");
00071 add_messageinfo("StopMessage");
00072 add_messageinfo("WalkStraightMessage");
00073 add_messageinfo("WalkSidewaysMessage");
00074 add_messageinfo("WalkArcMessage");
00075 add_messageinfo("TurnMessage");
00076 add_messageinfo("KickMessage");
00077 add_messageinfo("ParkMessage");
00078 add_messageinfo("GetUpMessage");
00079 add_messageinfo("StandupMessage");
00080 add_messageinfo("YawPitchHeadMessage");
00081 add_messageinfo("SetStiffnessParamsMessage");
00082 unsigned char tmp_hash[] = {0xee, 0x4a, 0x86, 0xce, 0x88, 0xf0, 0x83, 0xef, 0x80, 0xa, 0x8e, 0x3b, 0x3f, 0xae, 0xe3, 0x8b};
00083 set_hash(tmp_hash);
00084 }
00085
00086
00087 HumanoidMotionInterface::~HumanoidMotionInterface()
00088 {
00089 free(data_ptr);
00090 }
00091
00092
00093
00094
00095 const char *
00096 HumanoidMotionInterface::tostring_LegEnum(LegEnum value) const
00097 {
00098 switch (value) {
00099 case LEG_LEFT: return "LEG_LEFT";
00100 case LEG_RIGHT: return "LEG_RIGHT";
00101 default: return "UNKNOWN";
00102 }
00103 }
00104
00105
00106
00107
00108 const char *
00109 HumanoidMotionInterface::tostring_StandupEnum(StandupEnum value) const
00110 {
00111 switch (value) {
00112 case STANDUP_DETECT: return "STANDUP_DETECT";
00113 case STANDUP_BACK: return "STANDUP_BACK";
00114 case STANDUP_FRONT: return "STANDUP_FRONT";
00115 default: return "UNKNOWN";
00116 }
00117 }
00118
00119
00120
00121
00122 const char *
00123 HumanoidMotionInterface::tostring_StiffnessMotionPatternEnum(StiffnessMotionPatternEnum value) const
00124 {
00125 switch (value) {
00126 case WALK: return "WALK";
00127 case KICK: return "KICK";
00128 default: return "UNKNOWN";
00129 }
00130 }
00131
00132
00133
00134
00135
00136 bool
00137 HumanoidMotionInterface::is_moving() const
00138 {
00139 return data->moving;
00140 }
00141
00142
00143
00144
00145
00146 size_t
00147 HumanoidMotionInterface::maxlenof_moving() const
00148 {
00149 return 1;
00150 }
00151
00152
00153
00154
00155
00156 void
00157 HumanoidMotionInterface::set_moving(const bool new_moving)
00158 {
00159 data->moving = new_moving;
00160 data_changed = true;
00161 }
00162
00163
00164
00165
00166
00167 HumanoidMotionInterface::LegEnum
00168 HumanoidMotionInterface::supporting_leg() const
00169 {
00170 return data->supporting_leg;
00171 }
00172
00173
00174
00175
00176
00177 size_t
00178 HumanoidMotionInterface::maxlenof_supporting_leg() const
00179 {
00180 return 1;
00181 }
00182
00183
00184
00185
00186
00187 void
00188 HumanoidMotionInterface::set_supporting_leg(const LegEnum new_supporting_leg)
00189 {
00190 data->supporting_leg = new_supporting_leg;
00191 data_changed = true;
00192 }
00193
00194
00195
00196
00197
00198
00199
00200 float
00201 HumanoidMotionInterface::max_step_length() const
00202 {
00203 return data->max_step_length;
00204 }
00205
00206
00207
00208
00209
00210 size_t
00211 HumanoidMotionInterface::maxlenof_max_step_length() const
00212 {
00213 return 1;
00214 }
00215
00216
00217
00218
00219
00220
00221
00222 void
00223 HumanoidMotionInterface::set_max_step_length(const float new_max_step_length)
00224 {
00225 data->max_step_length = new_max_step_length;
00226 data_changed = true;
00227 }
00228
00229
00230
00231
00232
00233
00234
00235 float
00236 HumanoidMotionInterface::max_step_height() const
00237 {
00238 return data->max_step_height;
00239 }
00240
00241
00242
00243
00244
00245 size_t
00246 HumanoidMotionInterface::maxlenof_max_step_height() const
00247 {
00248 return 1;
00249 }
00250
00251
00252
00253
00254
00255
00256
00257 void
00258 HumanoidMotionInterface::set_max_step_height(const float new_max_step_height)
00259 {
00260 data->max_step_height = new_max_step_height;
00261 data_changed = true;
00262 }
00263
00264
00265
00266
00267
00268
00269
00270 float
00271 HumanoidMotionInterface::max_step_side() const
00272 {
00273 return data->max_step_side;
00274 }
00275
00276
00277
00278
00279
00280 size_t
00281 HumanoidMotionInterface::maxlenof_max_step_side() const
00282 {
00283 return 1;
00284 }
00285
00286
00287
00288
00289
00290
00291
00292 void
00293 HumanoidMotionInterface::set_max_step_side(const float new_max_step_side)
00294 {
00295 data->max_step_side = new_max_step_side;
00296 data_changed = true;
00297 }
00298
00299
00300
00301
00302
00303
00304
00305 float
00306 HumanoidMotionInterface::max_step_turn() const
00307 {
00308 return data->max_step_turn;
00309 }
00310
00311
00312
00313
00314
00315 size_t
00316 HumanoidMotionInterface::maxlenof_max_step_turn() const
00317 {
00318 return 1;
00319 }
00320
00321
00322
00323
00324
00325
00326
00327 void
00328 HumanoidMotionInterface::set_max_step_turn(const float new_max_step_turn)
00329 {
00330 data->max_step_turn = new_max_step_turn;
00331 data_changed = true;
00332 }
00333
00334
00335
00336
00337
00338
00339
00340 float
00341 HumanoidMotionInterface::zmp_offset_forward() const
00342 {
00343 return data->zmp_offset_forward;
00344 }
00345
00346
00347
00348
00349
00350 size_t
00351 HumanoidMotionInterface::maxlenof_zmp_offset_forward() const
00352 {
00353 return 1;
00354 }
00355
00356
00357
00358
00359
00360
00361
00362 void
00363 HumanoidMotionInterface::set_zmp_offset_forward(const float new_zmp_offset_forward)
00364 {
00365 data->zmp_offset_forward = new_zmp_offset_forward;
00366 data_changed = true;
00367 }
00368
00369
00370
00371
00372
00373
00374
00375 float
00376 HumanoidMotionInterface::zmp_offset_sideward() const
00377 {
00378 return data->zmp_offset_sideward;
00379 }
00380
00381
00382
00383
00384
00385 size_t
00386 HumanoidMotionInterface::maxlenof_zmp_offset_sideward() const
00387 {
00388 return 1;
00389 }
00390
00391
00392
00393
00394
00395
00396
00397 void
00398 HumanoidMotionInterface::set_zmp_offset_sideward(const float new_zmp_offset_sideward)
00399 {
00400 data->zmp_offset_sideward = new_zmp_offset_sideward;
00401 data_changed = true;
00402 }
00403
00404
00405
00406
00407
00408
00409
00410
00411 float
00412 HumanoidMotionInterface::l_hip_roll_compensation() const
00413 {
00414 return data->l_hip_roll_compensation;
00415 }
00416
00417
00418
00419
00420
00421 size_t
00422 HumanoidMotionInterface::maxlenof_l_hip_roll_compensation() const
00423 {
00424 return 1;
00425 }
00426
00427
00428
00429
00430
00431
00432
00433
00434 void
00435 HumanoidMotionInterface::set_l_hip_roll_compensation(const float new_l_hip_roll_compensation)
00436 {
00437 data->l_hip_roll_compensation = new_l_hip_roll_compensation;
00438 data_changed = true;
00439 }
00440
00441
00442
00443
00444
00445
00446
00447
00448 float
00449 HumanoidMotionInterface::r_hip_roll_compensation() const
00450 {
00451 return data->r_hip_roll_compensation;
00452 }
00453
00454
00455
00456
00457
00458 size_t
00459 HumanoidMotionInterface::maxlenof_r_hip_roll_compensation() const
00460 {
00461 return 1;
00462 }
00463
00464
00465
00466
00467
00468
00469
00470
00471 void
00472 HumanoidMotionInterface::set_r_hip_roll_compensation(const float new_r_hip_roll_compensation)
00473 {
00474 data->r_hip_roll_compensation = new_r_hip_roll_compensation;
00475 data_changed = true;
00476 }
00477
00478
00479
00480
00481
00482
00483
00484
00485 float
00486 HumanoidMotionInterface::hip_height() const
00487 {
00488 return data->hip_height;
00489 }
00490
00491
00492
00493
00494
00495 size_t
00496 HumanoidMotionInterface::maxlenof_hip_height() const
00497 {
00498 return 1;
00499 }
00500
00501
00502
00503
00504
00505
00506
00507
00508 void
00509 HumanoidMotionInterface::set_hip_height(const float new_hip_height)
00510 {
00511 data->hip_height = new_hip_height;
00512 data_changed = true;
00513 }
00514
00515
00516
00517
00518
00519
00520
00521
00522 float
00523 HumanoidMotionInterface::torso_sideward_orientation() const
00524 {
00525 return data->torso_sideward_orientation;
00526 }
00527
00528
00529
00530
00531
00532 size_t
00533 HumanoidMotionInterface::maxlenof_torso_sideward_orientation() const
00534 {
00535 return 1;
00536 }
00537
00538
00539
00540
00541
00542
00543
00544
00545 void
00546 HumanoidMotionInterface::set_torso_sideward_orientation(const float new_torso_sideward_orientation)
00547 {
00548 data->torso_sideward_orientation = new_torso_sideward_orientation;
00549 data_changed = true;
00550 }
00551
00552
00553
00554
00555
00556
00557
00558 bool
00559 HumanoidMotionInterface::is_arms_enabled() const
00560 {
00561 return data->arms_enabled;
00562 }
00563
00564
00565
00566
00567
00568 size_t
00569 HumanoidMotionInterface::maxlenof_arms_enabled() const
00570 {
00571 return 1;
00572 }
00573
00574
00575
00576
00577
00578
00579
00580 void
00581 HumanoidMotionInterface::set_arms_enabled(const bool new_arms_enabled)
00582 {
00583 data->arms_enabled = new_arms_enabled;
00584 data_changed = true;
00585 }
00586
00587
00588
00589
00590
00591
00592
00593 float
00594 HumanoidMotionInterface::shoulder_pitch_median() const
00595 {
00596 return data->shoulder_pitch_median;
00597 }
00598
00599
00600
00601
00602
00603 size_t
00604 HumanoidMotionInterface::maxlenof_shoulder_pitch_median() const
00605 {
00606 return 1;
00607 }
00608
00609
00610
00611
00612
00613
00614
00615 void
00616 HumanoidMotionInterface::set_shoulder_pitch_median(const float new_shoulder_pitch_median)
00617 {
00618 data->shoulder_pitch_median = new_shoulder_pitch_median;
00619 data_changed = true;
00620 }
00621
00622
00623
00624
00625
00626
00627
00628 float
00629 HumanoidMotionInterface::shoulder_pitch_amplitude() const
00630 {
00631 return data->shoulder_pitch_amplitude;
00632 }
00633
00634
00635
00636
00637
00638 size_t
00639 HumanoidMotionInterface::maxlenof_shoulder_pitch_amplitude() const
00640 {
00641 return 1;
00642 }
00643
00644
00645
00646
00647
00648
00649
00650 void
00651 HumanoidMotionInterface::set_shoulder_pitch_amplitude(const float new_shoulder_pitch_amplitude)
00652 {
00653 data->shoulder_pitch_amplitude = new_shoulder_pitch_amplitude;
00654 data_changed = true;
00655 }
00656
00657
00658
00659
00660
00661
00662
00663 float
00664 HumanoidMotionInterface::elbow_roll_median() const
00665 {
00666 return data->elbow_roll_median;
00667 }
00668
00669
00670
00671
00672
00673 size_t
00674 HumanoidMotionInterface::maxlenof_elbow_roll_median() const
00675 {
00676 return 1;
00677 }
00678
00679
00680
00681
00682
00683
00684
00685 void
00686 HumanoidMotionInterface::set_elbow_roll_median(const float new_elbow_roll_median)
00687 {
00688 data->elbow_roll_median = new_elbow_roll_median;
00689 data_changed = true;
00690 }
00691
00692
00693
00694
00695
00696
00697
00698 float
00699 HumanoidMotionInterface::elbow_roll_amplitude() const
00700 {
00701 return data->elbow_roll_amplitude;
00702 }
00703
00704
00705
00706
00707
00708 size_t
00709 HumanoidMotionInterface::maxlenof_elbow_roll_amplitude() const
00710 {
00711 return 1;
00712 }
00713
00714
00715
00716
00717
00718
00719
00720 void
00721 HumanoidMotionInterface::set_elbow_roll_amplitude(const float new_elbow_roll_amplitude)
00722 {
00723 data->elbow_roll_amplitude = new_elbow_roll_amplitude;
00724 data_changed = true;
00725 }
00726
00727
00728
00729
00730
00731
00732
00733
00734 uint32_t
00735 HumanoidMotionInterface::msgid() const
00736 {
00737 return data->msgid;
00738 }
00739
00740
00741
00742
00743
00744 size_t
00745 HumanoidMotionInterface::maxlenof_msgid() const
00746 {
00747 return 1;
00748 }
00749
00750
00751
00752
00753
00754
00755
00756
00757 void
00758 HumanoidMotionInterface::set_msgid(const uint32_t new_msgid)
00759 {
00760 data->msgid = new_msgid;
00761 data_changed = true;
00762 }
00763
00764
00765 Message *
00766 HumanoidMotionInterface::create_message(const char *type) const
00767 {
00768 if ( strncmp("SetWalkParamsMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00769 return new SetWalkParamsMessage();
00770 } else if ( strncmp("SetWalkArmsParamsMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00771 return new SetWalkArmsParamsMessage();
00772 } else if ( strncmp("StopMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00773 return new StopMessage();
00774 } else if ( strncmp("WalkStraightMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00775 return new WalkStraightMessage();
00776 } else if ( strncmp("WalkSidewaysMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00777 return new WalkSidewaysMessage();
00778 } else if ( strncmp("WalkArcMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00779 return new WalkArcMessage();
00780 } else if ( strncmp("TurnMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00781 return new TurnMessage();
00782 } else if ( strncmp("KickMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00783 return new KickMessage();
00784 } else if ( strncmp("ParkMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00785 return new ParkMessage();
00786 } else if ( strncmp("GetUpMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00787 return new GetUpMessage();
00788 } else if ( strncmp("StandupMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00789 return new StandupMessage();
00790 } else if ( strncmp("YawPitchHeadMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00791 return new YawPitchHeadMessage();
00792 } else if ( strncmp("SetStiffnessParamsMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00793 return new SetStiffnessParamsMessage();
00794 } else {
00795 throw UnknownTypeException("The given type '%s' does not match any known "
00796 "message type for this interface type.", type);
00797 }
00798 }
00799
00800
00801
00802
00803
00804 void
00805 HumanoidMotionInterface::copy_values(const Interface *other)
00806 {
00807 const HumanoidMotionInterface *oi = dynamic_cast<const HumanoidMotionInterface *>(other);
00808 if (oi == NULL) {
00809 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
00810 type(), other->type());
00811 }
00812 memcpy(data, oi->data, sizeof(HumanoidMotionInterface_data_t));
00813 }
00814
00815 const char *
00816 HumanoidMotionInterface::enum_tostring(const char *enumtype, int val) const
00817 {
00818 if (strcmp(enumtype, "LegEnum") == 0) {
00819 return tostring_LegEnum((LegEnum)val);
00820 }
00821 if (strcmp(enumtype, "StandupEnum") == 0) {
00822 return tostring_StandupEnum((StandupEnum)val);
00823 }
00824 if (strcmp(enumtype, "StiffnessMotionPatternEnum") == 0) {
00825 return tostring_StiffnessMotionPatternEnum((StiffnessMotionPatternEnum)val);
00826 }
00827 throw UnknownTypeException("Unknown enum type %s", enumtype);
00828 }
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850 HumanoidMotionInterface::SetWalkParamsMessage::SetWalkParamsMessage(const float ini_max_step_length, const float ini_max_step_height, const float ini_max_step_side, const float ini_max_step_turn, const float ini_zmp_offset_forward, const float ini_zmp_offset_sideward, const float ini_l_hip_roll_compensation, const float ini_r_hip_roll_compensation, const float ini_hip_height, const float ini_torso_sideward_orientation) : Message("SetWalkParamsMessage")
00851 {
00852 data_size = sizeof(SetWalkParamsMessage_data_t);
00853 data_ptr = malloc(data_size);
00854 memset(data_ptr, 0, data_size);
00855 data = (SetWalkParamsMessage_data_t *)data_ptr;
00856 data_ts = (message_data_ts_t *)data_ptr;
00857 data->max_step_length = ini_max_step_length;
00858 data->max_step_height = ini_max_step_height;
00859 data->max_step_side = ini_max_step_side;
00860 data->max_step_turn = ini_max_step_turn;
00861 data->zmp_offset_forward = ini_zmp_offset_forward;
00862 data->zmp_offset_sideward = ini_zmp_offset_sideward;
00863 data->l_hip_roll_compensation = ini_l_hip_roll_compensation;
00864 data->r_hip_roll_compensation = ini_r_hip_roll_compensation;
00865 data->hip_height = ini_hip_height;
00866 data->torso_sideward_orientation = ini_torso_sideward_orientation;
00867 add_fieldinfo(IFT_FLOAT, "max_step_length", 1, &data->max_step_length);
00868 add_fieldinfo(IFT_FLOAT, "max_step_height", 1, &data->max_step_height);
00869 add_fieldinfo(IFT_FLOAT, "max_step_side", 1, &data->max_step_side);
00870 add_fieldinfo(IFT_FLOAT, "max_step_turn", 1, &data->max_step_turn);
00871 add_fieldinfo(IFT_FLOAT, "zmp_offset_forward", 1, &data->zmp_offset_forward);
00872 add_fieldinfo(IFT_FLOAT, "zmp_offset_sideward", 1, &data->zmp_offset_sideward);
00873 add_fieldinfo(IFT_FLOAT, "l_hip_roll_compensation", 1, &data->l_hip_roll_compensation);
00874 add_fieldinfo(IFT_FLOAT, "r_hip_roll_compensation", 1, &data->r_hip_roll_compensation);
00875 add_fieldinfo(IFT_FLOAT, "hip_height", 1, &data->hip_height);
00876 add_fieldinfo(IFT_FLOAT, "torso_sideward_orientation", 1, &data->torso_sideward_orientation);
00877 }
00878
00879 HumanoidMotionInterface::SetWalkParamsMessage::SetWalkParamsMessage() : Message("SetWalkParamsMessage")
00880 {
00881 data_size = sizeof(SetWalkParamsMessage_data_t);
00882 data_ptr = malloc(data_size);
00883 memset(data_ptr, 0, data_size);
00884 data = (SetWalkParamsMessage_data_t *)data_ptr;
00885 data_ts = (message_data_ts_t *)data_ptr;
00886 add_fieldinfo(IFT_FLOAT, "max_step_length", 1, &data->max_step_length);
00887 add_fieldinfo(IFT_FLOAT, "max_step_height", 1, &data->max_step_height);
00888 add_fieldinfo(IFT_FLOAT, "max_step_side", 1, &data->max_step_side);
00889 add_fieldinfo(IFT_FLOAT, "max_step_turn", 1, &data->max_step_turn);
00890 add_fieldinfo(IFT_FLOAT, "zmp_offset_forward", 1, &data->zmp_offset_forward);
00891 add_fieldinfo(IFT_FLOAT, "zmp_offset_sideward", 1, &data->zmp_offset_sideward);
00892 add_fieldinfo(IFT_FLOAT, "l_hip_roll_compensation", 1, &data->l_hip_roll_compensation);
00893 add_fieldinfo(IFT_FLOAT, "r_hip_roll_compensation", 1, &data->r_hip_roll_compensation);
00894 add_fieldinfo(IFT_FLOAT, "hip_height", 1, &data->hip_height);
00895 add_fieldinfo(IFT_FLOAT, "torso_sideward_orientation", 1, &data->torso_sideward_orientation);
00896 }
00897
00898
00899 HumanoidMotionInterface::SetWalkParamsMessage::~SetWalkParamsMessage()
00900 {
00901 free(data_ptr);
00902 }
00903
00904
00905
00906
00907 HumanoidMotionInterface::SetWalkParamsMessage::SetWalkParamsMessage(const SetWalkParamsMessage *m) : Message("SetWalkParamsMessage")
00908 {
00909 data_size = m->data_size;
00910 data_ptr = malloc(data_size);
00911 memcpy(data_ptr, m->data_ptr, data_size);
00912 data = (SetWalkParamsMessage_data_t *)data_ptr;
00913 data_ts = (message_data_ts_t *)data_ptr;
00914 }
00915
00916
00917
00918
00919
00920
00921
00922
00923 float
00924 HumanoidMotionInterface::SetWalkParamsMessage::max_step_length() const
00925 {
00926 return data->max_step_length;
00927 }
00928
00929
00930
00931
00932
00933 size_t
00934 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_max_step_length() const
00935 {
00936 return 1;
00937 }
00938
00939
00940
00941
00942
00943
00944
00945 void
00946 HumanoidMotionInterface::SetWalkParamsMessage::set_max_step_length(const float new_max_step_length)
00947 {
00948 data->max_step_length = new_max_step_length;
00949 }
00950
00951
00952
00953
00954
00955
00956
00957 float
00958 HumanoidMotionInterface::SetWalkParamsMessage::max_step_height() const
00959 {
00960 return data->max_step_height;
00961 }
00962
00963
00964
00965
00966
00967 size_t
00968 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_max_step_height() const
00969 {
00970 return 1;
00971 }
00972
00973
00974
00975
00976
00977
00978
00979 void
00980 HumanoidMotionInterface::SetWalkParamsMessage::set_max_step_height(const float new_max_step_height)
00981 {
00982 data->max_step_height = new_max_step_height;
00983 }
00984
00985
00986
00987
00988
00989
00990
00991 float
00992 HumanoidMotionInterface::SetWalkParamsMessage::max_step_side() const
00993 {
00994 return data->max_step_side;
00995 }
00996
00997
00998
00999
01000
01001 size_t
01002 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_max_step_side() const
01003 {
01004 return 1;
01005 }
01006
01007
01008
01009
01010
01011
01012
01013 void
01014 HumanoidMotionInterface::SetWalkParamsMessage::set_max_step_side(const float new_max_step_side)
01015 {
01016 data->max_step_side = new_max_step_side;
01017 }
01018
01019
01020
01021
01022
01023
01024
01025 float
01026 HumanoidMotionInterface::SetWalkParamsMessage::max_step_turn() const
01027 {
01028 return data->max_step_turn;
01029 }
01030
01031
01032
01033
01034
01035 size_t
01036 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_max_step_turn() const
01037 {
01038 return 1;
01039 }
01040
01041
01042
01043
01044
01045
01046
01047 void
01048 HumanoidMotionInterface::SetWalkParamsMessage::set_max_step_turn(const float new_max_step_turn)
01049 {
01050 data->max_step_turn = new_max_step_turn;
01051 }
01052
01053
01054
01055
01056
01057
01058
01059 float
01060 HumanoidMotionInterface::SetWalkParamsMessage::zmp_offset_forward() const
01061 {
01062 return data->zmp_offset_forward;
01063 }
01064
01065
01066
01067
01068
01069 size_t
01070 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_zmp_offset_forward() const
01071 {
01072 return 1;
01073 }
01074
01075
01076
01077
01078
01079
01080
01081 void
01082 HumanoidMotionInterface::SetWalkParamsMessage::set_zmp_offset_forward(const float new_zmp_offset_forward)
01083 {
01084 data->zmp_offset_forward = new_zmp_offset_forward;
01085 }
01086
01087
01088
01089
01090
01091
01092
01093 float
01094 HumanoidMotionInterface::SetWalkParamsMessage::zmp_offset_sideward() const
01095 {
01096 return data->zmp_offset_sideward;
01097 }
01098
01099
01100
01101
01102
01103 size_t
01104 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_zmp_offset_sideward() const
01105 {
01106 return 1;
01107 }
01108
01109
01110
01111
01112
01113
01114
01115 void
01116 HumanoidMotionInterface::SetWalkParamsMessage::set_zmp_offset_sideward(const float new_zmp_offset_sideward)
01117 {
01118 data->zmp_offset_sideward = new_zmp_offset_sideward;
01119 }
01120
01121
01122
01123
01124
01125
01126
01127
01128 float
01129 HumanoidMotionInterface::SetWalkParamsMessage::l_hip_roll_compensation() const
01130 {
01131 return data->l_hip_roll_compensation;
01132 }
01133
01134
01135
01136
01137
01138 size_t
01139 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_l_hip_roll_compensation() const
01140 {
01141 return 1;
01142 }
01143
01144
01145
01146
01147
01148
01149
01150
01151 void
01152 HumanoidMotionInterface::SetWalkParamsMessage::set_l_hip_roll_compensation(const float new_l_hip_roll_compensation)
01153 {
01154 data->l_hip_roll_compensation = new_l_hip_roll_compensation;
01155 }
01156
01157
01158
01159
01160
01161
01162
01163
01164 float
01165 HumanoidMotionInterface::SetWalkParamsMessage::r_hip_roll_compensation() const
01166 {
01167 return data->r_hip_roll_compensation;
01168 }
01169
01170
01171
01172
01173
01174 size_t
01175 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_r_hip_roll_compensation() const
01176 {
01177 return 1;
01178 }
01179
01180
01181
01182
01183
01184
01185
01186
01187 void
01188 HumanoidMotionInterface::SetWalkParamsMessage::set_r_hip_roll_compensation(const float new_r_hip_roll_compensation)
01189 {
01190 data->r_hip_roll_compensation = new_r_hip_roll_compensation;
01191 }
01192
01193
01194
01195
01196
01197
01198
01199
01200 float
01201 HumanoidMotionInterface::SetWalkParamsMessage::hip_height() const
01202 {
01203 return data->hip_height;
01204 }
01205
01206
01207
01208
01209
01210 size_t
01211 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_hip_height() const
01212 {
01213 return 1;
01214 }
01215
01216
01217
01218
01219
01220
01221
01222
01223 void
01224 HumanoidMotionInterface::SetWalkParamsMessage::set_hip_height(const float new_hip_height)
01225 {
01226 data->hip_height = new_hip_height;
01227 }
01228
01229
01230
01231
01232
01233
01234
01235
01236 float
01237 HumanoidMotionInterface::SetWalkParamsMessage::torso_sideward_orientation() const
01238 {
01239 return data->torso_sideward_orientation;
01240 }
01241
01242
01243
01244
01245
01246 size_t
01247 HumanoidMotionInterface::SetWalkParamsMessage::maxlenof_torso_sideward_orientation() const
01248 {
01249 return 1;
01250 }
01251
01252
01253
01254
01255
01256
01257
01258
01259 void
01260 HumanoidMotionInterface::SetWalkParamsMessage::set_torso_sideward_orientation(const float new_torso_sideward_orientation)
01261 {
01262 data->torso_sideward_orientation = new_torso_sideward_orientation;
01263 }
01264
01265
01266
01267
01268
01269
01270 Message *
01271 HumanoidMotionInterface::SetWalkParamsMessage::clone() const
01272 {
01273 return new HumanoidMotionInterface::SetWalkParamsMessage(this);
01274 }
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288
01289 HumanoidMotionInterface::SetWalkArmsParamsMessage::SetWalkArmsParamsMessage(const bool ini_arms_enabled, const float ini_shoulder_pitch_median, const float ini_shoulder_pitch_amplitude, const float ini_elbow_roll_median, const float ini_elbow_roll_amplitude) : Message("SetWalkArmsParamsMessage")
01290 {
01291 data_size = sizeof(SetWalkArmsParamsMessage_data_t);
01292 data_ptr = malloc(data_size);
01293 memset(data_ptr, 0, data_size);
01294 data = (SetWalkArmsParamsMessage_data_t *)data_ptr;
01295 data_ts = (message_data_ts_t *)data_ptr;
01296 data->arms_enabled = ini_arms_enabled;
01297 data->shoulder_pitch_median = ini_shoulder_pitch_median;
01298 data->shoulder_pitch_amplitude = ini_shoulder_pitch_amplitude;
01299 data->elbow_roll_median = ini_elbow_roll_median;
01300 data->elbow_roll_amplitude = ini_elbow_roll_amplitude;
01301 add_fieldinfo(IFT_BOOL, "arms_enabled", 1, &data->arms_enabled);
01302 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_median", 1, &data->shoulder_pitch_median);
01303 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_amplitude", 1, &data->shoulder_pitch_amplitude);
01304 add_fieldinfo(IFT_FLOAT, "elbow_roll_median", 1, &data->elbow_roll_median);
01305 add_fieldinfo(IFT_FLOAT, "elbow_roll_amplitude", 1, &data->elbow_roll_amplitude);
01306 }
01307
01308 HumanoidMotionInterface::SetWalkArmsParamsMessage::SetWalkArmsParamsMessage() : Message("SetWalkArmsParamsMessage")
01309 {
01310 data_size = sizeof(SetWalkArmsParamsMessage_data_t);
01311 data_ptr = malloc(data_size);
01312 memset(data_ptr, 0, data_size);
01313 data = (SetWalkArmsParamsMessage_data_t *)data_ptr;
01314 data_ts = (message_data_ts_t *)data_ptr;
01315 add_fieldinfo(IFT_BOOL, "arms_enabled", 1, &data->arms_enabled);
01316 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_median", 1, &data->shoulder_pitch_median);
01317 add_fieldinfo(IFT_FLOAT, "shoulder_pitch_amplitude", 1, &data->shoulder_pitch_amplitude);
01318 add_fieldinfo(IFT_FLOAT, "elbow_roll_median", 1, &data->elbow_roll_median);
01319 add_fieldinfo(IFT_FLOAT, "elbow_roll_amplitude", 1, &data->elbow_roll_amplitude);
01320 }
01321
01322
01323 HumanoidMotionInterface::SetWalkArmsParamsMessage::~SetWalkArmsParamsMessage()
01324 {
01325 free(data_ptr);
01326 }
01327
01328
01329
01330
01331 HumanoidMotionInterface::SetWalkArmsParamsMessage::SetWalkArmsParamsMessage(const SetWalkArmsParamsMessage *m) : Message("SetWalkArmsParamsMessage")
01332 {
01333 data_size = m->data_size;
01334 data_ptr = malloc(data_size);
01335 memcpy(data_ptr, m->data_ptr, data_size);
01336 data = (SetWalkArmsParamsMessage_data_t *)data_ptr;
01337 data_ts = (message_data_ts_t *)data_ptr;
01338 }
01339
01340
01341
01342
01343
01344
01345
01346
01347 bool
01348 HumanoidMotionInterface::SetWalkArmsParamsMessage::is_arms_enabled() const
01349 {
01350 return data->arms_enabled;
01351 }
01352
01353
01354
01355
01356
01357 size_t
01358 HumanoidMotionInterface::SetWalkArmsParamsMessage::maxlenof_arms_enabled() const
01359 {
01360 return 1;
01361 }
01362
01363
01364
01365
01366
01367
01368
01369 void
01370 HumanoidMotionInterface::SetWalkArmsParamsMessage::set_arms_enabled(const bool new_arms_enabled)
01371 {
01372 data->arms_enabled = new_arms_enabled;
01373 }
01374
01375
01376
01377
01378
01379
01380
01381 float
01382 HumanoidMotionInterface::SetWalkArmsParamsMessage::shoulder_pitch_median() const
01383 {
01384 return data->shoulder_pitch_median;
01385 }
01386
01387
01388
01389
01390
01391 size_t
01392 HumanoidMotionInterface::SetWalkArmsParamsMessage::maxlenof_shoulder_pitch_median() const
01393 {
01394 return 1;
01395 }
01396
01397
01398
01399
01400
01401
01402
01403 void
01404 HumanoidMotionInterface::SetWalkArmsParamsMessage::set_shoulder_pitch_median(const float new_shoulder_pitch_median)
01405 {
01406 data->shoulder_pitch_median = new_shoulder_pitch_median;
01407 }
01408
01409
01410
01411
01412
01413
01414
01415 float
01416 HumanoidMotionInterface::SetWalkArmsParamsMessage::shoulder_pitch_amplitude() const
01417 {
01418 return data->shoulder_pitch_amplitude;
01419 }
01420
01421
01422
01423
01424
01425 size_t
01426 HumanoidMotionInterface::SetWalkArmsParamsMessage::maxlenof_shoulder_pitch_amplitude() const
01427 {
01428 return 1;
01429 }
01430
01431
01432
01433
01434
01435
01436
01437 void
01438 HumanoidMotionInterface::SetWalkArmsParamsMessage::set_shoulder_pitch_amplitude(const float new_shoulder_pitch_amplitude)
01439 {
01440 data->shoulder_pitch_amplitude = new_shoulder_pitch_amplitude;
01441 }
01442
01443
01444
01445
01446
01447
01448
01449 float
01450 HumanoidMotionInterface::SetWalkArmsParamsMessage::elbow_roll_median() const
01451 {
01452 return data->elbow_roll_median;
01453 }
01454
01455
01456
01457
01458
01459 size_t
01460 HumanoidMotionInterface::SetWalkArmsParamsMessage::maxlenof_elbow_roll_median() const
01461 {
01462 return 1;
01463 }
01464
01465
01466
01467
01468
01469
01470
01471 void
01472 HumanoidMotionInterface::SetWalkArmsParamsMessage::set_elbow_roll_median(const float new_elbow_roll_median)
01473 {
01474 data->elbow_roll_median = new_elbow_roll_median;
01475 }
01476
01477
01478
01479
01480
01481
01482
01483 float
01484 HumanoidMotionInterface::SetWalkArmsParamsMessage::elbow_roll_amplitude() const
01485 {
01486 return data->elbow_roll_amplitude;
01487 }
01488
01489
01490
01491
01492
01493 size_t
01494 HumanoidMotionInterface::SetWalkArmsParamsMessage::maxlenof_elbow_roll_amplitude() const
01495 {
01496 return 1;
01497 }
01498
01499
01500
01501
01502
01503
01504
01505 void
01506 HumanoidMotionInterface::SetWalkArmsParamsMessage::set_elbow_roll_amplitude(const float new_elbow_roll_amplitude)
01507 {
01508 data->elbow_roll_amplitude = new_elbow_roll_amplitude;
01509 }
01510
01511
01512
01513
01514
01515
01516 Message *
01517 HumanoidMotionInterface::SetWalkArmsParamsMessage::clone() const
01518 {
01519 return new HumanoidMotionInterface::SetWalkArmsParamsMessage(this);
01520 }
01521
01522
01523
01524
01525
01526
01527
01528
01529 HumanoidMotionInterface::StopMessage::StopMessage() : Message("StopMessage")
01530 {
01531 data_size = sizeof(StopMessage_data_t);
01532 data_ptr = malloc(data_size);
01533 memset(data_ptr, 0, data_size);
01534 data = (StopMessage_data_t *)data_ptr;
01535 data_ts = (message_data_ts_t *)data_ptr;
01536 }
01537
01538
01539 HumanoidMotionInterface::StopMessage::~StopMessage()
01540 {
01541 free(data_ptr);
01542 }
01543
01544
01545
01546
01547 HumanoidMotionInterface::StopMessage::StopMessage(const StopMessage *m) : Message("StopMessage")
01548 {
01549 data_size = m->data_size;
01550 data_ptr = malloc(data_size);
01551 memcpy(data_ptr, m->data_ptr, data_size);
01552 data = (StopMessage_data_t *)data_ptr;
01553 data_ts = (message_data_ts_t *)data_ptr;
01554 }
01555
01556
01557
01558
01559
01560
01561
01562 Message *
01563 HumanoidMotionInterface::StopMessage::clone() const
01564 {
01565 return new HumanoidMotionInterface::StopMessage(this);
01566 }
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577
01578 HumanoidMotionInterface::WalkStraightMessage::WalkStraightMessage(const float ini_distance, const uint32_t ini_num_samples) : Message("WalkStraightMessage")
01579 {
01580 data_size = sizeof(WalkStraightMessage_data_t);
01581 data_ptr = malloc(data_size);
01582 memset(data_ptr, 0, data_size);
01583 data = (WalkStraightMessage_data_t *)data_ptr;
01584 data_ts = (message_data_ts_t *)data_ptr;
01585 data->distance = ini_distance;
01586 data->num_samples = ini_num_samples;
01587 add_fieldinfo(IFT_FLOAT, "distance", 1, &data->distance);
01588 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01589 }
01590
01591 HumanoidMotionInterface::WalkStraightMessage::WalkStraightMessage() : Message("WalkStraightMessage")
01592 {
01593 data_size = sizeof(WalkStraightMessage_data_t);
01594 data_ptr = malloc(data_size);
01595 memset(data_ptr, 0, data_size);
01596 data = (WalkStraightMessage_data_t *)data_ptr;
01597 data_ts = (message_data_ts_t *)data_ptr;
01598 add_fieldinfo(IFT_FLOAT, "distance", 1, &data->distance);
01599 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01600 }
01601
01602
01603 HumanoidMotionInterface::WalkStraightMessage::~WalkStraightMessage()
01604 {
01605 free(data_ptr);
01606 }
01607
01608
01609
01610
01611 HumanoidMotionInterface::WalkStraightMessage::WalkStraightMessage(const WalkStraightMessage *m) : Message("WalkStraightMessage")
01612 {
01613 data_size = m->data_size;
01614 data_ptr = malloc(data_size);
01615 memcpy(data_ptr, m->data_ptr, data_size);
01616 data = (WalkStraightMessage_data_t *)data_ptr;
01617 data_ts = (message_data_ts_t *)data_ptr;
01618 }
01619
01620
01621
01622
01623
01624
01625 float
01626 HumanoidMotionInterface::WalkStraightMessage::distance() const
01627 {
01628 return data->distance;
01629 }
01630
01631
01632
01633
01634
01635 size_t
01636 HumanoidMotionInterface::WalkStraightMessage::maxlenof_distance() const
01637 {
01638 return 1;
01639 }
01640
01641
01642
01643
01644
01645 void
01646 HumanoidMotionInterface::WalkStraightMessage::set_distance(const float new_distance)
01647 {
01648 data->distance = new_distance;
01649 }
01650
01651
01652
01653
01654
01655
01656
01657 uint32_t
01658 HumanoidMotionInterface::WalkStraightMessage::num_samples() const
01659 {
01660 return data->num_samples;
01661 }
01662
01663
01664
01665
01666
01667 size_t
01668 HumanoidMotionInterface::WalkStraightMessage::maxlenof_num_samples() const
01669 {
01670 return 1;
01671 }
01672
01673
01674
01675
01676
01677
01678
01679 void
01680 HumanoidMotionInterface::WalkStraightMessage::set_num_samples(const uint32_t new_num_samples)
01681 {
01682 data->num_samples = new_num_samples;
01683 }
01684
01685
01686
01687
01688
01689
01690 Message *
01691 HumanoidMotionInterface::WalkStraightMessage::clone() const
01692 {
01693 return new HumanoidMotionInterface::WalkStraightMessage(this);
01694 }
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706 HumanoidMotionInterface::WalkSidewaysMessage::WalkSidewaysMessage(const float ini_distance, const uint32_t ini_num_samples) : Message("WalkSidewaysMessage")
01707 {
01708 data_size = sizeof(WalkSidewaysMessage_data_t);
01709 data_ptr = malloc(data_size);
01710 memset(data_ptr, 0, data_size);
01711 data = (WalkSidewaysMessage_data_t *)data_ptr;
01712 data_ts = (message_data_ts_t *)data_ptr;
01713 data->distance = ini_distance;
01714 data->num_samples = ini_num_samples;
01715 add_fieldinfo(IFT_FLOAT, "distance", 1, &data->distance);
01716 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01717 }
01718
01719 HumanoidMotionInterface::WalkSidewaysMessage::WalkSidewaysMessage() : Message("WalkSidewaysMessage")
01720 {
01721 data_size = sizeof(WalkSidewaysMessage_data_t);
01722 data_ptr = malloc(data_size);
01723 memset(data_ptr, 0, data_size);
01724 data = (WalkSidewaysMessage_data_t *)data_ptr;
01725 data_ts = (message_data_ts_t *)data_ptr;
01726 add_fieldinfo(IFT_FLOAT, "distance", 1, &data->distance);
01727 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01728 }
01729
01730
01731 HumanoidMotionInterface::WalkSidewaysMessage::~WalkSidewaysMessage()
01732 {
01733 free(data_ptr);
01734 }
01735
01736
01737
01738
01739 HumanoidMotionInterface::WalkSidewaysMessage::WalkSidewaysMessage(const WalkSidewaysMessage *m) : Message("WalkSidewaysMessage")
01740 {
01741 data_size = m->data_size;
01742 data_ptr = malloc(data_size);
01743 memcpy(data_ptr, m->data_ptr, data_size);
01744 data = (WalkSidewaysMessage_data_t *)data_ptr;
01745 data_ts = (message_data_ts_t *)data_ptr;
01746 }
01747
01748
01749
01750
01751
01752
01753 float
01754 HumanoidMotionInterface::WalkSidewaysMessage::distance() const
01755 {
01756 return data->distance;
01757 }
01758
01759
01760
01761
01762
01763 size_t
01764 HumanoidMotionInterface::WalkSidewaysMessage::maxlenof_distance() const
01765 {
01766 return 1;
01767 }
01768
01769
01770
01771
01772
01773 void
01774 HumanoidMotionInterface::WalkSidewaysMessage::set_distance(const float new_distance)
01775 {
01776 data->distance = new_distance;
01777 }
01778
01779
01780
01781
01782
01783
01784
01785 uint32_t
01786 HumanoidMotionInterface::WalkSidewaysMessage::num_samples() const
01787 {
01788 return data->num_samples;
01789 }
01790
01791
01792
01793
01794
01795 size_t
01796 HumanoidMotionInterface::WalkSidewaysMessage::maxlenof_num_samples() const
01797 {
01798 return 1;
01799 }
01800
01801
01802
01803
01804
01805
01806
01807 void
01808 HumanoidMotionInterface::WalkSidewaysMessage::set_num_samples(const uint32_t new_num_samples)
01809 {
01810 data->num_samples = new_num_samples;
01811 }
01812
01813
01814
01815
01816
01817
01818 Message *
01819 HumanoidMotionInterface::WalkSidewaysMessage::clone() const
01820 {
01821 return new HumanoidMotionInterface::WalkSidewaysMessage(this);
01822 }
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835 HumanoidMotionInterface::WalkArcMessage::WalkArcMessage(const float ini_angle, const float ini_radius, const uint32_t ini_num_samples) : Message("WalkArcMessage")
01836 {
01837 data_size = sizeof(WalkArcMessage_data_t);
01838 data_ptr = malloc(data_size);
01839 memset(data_ptr, 0, data_size);
01840 data = (WalkArcMessage_data_t *)data_ptr;
01841 data_ts = (message_data_ts_t *)data_ptr;
01842 data->angle = ini_angle;
01843 data->radius = ini_radius;
01844 data->num_samples = ini_num_samples;
01845 add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
01846 add_fieldinfo(IFT_FLOAT, "radius", 1, &data->radius);
01847 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01848 }
01849
01850 HumanoidMotionInterface::WalkArcMessage::WalkArcMessage() : Message("WalkArcMessage")
01851 {
01852 data_size = sizeof(WalkArcMessage_data_t);
01853 data_ptr = malloc(data_size);
01854 memset(data_ptr, 0, data_size);
01855 data = (WalkArcMessage_data_t *)data_ptr;
01856 data_ts = (message_data_ts_t *)data_ptr;
01857 add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
01858 add_fieldinfo(IFT_FLOAT, "radius", 1, &data->radius);
01859 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
01860 }
01861
01862
01863 HumanoidMotionInterface::WalkArcMessage::~WalkArcMessage()
01864 {
01865 free(data_ptr);
01866 }
01867
01868
01869
01870
01871 HumanoidMotionInterface::WalkArcMessage::WalkArcMessage(const WalkArcMessage *m) : Message("WalkArcMessage")
01872 {
01873 data_size = m->data_size;
01874 data_ptr = malloc(data_size);
01875 memcpy(data_ptr, m->data_ptr, data_size);
01876 data = (WalkArcMessage_data_t *)data_ptr;
01877 data_ts = (message_data_ts_t *)data_ptr;
01878 }
01879
01880
01881
01882
01883
01884
01885 float
01886 HumanoidMotionInterface::WalkArcMessage::angle() const
01887 {
01888 return data->angle;
01889 }
01890
01891
01892
01893
01894
01895 size_t
01896 HumanoidMotionInterface::WalkArcMessage::maxlenof_angle() const
01897 {
01898 return 1;
01899 }
01900
01901
01902
01903
01904
01905 void
01906 HumanoidMotionInterface::WalkArcMessage::set_angle(const float new_angle)
01907 {
01908 data->angle = new_angle;
01909 }
01910
01911
01912
01913
01914
01915 float
01916 HumanoidMotionInterface::WalkArcMessage::radius() const
01917 {
01918 return data->radius;
01919 }
01920
01921
01922
01923
01924
01925 size_t
01926 HumanoidMotionInterface::WalkArcMessage::maxlenof_radius() const
01927 {
01928 return 1;
01929 }
01930
01931
01932
01933
01934
01935 void
01936 HumanoidMotionInterface::WalkArcMessage::set_radius(const float new_radius)
01937 {
01938 data->radius = new_radius;
01939 }
01940
01941
01942
01943
01944
01945
01946
01947 uint32_t
01948 HumanoidMotionInterface::WalkArcMessage::num_samples() const
01949 {
01950 return data->num_samples;
01951 }
01952
01953
01954
01955
01956
01957 size_t
01958 HumanoidMotionInterface::WalkArcMessage::maxlenof_num_samples() const
01959 {
01960 return 1;
01961 }
01962
01963
01964
01965
01966
01967
01968
01969 void
01970 HumanoidMotionInterface::WalkArcMessage::set_num_samples(const uint32_t new_num_samples)
01971 {
01972 data->num_samples = new_num_samples;
01973 }
01974
01975
01976
01977
01978
01979
01980 Message *
01981 HumanoidMotionInterface::WalkArcMessage::clone() const
01982 {
01983 return new HumanoidMotionInterface::WalkArcMessage(this);
01984 }
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996 HumanoidMotionInterface::TurnMessage::TurnMessage(const float ini_angle, const uint32_t ini_num_samples) : Message("TurnMessage")
01997 {
01998 data_size = sizeof(TurnMessage_data_t);
01999 data_ptr = malloc(data_size);
02000 memset(data_ptr, 0, data_size);
02001 data = (TurnMessage_data_t *)data_ptr;
02002 data_ts = (message_data_ts_t *)data_ptr;
02003 data->angle = ini_angle;
02004 data->num_samples = ini_num_samples;
02005 add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
02006 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
02007 }
02008
02009 HumanoidMotionInterface::TurnMessage::TurnMessage() : Message("TurnMessage")
02010 {
02011 data_size = sizeof(TurnMessage_data_t);
02012 data_ptr = malloc(data_size);
02013 memset(data_ptr, 0, data_size);
02014 data = (TurnMessage_data_t *)data_ptr;
02015 data_ts = (message_data_ts_t *)data_ptr;
02016 add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
02017 add_fieldinfo(IFT_UINT32, "num_samples", 1, &data->num_samples);
02018 }
02019
02020
02021 HumanoidMotionInterface::TurnMessage::~TurnMessage()
02022 {
02023 free(data_ptr);
02024 }
02025
02026
02027
02028
02029 HumanoidMotionInterface::TurnMessage::TurnMessage(const TurnMessage *m) : Message("TurnMessage")
02030 {
02031 data_size = m->data_size;
02032 data_ptr = malloc(data_size);
02033 memcpy(data_ptr, m->data_ptr, data_size);
02034 data = (TurnMessage_data_t *)data_ptr;
02035 data_ts = (message_data_ts_t *)data_ptr;
02036 }
02037
02038
02039
02040
02041
02042
02043 float
02044 HumanoidMotionInterface::TurnMessage::angle() const
02045 {
02046 return data->angle;
02047 }
02048
02049
02050
02051
02052
02053 size_t
02054 HumanoidMotionInterface::TurnMessage::maxlenof_angle() const
02055 {
02056 return 1;
02057 }
02058
02059
02060
02061
02062
02063 void
02064 HumanoidMotionInterface::TurnMessage::set_angle(const float new_angle)
02065 {
02066 data->angle = new_angle;
02067 }
02068
02069
02070
02071
02072
02073
02074
02075 uint32_t
02076 HumanoidMotionInterface::TurnMessage::num_samples() const
02077 {
02078 return data->num_samples;
02079 }
02080
02081
02082
02083
02084
02085 size_t
02086 HumanoidMotionInterface::TurnMessage::maxlenof_num_samples() const
02087 {
02088 return 1;
02089 }
02090
02091
02092
02093
02094
02095
02096
02097 void
02098 HumanoidMotionInterface::TurnMessage::set_num_samples(const uint32_t new_num_samples)
02099 {
02100 data->num_samples = new_num_samples;
02101 }
02102
02103
02104
02105
02106
02107
02108 Message *
02109 HumanoidMotionInterface::TurnMessage::clone() const
02110 {
02111 return new HumanoidMotionInterface::TurnMessage(this);
02112 }
02113
02114
02115
02116
02117
02118
02119
02120
02121
02122
02123
02124 HumanoidMotionInterface::KickMessage::KickMessage(const LegEnum ini_leg, const float ini_strength) : Message("KickMessage")
02125 {
02126 data_size = sizeof(KickMessage_data_t);
02127 data_ptr = malloc(data_size);
02128 memset(data_ptr, 0, data_size);
02129 data = (KickMessage_data_t *)data_ptr;
02130 data_ts = (message_data_ts_t *)data_ptr;
02131 data->leg = ini_leg;
02132 data->strength = ini_strength;
02133 add_fieldinfo(IFT_ENUM, "leg", 1, &data->leg, "LegEnum");
02134 add_fieldinfo(IFT_FLOAT, "strength", 1, &data->strength);
02135 }
02136
02137 HumanoidMotionInterface::KickMessage::KickMessage() : Message("KickMessage")
02138 {
02139 data_size = sizeof(KickMessage_data_t);
02140 data_ptr = malloc(data_size);
02141 memset(data_ptr, 0, data_size);
02142 data = (KickMessage_data_t *)data_ptr;
02143 data_ts = (message_data_ts_t *)data_ptr;
02144 add_fieldinfo(IFT_ENUM, "leg", 1, &data->leg, "LegEnum");
02145 add_fieldinfo(IFT_FLOAT, "strength", 1, &data->strength);
02146 }
02147
02148
02149 HumanoidMotionInterface::KickMessage::~KickMessage()
02150 {
02151 free(data_ptr);
02152 }
02153
02154
02155
02156
02157 HumanoidMotionInterface::KickMessage::KickMessage(const KickMessage *m) : Message("KickMessage")
02158 {
02159 data_size = m->data_size;
02160 data_ptr = malloc(data_size);
02161 memcpy(data_ptr, m->data_ptr, data_size);
02162 data = (KickMessage_data_t *)data_ptr;
02163 data_ts = (message_data_ts_t *)data_ptr;
02164 }
02165
02166
02167
02168
02169
02170
02171 HumanoidMotionInterface::LegEnum
02172 HumanoidMotionInterface::KickMessage::leg() const
02173 {
02174 return data->leg;
02175 }
02176
02177
02178
02179
02180
02181 size_t
02182 HumanoidMotionInterface::KickMessage::maxlenof_leg() const
02183 {
02184 return 1;
02185 }
02186
02187
02188
02189
02190
02191 void
02192 HumanoidMotionInterface::KickMessage::set_leg(const LegEnum new_leg)
02193 {
02194 data->leg = new_leg;
02195 }
02196
02197
02198
02199
02200
02201 float
02202 HumanoidMotionInterface::KickMessage::strength() const
02203 {
02204 return data->strength;
02205 }
02206
02207
02208
02209
02210
02211 size_t
02212 HumanoidMotionInterface::KickMessage::maxlenof_strength() const
02213 {
02214 return 1;
02215 }
02216
02217
02218
02219
02220
02221 void
02222 HumanoidMotionInterface::KickMessage::set_strength(const float new_strength)
02223 {
02224 data->strength = new_strength;
02225 }
02226
02227
02228
02229
02230
02231
02232 Message *
02233 HumanoidMotionInterface::KickMessage::clone() const
02234 {
02235 return new HumanoidMotionInterface::KickMessage(this);
02236 }
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247 HumanoidMotionInterface::ParkMessage::ParkMessage(const float ini_time_sec) : Message("ParkMessage")
02248 {
02249 data_size = sizeof(ParkMessage_data_t);
02250 data_ptr = malloc(data_size);
02251 memset(data_ptr, 0, data_size);
02252 data = (ParkMessage_data_t *)data_ptr;
02253 data_ts = (message_data_ts_t *)data_ptr;
02254 data->time_sec = ini_time_sec;
02255 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02256 }
02257
02258 HumanoidMotionInterface::ParkMessage::ParkMessage() : Message("ParkMessage")
02259 {
02260 data_size = sizeof(ParkMessage_data_t);
02261 data_ptr = malloc(data_size);
02262 memset(data_ptr, 0, data_size);
02263 data = (ParkMessage_data_t *)data_ptr;
02264 data_ts = (message_data_ts_t *)data_ptr;
02265 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02266 }
02267
02268
02269 HumanoidMotionInterface::ParkMessage::~ParkMessage()
02270 {
02271 free(data_ptr);
02272 }
02273
02274
02275
02276
02277 HumanoidMotionInterface::ParkMessage::ParkMessage(const ParkMessage *m) : Message("ParkMessage")
02278 {
02279 data_size = m->data_size;
02280 data_ptr = malloc(data_size);
02281 memcpy(data_ptr, m->data_ptr, data_size);
02282 data = (ParkMessage_data_t *)data_ptr;
02283 data_ts = (message_data_ts_t *)data_ptr;
02284 }
02285
02286
02287
02288
02289
02290
02291 float
02292 HumanoidMotionInterface::ParkMessage::time_sec() const
02293 {
02294 return data->time_sec;
02295 }
02296
02297
02298
02299
02300
02301 size_t
02302 HumanoidMotionInterface::ParkMessage::maxlenof_time_sec() const
02303 {
02304 return 1;
02305 }
02306
02307
02308
02309
02310
02311 void
02312 HumanoidMotionInterface::ParkMessage::set_time_sec(const float new_time_sec)
02313 {
02314 data->time_sec = new_time_sec;
02315 }
02316
02317
02318
02319
02320
02321
02322 Message *
02323 HumanoidMotionInterface::ParkMessage::clone() const
02324 {
02325 return new HumanoidMotionInterface::ParkMessage(this);
02326 }
02327
02328
02329
02330
02331
02332
02333
02334
02335
02336
02337 HumanoidMotionInterface::GetUpMessage::GetUpMessage(const float ini_time_sec) : Message("GetUpMessage")
02338 {
02339 data_size = sizeof(GetUpMessage_data_t);
02340 data_ptr = malloc(data_size);
02341 memset(data_ptr, 0, data_size);
02342 data = (GetUpMessage_data_t *)data_ptr;
02343 data_ts = (message_data_ts_t *)data_ptr;
02344 data->time_sec = ini_time_sec;
02345 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02346 }
02347
02348 HumanoidMotionInterface::GetUpMessage::GetUpMessage() : Message("GetUpMessage")
02349 {
02350 data_size = sizeof(GetUpMessage_data_t);
02351 data_ptr = malloc(data_size);
02352 memset(data_ptr, 0, data_size);
02353 data = (GetUpMessage_data_t *)data_ptr;
02354 data_ts = (message_data_ts_t *)data_ptr;
02355 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02356 }
02357
02358
02359 HumanoidMotionInterface::GetUpMessage::~GetUpMessage()
02360 {
02361 free(data_ptr);
02362 }
02363
02364
02365
02366
02367 HumanoidMotionInterface::GetUpMessage::GetUpMessage(const GetUpMessage *m) : Message("GetUpMessage")
02368 {
02369 data_size = m->data_size;
02370 data_ptr = malloc(data_size);
02371 memcpy(data_ptr, m->data_ptr, data_size);
02372 data = (GetUpMessage_data_t *)data_ptr;
02373 data_ts = (message_data_ts_t *)data_ptr;
02374 }
02375
02376
02377
02378
02379
02380
02381 float
02382 HumanoidMotionInterface::GetUpMessage::time_sec() const
02383 {
02384 return data->time_sec;
02385 }
02386
02387
02388
02389
02390
02391 size_t
02392 HumanoidMotionInterface::GetUpMessage::maxlenof_time_sec() const
02393 {
02394 return 1;
02395 }
02396
02397
02398
02399
02400
02401 void
02402 HumanoidMotionInterface::GetUpMessage::set_time_sec(const float new_time_sec)
02403 {
02404 data->time_sec = new_time_sec;
02405 }
02406
02407
02408
02409
02410
02411
02412 Message *
02413 HumanoidMotionInterface::GetUpMessage::clone() const
02414 {
02415 return new HumanoidMotionInterface::GetUpMessage(this);
02416 }
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427 HumanoidMotionInterface::StandupMessage::StandupMessage(const StandupEnum ini_from_pos) : Message("StandupMessage")
02428 {
02429 data_size = sizeof(StandupMessage_data_t);
02430 data_ptr = malloc(data_size);
02431 memset(data_ptr, 0, data_size);
02432 data = (StandupMessage_data_t *)data_ptr;
02433 data_ts = (message_data_ts_t *)data_ptr;
02434 data->from_pos = ini_from_pos;
02435 add_fieldinfo(IFT_ENUM, "from_pos", 1, &data->from_pos, "StandupEnum");
02436 }
02437
02438 HumanoidMotionInterface::StandupMessage::StandupMessage() : Message("StandupMessage")
02439 {
02440 data_size = sizeof(StandupMessage_data_t);
02441 data_ptr = malloc(data_size);
02442 memset(data_ptr, 0, data_size);
02443 data = (StandupMessage_data_t *)data_ptr;
02444 data_ts = (message_data_ts_t *)data_ptr;
02445 add_fieldinfo(IFT_ENUM, "from_pos", 1, &data->from_pos, "StandupEnum");
02446 }
02447
02448
02449 HumanoidMotionInterface::StandupMessage::~StandupMessage()
02450 {
02451 free(data_ptr);
02452 }
02453
02454
02455
02456
02457 HumanoidMotionInterface::StandupMessage::StandupMessage(const StandupMessage *m) : Message("StandupMessage")
02458 {
02459 data_size = m->data_size;
02460 data_ptr = malloc(data_size);
02461 memcpy(data_ptr, m->data_ptr, data_size);
02462 data = (StandupMessage_data_t *)data_ptr;
02463 data_ts = (message_data_ts_t *)data_ptr;
02464 }
02465
02466
02467
02468
02469
02470
02471 HumanoidMotionInterface::StandupEnum
02472 HumanoidMotionInterface::StandupMessage::from_pos() const
02473 {
02474 return data->from_pos;
02475 }
02476
02477
02478
02479
02480
02481 size_t
02482 HumanoidMotionInterface::StandupMessage::maxlenof_from_pos() const
02483 {
02484 return 1;
02485 }
02486
02487
02488
02489
02490
02491 void
02492 HumanoidMotionInterface::StandupMessage::set_from_pos(const StandupEnum new_from_pos)
02493 {
02494 data->from_pos = new_from_pos;
02495 }
02496
02497
02498
02499
02500
02501
02502 Message *
02503 HumanoidMotionInterface::StandupMessage::clone() const
02504 {
02505 return new HumanoidMotionInterface::StandupMessage(this);
02506 }
02507
02508
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519 HumanoidMotionInterface::YawPitchHeadMessage::YawPitchHeadMessage(const float ini_yaw, const float ini_pitch, const float ini_time_sec) : Message("YawPitchHeadMessage")
02520 {
02521 data_size = sizeof(YawPitchHeadMessage_data_t);
02522 data_ptr = malloc(data_size);
02523 memset(data_ptr, 0, data_size);
02524 data = (YawPitchHeadMessage_data_t *)data_ptr;
02525 data_ts = (message_data_ts_t *)data_ptr;
02526 data->yaw = ini_yaw;
02527 data->pitch = ini_pitch;
02528 data->time_sec = ini_time_sec;
02529 add_fieldinfo(IFT_FLOAT, "yaw", 1, &data->yaw);
02530 add_fieldinfo(IFT_FLOAT, "pitch", 1, &data->pitch);
02531 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02532 }
02533
02534 HumanoidMotionInterface::YawPitchHeadMessage::YawPitchHeadMessage() : Message("YawPitchHeadMessage")
02535 {
02536 data_size = sizeof(YawPitchHeadMessage_data_t);
02537 data_ptr = malloc(data_size);
02538 memset(data_ptr, 0, data_size);
02539 data = (YawPitchHeadMessage_data_t *)data_ptr;
02540 data_ts = (message_data_ts_t *)data_ptr;
02541 add_fieldinfo(IFT_FLOAT, "yaw", 1, &data->yaw);
02542 add_fieldinfo(IFT_FLOAT, "pitch", 1, &data->pitch);
02543 add_fieldinfo(IFT_FLOAT, "time_sec", 1, &data->time_sec);
02544 }
02545
02546
02547 HumanoidMotionInterface::YawPitchHeadMessage::~YawPitchHeadMessage()
02548 {
02549 free(data_ptr);
02550 }
02551
02552
02553
02554
02555 HumanoidMotionInterface::YawPitchHeadMessage::YawPitchHeadMessage(const YawPitchHeadMessage *m) : Message("YawPitchHeadMessage")
02556 {
02557 data_size = m->data_size;
02558 data_ptr = malloc(data_size);
02559 memcpy(data_ptr, m->data_ptr, data_size);
02560 data = (YawPitchHeadMessage_data_t *)data_ptr;
02561 data_ts = (message_data_ts_t *)data_ptr;
02562 }
02563
02564
02565
02566
02567
02568
02569 float
02570 HumanoidMotionInterface::YawPitchHeadMessage::yaw() const
02571 {
02572 return data->yaw;
02573 }
02574
02575
02576
02577
02578
02579 size_t
02580 HumanoidMotionInterface::YawPitchHeadMessage::maxlenof_yaw() const
02581 {
02582 return 1;
02583 }
02584
02585
02586
02587
02588
02589 void
02590 HumanoidMotionInterface::YawPitchHeadMessage::set_yaw(const float new_yaw)
02591 {
02592 data->yaw = new_yaw;
02593 }
02594
02595
02596
02597
02598
02599 float
02600 HumanoidMotionInterface::YawPitchHeadMessage::pitch() const
02601 {
02602 return data->pitch;
02603 }
02604
02605
02606
02607
02608
02609 size_t
02610 HumanoidMotionInterface::YawPitchHeadMessage::maxlenof_pitch() const
02611 {
02612 return 1;
02613 }
02614
02615
02616
02617
02618
02619 void
02620 HumanoidMotionInterface::YawPitchHeadMessage::set_pitch(const float new_pitch)
02621 {
02622 data->pitch = new_pitch;
02623 }
02624
02625
02626
02627
02628
02629 float
02630 HumanoidMotionInterface::YawPitchHeadMessage::time_sec() const
02631 {
02632 return data->time_sec;
02633 }
02634
02635
02636
02637
02638
02639 size_t
02640 HumanoidMotionInterface::YawPitchHeadMessage::maxlenof_time_sec() const
02641 {
02642 return 1;
02643 }
02644
02645
02646
02647
02648
02649 void
02650 HumanoidMotionInterface::YawPitchHeadMessage::set_time_sec(const float new_time_sec)
02651 {
02652 data->time_sec = new_time_sec;
02653 }
02654
02655
02656
02657
02658
02659
02660 Message *
02661 HumanoidMotionInterface::YawPitchHeadMessage::clone() const
02662 {
02663 return new HumanoidMotionInterface::YawPitchHeadMessage(this);
02664 }
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682
02683
02684
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
02696
02697 HumanoidMotionInterface::SetStiffnessParamsMessage::SetStiffnessParamsMessage(const StiffnessMotionPatternEnum ini_motion_pattern, const float ini_head_yaw, const float ini_head_pitch, const float ini_l_shoulder_pitch, const float ini_l_shoulder_roll, const float ini_l_elbow_yaw, const float ini_l_elbow_roll, const float ini_l_hip_yaw_pitch, const float ini_l_hip_roll, const float ini_l_hip_pitch, const float ini_l_knee_pitch, const float ini_l_ankle_pitch, const float ini_l_ankle_roll, const float ini_r_hip_yaw_pitch, const float ini_r_hip_roll, const float ini_r_hip_pitch, const float ini_r_knee_pitch, const float ini_r_ankle_pitch, const float ini_r_ankle_roll, const float ini_r_shoulder_pitch, const float ini_r_shoulder_roll, const float ini_r_elbow_yaw, const float ini_r_elbow_roll) : Message("SetStiffnessParamsMessage")
02698 {
02699 data_size = sizeof(SetStiffnessParamsMessage_data_t);
02700 data_ptr = malloc(data_size);
02701 memset(data_ptr, 0, data_size);
02702 data = (SetStiffnessParamsMessage_data_t *)data_ptr;
02703 data_ts = (message_data_ts_t *)data_ptr;
02704 data->motion_pattern = ini_motion_pattern;
02705 data->head_yaw = ini_head_yaw;
02706 data->head_pitch = ini_head_pitch;
02707 data->l_shoulder_pitch = ini_l_shoulder_pitch;
02708 data->l_shoulder_roll = ini_l_shoulder_roll;
02709 data->l_elbow_yaw = ini_l_elbow_yaw;
02710 data->l_elbow_roll = ini_l_elbow_roll;
02711 data->l_hip_yaw_pitch = ini_l_hip_yaw_pitch;
02712 data->l_hip_roll = ini_l_hip_roll;
02713 data->l_hip_pitch = ini_l_hip_pitch;
02714 data->l_knee_pitch = ini_l_knee_pitch;
02715 data->l_ankle_pitch = ini_l_ankle_pitch;
02716 data->l_ankle_roll = ini_l_ankle_roll;
02717 data->r_hip_yaw_pitch = ini_r_hip_yaw_pitch;
02718 data->r_hip_roll = ini_r_hip_roll;
02719 data->r_hip_pitch = ini_r_hip_pitch;
02720 data->r_knee_pitch = ini_r_knee_pitch;
02721 data->r_ankle_pitch = ini_r_ankle_pitch;
02722 data->r_ankle_roll = ini_r_ankle_roll;
02723 data->r_shoulder_pitch = ini_r_shoulder_pitch;
02724 data->r_shoulder_roll = ini_r_shoulder_roll;
02725 data->r_elbow_yaw = ini_r_elbow_yaw;
02726 data->r_elbow_roll = ini_r_elbow_roll;
02727 add_fieldinfo(IFT_ENUM, "motion_pattern", 1, &data->motion_pattern, "StiffnessMotionPatternEnum");
02728 add_fieldinfo(IFT_FLOAT, "head_yaw", 1, &data->head_yaw);
02729 add_fieldinfo(IFT_FLOAT, "head_pitch", 1, &data->head_pitch);
02730 add_fieldinfo(IFT_FLOAT, "l_shoulder_pitch", 1, &data->l_shoulder_pitch);
02731 add_fieldinfo(IFT_FLOAT, "l_shoulder_roll", 1, &data->l_shoulder_roll);
02732 add_fieldinfo(IFT_FLOAT, "l_elbow_yaw", 1, &data->l_elbow_yaw);
02733 add_fieldinfo(IFT_FLOAT, "l_elbow_roll", 1, &data->l_elbow_roll);
02734 add_fieldinfo(IFT_FLOAT, "l_hip_yaw_pitch", 1, &data->l_hip_yaw_pitch);
02735 add_fieldinfo(IFT_FLOAT, "l_hip_roll", 1, &data->l_hip_roll);
02736 add_fieldinfo(IFT_FLOAT, "l_hip_pitch", 1, &data->l_hip_pitch);
02737 add_fieldinfo(IFT_FLOAT, "l_knee_pitch", 1, &data->l_knee_pitch);
02738 add_fieldinfo(IFT_FLOAT, "l_ankle_pitch", 1, &data->l_ankle_pitch);
02739 add_fieldinfo(IFT_FLOAT, "l_ankle_roll", 1, &data->l_ankle_roll);
02740 add_fieldinfo(IFT_FLOAT, "r_hip_yaw_pitch", 1, &data->r_hip_yaw_pitch);
02741 add_fieldinfo(IFT_FLOAT, "r_hip_roll", 1, &data->r_hip_roll);
02742 add_fieldinfo(IFT_FLOAT, "r_hip_pitch", 1, &data->r_hip_pitch);
02743 add_fieldinfo(IFT_FLOAT, "r_knee_pitch", 1, &data->r_knee_pitch);
02744 add_fieldinfo(IFT_FLOAT, "r_ankle_pitch", 1, &data->r_ankle_pitch);
02745 add_fieldinfo(IFT_FLOAT, "r_ankle_roll", 1, &data->r_ankle_roll);
02746 add_fieldinfo(IFT_FLOAT, "r_shoulder_pitch", 1, &data->r_shoulder_pitch);
02747 add_fieldinfo(IFT_FLOAT, "r_shoulder_roll", 1, &data->r_shoulder_roll);
02748 add_fieldinfo(IFT_FLOAT, "r_elbow_yaw", 1, &data->r_elbow_yaw);
02749 add_fieldinfo(IFT_FLOAT, "r_elbow_roll", 1, &data->r_elbow_roll);
02750 }
02751
02752 HumanoidMotionInterface::SetStiffnessParamsMessage::SetStiffnessParamsMessage() : Message("SetStiffnessParamsMessage")
02753 {
02754 data_size = sizeof(SetStiffnessParamsMessage_data_t);
02755 data_ptr = malloc(data_size);
02756 memset(data_ptr, 0, data_size);
02757 data = (SetStiffnessParamsMessage_data_t *)data_ptr;
02758 data_ts = (message_data_ts_t *)data_ptr;
02759 add_fieldinfo(IFT_ENUM, "motion_pattern", 1, &data->motion_pattern, "StiffnessMotionPatternEnum");
02760 add_fieldinfo(IFT_FLOAT, "head_yaw", 1, &data->head_yaw);
02761 add_fieldinfo(IFT_FLOAT, "head_pitch", 1, &data->head_pitch);
02762 add_fieldinfo(IFT_FLOAT, "l_shoulder_pitch", 1, &data->l_shoulder_pitch);
02763 add_fieldinfo(IFT_FLOAT, "l_shoulder_roll", 1, &data->l_shoulder_roll);
02764 add_fieldinfo(IFT_FLOAT, "l_elbow_yaw", 1, &data->l_elbow_yaw);
02765 add_fieldinfo(IFT_FLOAT, "l_elbow_roll", 1, &data->l_elbow_roll);
02766 add_fieldinfo(IFT_FLOAT, "l_hip_yaw_pitch", 1, &data->l_hip_yaw_pitch);
02767 add_fieldinfo(IFT_FLOAT, "l_hip_roll", 1, &data->l_hip_roll);
02768 add_fieldinfo(IFT_FLOAT, "l_hip_pitch", 1, &data->l_hip_pitch);
02769 add_fieldinfo(IFT_FLOAT, "l_knee_pitch", 1, &data->l_knee_pitch);
02770 add_fieldinfo(IFT_FLOAT, "l_ankle_pitch", 1, &data->l_ankle_pitch);
02771 add_fieldinfo(IFT_FLOAT, "l_ankle_roll", 1, &data->l_ankle_roll);
02772 add_fieldinfo(IFT_FLOAT, "r_hip_yaw_pitch", 1, &data->r_hip_yaw_pitch);
02773 add_fieldinfo(IFT_FLOAT, "r_hip_roll", 1, &data->r_hip_roll);
02774 add_fieldinfo(IFT_FLOAT, "r_hip_pitch", 1, &data->r_hip_pitch);
02775 add_fieldinfo(IFT_FLOAT, "r_knee_pitch", 1, &data->r_knee_pitch);
02776 add_fieldinfo(IFT_FLOAT, "r_ankle_pitch", 1, &data->r_ankle_pitch);
02777 add_fieldinfo(IFT_FLOAT, "r_ankle_roll", 1, &data->r_ankle_roll);
02778 add_fieldinfo(IFT_FLOAT, "r_shoulder_pitch", 1, &data->r_shoulder_pitch);
02779 add_fieldinfo(IFT_FLOAT, "r_shoulder_roll", 1, &data->r_shoulder_roll);
02780 add_fieldinfo(IFT_FLOAT, "r_elbow_yaw", 1, &data->r_elbow_yaw);
02781 add_fieldinfo(IFT_FLOAT, "r_elbow_roll", 1, &data->r_elbow_roll);
02782 }
02783
02784
02785 HumanoidMotionInterface::SetStiffnessParamsMessage::~SetStiffnessParamsMessage()
02786 {
02787 free(data_ptr);
02788 }
02789
02790
02791
02792
02793 HumanoidMotionInterface::SetStiffnessParamsMessage::SetStiffnessParamsMessage(const SetStiffnessParamsMessage *m) : Message("SetStiffnessParamsMessage")
02794 {
02795 data_size = m->data_size;
02796 data_ptr = malloc(data_size);
02797 memcpy(data_ptr, m->data_ptr, data_size);
02798 data = (SetStiffnessParamsMessage_data_t *)data_ptr;
02799 data_ts = (message_data_ts_t *)data_ptr;
02800 }
02801
02802
02803
02804
02805
02806
02807 HumanoidMotionInterface::StiffnessMotionPatternEnum
02808 HumanoidMotionInterface::SetStiffnessParamsMessage::motion_pattern() const
02809 {
02810 return data->motion_pattern;
02811 }
02812
02813
02814
02815
02816
02817 size_t
02818 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_motion_pattern() const
02819 {
02820 return 1;
02821 }
02822
02823
02824
02825
02826
02827 void
02828 HumanoidMotionInterface::SetStiffnessParamsMessage::set_motion_pattern(const StiffnessMotionPatternEnum new_motion_pattern)
02829 {
02830 data->motion_pattern = new_motion_pattern;
02831 }
02832
02833
02834
02835
02836
02837 float
02838 HumanoidMotionInterface::SetStiffnessParamsMessage::head_yaw() const
02839 {
02840 return data->head_yaw;
02841 }
02842
02843
02844
02845
02846
02847 size_t
02848 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_head_yaw() const
02849 {
02850 return 1;
02851 }
02852
02853
02854
02855
02856
02857 void
02858 HumanoidMotionInterface::SetStiffnessParamsMessage::set_head_yaw(const float new_head_yaw)
02859 {
02860 data->head_yaw = new_head_yaw;
02861 }
02862
02863
02864
02865
02866
02867 float
02868 HumanoidMotionInterface::SetStiffnessParamsMessage::head_pitch() const
02869 {
02870 return data->head_pitch;
02871 }
02872
02873
02874
02875
02876
02877 size_t
02878 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_head_pitch() const
02879 {
02880 return 1;
02881 }
02882
02883
02884
02885
02886
02887 void
02888 HumanoidMotionInterface::SetStiffnessParamsMessage::set_head_pitch(const float new_head_pitch)
02889 {
02890 data->head_pitch = new_head_pitch;
02891 }
02892
02893
02894
02895
02896
02897 float
02898 HumanoidMotionInterface::SetStiffnessParamsMessage::l_shoulder_pitch() const
02899 {
02900 return data->l_shoulder_pitch;
02901 }
02902
02903
02904
02905
02906
02907 size_t
02908 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_shoulder_pitch() const
02909 {
02910 return 1;
02911 }
02912
02913
02914
02915
02916
02917 void
02918 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_shoulder_pitch(const float new_l_shoulder_pitch)
02919 {
02920 data->l_shoulder_pitch = new_l_shoulder_pitch;
02921 }
02922
02923
02924
02925
02926
02927 float
02928 HumanoidMotionInterface::SetStiffnessParamsMessage::l_shoulder_roll() const
02929 {
02930 return data->l_shoulder_roll;
02931 }
02932
02933
02934
02935
02936
02937 size_t
02938 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_shoulder_roll() const
02939 {
02940 return 1;
02941 }
02942
02943
02944
02945
02946
02947 void
02948 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_shoulder_roll(const float new_l_shoulder_roll)
02949 {
02950 data->l_shoulder_roll = new_l_shoulder_roll;
02951 }
02952
02953
02954
02955
02956
02957 float
02958 HumanoidMotionInterface::SetStiffnessParamsMessage::l_elbow_yaw() const
02959 {
02960 return data->l_elbow_yaw;
02961 }
02962
02963
02964
02965
02966
02967 size_t
02968 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_elbow_yaw() const
02969 {
02970 return 1;
02971 }
02972
02973
02974
02975
02976
02977 void
02978 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_elbow_yaw(const float new_l_elbow_yaw)
02979 {
02980 data->l_elbow_yaw = new_l_elbow_yaw;
02981 }
02982
02983
02984
02985
02986
02987 float
02988 HumanoidMotionInterface::SetStiffnessParamsMessage::l_elbow_roll() const
02989 {
02990 return data->l_elbow_roll;
02991 }
02992
02993
02994
02995
02996
02997 size_t
02998 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_elbow_roll() const
02999 {
03000 return 1;
03001 }
03002
03003
03004
03005
03006
03007 void
03008 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_elbow_roll(const float new_l_elbow_roll)
03009 {
03010 data->l_elbow_roll = new_l_elbow_roll;
03011 }
03012
03013
03014
03015
03016
03017 float
03018 HumanoidMotionInterface::SetStiffnessParamsMessage::l_hip_yaw_pitch() const
03019 {
03020 return data->l_hip_yaw_pitch;
03021 }
03022
03023
03024
03025
03026
03027 size_t
03028 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_hip_yaw_pitch() const
03029 {
03030 return 1;
03031 }
03032
03033
03034
03035
03036
03037 void
03038 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_hip_yaw_pitch(const float new_l_hip_yaw_pitch)
03039 {
03040 data->l_hip_yaw_pitch = new_l_hip_yaw_pitch;
03041 }
03042
03043
03044
03045
03046
03047 float
03048 HumanoidMotionInterface::SetStiffnessParamsMessage::l_hip_roll() const
03049 {
03050 return data->l_hip_roll;
03051 }
03052
03053
03054
03055
03056
03057 size_t
03058 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_hip_roll() const
03059 {
03060 return 1;
03061 }
03062
03063
03064
03065
03066
03067 void
03068 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_hip_roll(const float new_l_hip_roll)
03069 {
03070 data->l_hip_roll = new_l_hip_roll;
03071 }
03072
03073
03074
03075
03076
03077 float
03078 HumanoidMotionInterface::SetStiffnessParamsMessage::l_hip_pitch() const
03079 {
03080 return data->l_hip_pitch;
03081 }
03082
03083
03084
03085
03086
03087 size_t
03088 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_hip_pitch() const
03089 {
03090 return 1;
03091 }
03092
03093
03094
03095
03096
03097 void
03098 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_hip_pitch(const float new_l_hip_pitch)
03099 {
03100 data->l_hip_pitch = new_l_hip_pitch;
03101 }
03102
03103
03104
03105
03106
03107 float
03108 HumanoidMotionInterface::SetStiffnessParamsMessage::l_knee_pitch() const
03109 {
03110 return data->l_knee_pitch;
03111 }
03112
03113
03114
03115
03116
03117 size_t
03118 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_knee_pitch() const
03119 {
03120 return 1;
03121 }
03122
03123
03124
03125
03126
03127 void
03128 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_knee_pitch(const float new_l_knee_pitch)
03129 {
03130 data->l_knee_pitch = new_l_knee_pitch;
03131 }
03132
03133
03134
03135
03136
03137 float
03138 HumanoidMotionInterface::SetStiffnessParamsMessage::l_ankle_pitch() const
03139 {
03140 return data->l_ankle_pitch;
03141 }
03142
03143
03144
03145
03146
03147 size_t
03148 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_ankle_pitch() const
03149 {
03150 return 1;
03151 }
03152
03153
03154
03155
03156
03157 void
03158 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_ankle_pitch(const float new_l_ankle_pitch)
03159 {
03160 data->l_ankle_pitch = new_l_ankle_pitch;
03161 }
03162
03163
03164
03165
03166
03167 float
03168 HumanoidMotionInterface::SetStiffnessParamsMessage::l_ankle_roll() const
03169 {
03170 return data->l_ankle_roll;
03171 }
03172
03173
03174
03175
03176
03177 size_t
03178 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_l_ankle_roll() const
03179 {
03180 return 1;
03181 }
03182
03183
03184
03185
03186
03187 void
03188 HumanoidMotionInterface::SetStiffnessParamsMessage::set_l_ankle_roll(const float new_l_ankle_roll)
03189 {
03190 data->l_ankle_roll = new_l_ankle_roll;
03191 }
03192
03193
03194
03195
03196
03197 float
03198 HumanoidMotionInterface::SetStiffnessParamsMessage::r_hip_yaw_pitch() const
03199 {
03200 return data->r_hip_yaw_pitch;
03201 }
03202
03203
03204
03205
03206
03207 size_t
03208 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_hip_yaw_pitch() const
03209 {
03210 return 1;
03211 }
03212
03213
03214
03215
03216
03217 void
03218 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_hip_yaw_pitch(const float new_r_hip_yaw_pitch)
03219 {
03220 data->r_hip_yaw_pitch = new_r_hip_yaw_pitch;
03221 }
03222
03223
03224
03225
03226
03227 float
03228 HumanoidMotionInterface::SetStiffnessParamsMessage::r_hip_roll() const
03229 {
03230 return data->r_hip_roll;
03231 }
03232
03233
03234
03235
03236
03237 size_t
03238 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_hip_roll() const
03239 {
03240 return 1;
03241 }
03242
03243
03244
03245
03246
03247 void
03248 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_hip_roll(const float new_r_hip_roll)
03249 {
03250 data->r_hip_roll = new_r_hip_roll;
03251 }
03252
03253
03254
03255
03256
03257 float
03258 HumanoidMotionInterface::SetStiffnessParamsMessage::r_hip_pitch() const
03259 {
03260 return data->r_hip_pitch;
03261 }
03262
03263
03264
03265
03266
03267 size_t
03268 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_hip_pitch() const
03269 {
03270 return 1;
03271 }
03272
03273
03274
03275
03276
03277 void
03278 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_hip_pitch(const float new_r_hip_pitch)
03279 {
03280 data->r_hip_pitch = new_r_hip_pitch;
03281 }
03282
03283
03284
03285
03286
03287 float
03288 HumanoidMotionInterface::SetStiffnessParamsMessage::r_knee_pitch() const
03289 {
03290 return data->r_knee_pitch;
03291 }
03292
03293
03294
03295
03296
03297 size_t
03298 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_knee_pitch() const
03299 {
03300 return 1;
03301 }
03302
03303
03304
03305
03306
03307 void
03308 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_knee_pitch(const float new_r_knee_pitch)
03309 {
03310 data->r_knee_pitch = new_r_knee_pitch;
03311 }
03312
03313
03314
03315
03316
03317 float
03318 HumanoidMotionInterface::SetStiffnessParamsMessage::r_ankle_pitch() const
03319 {
03320 return data->r_ankle_pitch;
03321 }
03322
03323
03324
03325
03326
03327 size_t
03328 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_ankle_pitch() const
03329 {
03330 return 1;
03331 }
03332
03333
03334
03335
03336
03337 void
03338 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_ankle_pitch(const float new_r_ankle_pitch)
03339 {
03340 data->r_ankle_pitch = new_r_ankle_pitch;
03341 }
03342
03343
03344
03345
03346
03347 float
03348 HumanoidMotionInterface::SetStiffnessParamsMessage::r_ankle_roll() const
03349 {
03350 return data->r_ankle_roll;
03351 }
03352
03353
03354
03355
03356
03357 size_t
03358 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_ankle_roll() const
03359 {
03360 return 1;
03361 }
03362
03363
03364
03365
03366
03367 void
03368 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_ankle_roll(const float new_r_ankle_roll)
03369 {
03370 data->r_ankle_roll = new_r_ankle_roll;
03371 }
03372
03373
03374
03375
03376
03377 float
03378 HumanoidMotionInterface::SetStiffnessParamsMessage::r_shoulder_pitch() const
03379 {
03380 return data->r_shoulder_pitch;
03381 }
03382
03383
03384
03385
03386
03387 size_t
03388 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_shoulder_pitch() const
03389 {
03390 return 1;
03391 }
03392
03393
03394
03395
03396
03397 void
03398 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_shoulder_pitch(const float new_r_shoulder_pitch)
03399 {
03400 data->r_shoulder_pitch = new_r_shoulder_pitch;
03401 }
03402
03403
03404
03405
03406
03407 float
03408 HumanoidMotionInterface::SetStiffnessParamsMessage::r_shoulder_roll() const
03409 {
03410 return data->r_shoulder_roll;
03411 }
03412
03413
03414
03415
03416
03417 size_t
03418 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_shoulder_roll() const
03419 {
03420 return 1;
03421 }
03422
03423
03424
03425
03426
03427 void
03428 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_shoulder_roll(const float new_r_shoulder_roll)
03429 {
03430 data->r_shoulder_roll = new_r_shoulder_roll;
03431 }
03432
03433
03434
03435
03436
03437 float
03438 HumanoidMotionInterface::SetStiffnessParamsMessage::r_elbow_yaw() const
03439 {
03440 return data->r_elbow_yaw;
03441 }
03442
03443
03444
03445
03446
03447 size_t
03448 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_elbow_yaw() const
03449 {
03450 return 1;
03451 }
03452
03453
03454
03455
03456
03457 void
03458 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_elbow_yaw(const float new_r_elbow_yaw)
03459 {
03460 data->r_elbow_yaw = new_r_elbow_yaw;
03461 }
03462
03463
03464
03465
03466
03467 float
03468 HumanoidMotionInterface::SetStiffnessParamsMessage::r_elbow_roll() const
03469 {
03470 return data->r_elbow_roll;
03471 }
03472
03473
03474
03475
03476
03477 size_t
03478 HumanoidMotionInterface::SetStiffnessParamsMessage::maxlenof_r_elbow_roll() const
03479 {
03480 return 1;
03481 }
03482
03483
03484
03485
03486
03487 void
03488 HumanoidMotionInterface::SetStiffnessParamsMessage::set_r_elbow_roll(const float new_r_elbow_roll)
03489 {
03490 data->r_elbow_roll = new_r_elbow_roll;
03491 }
03492
03493
03494
03495
03496
03497
03498 Message *
03499 HumanoidMotionInterface::SetStiffnessParamsMessage::clone() const
03500 {
03501 return new HumanoidMotionInterface::SetStiffnessParamsMessage(this);
03502 }
03503
03504
03505
03506
03507 bool
03508 HumanoidMotionInterface::message_valid(const Message *message) const
03509 {
03510 const SetWalkParamsMessage *m0 = dynamic_cast<const SetWalkParamsMessage *>(message);
03511 if ( m0 != NULL ) {
03512 return true;
03513 }
03514 const SetWalkArmsParamsMessage *m1 = dynamic_cast<const SetWalkArmsParamsMessage *>(message);
03515 if ( m1 != NULL ) {
03516 return true;
03517 }
03518 const StopMessage *m2 = dynamic_cast<const StopMessage *>(message);
03519 if ( m2 != NULL ) {
03520 return true;
03521 }
03522 const WalkStraightMessage *m3 = dynamic_cast<const WalkStraightMessage *>(message);
03523 if ( m3 != NULL ) {
03524 return true;
03525 }
03526 const WalkSidewaysMessage *m4 = dynamic_cast<const WalkSidewaysMessage *>(message);
03527 if ( m4 != NULL ) {
03528 return true;
03529 }
03530 const WalkArcMessage *m5 = dynamic_cast<const WalkArcMessage *>(message);
03531 if ( m5 != NULL ) {
03532 return true;
03533 }
03534 const TurnMessage *m6 = dynamic_cast<const TurnMessage *>(message);
03535 if ( m6 != NULL ) {
03536 return true;
03537 }
03538 const KickMessage *m7 = dynamic_cast<const KickMessage *>(message);
03539 if ( m7 != NULL ) {
03540 return true;
03541 }
03542 const ParkMessage *m8 = dynamic_cast<const ParkMessage *>(message);
03543 if ( m8 != NULL ) {
03544 return true;
03545 }
03546 const GetUpMessage *m9 = dynamic_cast<const GetUpMessage *>(message);
03547 if ( m9 != NULL ) {
03548 return true;
03549 }
03550 const StandupMessage *m10 = dynamic_cast<const StandupMessage *>(message);
03551 if ( m10 != NULL ) {
03552 return true;
03553 }
03554 const YawPitchHeadMessage *m11 = dynamic_cast<const YawPitchHeadMessage *>(message);
03555 if ( m11 != NULL ) {
03556 return true;
03557 }
03558 const SetStiffnessParamsMessage *m12 = dynamic_cast<const SetStiffnessParamsMessage *>(message);
03559 if ( m12 != NULL ) {
03560 return true;
03561 }
03562 return false;
03563 }
03564
03565
03566 EXPORT_INTERFACE(HumanoidMotionInterface)
03567
03568
03569
03570 }