PortHandler.cpp
Go to the documentation of this file.
1 #include <hrpModel/Link.h>
2 #include <hrpModel/Sensor.h>
3 #include <hrpModel/Light.h>
4 #include "PortHandler.h"
5 
6 using namespace hrp;
7 
10  const char *i_portName,
11  const std::vector<Link *> &i_joints,
12  std::vector<OpenHRP::RobotHardwareService::SwitchStatus> *i_servo) :
13  InPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
14  m_joints(i_joints),
15  m_servo(*i_servo)
16 {
17  m_data.data.length(m_joints.size());
18 }
19 
22  const char *i_portName,
23  const std::vector<Link *> &i_joints) :
24  OutPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
25  m_joints(i_joints)
26 {
27  m_data.data.length(m_joints.size());
28 }
29 
32  const char *i_portName,
33  const std::vector<Link *> &i_joints,
34  std::vector<OpenHRP::RobotHardwareService::SwitchStatus> *i_servo) :
35  JointInPortHandler(i_rtc, i_portName, i_joints, i_servo)
36 {
37 }
38 
40 {
41  if (m_port.isNew()){
42  do {
43  m_port.read();
44  }while(m_port.isNew());
45  for (size_t i=0; i<m_joints.size(); i++){
46  if (m_joints[i] && m_servo[i] == OpenHRP::RobotHardwareService::SWITCH_ON) m_joints[i]->q = m_data.data[i];
47  }
48  }
49 }
50 
53  const char *i_portName,
54  const std::vector<Link *> &i_joints) :
55  JointOutPortHandler(i_rtc, i_portName, i_joints)
56 {
57 }
58 
60 {
61  for (size_t i=0; i<m_joints.size(); i++){
62  if (m_joints[i]) m_data.data[i] = m_joints[i]->q;
63  }
64  write(time);
65 }
66 
69  const char *i_portName,
70  const std::vector<Link *> &i_joints,
71  std::vector<OpenHRP::RobotHardwareService::SwitchStatus> *i_servo) :
72  JointInPortHandler(i_rtc, i_portName, i_joints, i_servo)
73 {
74 }
75 
77 {
78  if (m_port.isNew()){
79  do{
80  m_port.read();
81  }while(m_port.isNew());
82  for (size_t i=0; i<m_joints.size(); i++){
83  if (m_joints[i] && m_servo[i] == OpenHRP::RobotHardwareService::SWITCH_ON) m_joints[i]->dq = m_data.data[i];
84  }
85  }
86 }
87 
90  const char *i_portName,
91  const std::vector<Link *> &i_joints) :
92  JointOutPortHandler(i_rtc, i_portName, i_joints)
93 {
94 }
95 
97 {
98  for (size_t i=0; i<m_joints.size(); i++){
99  if (m_joints[i]) m_data.data[i] = m_joints[i]->dq;
100  }
101  write(time);
102 }
103 
106  const char *i_portName,
107  const std::vector<Link *> &i_joints,
108  std::vector<OpenHRP::RobotHardwareService::SwitchStatus> *i_servo) :
109  JointInPortHandler(i_rtc, i_portName, i_joints, i_servo)
110 {
111 }
112 
114 {
115  if (m_port.isNew()){
116  do{
117  m_port.read();
118  }while(m_port.isNew());
119  for (size_t i=0; i<m_joints.size(); i++){
120  if (m_joints[i] && m_servo[i] == OpenHRP::RobotHardwareService::SWITCH_ON) m_joints[i]->ddq = m_data.data[i];
121  }
122  }
123 }
124 
127  const char *i_portName,
128  const std::vector<Link *> &i_joints) :
129  JointOutPortHandler(i_rtc, i_portName, i_joints)
130 {
131 }
132 
134 {
135  for (size_t i=0; i<m_joints.size(); i++){
136  if (m_joints[i]) m_data.data[i] = m_joints[i]->ddq;
137  }
138  write(time);
139 }
140 
143  const char *i_portName,
144  const std::vector<Link *> &i_joints,
145  std::vector<OpenHRP::RobotHardwareService::SwitchStatus> *i_servo) :
146  JointInPortHandler(i_rtc, i_portName, i_joints, i_servo)
147 {
148 }
149 
151 {
152  if (m_port.isNew()){
153  do{
154  m_port.read();
155  }while(m_port.isNew());
156  if (m_data.data.length() != m_joints.size()){
157  std::cerr << "JointTorqueInPortHandler: data length mismatch(length of input data:"
158  << m_data.data.length() << "<->the number of joints:" << m_joints.size()
159  << ")" << std::endl;
160  }
161  for (size_t i=0; i<m_joints.size(); i++){
162  if (m_joints[i] && m_servo[i] == OpenHRP::RobotHardwareService::SWITCH_ON) m_joints[i]->u = m_data.data[i];
163  }
164  }
165 }
166 
169  const char *i_portName,
170  const std::vector<Link *> &i_joints) :
171  JointOutPortHandler(i_rtc, i_portName, i_joints)
172 {
173 }
174 
176 {
177  for (size_t i=0; i<m_joints.size(); i++){
178  if (m_joints[i]) m_data.data[i] = m_joints[i]->u;
179  }
180  write(time);
181 }
182 
185  const char *i_portName,
186  ForceSensor *i_sensor) :
187  SensorPortHandler<ForceSensor, RTC::TimedDoubleSeq>(i_rtc, i_portName, i_sensor)
188 {
189  m_data.data.length(6);
190 }
191 
193 {
194  setVector3(m_sensor->f, m_data.data, 0);
195  setVector3(m_sensor->tau, m_data.data, 3);
196  write(time);
197 }
198 
201  const char *i_portName,
202  RateGyroSensor *i_sensor) :
203  SensorPortHandler<RateGyroSensor, RTC::TimedAngularVelocity3D>(i_rtc, i_portName, i_sensor)
204 {
205 }
206 
208 {
209  m_data.data.avx = m_sensor->w[0];
210  m_data.data.avy = m_sensor->w[1];
211  m_data.data.avz = m_sensor->w[2];
212  write(time);
213 }
214 
217  const char *i_portName,
218  AccelSensor *i_sensor) :
219  SensorPortHandler<AccelSensor, RTC::TimedAcceleration3D>(i_rtc, i_portName, i_sensor)
220 {
221 }
222 
224 {
225  m_data.data.ax = m_sensor->dv[0];
226  m_data.data.ay = m_sensor->dv[1];
227  m_data.data.az = m_sensor->dv[2];
228  write(time);
229 }
230 
233  const char *i_portName,
234  RangeSensor *i_sensor) :
235  SensorPortHandler<RangeSensor, RTC::RangeData>(i_rtc, i_portName, i_sensor)
236 {
237  i_sensor->isEnabled = true;
238  m_data.config.minAngle = -i_sensor->scanAngle/2;
239  m_data.config.maxAngle = i_sensor->scanAngle/2;
240  m_data.config.angularRes = i_sensor->scanStep;
241  m_data.config.minRange = 0;
242  m_data.config.maxRange = i_sensor->maxDistance;
243  m_data.config.rangeRes = 0;
244  m_data.config.frequency = i_sensor->scanRate;
245 }
246 
248 {
249  if (m_sensor->isUpdated){
250  if (m_data.ranges.length() != m_sensor->distances.size()){
251  m_data.ranges.length(m_sensor->distances.size());
252  }
253  memcpy(m_data.ranges.get_buffer(), &(m_sensor->distances[0]),
254  sizeof(double)*m_sensor->distances.size());
255  write(time);
256  m_sensor->isUpdated = false;
257  }
258 }
259 
260 
263  const char *i_portName,
264  VisionSensor *i_sensor) :
265  SensorPortHandler<VisionSensor, Img::TimedCameraImage>(i_rtc, i_portName, i_sensor)
266 {
267  i_sensor->isEnabled = true;
268  if (m_sensor->imageType == VisionSensor::COLOR
269  || m_sensor->imageType == VisionSensor::COLOR_DEPTH){
270  m_data.data.image.width = m_sensor->width;
271  m_data.data.image.height = m_sensor->height;
272  m_data.data.image.format = Img::CF_RGB;
273  int len = m_sensor->width*m_sensor->height*3;
274  m_data.data.image.raw_data.length(len);
275  m_data.data.intrinsic.distortion_coefficient.length(5);
276  for(int i = 0; i < 5; i++){
277  m_data.data.intrinsic.distortion_coefficient[i] = 0;
278  }
279  double fovx = m_sensor->width/m_sensor->height*m_sensor->fovy;
280  m_data.data.intrinsic.matrix_element[0]=0.5 * m_sensor->width/tan(fovx/2.0);
281  m_data.data.intrinsic.matrix_element[1]=0.0;
282  m_data.data.intrinsic.matrix_element[2]=m_sensor->width/2;
283  m_data.data.intrinsic.matrix_element[3]=0.5 * m_sensor->height/tan(m_sensor->fovy/2.0);
284  m_data.data.intrinsic.matrix_element[4]=m_sensor->height/2;
285  }else if(m_sensor->imageType == VisionSensor::MONO
286  || m_sensor->imageType == VisionSensor::MONO_DEPTH){
287  m_data.data.image.width = m_sensor->width;
288  m_data.data.image.height = m_sensor->height;
289  m_data.data.image.format = Img::CF_GRAY;
290  int len = m_sensor->width*m_sensor->height;
291  m_data.data.image.raw_data.length(len);
292  m_data.data.intrinsic.distortion_coefficient.length(5);
293  for(int i = 0; i < 5; i++){
294  m_data.data.intrinsic.distortion_coefficient[i] = 0;
295  }
296  double fovx = m_sensor->width/m_sensor->height*m_sensor->fovy;
297  m_data.data.intrinsic.matrix_element[0]=0.5 * m_sensor->width/tan(fovx/2.0);
298  m_data.data.intrinsic.matrix_element[1]=0.0;
299  m_data.data.intrinsic.matrix_element[2]=m_sensor->width/2;
300  m_data.data.intrinsic.matrix_element[3]=0.5 * m_sensor->height/tan(m_sensor->fovy/2.0);
301  m_data.data.intrinsic.matrix_element[4]=m_sensor->height/2;
302  }
303 }
304 
306 {
307  if (m_sensor->isUpdated){
308  if (m_sensor->imageType == VisionSensor::COLOR
309  || m_sensor->imageType == VisionSensor::MONO
310  || m_sensor->imageType == VisionSensor::COLOR_DEPTH
311  || m_sensor->imageType == VisionSensor::MONO_DEPTH){
312  if (m_data.data.image.raw_data.length() != m_sensor->image.size()){
313  std::cerr << "BodyRTC: mismatch image length "
314  << m_data.data.image.raw_data.length()
315  << "<->" << m_sensor->image.size() << std::endl;
316  }else{
317  memcpy(m_data.data.image.raw_data.get_buffer(),
318  &m_sensor->image[0], m_sensor->image.size());
319  write(time);
320 #if 0
321  char filename[20];
322  sprintf(filename, "camera%d.ppm", m_sensor->id);
323  std::ofstream ofs(filename, std::ios::out | std::ios::trunc | std::ios::binary );
324  char buf[10];
325  unsigned char *pixels = &m_sensor->image[0];
326  sprintf(buf, "%d %d", m_sensor->width, m_sensor->height);
327  if (m_sensor->imageType == VisionSensor::COLOR
328  || m_sensor->imageType == VisionSensor::COLOR_DEPTH){
329  ofs << "P6";
330  }else{
331  ofs << "P5";
332  }
333  ofs << std::endl << buf << std::endl << "255" << std::endl;
334  ofs.write((char *)pixels, m_sensor->image.size());
335 #endif
336  }
337  }
338  m_sensor->isUpdated = false;
339  }
340 }
341 
344  const char *i_portName,
345  VisionSensor *i_sensor) :
346  SensorPortHandler<VisionSensor, PointCloudTypes::PointCloud>(i_rtc, i_portName, i_sensor)
347 {
348  i_sensor->isEnabled = true;
349  switch(m_sensor->imageType){
350  case VisionSensor::DEPTH:
351  m_pcFormat = "xyz"; break;
352  case VisionSensor::COLOR_DEPTH:
353  m_pcFormat = "xyzrgb"; break;
354  case VisionSensor::MONO_DEPTH:
355  m_pcFormat = "xyz"; break;
356  default:
357  std::cout << "VisionSensor " << m_sensor->name
358  << " doesn't have distance measuring function" << std::endl;
359  break;
360  }
361  m_data.width = m_sensor->width;
362  m_data.height = m_sensor->height;
363  m_data.type = m_pcFormat.c_str();
364 
365  bool colored = false;
366  if (m_pcFormat == "xyz"){
367  m_data.fields.length(3);
368  }else if (m_pcFormat == "xyzrgb"){
369  m_data.fields.length(6);
370  colored = true;
371  }else{
372  std::cerr << "unknown point cloud format:[" << m_pcFormat << "]" << std::endl;
373  }
374  m_data.fields[0].name = "x";
375  m_data.fields[0].offset = 0;
376  m_data.fields[0].data_type = PointCloudTypes::FLOAT32;
377  m_data.fields[0].count = 4;
378  m_data.fields[1].name = "y";
379  m_data.fields[1].offset = 4;
380  m_data.fields[1].data_type = PointCloudTypes::FLOAT32;
381  m_data.fields[1].count = 4;
382  m_data.fields[2].name = "z";
383  m_data.fields[2].offset = 8;
384  m_data.fields[2].data_type = PointCloudTypes::FLOAT32;
385  m_data.fields[2].count = 4;
386  if (m_pcFormat == "xyzrgb"){
387  m_data.fields[3].name = "r";
388  m_data.fields[3].offset = 12;
389  m_data.fields[3].data_type = PointCloudTypes::UINT8;
390  m_data.fields[3].count = 1;
391  m_data.fields[4].name = "g";
392  m_data.fields[4].offset = 13;
393  m_data.fields[4].data_type = PointCloudTypes::UINT8;
394  m_data.fields[4].count = 1;
395  m_data.fields[5].name = "b";
396  m_data.fields[5].offset = 14;
397  m_data.fields[5].data_type = PointCloudTypes::UINT8;
398  m_data.fields[5].count = 1;
399  }
400  m_data.is_bigendian = false;
401  m_data.point_step = 16;
402  m_data.is_dense = true;
403  m_data.row_step = m_data.point_step*m_sensor->width;
404 }
405 
407 {
408  if (m_sensor->isUpdated){
409  m_data.data.length(m_sensor->depth.size());
410  memcpy(m_data.data.get_buffer(), &m_sensor->depth[0],
411  m_sensor->depth.size());
412  write(time);
413  }
414  m_sensor->isUpdated = false;
415 }
416 
419  const char *i_portName,
420  hrp::Link *i_link) :
421  InPortHandler<RTC::TimedPose3D>(i_rtc, i_portName),
422  m_link(i_link)
423 {
424 }
425 
426 void AbsTransformInPortHandler::update()
427 {
428  if (m_port.isNew()){
429  do{
430  m_port.read();
431  }while(m_port.isNew());
432  m_link->p <<
433  m_data.data.position.x,
434  m_data.data.position.y,
435  m_data.data.position.z;
436  hrp::Matrix33 R = hrp::rotFromRpy(m_data.data.orientation.r,
437  m_data.data.orientation.p,
438  m_data.data.orientation.y);
439  m_link->setSegmentAttitude(R);
440  }
441 }
442 
445  const char *i_portName,
446  hrp::Link *i_link) :
447  InPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
448  m_link(i_link)
449 {
450 }
451 
453 {
454  if (m_port.isNew()){
455  do{
456  m_port.read();
457  }while(m_port.isNew());
458  m_link->v << m_data.data[0], m_data.data[1], m_data.data[2];
459  m_link->w << m_data.data[3], m_data.data[4], m_data.data[5];
460  m_link->vo = m_link->v - m_link->w.cross(m_link->p);
461  }
462 }
463 
466  const char *i_portName,
467  hrp::Link *i_link) :
468  InPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
469  m_link(i_link)
470 {
471 }
472 
474 {
475  if (m_port.isNew()){
476  do{
477  m_port.read();
478  }while(m_port.isNew());
479  m_link->dv << m_data.data[0], m_data.data[1], m_data.data[2];
480  m_link->dw << m_data.data[3], m_data.data[4], m_data.data[5];
481  }
482 }
483 
486  const char *i_portName,
487  hrp::VisionSensor *i_sensor) :
488  InPortHandler<RTC::TimedDouble>(i_rtc, i_portName),
489  m_sensor(i_sensor)
490 {
491 }
492 
494 {
495  if (m_port.isNew()){
496  do {
497  m_port.read();
498  }while(m_port.isNew());
499  m_sensor->frameRate = m_data.data;
500  }
501 }
502 
505  const char *i_portName,
506  hrp::Light *i_light) :
507  InPortHandler<RTC::TimedBoolean>(i_rtc, i_portName),
508  m_light(i_light)
509 {
510 }
511 
513 {
514  if (m_port.isNew()){
515  do {
516  m_port.read();
517  }while(m_port.isNew());
518  m_light->on = m_data.data;
519  }
520 }
521 
524  const char *i_portName,
525  hrp::Link *i_link) :
526  OutPortHandler<RTC::TimedPose3D>(i_rtc, i_portName),
527  m_link(i_link), m_sensor(NULL)
528 {
529 }
530 
533  const char *i_portName,
534  hrp::Sensor *i_sensor) :
535  OutPortHandler<RTC::TimedPose3D>(i_rtc, i_portName),
536  m_link(NULL), m_sensor(i_sensor)
537 {
538 }
539 
540 void AbsTransformOutPortHandler::update(double time)
541 {
542  hrp::Vector3 p;
544  if (m_link){
545  p = m_link->p;
546  R = m_link->attitude();
547  }else{
548  hrp::Link *parent = m_sensor->link;
549  p = parent->R*m_sensor->localPos+parent->p;
550  R = parent->R*m_sensor->localR;
551  }
552  m_data.data.position.x = p[0];
553  m_data.data.position.y = p[1];
554  m_data.data.position.z = p[2];
555  hrp::Vector3 rpy = rpyFromRot(R);
556  m_data.data.orientation.r = rpy[0];
557  m_data.data.orientation.p = rpy[1];
558  m_data.data.orientation.y = rpy[2];
559  write(time);
560 }
561 
562 
565  const char *i_portName,
566  hrp::Link *i_link) :
567  OutPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
568  m_link(i_link)
569 {
570  m_data.data.length(6);
571 }
572 
574  m_data.data[0] = m_link->v(0);
575  m_data.data[1] = m_link->v(1);
576  m_data.data[2] = m_link->v(2);
577  m_data.data[3] = m_link->w(0);
578  m_data.data[4] = m_link->w(1);
579  m_data.data[5] = m_link->w(2);
580 }
581 
584  const char *i_portName,
585  hrp::Link *i_link) :
586  OutPortHandler<RTC::TimedDoubleSeq>(i_rtc, i_portName),
587  m_link(i_link)
588 {
589  m_data.data.length(6);
590 }
591 
593 {
594  m_data.data[0] = m_link->dv(0);
595  m_data.data[1] = m_link->dv(1);
596  m_data.data[2] = m_link->dv(2);
597  m_data.data[3] = m_link->dw(0);
598  m_data.data[4] = m_link->dw(1);
599  m_data.data[5] = m_link->dw(2);
600 }
601 
604  const char *i_portName,
605  BodyRTC *i_body) :
606  OutPortHandler<RTC::TimedLong>(i_rtc, i_portName),
607  m_body(i_body)
608 {
609 }
610 
612 {
614  m_data.data = m_body->m_emergencyReason;
615  write(time);
616  }
617 }
618 
621  const char *i_portName,
622  BodyRTC *i_body) :
623  OutPortHandler<OpenHRP::TimedLongSeqSeq>(i_rtc, i_portName),
624  m_body(i_body)
625 {
626  rs = new OpenHRP::RobotHardwareService::RobotState();
627 }
628 
630 {
631  m_body->getStatus(rs);
632  m_data.data.length(rs->servoState.length());
633  for (size_t i=0; i < rs->servoState.length(); i++) {
634  m_data.data[i].length(rs->servoState[i].length());
635  for (size_t j=0; j < rs->servoState[i].length(); j++) {
636  m_data.data[i][j] = rs->servoState[i][j];
637  }
638  }
639  write(time);
640 }
std::vector< double > distances
JointInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints, std::vector< OpenHRP::RobotHardwareService::SwitchStatus > *i_servo)
Definition: PortHandler.cpp:8
ServoStatePortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, BodyRTC *i_body)
BodyRTC::emg_reason m_emergencyReason
Definition: BodyRTC.h:141
JointTorqueInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints, std::vector< OpenHRP::RobotHardwareService::SwitchStatus > *i_servo)
AbsTransformInPortHandler(PortInfo &info)
AbsTransformOutPortHandler(PortInfo &info)
AccelSensorPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::AccelSensor *i_sensor)
void update(double time)
Definition: PortHandler.cpp:96
JointValueInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints, std::vector< OpenHRP::RobotHardwareService::SwitchStatus > *i_servo)
Definition: PortHandler.cpp:30
char * filename
RangeSensorPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::RangeSensor *i_sensor)
std::string name
void update(double time)
EmergencySignalPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, BodyRTC *i_body)
std::vector< unsigned char > image
void update(double time)
void update(double time)
JointAccelerationInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints, std::vector< OpenHRP::RobotHardwareService::SwitchStatus > *i_servo)
void setVector3(const Vector3 &v3, V &v, size_t top=0)
png_uint_32 i
ForceSensorPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::ForceSensor *i_sensor)
PointCloudPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::VisionSensor *i_sensor)
void update(double time)
Definition: PortHandler.cpp:59
void update(double time)
Eigen::Vector3d Vector3
Matrix33 rotFromRpy(const Vector3 &rpy)
Eigen::Matrix3d Matrix33
void update(double time)
JointValueOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints)
Definition: PortHandler.cpp:51
JointVelocityInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints, std::vector< OpenHRP::RobotHardwareService::SwitchStatus > *i_servo)
Definition: PortHandler.cpp:67
def j(str, encoding="cp932")
std::vector< OpenHRP::RobotHardwareService::SwitchStatus > & m_servo
Definition: PortHandler.h:70
OpenHRP::RobotHardwareService::RobotState * rs
Definition: PortHandler.h:353
void update(double time)
std::vector< hrp::Link * > m_joints
Definition: PortHandler.h:80
FrameRateInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::VisionSensor *i_sensor)
void update(double time)
hrp::VisionSensor * m_sensor
Definition: PortHandler.h:202
png_bytep buf
VisionSensorPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::VisionSensor *i_sensor)
JointAccelerationOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints)
RateGyroSensorPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::RateGyroSensor *i_sensor)
HRP_UTIL_EXPORT Vector3 rpyFromRot(const Matrix33 &m)
void update(double time)
void update(double time)
std::vector< unsigned char > depth
std::string sprintf(char const *__restrict fmt,...)
virtual bool isNew()
AbsAccelerationInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::Link *i_link)
JointOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints)
Definition: PortHandler.cpp:20
void update(double time)
JointTorqueOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints)
LightSwitchInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::Light *i_light)
std::string m_pcFormat
Definition: PortHandler.h:330
JointVelocityOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, const std::vector< hrp::Link * > &i_joints)
Definition: PortHandler.cpp:88
AbsAccelerationOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::Link *i_link)
AbsVelocityInPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::Link *i_link)
std::vector< hrp::Link * > m_joints
Definition: PortHandler.h:69
void getStatus(OpenHRP::RobotHardwareService::RobotState *rs)
Definition: BodyRTC.cpp:414
ImageType imageType
AbsVelocityOutPortHandler(RTC::DataFlowComponentBase *i_rtc, const char *i_portName, hrp::Link *i_link)


hrpsys
Author(s): AIST, Fumio Kanehiro
autogenerated on Thu May 6 2021 02:41:50