Controller_impl.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008, AIST, the University of Tokyo and General Robotix Inc.
3  * All rights reserved. This program is made available under the terms of the
4  * Eclipse Public License v1.0 which accompanies this distribution, and is
5  * available at http://www.eclipse.org/legal/epl-v10.html
6  * Contributors:
7  * National Institute of Advanced Industrial Science and Technology (AIST)
8  * General Robotix Inc.
9  */
15 #include "Controller_impl.h"
16 
17 #include <string>
18 #include <iostream>
19 #include <rtm/Manager.h>
20 #include <rtm/RTObject.h>
21 #include <rtm/NVUtil.h>
22 
23 #include <hrpCorba/ORBwrap.h>
24 
25 #include "VirtualRobotRTC.h"
26 
27 using namespace std;
28 using namespace boost;
29 
30 namespace {
31  const bool CONTROLLER_BRIDGE_DEBUG = false;
32 }
33 
34 
36  : bridgeConf(bridgeConf),
37  rtcManager(rtcManager),
38  modelName(""),
39  bRestart(false)
40 {
41  if(CONTROLLER_BRIDGE_DEBUG){
42  cout << "Controller_impl::Controller_impl" << endl;
43  }
45 
46  RTC::RtcBase* rtc = rtcManager->createComponent("VirtualRobot");
47  virtualRobotRTC = dynamic_cast<VirtualRobotRTC*>(rtc);
48 }
49 
50 
52 {
53  if(CONTROLLER_BRIDGE_DEBUG){
54  cout << "Controller_impl::~Controller_impl" << endl;
55  }
56  delete naming;
57 
59 }
60 
61 
63 {
65 
66  string nameServer = rtcManager.getConfig()["corba.nameservers"];
67  cout << "setting naming" << endl;
68  int comPos = nameServer.find(",");
69  if (comPos < 0){
70  comPos = nameServer.length();
71  }
72  nameServer = nameServer.substr(0, comPos);
73  naming = new RTC::CorbaNaming(rtcManager.getORB(), nameServer.c_str());
74 
75  for (TimeRateMap::iterator it = bridgeConf->timeRateMap.begin(); it != bridgeConf->timeRateMap.end(); ++it){
76  RTC::RTObject_var rtcRef;
77  string rtcName = it->first;
78  if ( rtcName != "" ) {
79  string rtcNamingName = rtcName + ".rtc";
80  try {
81  CORBA::Object_var objRef = naming->resolve(rtcNamingName.c_str());
82  if ( CORBA::is_nil(objRef) ) {
83  cerr << rtcName << " is not found." << endl;
84  throw OpenHRP::Controller::ControllerException(string(rtcName+" is not found.").c_str());
85  } else {
86  rtcRef = RTC::RTObject::_narrow(objRef);
87  if(CORBA::is_nil(rtcRef)){
88  cerr << rtcName << " is not an RTC object." << endl;
89  throw OpenHRP::Controller::ControllerException(string(rtcName+" is not an RTC object.").c_str());
90  }
91  }
92  } catch(CORBA_SystemException& ex) {
93  cerr << ex._rep_id() << endl;
94  cerr << "exception in Controller_impl::detectRtcs" << endl;
95  } catch(...){
96  cerr << "unknown exception in Controller_impl::detectRtcs()" << endl;
97  }
98  }
99  if (!CORBA::is_nil(rtcRef)) {
101  }
102  }
103 
104  cout << "setup RT components" << endl;
105 
106  for(size_t i=0; i < bridgeConf->portConnections.size(); ++i){
107 
108  PortConnection& connection = bridgeConf->portConnections[i];
109 
110  RTC::RTObject_var rtcRef;
111  string rtcName;
112 
113  if(connection.controllerInstanceName.empty()){
114  if(!bridgeConf->moduleInfoList.empty()){
115  RTC::RtcBase* rtcServant = bridgeConf->moduleInfoList.front().rtcServant;
116  rtcName = "";
117  rtcRef = rtcServant->getObjRef();
118  }
119  } else {
120  rtcName = connection.controllerInstanceName;
121  }
122 
123  RtcInfoMap::iterator it = rtcInfoMap.find(rtcName);
124  if(it==rtcInfoMap.end()){
125  if(rtcName!=""){
126  string rtcNamingName = rtcName + ".rtc";
127  CORBA::Object_var objRef = naming->resolve(rtcNamingName.c_str());
128  if(CORBA::is_nil(objRef)){
129  cerr << rtcName << " is not found." << endl;
130  throw OpenHRP::Controller::ControllerException(string(rtcName+" is not found.").c_str());
131  } else {
132  rtcRef = RTC::RTObject::_narrow(objRef);
133  if(CORBA::is_nil(rtcRef)){
134  cerr << rtcName << " is not an RTC object." << endl;
135  throw OpenHRP::Controller::ControllerException(string(rtcName+" is not an RTC object.").c_str());
136  }
137  }
138  }
139  if(!CORBA::is_nil(rtcRef)){
140  RtcInfoPtr rtcInfo = addRtcVectorWithConnection(rtcRef);
141  rtcInfoMap.insert(make_pair(rtcName,rtcInfo));
142  }
143  }
144  }
145 
146  RTC::RTCList_var rtcList = virtualRobotRTC->getConnectedRtcs();
147  for(CORBA::ULong i=0; i < rtcList->length(); ++i){
148  addRtcVectorWithConnection(rtcList[i]);
149  }
150 }
151 
152 
154 {
155  Port_Service_List_Var_Type ports = rtcInfo->rtcRef->get_ports();
156  for(CORBA::ULong i=0; i < ports->length(); ++i){
157  RTC::PortProfile_var profile = ports[i]->get_port_profile();
158  std::string portName(profile->name);
159  string::size_type index = portName.rfind(".");
160  if (index != string::npos) portName = portName.substr(index+1);
161  rtcInfo->portMap[portName] = ports[i];
162  }
163 }
164 
166 {
167  RtcInfoVector::iterator it = rtcInfoVector.begin();
168  for( ; it != rtcInfoVector.end(); ++it){
169  if((*it)->rtcRef->_is_equivalent(new_rtcRef))
170  return *it;
171  }
172 
173  RtcInfoPtr rtcInfo(new RtcInfo());
174  rtcInfo->rtcRef = new_rtcRef;
175  makePortMap(rtcInfo);
176  string rtcName = (string)rtcInfo->rtcRef->get_component_profile()->instance_name;
177 
178  if ( bridgeConf->timeRateMap.size() == 0 ) {
179  rtcInfo->timeRate = 1.0;
180  rtcInfo->timeRateCounter = 0.0;
181  } else {
182  TimeRateMap::iterator p = bridgeConf->timeRateMap.find(rtcName);
183  if ( p != bridgeConf->timeRateMap.end() ) {
184  rtcInfo->timeRate = (double)p->second;
185  rtcInfo->timeRateCounter = 1.0 - rtcInfo->timeRate;
186  } else {
187  rtcInfo->timeRate = 0.0;
188  rtcInfo->timeRateCounter = 0.0;
189  }
190  cout << "periodic-rate (" << rtcName << ") = " << rtcInfo->timeRate << endl;
191  }
192  rtcInfoVector.push_back(rtcInfo);
193 
194 
195 #ifdef OPENRTM_VERSION_042
196  RTC::ExecutionContextServiceList_var eclist = rtcInfo->rtcRef->get_execution_context_services();
197  for(CORBA::ULong i=0; i < eclist->length(); ++i){
198  if(!CORBA::is_nil(eclist[i])){
199  rtcInfo->execContext = ExtTrigExecutionContextService_Type::_narrow(eclist[i]);
200  if(!CORBA::is_nil(rtcInfo->execContext)){
201  cout << "detected the ExtTrigExecutionContext" << endl;
202  }
203  break;
204  }
205  }
206 #else
207  RTC::ExecutionContextList_var eclist = rtcInfo->rtcRef->get_owned_contexts();
208  for(CORBA::ULong i=0; i < eclist->length(); ++i){
209  if(!CORBA::is_nil(eclist[i])){
210  rtcInfo->execContext = ExtTrigExecutionContextService_Type::_narrow(eclist[i]);
211  if(!CORBA::is_nil(rtcInfo->execContext)){
212  cout << "detected the ExtTrigExecutionContext" << endl;
213  }
214  break;
215  }
216  }
217 #endif
218  return rtcInfo;
219 }
220 
222 {
223  for(size_t i=0; i < bridgeConf->portConnections.size(); ++i){
224 
225  const PortConnection& connection = bridgeConf->portConnections[i];
226 
227  string controllerInstanceName = connection.controllerInstanceName;
228  if(controllerInstanceName.empty()){
229  if(!bridgeConf->moduleInfoList.empty()){
230  controllerInstanceName = "";
231  }
232  }
233 
234  cout << "connect " << virtualRobotRTC->getInstanceName() << ":" << connection.robotPortName;
235  cout << " <--> " << controllerInstanceName << ":" << connection.controllerPortName;
236 
237  int connected = false;
238 
239  RtcInfoMap::iterator p = rtcInfoMap.find(controllerInstanceName);
240  if(p != rtcInfoMap.end()){
241  RtcInfoPtr rtcInfo = p->second;
242 
243  PortMap::iterator q = rtcInfo->portMap.find(connection.controllerPortName);
244  if(q == rtcInfo->portMap.end()){
245  cerr << "\n";
246  cerr << controllerInstanceName << " does not have a port ";
247  cerr << connection.controllerPortName << "\n";
248  throw OpenHRP::Controller::ControllerException("not found a port");
249  } else {
250  Port_Service_Ptr_Type controllerPortRef = q->second;
251 
252  PortHandlerPtr robotPortHandler = virtualRobotRTC->getPortHandler(connection.robotPortName);
253  if(!robotPortHandler){
254  cerr << "\n";
255  cerr << "The robot does not have a port named " << connection.robotPortName << "\n";
256  throw OpenHRP::Controller::ControllerException("not found a port");
257  } else {
258  Port_Service_Ptr_Type robotPortRef = robotPortHandler->portRef;
259 
260  if(!CORBA::is_nil(robotPortRef)){
261  if(dynamic_pointer_cast<OutPortHandler>(robotPortHandler)){
262  connected = connectPorts(robotPortRef, controllerPortRef);
263  } else {
264  connected = connectPorts(controllerPortRef, robotPortRef);
265  }
266  }
267  }
268  }
269  }
270 
271  if(!connected){
272  cout << " ...ok" << endl;
273  } else if(connected == -1){
274  cerr << "Connection failed." << endl;
275  } else if(connected == 1){
276  cerr << " It has already been connected." << endl;
277  }
278  }
279 }
280 
281 
283 {
284  RTC::ConnectorProfileList_var connectorProfiles = inPort->get_connector_profiles();
285  for(CORBA::ULong i=0; i < connectorProfiles->length(); ++i){
286  RTC::ConnectorProfile& connectorProfile = connectorProfiles[i];
287  Port_Service_List_Type& connectedPorts = connectorProfile.ports;
288 
289  for(CORBA::ULong j=0; j < connectedPorts.length(); ++j){
290  Port_Service_Ptr_Type connectedPortRef = connectedPorts[j];
291  if(connectedPortRef->_is_equivalent(outPort)){
292  return 1;
293  }
294  }
295  }
296  // connect ports
297  RTC::ConnectorProfile cprof;
298  cprof.connector_id = "";
299  cprof.name = CORBA::string_dup("connector0");
300  cprof.ports.length(2);
301  cprof.ports[0] = Port_Service_Type::_duplicate(inPort);
302  cprof.ports[1] = Port_Service_Type::_duplicate(outPort);
303 
304  CORBA_SeqUtil::push_back(cprof.properties,
305  NVUtil::newNV("dataport.dataflow_type",
306  "Push"));
307 #ifdef OPENRTM_VERSION_042
308  CORBA_SeqUtil::push_back(cprof.properties,
309  NVUtil::newNV("dataport.interface_type",
310  "CORBA_Any"));
311  CORBA_SeqUtil::push_back(cprof.properties,
312  NVUtil::newNV("dataport.subscription_type",
313  "Flush"));
314 #else
315  CORBA_SeqUtil::push_back(cprof.properties,
316  NVUtil::newNV("dataport.interface_type",
317  "corba_cdr"));
318  CORBA_SeqUtil::push_back(cprof.properties,
319  NVUtil::newNV("dataport.subscription_type",
320  "flush"));
321 #endif
322  RTC::ReturnCode_t result = inPort->connect(cprof);
323 
324  if(result == RTC::RTC_OK)
325  return 0;
326  else
327  return -1;
328 }
329 
330 
332 {
333  this->dynamicsSimulator = DynamicsSimulator::_duplicate(dynamicsSimulator);
334 }
335 
336 
338 {
339  this->viewSimulator = ViewSimulator::_duplicate(viewSimulator);
340 }
341 
342 
344 {
345  if(CONTROLLER_BRIDGE_DEBUG){
346  cout << "Controller_impl::start" << endl;
347  }
348 
349  controlTime = 0.0;
350  try{
351  if( bRestart ){
352  restart();
353  } else {
354  if(!CORBA::is_nil(viewSimulator)) {
355  viewSimulator->getCameraSequenceOf(modelName.c_str(), cameras);
356  }else{
357  cameras = new CameraSequence(0);
358  }
360  }
361  } catch(CORBA_SystemException& ex){
362  cerr << ex._rep_id() << endl;
363  cerr << "exception in Controller_impl::start" << endl;
364  } catch(...){
365  cerr << "unknown exception in Controller_impl::start()" << endl;
366  }
367 }
368 
369 
371 {
372  if(!sensorStateUpdated){
373  dynamicsSimulator->getCharacterSensorState(modelName.c_str(), sensorState);
374  sensorStateUpdated = true;
375  }
376 
377  return sensorState;
378 }
379 
380 
382 (const std::string& linkName, DynamicsSimulator::LinkDataType linkDataType)
383 {
384  DblSequence_var data;
385  dynamicsSimulator->getCharacterLinkData(modelName.c_str(), linkName.c_str(), linkDataType, data.out());
386  return data._retn();
387 }
388 
389 
390 DblSequence* Controller_impl::getSensorDataFromSimulator(const std::string& sensorName)
391 {
392  DblSequence_var data;
393  dynamicsSimulator->getCharacterSensorValues(modelName.c_str(), sensorName.c_str(), data.out());
394  return data._retn();
395 }
396 
397 
399 {
400  if(cameras->length()!=0){
401  ImageData_var imageData = cameras[cameraId]->getImageData();
402  return imageData._retn();
403  }else{
404  ImageData* imageData = new ImageData;
405  imageData->floatData.length(0);
406  imageData->longData.length(0);
407  imageData->octetData.length(0);
408  return imageData;
409  }
410 }
411 
412 
414 {
415  if(CONTROLLER_BRIDGE_DEBUG){
416  cout << "Controller_impl::input" << endl;
417  }
418 
419  sensorStateUpdated = false;
420 
422 }
423 
424 
425 DblSequence& Controller_impl::getJointDataSeqRef(DynamicsSimulator::LinkDataType linkDataType)
426 {
427  return outputJointValueSeqInfos[linkDataType].values;
428 }
429 
430 
431 void Controller_impl::flushJointDataSeqToSimulator(DynamicsSimulator::LinkDataType linkDataType)
432 {
433  JointValueSeqInfoMap::iterator p = outputJointValueSeqInfos.find(linkDataType);
434  if(p != outputJointValueSeqInfos.end()){
435  JointValueSeqInfo& info = p->second;
436  if(!info.flushed){
437  dynamicsSimulator->setCharacterAllLinkData(modelName.c_str(), linkDataType, info.values);
438  info.flushed = true;
439  }
440  }
441 }
442 
443 void Controller_impl::flushLinkDataToSimulator(const std::string& linkName,
444  DynamicsSimulator::LinkDataType linkDataType,
445  const DblSequence& linkData)
446 {
447  dynamicsSimulator->setCharacterLinkData(modelName.c_str(), linkName.c_str(),
448  linkDataType, linkData);
449 }
450 
452 {
453  if(CONTROLLER_BRIDGE_DEBUG){
454  cout << "Controller_impl::output" << endl;
455  }
456 
457  for(JointValueSeqInfoMap::iterator p = outputJointValueSeqInfos.begin();
458  p != outputJointValueSeqInfos.end(); ++p){
459  JointValueSeqInfo& info = p->second;
460  info.flushed = false;
461  }
462 
464 }
465 
466 
468 {
469  if(CONTROLLER_BRIDGE_DEBUG){
470  cout << "Controller_impl::control" << endl;
471  }
472 
474 
475  for(RtcInfoVector::iterator p = rtcInfoVector.begin(); p != rtcInfoVector.end(); ++p){
476  RtcInfoPtr& rtcInfo = *p;
477  if(!CORBA::is_nil(rtcInfo->execContext)){
478  rtcInfo->timeRateCounter += rtcInfo->timeRate;
479  if(rtcInfo->timeRateCounter + rtcInfo->timeRate/2.0 > 1.0){
480  rtcInfo->execContext->tick();
481  rtcInfo->timeRateCounter -= 1.0;
482  }
483  }
484  }
485 
487 
489 }
490 
491 
493 {
495 }
496 
497 
499 {
500  if(CONTROLLER_BRIDGE_DEBUG){
501  cout << "Controller_impl::destroy()" << endl;
502  }
503  PortableServer::POA_var poa = _default_POA();
504  PortableServer::ObjectId_var id = poa->servant_to_id(this);
505  poa->deactivate_object(id);
506 }
507 
508 // TAWARA INSERT CODE 2009/01/14 START
509 
511 {
512  if(CONTROLLER_BRIDGE_DEBUG){
513  cout << "Controller_impl::initialize()" << endl;
514  }
515 
516  if( virtualRobotRTC)
517  {
519  bRestart = false;
520  } else {
522  try{
524  throw OpenHRP::Controller::ControllerException("Error OutPort StepTime");
525  detectRtcs();
527  } catch(CORBA_SystemException& ex){
528  cerr << ex._rep_id() << endl;
529  cerr << "exception in initializeController" << endl;
530  throw OpenHRP::Controller::ControllerException("");
531  } catch(std::invalid_argument& ex){
532  cerr << "invalid argument : " << ex.what() << endl;
533  throw OpenHRP::Controller::ControllerException("");
534  }
535  }
536  }
537 }
539 {
540  if(CONTROLLER_BRIDGE_DEBUG){
541  cout << "Controller_impl::shutdown()" << endl;
542  }
543  destroy();
545 }
546 
548 {
550 }
552 {
553  for(RtcInfoVector::iterator p = rtcInfoVector.begin(); p != rtcInfoVector.end(); ++p){
554  RtcInfoPtr& rtcInfo = *p;
555  if(!CORBA::is_nil(rtcInfo->execContext)){
556  if( RTC::PRECONDITION_NOT_MET == rtcInfo->execContext->activate_component(rtcInfo->rtcRef) )
557  {
558  rtcInfo->execContext->reset_component(rtcInfo->rtcRef);
559  rtcInfo->execContext->activate_component(rtcInfo->rtcRef);
560  }
561  }
562  }
563 
564  RTC::ExecutionContextList_var eclist = virtualRobotRTC->get_owned_contexts();
565  for(CORBA::ULong i=0; i < eclist->length(); ++i){
566  if(!CORBA::is_nil(eclist[i])){
567  ExtTrigExecutionContextService_Var_Type execContext = ExtTrigExecutionContextService_Type::_narrow(eclist[i]);
568  if(!CORBA::is_nil(execContext)){
569  if( RTC::PRECONDITION_NOT_MET == execContext->activate_component(virtualRobotRTC->getObjRef()) )
570  {
571  execContext->reset_component(virtualRobotRTC->getObjRef());
572  execContext->tick();
573  execContext->activate_component(virtualRobotRTC->getObjRef());
574  }
575  execContext->tick();
576  }
577  break;
578  }
579  }
580 }
581 
583 {
584  std::vector<ExtTrigExecutionContextService_Var_Type> vecExecContext;
585  for(RtcInfoVector::iterator p = rtcInfoVector.begin(); p != rtcInfoVector.end(); ++p){
586  RtcInfoPtr& rtcInfo = *p;
587  if(!CORBA::is_nil(rtcInfo->execContext)){
588 #ifdef OPENRTM_VERISON110
589  rtcInfo->execContext->deactivate_component(rtcInfo->rtcRef);
590  vecExecContext.push_back(rtcInfo->execContext);
591 #else
592  if ( RTC::RTC_OK == rtcInfo->execContext->deactivate_component(rtcInfo->rtcRef) ){
593  vecExecContext.push_back(rtcInfo->execContext);
594  }
595 #endif
596  }
597  }
598  RTC::ExecutionContextList_var eclist = virtualRobotRTC->get_owned_contexts();
599  for(CORBA::ULong i=0; i < eclist->length(); ++i){
600  if(!CORBA::is_nil(eclist[i])){
601  ExtTrigExecutionContextService_Var_Type execContext = ExtTrigExecutionContextService_Type::_narrow(eclist[i]);
602  if(!CORBA::is_nil(execContext)){
603  execContext->deactivate_component(virtualRobotRTC->getObjRef());
604  vecExecContext.push_back(execContext);
605  }
606  break;
607  }
608  }
609  for( std::vector<ExtTrigExecutionContextService_Var_Type>::iterator ite = vecExecContext.begin();
610  ite != vecExecContext.end(); ++ite ){
611  if(!CORBA::is_nil( *ite )){
612  try{
613  // Trigger onDeactivated in component.
614  (*ite)->tick();
615  } catch ( CORBA_SystemException& ex){
616  cerr << ex._rep_id() << endl;
617  cerr << "exception in Controller_impl::deactiveComponents" << endl;
618  } catch (...) {
619  cerr << "unknown exception in Controller_impl::initialize()" << endl;
620  }
621  }
622  }
623 }
SDOPackage::NameValue newNV(const char *name, Value value)
png_infop png_charpp int png_charpp profile
Definition: png.h:2382
VirtualRobotRTC * virtualRobotRTC
RTObject_impl * createComponent(const char *comp_args)
virtual void output()
int connectPorts(Port_Service_Ptr_Type outPort, Port_Service_Ptr_Type inPort)
void readDataFromInPorts(Controller_impl *controller)
Modifications controlling boost library behavior.
Definition: ColladaUtil.h:306
void makePortMap(RtcInfoPtr &rtcInfo)
void writeDataToOutPorts(Controller_impl *controller)
void outputDataToSimulator(Controller_impl *controller)
virtual void shutdown()
OpenRTM::ExtTrigExecutionContextService_var ExtTrigExecutionContextService_Var_Type
RTC::Manager * rtcManager
ImageData * getCameraImageFromSimulator(int cameraId)
PortHandlerPtr getPortHandler(const std::string &name)
boost::shared_ptr< RtcInfo > RtcInfoPtr
#define CORBA_SystemException
Definition: ORBwrap.h:30
std::string modelName
void terminate()
virtual void input()
CORBA::Object_ptr resolve(const CosNaming::Name &name)
DblSequence & getJointDataSeqRef(DynamicsSimulator::LinkDataType linkDataType)
CORBA::ORB_ptr getORB()
TimeRateMap timeRateMap
Definition: BridgeConf.h:116
RTC::PortServiceList_var Port_Service_List_Var_Type
png_uint_32 i
Definition: png.h:2735
virtual void setDynamicsSimulator(DynamicsSimulator_ptr dynamicsSimulator)
std::string controllerInstanceName
Definition: BridgeConf.h:70
static Manager & instance()
RtcInfoMap rtcInfoMap
PortConnectionList portConnections
Definition: BridgeConf.h:114
boost::shared_ptr< PortHandler > PortHandlerPtr
JointValueSeqInfoMap outputJointValueSeqInfos
coil::Properties & getConfig()
SensorState & getCurrentSensorState()
virtual void start()
DynamicsSimulator_var dynamicsSimulator
BridgeConf * bridgeConf
std::string robotPortName
Definition: BridgeConf.h:69
RTC::CorbaNaming * naming
void flushJointDataSeqToSimulator(DynamicsSimulator::LinkDataType linkDataType)
CameraSequence_var cameras
def j(str, encoding="cp932")
list index
void inputDataFromSimulator(Controller_impl *controller)
void flushLinkDataToSimulator(const std::string &linkName, DynamicsSimulator::LinkDataType linkDataType, const DblSequence &linkData)
virtual void setViewSimulator(ViewSimulator_ptr viewSimulator)
Controller_impl(RTC::Manager *rtcManager, BridgeConf *bridgeConf)
const char * getInstanceName()
virtual void control()
RTC::PortServiceList Port_Service_List_Type
virtual ExecutionContextList * get_owned_contexts()
DblSequence * getLinkDataFromSimulator(const std::string &linkName, DynamicsSimulator::LinkDataType linkDataType)
bool checkOutPortStepTime(double controlTimeStep)
virtual void stop()
backing_store_ptr info
Definition: jmemsys.h:181
static void registerFactory(RTC::Manager *manager, const char *componentTypeName)
RTC::RTCList * getConnectedRtcs()
RtcInfoVector rtcInfoVector
RTC::PortService_ptr Port_Service_Ptr_Type
void push_back(CorbaSequence &seq, SequenceElement elem)
JSAMPIMAGE data
Definition: jpeglib.h:945
Controller_impl::RtcInfoPtr addRtcVectorWithConnection(RTC::RTObject_var rtcRef)
DblSequence * getSensorDataFromSimulator(const std::string &sensorName)
virtual void initialize()
std::string controllerPortName
Definition: BridgeConf.h:71
RTObject_ptr getObjRef() const
const char * getVirtualRobotRtcTypeName()
Definition: BridgeConf.cpp:378
virtual void destroy()
ViewSimulator_var viewSimulator
SensorState_var sensorState
ModuleInfoList moduleInfoList
Definition: BridgeConf.h:112


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat Apr 13 2019 02:14:20