00001 #!/usr/bin/env python 00002 # -*- coding: euc-jp -*- 00003 00004 ## 00005 # @file RTObject.py 00006 # @brief RT component base class 00007 # @date $Date: $ 00008 # @author Noriaki Ando <n-ando@aist.go.jp> and Shinji Kurihara 00009 # 00010 # Copyright (C) 2006-2008 00011 # Task-intelligence Research Group, 00012 # Intelligent Systems Research Institute, 00013 # National Institute of 00014 # Advanced Industrial Science and Technology (AIST), Japan 00015 # All rights reserved. 00016 00017 00018 00019 import string 00020 import sys 00021 import copy 00022 00023 from omniORB import any 00024 from omniORB import CORBA 00025 00026 import OpenRTM__POA 00027 import RTC 00028 import SDOPackage 00029 import OpenRTM_aist 00030 00031 ECOTHER_OFFSET = 1000 00032 00033 default_conf = [ 00034 "implementation_id","", 00035 "type_name", "", 00036 "description", "", 00037 "version", "", 00038 "vendor", "", 00039 "category", "", 00040 "activity_type", "", 00041 "max_instance", "", 00042 "language", "", 00043 "lang_type", "", 00044 "conf", "", 00045 "" ] 00046 00047 00048 00049 ## 00050 # @if jp 00051 # @brief RTコンポーネントクラス 00052 # 00053 # 各RTコンポーネントのベースとなるクラス。 00054 # Robotic Technology Component 仕様中の lightweightRTComponentの実装クラス。 00055 # コンポーネントの機能を提供する ComponentAction インターフェースと 00056 # コンポーネントのライフサイクル管理を行うための LightweightRTObject の実装を 00057 # 提供する。 00058 # 実際にユーザがコンポーネントを作成する場合には、Execution Semantics に対応 00059 # した各サブクラスを利用する。<BR> 00060 # (現状の実装では Periodic Sampled Data Processing のみサポートしているため、 00061 # dataFlowComponent を直接継承している) 00062 # 00063 # @since 0.2.0 00064 # 00065 # @else 00066 # 00067 # @endif 00068 class RTObject_impl(OpenRTM__POA.DataFlowComponent): 00069 """ 00070 """ 00071 00072 ## 00073 # @if jp 00074 # @brief コンストラクタ 00075 # 00076 # コンストラクタ 00077 # 00078 # @param self 00079 # @param manager マネージャオブジェクト(デフォルト値:None) 00080 # @param orb ORB(デフォルト値:None) 00081 # @param poa POA(デフォルト値:None) 00082 # 00083 # @else 00084 # 00085 # @brief Consructor 00086 # 00087 # @param orb ORB 00088 # @param poa POA 00089 # 00090 # @endif 00091 def __init__(self, manager=None, orb=None, poa=None): 00092 if manager: 00093 self._manager = manager 00094 self._orb = self._manager.getORB() 00095 self._poa = self._manager.getPOA() 00096 self._portAdmin = OpenRTM_aist.PortAdmin(self._manager.getORB(),self._manager.getPOA()) 00097 else: 00098 self._manager = None 00099 self._orb = orb 00100 self._poa = poa 00101 self._portAdmin = OpenRTM_aist.PortAdmin(self._orb,self._poa) 00102 00103 if self._manager: 00104 self._rtcout = self._manager.getLogbuf("rtobject") 00105 else: 00106 self._rtcout = OpenRTM_aist.Manager.instance().getLogbuf("rtobject") 00107 00108 self._created = True 00109 self._properties = OpenRTM_aist.Properties(defaults_str=default_conf) 00110 self._configsets = OpenRTM_aist.ConfigAdmin(self._properties.getNode("conf")) 00111 self._profile = RTC.ComponentProfile("","","","","","",[],None,[]) 00112 00113 self._sdoservice = OpenRTM_aist.SdoServiceAdmin(self) 00114 self._SdoConfigImpl = OpenRTM_aist.Configuration_impl(self._configsets,self._sdoservice) 00115 self._SdoConfig = self._SdoConfigImpl.getObjRef() 00116 self._execContexts = [] 00117 self._objref = self._this() 00118 self._sdoOwnedOrganizations = [] #SDOPackage.OrganizationList() 00119 self._sdoSvcProfiles = [] #SDOPackage.ServiceProfileList() 00120 self._sdoOrganizations = [] #SDOPackage.OrganizationList() 00121 self._sdoStatus = [] #SDOPackage.NVList() 00122 self._ecMine = [] 00123 self._ecOther = [] 00124 self._eclist = [] 00125 self._exiting = False 00126 self._readAll = False 00127 self._writeAll = False 00128 self._readAllCompletion = False 00129 self._writeAllCompletion = False 00130 self._inports = [] 00131 self._outports = [] 00132 self._actionListeners = OpenRTM_aist.ComponentActionListeners() 00133 self._portconnListeners = OpenRTM_aist.PortConnectListeners() 00134 return 00135 00136 00137 ## 00138 # @if jp 00139 # 00140 # @brief デストラクタ 00141 # 00142 # @param self 00143 # 00144 # @else 00145 # 00146 # @brief destructor 00147 # 00148 # @endif 00149 def __del__(self): 00150 return 00151 00152 00153 #============================================================ 00154 # Overridden functions 00155 #============================================================ 00156 00157 ## 00158 # @if jp 00159 # 00160 # @brief 初期化処理用コールバック関数 00161 # 00162 # ComponentAction::on_initialize が呼ばれた際に実行されるコールバック 00163 # 関数。<BR> 00164 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00165 # 各コンポーネントの実際の初期化処理は、本関数をオーバーライドして実装する 00166 # 必要がある。 00167 # 00168 # @param self 00169 # 00170 # @return ReturnCode_t 型のリターンコード 00171 # 00172 # @else 00173 # 00174 # @endif 00175 def onInitialize(self): 00176 self._rtcout.RTC_TRACE("onInitialize()") 00177 return RTC.RTC_OK 00178 00179 00180 ## 00181 # @if jp 00182 # 00183 # @brief 終了処理用コールバック関数 00184 # 00185 # ComponentAction::on_finalize が呼ばれた際に実行されるコールバック 00186 # 関数。<BR> 00187 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00188 # 各コンポーネントの実際の終了処理は、本関数をオーバーライドして実装する 00189 # 必要がある。 00190 # 00191 # @param self 00192 # 00193 # @return ReturnCode_t 型のリターンコード 00194 # 00195 # @else 00196 # 00197 # @endif 00198 def onFinalize(self): 00199 self._rtcout.RTC_TRACE("onFinalize()") 00200 return RTC.RTC_OK 00201 00202 00203 ## 00204 # @if jp 00205 # 00206 # @brief 開始処理用コールバック関数 00207 # 00208 # ComponentAction::on_startup が呼ばれた際に実行されるコールバック 00209 # 関数。<BR> 00210 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00211 # 各コンポーネントの実際の開始処理は、本関数をオーバーライドして実装する 00212 # 必要がある。 00213 # 00214 # @param self 00215 # @param ec_id 参加している ExecutionContext の ID 00216 # 00217 # @return ReturnCode_t 型のリターンコード 00218 # 00219 # @else 00220 # 00221 # @endif 00222 def onStartup(self, ec_id): 00223 self._rtcout.RTC_TRACE("onStartup(%d)",ec_id) 00224 return RTC.RTC_OK 00225 00226 00227 ## 00228 # @if jp 00229 # 00230 # @brief 停止処理用コールバック関数 00231 # 00232 # ComponentAction::on_shutdown が呼ばれた際に実行されるコールバック 00233 # 関数。<BR> 00234 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00235 # 各コンポーネントの実際の停止処理は、本関数をオーバーライドして実装する 00236 # 必要がある。 00237 # 00238 # @param self 00239 # @param ec_id 参加している ExecutionContext の ID 00240 # 00241 # @return ReturnCode_t 型のリターンコード 00242 # 00243 # @else 00244 # 00245 # @endif 00246 def onShutdown(self, ec_id): 00247 self._rtcout.RTC_TRACE("onShutdown(%d)",ec_id) 00248 return RTC.RTC_OK 00249 00250 00251 ## 00252 # @if jp 00253 # 00254 # @brief 活性化処理用コールバック関数 00255 # 00256 # ComponentAction::on_activated が呼ばれた際に実行されるコールバック 00257 # 関数。<BR> 00258 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00259 # 各コンポーネントの実際の活性化処理は、本関数をオーバーライドして実装する 00260 # 必要がある。 00261 # 00262 # @param self 00263 # @param ec_id 参加している ExecutionContext の ID 00264 # 00265 # @return ReturnCode_t 型のリターンコード 00266 # 00267 # @else 00268 # 00269 # @endif 00270 def onActivated(self, ec_id): 00271 self._rtcout.RTC_TRACE("onActivated(%d)",ec_id) 00272 return RTC.RTC_OK 00273 00274 00275 ## 00276 # @if jp 00277 # 00278 # @brief 非活性化処理用コールバック関数 00279 # 00280 # ComponentAction::on_deactivated が呼ばれた際に実行されるコールバック 00281 # 関数。<BR> 00282 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00283 # 各コンポーネントの実際の非活性化処理は、本関数をオーバーライドして実装する 00284 # 必要がある。 00285 # 00286 # @param self 00287 # @param ec_id 参加している ExecutionContext の ID 00288 # 00289 # @return ReturnCode_t 型のリターンコード 00290 # 00291 # @else 00292 # 00293 # @endif 00294 def onDeactivated(self, ec_id): 00295 self._rtcout.RTC_TRACE("onDeactivated(%d)",ec_id) 00296 return RTC.RTC_OK 00297 00298 00299 ## 00300 # @if jp 00301 # 00302 # @brief 周期処理用コールバック関数 00303 # 00304 # DataFlowComponentAction::on_execute が呼ばれた際に実行される 00305 # コールバック関数。<BR> 00306 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00307 # 各コンポーネントの実際の周期処理は、本関数をオーバーライドして実装する 00308 # 必要がある。<BR> 00309 # 本関数は Periodic Sampled Data Processing における Two-Pass Executionの 00310 # １回目の実行パスとして定期的に呼び出される。 00311 # 00312 # @param self 00313 # @param ec_id 参加している ExecutionContext の ID 00314 # 00315 # @return ReturnCode_t 型のリターンコード 00316 # 00317 # @else 00318 # 00319 # @endif 00320 def onExecute(self, ec_id): 00321 self._rtcout.RTC_TRACE("onExecute(%d)",ec_id) 00322 return RTC.RTC_OK 00323 00324 00325 ## 00326 # @if jp 00327 # 00328 # @brief 中断処理用コールバック関数 00329 # 00330 # ComponentAction::on_aborting が呼ばれた際に実行されるコールバック 00331 # 関数。<BR> 00332 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00333 # 各コンポーネントの実際の中断処理は、本関数をオーバーライドして実装する 00334 # 必要がある。 00335 # 00336 # @param self 00337 # @param ec_id 参加している ExecutionContext の ID 00338 # 00339 # @return ReturnCode_t 型のリターンコード 00340 # 00341 # @else 00342 # 00343 # @endif 00344 def onAborting(self, ec_id): 00345 self._rtcout.RTC_TRACE("onAborting(%d)",ec_id) 00346 return RTC.RTC_OK 00347 00348 00349 ## 00350 # @if jp 00351 # 00352 # @brief エラー処理用コールバック関数 00353 # 00354 # ComponentAction::on_error が呼ばれた際に実行されるコールバック関数。<BR> 00355 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00356 # 各コンポーネントの実際のエラー処理は、本関数をオーバーライドして実装する 00357 # 必要がある。 00358 # 00359 # @param self 00360 # @param ec_id 参加している ExecutionContext の ID 00361 # 00362 # @return ReturnCode_t 型のリターンコード 00363 # 00364 # @else 00365 # 00366 # @endif 00367 def onError(self, ec_id): 00368 self._rtcout.RTC_TRACE("onError(%d)",ec_id) 00369 return RTC.RTC_OK 00370 00371 00372 ## 00373 # @if jp 00374 # 00375 # @brief リセット処理用コールバック関数 00376 # 00377 # ComponentAction::on_reset が呼ばれた際に実行されるコールバック関数。<BR> 00378 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00379 # 各コンポーネントの実際のリセット処理は、本関数をオーバーライドして実装する 00380 # 必要がある。 00381 # 00382 # @param self 00383 # @param ec_id 参加している ExecutionContext の ID 00384 # 00385 # @return ReturnCode_t 型のリターンコード 00386 # 00387 # @else 00388 # 00389 # @endif 00390 def onReset(self, ec_id): 00391 self._rtcout.RTC_TRACE("onReset(%d)",ec_id) 00392 return RTC.RTC_OK 00393 00394 00395 ## 00396 # @if jp 00397 # 00398 # @brief 状態変更処理用コールバック関数 00399 # 00400 # DataFlowComponentAction::on_state_update が呼ばれた際に実行される 00401 # コールバック関数。<BR> 00402 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00403 # 各コンポーネントの実際の状態変更処理は、本関数をオーバーライドして実装する 00404 # 必要がある。<BR> 00405 # 本関数は Periodic Sampled Data Processing における Two-Pass Executionの 00406 # ２回目の実行パスとして定期的に呼び出される。 00407 # 00408 # @param self 00409 # @param ec_id 参加している ExecutionContext の ID 00410 # 00411 # @return ReturnCode_t 型のリターンコード 00412 # 00413 # @else 00414 # 00415 # @endif 00416 def onStateUpdate(self, ec_id): 00417 self._rtcout.RTC_TRACE("onStateupdate(%d)",ec_id) 00418 return RTC.RTC_OK 00419 00420 00421 ## 00422 # @if jp 00423 # 00424 # @brief 動作周期変更通知用コールバック関数 00425 # 00426 # DataFlowComponentAction::on_rate_changed が呼ばれた際に実行される 00427 # コールバック関数。<BR> 00428 # 本関数は無条件に RTC::RTC_OK を返すようにダミー実装されているので、 00429 # 各コンポーネントの実際の状態変更処理は、本関数をオーバーライドして実装する 00430 # 必要がある。<BR> 00431 # 本関数は Periodic Sampled Data Processing において ExecutionContext の 00432 # 実行が更新された際に呼び出される。 00433 # 00434 # @param self 00435 # @param ec_id 参加している ExecutionContext の ID 00436 # 00437 # @return ReturnCode_t 型のリターンコード 00438 # 00439 # @else 00440 # 00441 # @endif 00442 def onRateChanged(self, ec_id): 00443 self._rtcout.RTC_TRACE("onRatechanged(%d)",ec_id) 00444 return RTC.RTC_OK 00445 00446 00447 #============================================================ 00448 # RTC::LightweightRTObject 00449 #============================================================ 00450 00451 ## 00452 # @if jp 00453 # 00454 # @brief [CORBA interface] RTCを初期化する 00455 # 00456 # このオペレーション呼び出しの結果として、ComponentAction::on_initialize 00457 # コールバック関数が呼ばれる。 00458 # 00459 # 制約 00460 # - RTC は Created状態の場合み初期化が行われる。他の状態にいる場合には 00461 # ReturnCode_t::PRECONDITION_NOT_MET が返され呼び出しは失敗する。 00462 # - このオペレーションは RTC のミドルウエアから呼ばれることを想定しており、 00463 # アプリケーション開発者は直接このオペレーションを呼ぶことは想定 00464 # されていない。 00465 # 00466 # @param self 00467 # 00468 # @return ReturnCode_t 型のリターンコード 00469 # 00470 # @else 00471 # 00472 # @brief Initialize the RTC that realizes this interface. 00473 # 00474 # The invocation of this operation shall result in the invocation of the 00475 # callback ComponentAction::on_initialize. 00476 # 00477 # Constraints 00478 # - An RTC may be initialized only while it is in the Created state. Any 00479 # attempt to invoke this operation while in another state shall fail 00480 # with ReturnCode_t::PRECONDITION_NOT_MET. 00481 # - Application developers are not expected to call this operation 00482 # directly; it exists for use by the RTC infrastructure. 00483 # 00484 # @return 00485 # 00486 # @endif 00487 def initialize(self): 00488 self._rtcout.RTC_TRACE("initialize()") 00489 00490 ec_args = self._properties.getProperty("exec_cxt.periodic.type") 00491 ec_args += "?" 00492 ec_args += "rate=" 00493 ec_args += self._properties.getProperty("exec_cxt.periodic.rate") 00494 00495 ec = OpenRTM_aist.Manager.instance().createContext(ec_args) 00496 if ec is None: 00497 return RTC.RTC_ERROR 00498 00499 ec.set_rate(float(self._properties.getProperty("exec_cxt.periodic.rate"))) 00500 self._eclist.append(ec) 00501 ecv = ec.getObjRef() 00502 if CORBA.is_nil(ecv): 00503 return RTC.RTC_ERROR 00504 00505 ec.bindComponent(self) 00506 00507 # at least one EC must be attached 00508 if len(self._ecMine) == 0: 00509 return RTC.PRECONDITION_NOT_MET 00510 00511 ret = self.on_initialize() 00512 if ret is not RTC.RTC_OK: 00513 return ret 00514 self._created = False 00515 00516 # -- entering alive state -- 00517 for i in range(len(self._ecMine)): 00518 self._rtcout.RTC_DEBUG("EC[%d] starting.", i) 00519 self._ecMine[i].start() 00520 00521 # ret must be RTC_OK 00522 return ret 00523 00524 00525 ## 00526 # @if jp 00527 # 00528 # @brief [CORBA interface] RTC を終了する 00529 # 00530 # このオペレーション呼び出しの結果として ComponentAction::on_finalize() 00531 # を呼び出す。 00532 # 00533 # 制約 00534 # - RTC が ExecutionContext に所属している間は終了されない。この場合は、 00535 # まず最初に ExecutionContextOperations::remove_component によって参加を 00536 # 解除しなければならない。これ以外の場合は、このオペレーション呼び出しは 00537 # いかなる場合も ReturnCode_t::PRECONDITION_NOT_ME で失敗する。 00538 # - RTC が Created 状態である場合、終了処理は行われない。 00539 # この場合、このオペレーション呼び出しはいかなる場合も 00540 # ReturnCode_t::PRECONDITION_NOT_MET で失敗する。 00541 # - このオペレーションはRTCのミドルウエアから呼ばれることを想定しており、 00542 # アプリケーション開発者は直接このオペレーションを呼ぶことは想定 00543 # されていない。 00544 # 00545 # @param self 00546 # 00547 # @return ReturnCode_t 型のリターンコード 00548 # 00549 # @else 00550 # 00551 # @brief Finalize the RTC for preparing it for destruction 00552 # 00553 # This invocation of this operation shall result in the invocation of the 00554 # callback ComponentAction::on_finalize. 00555 # 00556 # Constraints 00557 # - An RTC may not be finalized while it is participating in any execution 00558 # context. It must first be removed with 00559 # ExecutionContextOperations::remove_component. Otherwise, this operation 00560 # shall fail with ReturnCode_t::PRECONDITION_NOT_MET. 00561 # - An RTC may not be finalized while it is in the Created state. Any 00562 # attempt to invoke this operation while in that state shall fail with 00563 # ReturnCode_t::PRECONDITION_NOT_MET. 00564 # - Application developers are not expected to call this operation directly; 00565 # it exists for use by the RTC infrastructure. 00566 # 00567 # @return 00568 # 00569 # @endif 00570 def finalize(self): 00571 self._rtcout.RTC_TRACE("finalize()") 00572 if self._created or not self._exiting: 00573 return RTC.PRECONDITION_NOT_MET 00574 00575 # Return RTC::PRECONDITION_NOT_MET, 00576 # When the component is registered in ExecutionContext. 00577 if len(self._ecOther) != 0: 00578 for ec in self._ecOther: 00579 if not CORBA.is_nil(ec): 00580 return RTC.PRECONDITION_NOT_MET 00581 00582 self._ecOther = [] 00583 00584 ret = self.on_finalize() 00585 self.shutdown() 00586 return ret 00587 00588 00589 ## 00590 # @if jp 00591 # 00592 # @brief [CORBA interface] RTC がオーナーである ExecutionContext を 00593 # 停止させ、そのコンテンツと共に終了させる 00594 # 00595 # この RTC がオーナーであるすべての実行コンテキストを停止する。 00596 # この RTC が他の実行コンテキストを所有する RTC に属する実行コンテキスト 00597 # (i.e. 実行コンテキストを所有する RTC はすなわちその実行コンテキストの 00598 # オーナーである。)に参加している場合、当該 RTC はそれらのコンテキスト上 00599 # で非活性化されなければならない。 00600 # RTC が実行中のどの ExecutionContext でも Active 状態ではなくなった後、 00601 # この RTC とこれに含まれる RTC が終了する。 00602 # 00603 # 制約 00604 # - RTC が初期化されていなければ、終了させることはできない。 00605 # Created 状態にある RTC に exit() を呼び出した場合、 00606 # ReturnCode_t::PRECONDITION_NOT_MET で失敗する。 00607 # 00608 # @param self 00609 # 00610 # @return ReturnCode_t 型のリターンコード 00611 # 00612 # @else 00613 # 00614 # @brief Stop the RTC's execution context(s) and finalize it along with its 00615 # contents. 00616 # 00617 # Any execution contexts for which the RTC is the owner shall be stopped. 00618 # If the RTC participates in any execution contexts belonging to another 00619 # RTC that contains it, directly or indirectly (i.e. the containing RTC 00620 # is the owner of the ExecutionContext), it shall be deactivated in those 00621 # contexts. 00622 # After the RTC is no longer Active in any Running execution context, it 00623 # and any RTCs contained transitively within it shall be finalized. 00624 # 00625 # Constraints 00626 # - An RTC cannot be exited if it has not yet been initialized. Any 00627 # attempt to exit an RTC that is in the Created state shall fail with 00628 # ReturnCode_t::PRECONDITION_NOT_MET. 00629 # 00630 # @return 00631 # 00632 # @endif 00633 def exit(self): 00634 self._rtcout.RTC_TRACE("exit()") 00635 if self._created: 00636 return RTC.PRECONDITION_NOT_MET 00637 00638 # deactivate myself on owned EC 00639 OpenRTM_aist.CORBA_SeqUtil.for_each(self._ecMine, 00640 self.deactivate_comps(self._objref)) 00641 # deactivate myself on other EC 00642 OpenRTM_aist.CORBA_SeqUtil.for_each(self._ecOther, 00643 self.deactivate_comps(self._objref)) 00644 00645 # stop and detach myself from owned EC 00646 for ec in self._ecMine: 00647 if not CORBA.is_nil(ec) or not ec._non_existent(): 00648 # ret = ec.stop() 00649 # ec.remove_component(self._this()) 00650 pass 00651 00652 # detach myself from other EC 00653 for ec in self._ecOther: 00654 if not CORBA.is_nil(ec): 00655 # ec.stop() 00656 ec.remove_component(self._this()) 00657 00658 self._exiting = True 00659 return self.finalize() 00660 00661 00662 ## 00663 # @if jp 00664 # 00665 # @brief [CORBA interface] RTC が Alive 状態であるかどうか確認する。 00666 # 00667 # RTC が指定した ExecutionContext に対して Alive状態であるかどうか確認する。 00668 # RTC の状態が Active であるか、Inactive であるか、Error であるかは実行中の 00669 # ExecutionContext に依存する。すなわち、ある ExecutionContext に対しては 00670 # Active 状態であっても、他の ExecutionContext に対しては Inactive 状態と 00671 # なる場合もありえる。従って、このオペレーションは指定された 00672 # ExecutionContext に問い合わせて、この RTC の状態が Active、Inactive、 00673 # Error の場合には Alive 状態として返す。 00674 # 00675 # @param self 00676 # 00677 # @param exec_context 取得対象 ExecutionContext ハンドル 00678 # 00679 # @return Alive 状態確認結果 00680 # 00681 # @else 00682 # 00683 # @brief Confirm whether RTC is an Alive state or NOT. 00684 # 00685 # A component is alive or not regardless of the execution context from 00686 # which it is observed. However, whether or not it is Active, Inactive, 00687 # or in Error is dependent on the execution context(s) in which it is 00688 # running. That is, it may be Active in one context but Inactive in 00689 # another. Therefore, this operation shall report whether this RTC is 00690 # either Active, Inactive or in Error; which of those states a component 00691 # is in with respect to a particular context may be queried from the 00692 # context itself. 00693 # 00694 # @return Result of Alive state confirmation 00695 # 00696 # @endif 00697 # virtual CORBA::Boolean is_alive(ExecutionContext_ptr exec_context) 00698 def is_alive(self, exec_context): 00699 self._rtcout.RTC_TRACE("is_alive()") 00700 for ec in self._ecMine: 00701 if exec_context._is_equivalent(ec): 00702 return True 00703 00704 for ec in self._ecOther: 00705 if not CORBA.is_nil(ec): 00706 if exec_context._is_equivalent(ec): 00707 return True 00708 00709 return False 00710 00711 00712 ## 00713 # @if jp 00714 # @brief [CORBA interface] ExecutionContextListを取得する 00715 # 00716 # この RTC が所有する ExecutionContext のリストを取得する。 00717 # 00718 # @param self 00719 # 00720 # @return ExecutionContext リスト 00721 # 00722 # @else 00723 # @brief [CORBA interface] Get ExecutionContextList. 00724 # 00725 # This operation returns a list of all execution contexts owned by this RTC. 00726 # 00727 # @return ExecutionContext List 00728 # 00729 # @endif 00730 #def get_contexts(self): 00731 # execlist = [] 00732 # OpenRTM_aist.CORBA_SeqUtil.for_each(self._execContexts, self.ec_copy(execlist)) 00733 # return execlist 00734 00735 00736 ## 00737 # @if jp 00738 # @brief [CORBA interface] ExecutionContextを取得する 00739 # 00740 # 指定したハンドルの ExecutionContext を取得する。 00741 # ハンドルから ExecutionContext へのマッピングは、特定の RTC インスタンスに 00742 # 固有である。ハンドルはこの RTC を attach_context した際に取得できる。 00743 # 00744 # @param self 00745 # @param ec_id 取得対象 ExecutionContext ハンドル 00746 # 00747 # @return ExecutionContext 00748 # 00749 # @else 00750 # @brief [CORBA interface] Get ExecutionContext. 00751 # 00752 # Obtain a reference to the execution context represented by the given 00753 # handle. 00754 # The mapping from handle to context is specific to a particular RTC 00755 # instance. The given handle must have been obtained by a previous call to 00756 # attach_context on this RTC. 00757 # 00758 # @param ec_id ExecutionContext handle 00759 # 00760 # @return ExecutionContext 00761 # 00762 # @endif 00763 # virtual ExecutionContext_ptr get_context(UniqueId exec_handle) 00764 def get_context(self, ec_id): 00765 global ECOTHER_OFFSET 00766 00767 self._rtcout.RTC_TRACE("get_context(%d)", ec_id) 00768 # owned EC 00769 if ec_id < ECOTHER_OFFSET: 00770 if ec_id < len(self._ecMine): 00771 return self._ecMine[ec_id] 00772 else: 00773 return RTC.ExecutionContext._nil 00774 00775 # participating EC 00776 index = ec_id - ECOTHER_OFFSET 00777 00778 if index < len(self._ecOther): 00779 if not CORBA.is_nil(self._ecOther[index]): 00780 return self._ecOther[index] 00781 00782 return RTC.ExecutionContext._nil 00783 00784 00785 ## 00786 # @if jp 00787 # @brief [CORBA interface] 所有する ExecutionContextListを 取得する 00788 # 00789 # この RTC が所有する ExecutionContext のリストを取得する。 00790 # 00791 # @return ExecutionContext リスト 00792 # 00793 # @else 00794 # @brief [CORBA interface] Get ExecutionContextList. 00795 # 00796 # This operation returns a list of all execution contexts owned by this 00797 # RTC. 00798 # 00799 # @return ExecutionContext List 00800 # 00801 # @endif 00802 # virtual ExecutionContextList* get_owned_contexts() 00803 def get_owned_contexts(self): 00804 self._rtcout.RTC_TRACE("get_owned_contexts()") 00805 execlist = [] 00806 OpenRTM_aist.CORBA_SeqUtil.for_each(self._ecMine, self.ec_copy(execlist)) 00807 return execlist 00808 00809 ## 00810 # @if jp 00811 # @brief [CORBA interface] 参加している ExecutionContextList を取得する 00812 # 00813 # この RTC が参加している ExecutionContext のリストを取得する。 00814 # 00815 # @return ExecutionContext リスト 00816 # 00817 # @else 00818 # @brief [CORBA interface] Get participating ExecutionContextList. 00819 # 00820 # This operation returns a list of all execution contexts in 00821 # which this RTC participates. 00822 # 00823 # @return ExecutionContext List 00824 # 00825 # @endif 00826 # virtual ExecutionContextList* get_participating_contexts() 00827 def get_participating_contexts(self): 00828 self._rtcout.RTC_TRACE("get_participating_contexts()") 00829 execlist = [] 00830 OpenRTM_aist.CORBA_SeqUtil.for_each(self._ecOther, self.ec_copy(execlist)) 00831 return execlist 00832 00833 00834 # 00835 # @if jp 00836 # @brief [CORBA interface] ExecutionContext のハンドルを返す 00837 # 00838 # @param ExecutionContext 実行コンテキスト 00839 # 00840 # @return ExecutionContextHandle 00841 # 00842 # 与えられた実行コンテキストに関連付けられたハンドルを返す。 00843 # 00844 # @else 00845 # @brief [CORBA interface] Return a handle of a ExecutionContext 00846 # 00847 # @param ExecutionContext 00848 # 00849 # @return ExecutionContextHandle 00850 # 00851 # This operation returns a handle that is associated with the given 00852 # execution context. 00853 # 00854 # @endif 00855 # 00856 # virtual ExecutionContextHandle_t 00857 # get_context_handle(ExecutionContext_ptr cxt) 00858 def get_context_handle(self, cxt): 00859 self._rtcout.RTC_TRACE("get_context_handle()") 00860 00861 num = OpenRTM_aist.CORBA_SeqUtil.find(self._ecMine, self.ec_find(cxt)) 00862 if num != -1: 00863 return long(num) 00864 00865 num = OpenRTM_aist.CORBA_SeqUtil.find(self._ecOther, self.ec_find(cxt)) 00866 if num != -1: 00867 return long(num) 00868 00869 return long(-1) 00870 00871 00872 #============================================================ 00873 # RTC::RTObject 00874 #============================================================ 00875 00876 ## 00877 # @if jp 00878 # 00879 # @brief [RTObject CORBA interface] コンポーネントプロファイルを取得する 00880 # 00881 # 当該コンポーネントのプロファイル情報を返す。 00882 # 00883 # @param self 00884 # 00885 # @return コンポーネントプロファイル 00886 # 00887 # @else 00888 # 00889 # @brief [RTObject CORBA interface] Get RTC's profile 00890 # 00891 # This operation returns the ComponentProfile of the RTC 00892 # 00893 # @return ComponentProfile 00894 # 00895 # @endif 00896 # virtual ComponentProfile* get_component_profile() 00897 def get_component_profile(self): 00898 self._rtcout.RTC_TRACE("get_component_profile()") 00899 try: 00900 prop_ = RTC.ComponentProfile(self._properties.getProperty("instance_name"), 00901 self._properties.getProperty("type_name"), 00902 self._properties.getProperty("description"), 00903 self._properties.getProperty("version"), 00904 self._properties.getProperty("vendor"), 00905 self._properties.getProperty("category"), 00906 self._portAdmin.getPortProfileList(), 00907 self._profile.parent, 00908 self._profile.properties) 00909 OpenRTM_aist.NVUtil.copyFromProperties(self._profile.properties, self._properties) 00910 return prop_ 00911 # return RTC.ComponentProfile(self._profile.instance_name, 00912 # self._profile.type_name, 00913 # self._profile.description, 00914 # self._profile.version, 00915 # self._profile.vendor, 00916 # self._profile.category, 00917 # self._portAdmin.getPortProfileList(), 00918 # self._profile.parent, 00919 # self._profile.properties) 00920 00921 except: 00922 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 00923 00924 assert(False) 00925 return None 00926 00927 00928 ## 00929 # @if jp 00930 # 00931 # @brief [RTObject CORBA interface] ポートを取得する 00932 # 00933 # 当該コンポーネントが保有するポートの参照を返す。 00934 # 00935 # @param self 00936 # 00937 # @return ポートリスト 00938 # 00939 # @else 00940 # 00941 # @brief [RTObject CORBA interface] Get Ports 00942 # 00943 # This operation returns a list of the RTCs ports. 00944 # 00945 # @return PortList 00946 # 00947 # @endif 00948 # virtual PortServiceList* get_ports() 00949 def get_ports(self): 00950 self._rtcout.RTC_TRACE("get_ports()") 00951 try: 00952 return self._portAdmin.getPortServiceList() 00953 except: 00954 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 00955 00956 assert(False) 00957 return [] 00958 00959 00960 00961 # RTC::ComponentAction 00962 00963 ## 00964 # @if jp 00965 # @brief [CORBA interface] ExecutionContextをattachする 00966 # 00967 # 指定した ExecutionContext にこの RTC を所属させる。この RTC と関連する 00968 # ExecutionContext のハンドルを返す。 00969 # このオペレーションは、ExecutionContextOperations::add_component が呼ばれた 00970 # 際に呼び出される。返されたハンドルは他のクライアントで使用することを想定 00971 # していない。 00972 # 00973 # @param self 00974 # @param exec_context 所属先 ExecutionContext 00975 # 00976 # @return ExecutionContext ハンドル 00977 # 00978 # @else 00979 # @brief [CORBA interface] Attach ExecutionContext. 00980 # 00981 # Inform this RTC that it is participating in the given execution context. 00982 # Return a handle that represents the association of this RTC with the 00983 # context. 00984 # This operation is intended to be invoked by 00985 # ExecutionContextOperations::add_component. It is not intended for use by 00986 # other clients. 00987 # 00988 # @param exec_context Prticipating ExecutionContext 00989 # 00990 # @return ExecutionContext Handle 00991 # 00992 # @endif 00993 # UniqueId attach_context(ExecutionContext_ptr exec_context) 00994 def attach_context(self, exec_context): 00995 global ECOTHER_OFFSET 00996 self._rtcout.RTC_TRACE("attach_context()") 00997 # ID: 0 - (offset-1) : owned ec 00998 # ID: offset - : participating ec 00999 # owned ec index = ID 01000 # participate ec index = ID - offset 01001 ecs = exec_context._narrow(RTC.ExecutionContextService) 01002 if CORBA.is_nil(ecs): 01003 return -1 01004 01005 # if m_ecOther has nil element, insert attached ec to there. 01006 for i in range(len(self._ecOther)): 01007 if CORBA.is_nil(self._ecOther[i]): 01008 self._ecOther[i] = ecs 01009 ec_id = i + ECOTHER_OFFSET 01010 self.onAttachExecutionContext(ec_id) 01011 return ec_id 01012 01013 # no space in the list, push back ec to the last. 01014 OpenRTM_aist.CORBA_SeqUtil.push_back(self._ecOther,ecs) 01015 ec_id = long(len(self._ecOther) - 1 + ECOTHER_OFFSET) 01016 self.onAttachExecutionContext(ec_id) 01017 return ec_id 01018 01019 01020 # UniqueId bindContext(ExecutionContext_ptr exec_context); 01021 def bindContext(self, exec_context): 01022 global ECOTHER_OFFSET 01023 self._rtcout.RTC_TRACE("bindContext()") 01024 # ID: 0 - (offset-1) : owned ec 01025 # ID: offset - : participating ec 01026 # owned ec index = ID 01027 # participate ec index = ID - offset 01028 ecs = exec_context._narrow(RTC.ExecutionContextService) 01029 01030 if CORBA.is_nil(ecs): 01031 return -1 01032 01033 # if m_ecMine has nil element, insert attached ec to there. 01034 for i in range(len(self._ecMine)): 01035 if CORBA.is_nil(self._ecMine[i]): 01036 self._ecMine[i] = ecs 01037 self.onAttachExecutionContext(i) 01038 return i 01039 #return i + ECOTHER_OFFSET 01040 01041 # no space in the list, push back ec to the last. 01042 OpenRTM_aist.CORBA_SeqUtil.push_back(self._ecMine,ecs) 01043 01044 return long(len(self._ecMine) - 1) 01045 #return long(len(self._ecMine) - 1 + ECOTHER_OFFSET) 01046 01047 01048 ## 01049 # @if jp 01050 # @brief [CORBA interface] ExecutionContextをdetachする 01051 # 01052 # 指定した ExecutionContext からこの RTC の所属を解除する。 01053 # このオペレーションは、ExecutionContextOperations::remove_component が呼ば 01054 # れた際に呼び出される。返されたハンドルは他のクライアントで使用することを 01055 # 想定していない。 01056 # 01057 # 制約 01058 # - 指定された ExecutionContext に RTC がすでに所属していない場合には、 01059 # ReturnCode_t::PRECONDITION_NOT_MET が返される。 01060 # - 指定された ExecutionContext にたしいて対して RTC がActive 状態である場 01061 # 合には、 ReturnCode_t::PRECONDITION_NOT_MET が返される。 01062 # 01063 # @param self 01064 # @param ec_id 解除対象 ExecutionContextハンドル 01065 # 01066 # @return ReturnCode_t 型のリターンコード 01067 # 01068 # @else 01069 # @brief [CORBA interface] Attach ExecutionContext. 01070 # 01071 # Inform this RTC that it is no longer participating in the given execution 01072 # context. 01073 # This operation is intended to be invoked by 01074 # ExecutionContextOperations::remove_component. It is not intended for use 01075 # by other clients. 01076 # Constraints 01077 # - This operation may not be invoked if this RTC is not already 01078 # participating in the execution context. Such a call shall fail with 01079 # ReturnCode_t::PRECONDITION_NOT_MET. 01080 # - This operation may not be invoked if this RTC is Active in the indicated 01081 # execution context. Otherwise, it shall fail with 01082 # ReturnCode_t::PRECONDITION_NOT_MET. 01083 # 01084 # @param ec_id Dettaching ExecutionContext Handle 01085 # 01086 # @return 01087 # 01088 # @endif 01089 # ReturnCode_t detach_context(UniqueId exec_handle) 01090 def detach_context(self, ec_id): 01091 global ECOTHER_OFFSET 01092 self._rtcout.RTC_TRACE("detach_context(%d)", ec_id) 01093 len_ = len(self._ecOther) 01094 01095 # ID: 0 - (offset-1) : owned ec 01096 # ID: offset - : participating ec 01097 # owned ec index = ID 01098 # participate ec index = ID - offset 01099 if (long(ec_id) < long(ECOTHER_OFFSET)) or \ 01100 (long(ec_id - ECOTHER_OFFSET) > len_): 01101 return RTC.BAD_PARAMETER 01102 01103 index = long(ec_id - ECOTHER_OFFSET) 01104 01105 if index < 0 or CORBA.is_nil(self._ecOther[index]): 01106 return RTC.BAD_PARAMETER 01107 01108 #OpenRTM_aist.CORBA_SeqUtil.erase(self._ecOther, index) 01109 self._ecOther[index] = RTC.ExecutionContextService._nil 01110 self.onDetachExecutionContext(ec_id) 01111 return RTC.RTC_OK 01112 01113 01114 ## 01115 # @if jp 01116 # 01117 # @brief [ComponentAction CORBA interface] RTC の初期化 01118 # 01119 # RTC が初期化され、Alive 状態に遷移する。 01120 # RTC 固有の初期化処理はここで実行する。 01121 # このオペレーション呼び出しの結果として onInitialize() コールバック関数が 01122 # 呼び出される。 01123 # 01124 # @param self 01125 # 01126 # @return ReturnCode_t 型のリターンコード 01127 # 01128 # @else 01129 # 01130 # @brief [ComponentAction CORBA interface] Initialize RTC 01131 # 01132 # The RTC has been initialized and entered the Alive state. 01133 # Any RTC-specific initialization logic should be performed here. 01134 # 01135 # @return 01136 # 01137 # @endif 01138 def on_initialize(self): 01139 self._rtcout.RTC_TRACE("on_initialize()") 01140 ret = RTC.RTC_ERROR 01141 try: 01142 self.preOnInitialize(0) 01143 ret = self.onInitialize() 01144 except: 01145 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01146 ret = RTC.RTC_ERROR 01147 01148 active_set = self._properties.getProperty("configuration.active_config", 01149 "default") 01150 01151 if self._configsets.haveConfig(active_set): 01152 self._configsets.update(active_set) 01153 else: 01154 self._configsets.update("default") 01155 01156 self.postOnInitialize(0,ret) 01157 return ret 01158 01159 01160 ## 01161 # @if jp 01162 # 01163 # @brief [ComponentAction CORBA interface] RTC の終了 01164 # 01165 # RTC が破棄される。 01166 # RTC 固有の終了処理はここで実行する。 01167 # このオペレーション呼び出しの結果として onFinalize() コールバック関数が 01168 # 呼び出される。 01169 # 01170 # @param self 01171 # 01172 # @return ReturnCode_t 型のリターンコード 01173 # 01174 # @else 01175 # 01176 # @brief [ComponentAction CORBA interface] Finalize RTC 01177 # 01178 # The RTC is being destroyed. 01179 # Any final RTC-specific tear-down logic should be performed here. 01180 # 01181 # @return 01182 # 01183 # @endif 01184 def on_finalize(self): 01185 self._rtcout.RTC_TRACE("on_finalize()") 01186 ret = RTC.RTC_ERROR 01187 try: 01188 self.preOnFinalize(0) 01189 ret = self.onFinalize() 01190 except: 01191 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01192 ret = RTC.RTC_ERROR 01193 self.postOnFinalize(0, ret) 01194 return ret 01195 01196 01197 ## 01198 # @if jp 01199 # 01200 # @brief [ComponentAction CORBA interface] RTC の開始 01201 # 01202 # RTC が所属する ExecutionContext が Stopped 状態から Running 状態へ遷移 01203 # した場合に呼び出される。 01204 # このオペレーション呼び出しの結果として onStartup() コールバック関数が 01205 # 呼び出される。 01206 # 01207 # @param self 01208 # @param ec_id 状態遷移した ExecutionContext の ID 01209 # 01210 # @return ReturnCode_t 型のリターンコード 01211 # 01212 # @else 01213 # 01214 # @brief [ComponentAction CORBA interface] StartUp RTC 01215 # 01216 # The given execution context, in which the RTC is participating, has 01217 # transitioned from Stopped to Running. 01218 # 01219 # @param ec_id 01220 # 01221 # @return 01222 # 01223 # @endif 01224 def on_startup(self, ec_id): 01225 self._rtcout.RTC_TRACE("on_startup(%d)", ec_id) 01226 ret = RTC.RTC_ERROR 01227 try: 01228 self.preOnStartup(ec_id) 01229 ret = self.onStartup(ec_id) 01230 except: 01231 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01232 ret = RTC.RTC_ERROR 01233 self.postOnStartup(ec_id, ret) 01234 return ret 01235 01236 01237 ## 01238 # @if jp 01239 # 01240 # @brief [ComponentAction CORBA interface] RTC の停止 01241 # 01242 # RTC が所属する ExecutionContext が Running 状態から Stopped 状態へ遷移 01243 # した場合に呼び出される。 01244 # このオペレーション呼び出しの結果として onShutdown() コールバック関数が 01245 # 呼び出される。 01246 # 01247 # @param self 01248 # @param ec_id 状態遷移した ExecutionContext の ID 01249 # 01250 # @return ReturnCode_t 型のリターンコード 01251 # 01252 # @else 01253 # 01254 # @brief [ComponentAction CORBA interface] ShutDown RTC 01255 # 01256 # The given execution context, in which the RTC is participating, has 01257 # transitioned from Running to Stopped. 01258 # 01259 # @param ec_id 01260 # 01261 # @return 01262 # 01263 # @endif 01264 def on_shutdown(self, ec_id): 01265 self._rtcout.RTC_TRACE("on_shutdown(%d)", ec_id) 01266 ret = RTC.RTC_ERROR 01267 try: 01268 self.preOnShutdown(ec_id) 01269 ret = self.onShutdown(ec_id) 01270 except: 01271 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01272 ret = RTC.RTC_ERROR 01273 self.postOnShutdown(ec_id, ret) 01274 return ret 01275 01276 01277 ## 01278 # @if jp 01279 # 01280 # @brief [ComponentAction CORBA interface] RTC の活性化 01281 # 01282 # 所属する ExecutionContext から RTC が活性化された際に呼び出される。 01283 # このオペレーション呼び出しの結果として onActivated() コールバック関数が 01284 # 呼び出される。 01285 # 01286 # @param self 01287 # @param ec_id 活性化 ExecutionContext の ID 01288 # 01289 # @return ReturnCode_t 型のリターンコード 01290 # 01291 # @else 01292 # 01293 # @brief [ComponentAction CORBA interface] Activate RTC 01294 # 01295 # The RTC has been activated in the given execution context. 01296 # 01297 # @param ec_id 01298 # 01299 # @return 01300 # 01301 # @endif 01302 def on_activated(self, ec_id): 01303 self._rtcout.RTC_TRACE("on_activated(%d)", ec_id) 01304 ret = RTC.RTC_ERROR 01305 try: 01306 self.preOnActivated(ec_id) 01307 self._configsets.update() 01308 ret = self.onActivated(ec_id) 01309 self._portAdmin.activatePorts() 01310 except: 01311 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01312 ret = RTC.RTC_ERROR 01313 self.postOnActivated(ec_id, ret) 01314 return ret 01315 01316 01317 ## 01318 # @if jp 01319 # 01320 # @brief [ComponentAction CORBA interface] RTC の非活性化 01321 # 01322 # 所属する ExecutionContext から RTC が非活性化された際に呼び出される。 01323 # このオペレーション呼び出しの結果として onDeactivated() コールバック関数が 01324 # 呼び出される。 01325 # 01326 # @param self 01327 # @param ec_id 非活性化 ExecutionContext の ID 01328 # 01329 # @return ReturnCode_t 型のリターンコード 01330 # 01331 # @else 01332 # 01333 # @brief [ComponentAction CORBA interface] Deactivate RTC 01334 # 01335 # The RTC has been deactivated in the given execution context. 01336 # 01337 # @param ec_id 01338 # 01339 # @return 01340 # 01341 # @endif 01342 def on_deactivated(self, ec_id): 01343 self._rtcout.RTC_TRACE("on_deactivated(%d)", ec_id) 01344 ret = RTC.RTC_ERROR 01345 try: 01346 self.preOnDeactivated(ec_id) 01347 self._portAdmin.deactivatePorts() 01348 ret = self.onDeactivated(ec_id) 01349 except: 01350 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01351 ret = RTC.RTC_ERROR 01352 self.postOnDeactivated(ec_id, ret) 01353 return ret 01354 01355 01356 ## 01357 # @if jp 01358 # 01359 # @brief [ComponentAction CORBA interface] RTC のエラー状態への遷移 01360 # 01361 # RTC が所属する ExecutionContext が Active 状態から Error 状態へ遷移した 01362 # 場合に呼び出される。 01363 # このオペレーションは RTC が Error 状態に遷移した際に一度だけ呼び出される。 01364 # このオペレーション呼び出しの結果として onAborting() コールバック関数が 01365 # 呼び出される。 01366 # 01367 # @param self 01368 # @param ec_id 状態遷移した ExecutionContext の ID 01369 # 01370 # @return ReturnCode_t 型のリターンコード 01371 # 01372 # @else 01373 # 01374 # @brief [ComponentAction CORBA interface] Transition Error State 01375 # 01376 # The RTC is transitioning from the Active state to the Error state in some 01377 # execution context. 01378 # This callback is invoked only a single time for time that the RTC 01379 # transitions into the Error state from another state. This behavior is in 01380 # contrast to that of on_error. 01381 # 01382 # @param ec_id 01383 # 01384 # @return 01385 # 01386 # @endif 01387 def on_aborting(self, ec_id): 01388 self._rtcout.RTC_TRACE("on_aborting(%d)", ec_id) 01389 ret = RTC.RTC_ERROR 01390 try: 01391 self.preOnAborting(ec_id) 01392 ret = self.onAborting(ec_id) 01393 except: 01394 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01395 ret = RTC.RTC_ERROR 01396 self.postOnAborting(ec_id, ret) 01397 return ret 01398 01399 01400 ## 01401 # @if jp 01402 # 01403 # @brief [ComponentAction CORBA interface] RTC のエラー処理 01404 # 01405 # RTC がエラー状態にいる際に呼び出される。 01406 # RTC がエラー状態の場合に、対象となる ExecutionContext のExecutionKind に 01407 # 応じたタイミングで呼び出される。例えば、 01408 # - ExecutionKind が PERIODIC の場合、本オペレーションは 01409 # DataFlowComponentAction::on_execute と on_state_update の替わりに、 01410 # 設定された順番、設定された周期で呼び出される。 01411 # - ExecutionKind が EVENT_DRIVEN の場合、本オペレーションは 01412 # FsmParticipantAction::on_action が呼ばれた際に、替わりに呼び出される。 01413 # このオペレーション呼び出しの結果として onError() コールバック関数が呼び出 01414 # される。 01415 # 01416 # @param self 01417 # @param ec_id 対象 ExecutionContext の ID 01418 # 01419 # @return ReturnCode_t 型のリターンコード 01420 # 01421 # @else 01422 # 01423 # @brief [ComponentAction CORBA interface] Error Processing of RTC 01424 # 01425 # The RTC remains in the Error state. 01426 # If the RTC is in the Error state relative to some execution context when 01427 # it would otherwise be invoked from that context (according to the 01428 # context’s ExecutionKind), this callback shall be invoked instead. 01429 # For example, 01430 # - If the ExecutionKind is PERIODIC, this operation shall be invoked in 01431 # sorted order at the rate of the context instead of 01432 # DataFlowComponentAction::on_execute and on_state_update. 01433 # - If the ExecutionKind is EVENT_DRIVEN, this operation shall be invoked 01434 # whenever FsmParticipantAction::on_action would otherwise have been 01435 # invoked. 01436 # 01437 # @param ec_id 01438 # 01439 # @return 01440 # 01441 # @endif 01442 def on_error(self, ec_id): 01443 self._rtcout.RTC_TRACE("on_error(%d)", ec_id) 01444 ret = RTC.RTC_ERROR 01445 try: 01446 self.preOnError(ec_id) 01447 ret = self.onError(ec_id) 01448 except: 01449 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01450 ret = RTC.RTC_ERROR 01451 self._configsets.update() 01452 self.postOnError(ec_id, ret) 01453 return ret 01454 01455 01456 ## 01457 # @if jp 01458 # 01459 # @brief [ComponentAction CORBA interface] RTC のリセット 01460 # 01461 # Error 状態にある RTC のリカバリ処理を実行し、Inactive 状態に復帰させる 01462 # 場合に呼び出される。 01463 # RTC のリカバリ処理が成功した場合は Inactive 状態に復帰するが、それ以外の 01464 # 場合には Error 状態に留まる。 01465 # このオペレーション呼び出しの結果として onReset() コールバック関数が呼び 01466 # 出される。 01467 # 01468 # @param self 01469 # @param ec_id リセット対象 ExecutionContext の ID 01470 # 01471 # @return ReturnCode_t 型のリターンコード 01472 # 01473 # @else 01474 # 01475 # @brief [ComponentAction CORBA interface] Resetting RTC 01476 # 01477 # The RTC is in the Error state. An attempt is being made to recover it such 01478 # that it can return to the Inactive state. 01479 # If the RTC was successfully recovered and can safely return to the 01480 # Inactive state, this method shall complete with ReturnCode_t::OK. Any 01481 # other result shall indicate that the RTC should remain in the Error state. 01482 # 01483 # @param ec_id 01484 # 01485 # @return 01486 # 01487 # @endif 01488 def on_reset(self, ec_id): 01489 self._rtcout.RTC_TRACE("on_reset(%d)", ec_id) 01490 ret = RTC.RTC_ERROR 01491 try: 01492 self.preOnReset(ec_id) 01493 ret = self.onReset(ec_id) 01494 except: 01495 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01496 ret = RTC.RTC_ERROR 01497 self.postOnReset(ec_id, ret) 01498 return ret 01499 01500 01501 ## 01502 # @if jp 01503 # 01504 # @brief [DataFlowComponentAction CORBA interface] RTC の定常処理(第一周期) 01505 # 01506 # 以下の状態が保持されている場合に、設定された周期で定期的に呼び出される。 01507 # - RTC は Alive 状態である。 01508 # - 指定された ExecutionContext が Running 状態である。 01509 # 本オペレーションは、Two-Pass Execution の第一周期で実行される。 01510 # このオペレーション呼び出しの結果として onExecute() コールバック関数が呼び 01511 # 出される。 01512 # 01513 # 制約 01514 # - 指定された ExecutionContext の ExecutionKind は、 PERIODIC でなければな 01515 # らない 01516 # 01517 # @param self 01518 # @param ec_id 定常処理対象 ExecutionContext の ID 01519 # 01520 # @return ReturnCode_t 型のリターンコード 01521 # 01522 # @else 01523 # 01524 # @brief [DataFlowComponentAction CORBA interface] Primary Periodic 01525 # Operation of RTC 01526 # 01527 # This operation will be invoked periodically at the rate of the given 01528 # execution context as long as the following conditions hold: 01529 # - The RTC is Active. 01530 # - The given execution context is Running 01531 # This callback occurs during the first execution pass. 01532 # 01533 # Constraints 01534 # - The execution context of the given context shall be PERIODIC. 01535 # 01536 # @param ec_id 01537 # 01538 # @return 01539 # 01540 # @endif 01541 def on_execute(self, ec_id): 01542 self._rtcout.RTC_TRACE("on_execute(%d)", ec_id) 01543 ret = RTC.RTC_ERROR 01544 try: 01545 self.preOnExecute(ec_id) 01546 if self._readAll: 01547 self.readAll() 01548 01549 ret = self.onExecute(ec_id) 01550 01551 if self._writeAll: 01552 self.writeAll() 01553 01554 except: 01555 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01556 ret = RTC.RTC_ERROR 01557 self.postOnExecute(ec_id, ret) 01558 return ret 01559 01560 01561 ## 01562 # @if jp 01563 # 01564 # @brief [DataFlowComponentAction CORBA interface] RTC の定常処理(第二周期) 01565 # 01566 # 以下の状態が保持されている場合に、設定された周期で定期的に呼び出される。 01567 # - RTC は Alive 状態である。 01568 # - 指定された ExecutionContext が Running 状態である。 01569 # 本オペレーションは、Two-Pass Execution の第二周期で実行される。 01570 # このオペレーション呼び出しの結果として onStateUpdate() コールバック関数が 01571 # 呼び出される。 01572 # 01573 # 制約 01574 # - 指定された ExecutionContext の ExecutionKind は、 PERIODIC でなければな 01575 # らない 01576 # 01577 # @param self 01578 # @param ec_id 定常処理対象 ExecutionContext の ID 01579 # 01580 # @return ReturnCode_t 型のリターンコード 01581 # 01582 # @else 01583 # 01584 # @brief [DataFlowComponentAction CORBA interface] Secondary Periodic 01585 # Operation of RTC 01586 # 01587 # This operation will be invoked periodically at the rate of the given 01588 # execution context as long as the following conditions hold: 01589 # - The RTC is Active. 01590 # - The given execution context is Running 01591 # This callback occurs during the second execution pass. 01592 # 01593 # Constraints 01594 # - The execution context of the given context shall be PERIODIC. 01595 # 01596 # @param ec_id 01597 # 01598 # @return 01599 # 01600 # @endif 01601 def on_state_update(self, ec_id): 01602 self._rtcout.RTC_TRACE("on_state_update(%d)", ec_id) 01603 ret = RTC.RTC_ERROR 01604 try: 01605 self.preOnStateUpdate(ec_id) 01606 ret = self.onStateUpdate(ec_id) 01607 self._configsets.update() 01608 except: 01609 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01610 ret = RTC.RTC_ERROR 01611 self.postOnStateUpdate(ec_id, ret) 01612 return ret 01613 01614 01615 ## 01616 # @if jp 01617 # 01618 # @brief [DataFlowComponentAction CORBA interface] 実行周期変更通知 01619 # 01620 # 本オペレーションは、ExecutionContext の実行周期が変更されたことを通知する 01621 # 際に呼び出される。 01622 # このオペレーション呼び出しの結果として onRateChanged() コールバック関数が 01623 # 呼び出される。 01624 # 01625 # 制約 01626 # - 指定された ExecutionContext の ExecutionKind は、 PERIODIC でなければな 01627 # らない 01628 # 01629 # @param self 01630 # @param ec_id 定常処理対象 ExecutionContext の ID 01631 # 01632 # @return ReturnCode_t 型のリターンコード 01633 # 01634 # @else 01635 # 01636 # @brief [DataFlowComponentAction CORBA interface] Notify rate chenged 01637 # 01638 # This operation is a notification that the rate of the indicated execution 01639 # context has changed. 01640 # 01641 # Constraints 01642 # - The execution context of the given context shall be PERIODIC. 01643 # 01644 # @param ec_id 01645 # 01646 # @return 01647 # 01648 # @endif 01649 def on_rate_changed(self, ec_id): 01650 self._rtcout.RTC_TRACE("on_rate_changed(%d)", ec_id) 01651 ret = RTC.RTC_ERROR 01652 try: 01653 self.preOnRateChanged(ec_id) 01654 ret = self.onRateChanged(ec_id) 01655 except: 01656 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01657 ret = RTC.RTC_ERROR 01658 self.postOnRateChanged(ec_id, ret) 01659 return ret 01660 01661 01662 #============================================================ 01663 # SDOPackage::SdoSystemElement 01664 #============================================================ 01665 01666 ## 01667 # @if jp 01668 # 01669 # @brief [SDO interface] Organization リストの取得 01670 # 01671 # SDOSystemElement は0個もしくはそれ以上の Organization を所有することが 01672 # 出来る。 SDOSystemElement が1つ以上の Organization を所有している場合 01673 # には、このオペレーションは所有する Organization のリストを返す。 01674 # もしOrganizationを一つも所有していないければ空のリストを返す。 01675 # 01676 # @param self 01677 # 01678 # @return 所有している Organization リスト 01679 # 01680 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01681 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01682 # @exception NotAvailable SDOは存在するが応答がない。 01683 # @exception InternalError 内部的エラーが発生した。 01684 # 01685 # @else 01686 # 01687 # @brief [SDO interface] Getting Organizations 01688 # 01689 # SDOSystemElement can be the owner of zero or more organizations. 01690 # If the SDOSystemElement owns one or more Organizations, this operation 01691 # returns the list of Organizations that the SDOSystemElement owns. 01692 # If it does not own any Organization, it returns empty list. 01693 # 01694 # @return Owned Organization List 01695 # 01696 # @exception SDONotExists if the target SDO does not exist.(This exception 01697 # is mapped to CORBA standard system exception 01698 # OBJECT_NOT_EXIST.) 01699 # @exception NotAvailable if the target SDO is reachable but cannot 01700 # respond. 01701 # @exception InternalError if the target SDO cannot execute the operation 01702 # completely due to some internal error. 01703 # 01704 # @endif 01705 # virtual SDOPackage::OrganizationList* get_owned_organizations() 01706 def get_owned_organizations(self): 01707 self._rtcout.RTC_TRACE("get_owned_organizations()") 01708 try: 01709 return self._sdoOwnedOrganizations 01710 except: 01711 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01712 raise SDOPackage.NotAvailable("NotAvailable: get_owned_organizations") 01713 01714 return [] 01715 01716 01717 #============================================================ 01718 # SDOPackage::SDO 01719 #============================================================ 01720 01721 ## 01722 # @if jp 01723 # 01724 # @brief [SDO interface] SDO ID の取得 01725 # 01726 # SDO ID を返すオペレーション。 01727 # このオペレーションは以下の型の例外を発生させる。 01728 # 01729 # @param self 01730 # 01731 # @return リソースデータモデルで定義されている SDO の ID 01732 # 01733 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01734 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01735 # @exception NotAvailable SDOは存在するが応答がない。 01736 # @exception InternalError 内部的エラーが発生した。 01737 # 01738 # @else 01739 # 01740 # @brief [SDO interface] Getting SDO ID 01741 # 01742 # This operation returns id of the SDO. 01743 # This operation throws SDOException with one of the following types. 01744 # 01745 # @return id of the SDO defined in the resource data model. 01746 # 01747 # @exception SDONotExists if the target SDO does not exist.(This exception 01748 # is mapped to CORBA standard system exception 01749 # OBJECT_NOT_EXIST.) 01750 # @exception NotAvailable if the target SDO is reachable but cannot 01751 # respond. 01752 # @exception InternalError if the target SDO cannot execute the operation 01753 # completely due to some internal error. 01754 # 01755 # @endif 01756 # virtual char* get_sdo_id() 01757 def get_sdo_id(self): 01758 self._rtcout.RTC_TRACE("get_sdo_id()") 01759 try: 01760 return self._profile.instance_name 01761 except: 01762 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01763 raise SDOPackage.InternalError("get_sdo_id()") 01764 01765 01766 ## 01767 # @if jp 01768 # 01769 # @brief [SDO interface] SDO タイプの取得 01770 # 01771 # SDO Type を返すオペレーション。 01772 # このオペレーションは以下の型の例外を発生させる。 01773 # 01774 # @param self 01775 # 01776 # @return リソースデータモデルで定義されている SDO の Type 01777 # 01778 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01779 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01780 # @exception NotAvailable SDOは存在するが応答がない。 01781 # @exception InternalError 内部的エラーが発生した。 01782 # 01783 # @else 01784 # 01785 # @brief [SDO interface] Getting SDO type 01786 # 01787 # This operation returns sdoType of the SDO. 01788 # This operation throws SDOException with one of the following types. 01789 # 01790 # @return Type of the SDO defined in the resource data model. 01791 # 01792 # @exception SDONotExists if the target SDO does not exist.(This exception 01793 # is mapped to CORBA standard system exception 01794 # OBJECT_NOT_EXIST.) 01795 # @exception NotAvailable if the target SDO is reachable but cannot 01796 # respond. 01797 # @exception InternalError if the target SDO cannot execute the operation 01798 # completely due to some internal error. 01799 # 01800 # @endif 01801 # virtual char* get_sdo_type() 01802 def get_sdo_type(self): 01803 self._rtcout.RTC_TRACE("get_sdo_type()") 01804 try: 01805 return self._profile.description 01806 except: 01807 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01808 raise SDOPackage.InternalError("get_sdo_type()") 01809 return "" 01810 01811 01812 ## 01813 # @if jp 01814 # 01815 # @brief [SDO interface] SDO DeviceProfile リストの取得 01816 # 01817 # SDO の DeviceProfile を返すオペレーション。 SDO がハードウエアデバイス 01818 # に関連付けられていない場合には、空の DeviceProfile が返される。 01819 # このオペレーションは以下の型の例外を発生させる。 01820 # 01821 # @param self 01822 # 01823 # @return SDO DeviceProfile 01824 # 01825 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01826 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01827 # @exception NotAvailable SDOは存在するが応答がない。 01828 # @exception InternalError 内部的エラーが発生した。 01829 # 01830 # @else 01831 # 01832 # @brief [SDO interface] Getting SDO DeviceProfile 01833 # 01834 # This operation returns the DeviceProfile of the SDO. If the SDO does not 01835 # represent any hardware device, then a DeviceProfile with empty values 01836 # are returned. 01837 # This operation throws SDOException with one of the following types. 01838 # 01839 # @return The DeviceProfile of the SDO. 01840 # 01841 # @exception SDONotExists if the target SDO does not exist.(This exception 01842 # is mapped to CORBA standard system exception 01843 # OBJECT_NOT_EXIST.) 01844 # @exception NotAvailable if the target SDO is reachable but cannot 01845 # respond. 01846 # @exception InternalError if the target SDO cannot execute the operation 01847 # completely due to some internal error. 01848 # 01849 # @endif 01850 # virtual SDOPackage::DeviceProfile* get_device_profile() 01851 def get_device_profile(self): 01852 self._rtcout.RTC_TRACE("get_device_profile()") 01853 try: 01854 return self._SdoConfigImpl.getDeviceProfile() 01855 except: 01856 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01857 raise SDOPackage.InternalError("get_device_profile()") 01858 01859 return SDOPackage.DeviceProfile("","","","",[]) 01860 01861 01862 ## 01863 # @if jp 01864 # 01865 # @brief [SDO interface] SDO ServiceProfile の取得 01866 # 01867 # SDO が所有している Service の ServiceProfile を返すオペレーション。 01868 # SDO がサービスを一つも所有していない場合には、空のリストを返す。 01869 # このオペレーションは以下の型の例外を発生させる。 01870 # 01871 # @param self 01872 # 01873 # @return SDO が提供する全ての Service の ServiceProfile。 01874 # 01875 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01876 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01877 # @exception NotAvailable SDOは存在するが応答がない。 01878 # @exception InternalError 内部的エラーが発生した。 01879 # 01880 # @else 01881 # 01882 # @brief [SDO interface] Getting SDO ServiceProfile 01883 # 01884 # This operation returns a list of ServiceProfiles that the SDO has. 01885 # If the SDO does not provide any service, then an empty list is returned. 01886 # This operation throws SDOException with one of the following types. 01887 # 01888 # @return List of ServiceProfiles of all the services the SDO is 01889 # providing. 01890 # 01891 # @exception SDONotExists if the target SDO does not exist.(This exception 01892 # is mapped to CORBA standard system exception 01893 # OBJECT_NOT_EXIST.) 01894 # @exception NotAvailable if the target SDO is reachable but cannot 01895 # respond. 01896 # @exception InternalError if the target SDO cannot execute the operation 01897 # completely due to some internal error. 01898 # 01899 # @endif 01900 # virtual SDOPackage::ServiceProfileList* get_service_profiles() 01901 def get_service_profiles(self): 01902 self._rtcout.RTC_TRACE("get_service_profiles()") 01903 self._sdoSvcProfiles = self._SdoConfigImpl.getServiceProfiles() 01904 try: 01905 return self._sdoSvcProfiles 01906 except: 01907 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01908 raise SDOPackage.InternalError("get_service_profiles()") 01909 01910 return [] 01911 01912 01913 ## 01914 # @if jp 01915 # 01916 # @brief [SDO interface] 特定のServiceProfileの取得 01917 # 01918 # 引数 "id" で指定された名前のサービスの ServiceProfile を返す。 01919 # 01920 # @param self 01921 # @param _id SDO Service の ServiceProfile に関連付けられた識別子。 01922 # 01923 # @return 指定された SDO Service の ServiceProfile。 01924 # 01925 # @exception InvalidParameter "id" で指定した ServiceProfile が存在しない。 01926 # "id" が null。 01927 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01928 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01929 # @exception NotAvailable SDOは存在するが応答がない。 01930 # @exception InternalError 内部的エラーが発生した。 01931 # 01932 # @else 01933 # 01934 # @brief [SDO interface] Getting Organizations 01935 # 01936 # This operation returns the ServiceProfile that is specified by the 01937 # argument "id." 01938 # 01939 # @param _id The identifier referring to one of the ServiceProfiles. 01940 # 01941 # @return The profile of the specified service. 01942 # 01943 # @exception InvalidParameter if the ServiceProfile that is specified by 01944 # the argument 'id' does not exist or if 'id' 01945 # is 'null.' 01946 # @exception SDONotExists if the target SDO does not exist.(This exception 01947 # is mapped to CORBA standard system exception 01948 # OBJECT_NOT_EXIST.) 01949 # @exception NotAvailable If the target SDO is reachable but cannot 01950 # respond. 01951 # @exception InternalError If the target SDO cannot execute the operation 01952 # completely due to some internal error. 01953 # 01954 # @endif 01955 # virtual SDOPackage::ServiceProfile* get_service_profile(const char* id) 01956 def get_service_profile(self, _id): 01957 self._rtcout.RTC_TRACE("get_service_profile(%s)", _id) 01958 self._sdoSvcProfiles = self._SdoConfigImpl.getServiceProfiles() 01959 if not _id: 01960 raise SDOPackage.InvalidParameter("get_service_profile(): Empty name.") 01961 01962 try: 01963 index = OpenRTM_aist.CORBA_SeqUtil.find(self._sdoSvcProfiles, self.svc_name(_id)) 01964 01965 if index < 0: 01966 raise SDOPackage.InvalidParameter("get_service_profile(): Not found") 01967 01968 return self._sdoSvcProfiles[index] 01969 except: 01970 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 01971 raise SDOPackage.InternalError("get_service_profile()") 01972 01973 return SDOPackage.ServiceProfile("", "", [], None) 01974 01975 01976 ## 01977 # @if jp 01978 # 01979 # @brief [SDO interface] 指定された SDO Service の取得 01980 # 01981 # このオペレーションは引数 "id" で指定された名前によって区別される 01982 # SDO の Service へのオブジェクト参照を返す。 SDO により提供される 01983 # Service はそれぞれ一意の識別子により区別される。 01984 # 01985 # @param self 01986 # @param _id SDO Service に関連付けられた識別子。 01987 # 01988 # @return 要求された SDO Service への参照。 01989 # 01990 # 01991 # @exception InvalidParameter "id" で指定した ServiceProfile が存在しない。 01992 # "id" が null。 01993 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 01994 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 01995 # @exception NotAvailable SDOは存在するが応答がない。 01996 # @exception InternalError 内部的エラーが発生した。 01997 # 01998 # @else 01999 # 02000 # @brief [SDO interface] Getting specified SDO Service's reference 02001 # 02002 # This operation returns an object implementing an SDO's service that 02003 # is identified by the identifier specified as an argument. Different 02004 # services provided by an SDO are distinguished with different 02005 # identifiers. See OMG SDO specification Section 2.2.8, "ServiceProfile," 02006 # on page 2-12 for more details. 02007 # 02008 # @param _id The identifier referring to one of the SDO Service 02009 # @return The object implementing the requested service. 02010 # @exception InvalidParameter if argument “id” is null, or if the 02011 # ServiceProfile that is specified by argument 02012 # “id” does not exist. 02013 # @exception SDONotExists if the target SDO does not exist.(This exception 02014 # is mapped to CORBA standard system exception 02015 # OBJECT_NOT_EXIST.) 02016 # @exception NotAvailable If the target SDO is reachable but cannot 02017 # respond. 02018 # @exception InternalError If the target SDO cannot execute the operation 02019 # completely due to some internal error. 02020 # 02021 # @endif 02022 # virtual SDOPackage::SDOService_ptr get_sdo_service(const char* id) 02023 def get_sdo_service(self, _id): 02024 self._rtcout.RTC_TRACE("get_sdo_service(%s)", _id) 02025 self._sdoSvcProfiles = self._SdoConfigImpl.getServiceProfiles() 02026 02027 if not _id: 02028 raise SDOPackage.InvalidParameter("get_service(): Empty name.") 02029 02030 index = OpenRTM_aist.CORBA_SeqUtil.find(self._sdoSvcProfiles, self.svc_name(_id)) 02031 02032 if index < 0: 02033 raise SDOPackage.InvalidParameter("get_service(): Not found") 02034 02035 try: 02036 return self._sdoSvcProfiles[index].service 02037 except: 02038 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02039 raise SDOPackage.InternalError("get_service()") 02040 return SDOPackage.SDOService._nil 02041 02042 02043 ## 02044 # @if jp 02045 # 02046 # @brief [SDO interface] Configuration オブジェクトの取得 02047 # 02048 # このオペレーションは Configuration interface への参照を返す。 02049 # Configuration interface は各 SDO を管理するためのインターフェースの 02050 # ひとつである。このインターフェースは DeviceProfile, ServiceProfile, 02051 # Organization で定義された SDO の属性値を設定するために使用される。 02052 # Configuration インターフェースの詳細については、OMG SDO specification 02053 # の 2.3.5節, p.2-24 を参照のこと。 02054 # 02055 # @param self 02056 # 02057 # @return SDO の Configuration インターフェースへの参照 02058 # 02059 # @exception InterfaceNotImplemented SDOはConfigurationインターフェースを 02060 # 持たない。 02061 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 02062 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 02063 # @exception NotAvailable SDOは存在するが応答がない。 02064 # @exception InternalError 内部的エラーが発生した。 02065 # 02066 # @else 02067 # 02068 # @brief [SDO interface] Getting Configuration object 02069 # 02070 # This operation returns an object implementing the Configuration 02071 # interface. The Configuration interface is one of the interfaces that 02072 # each SDO maintains. The interface is used to configure the attributes 02073 # defined in DeviceProfile, ServiceProfile, and Organization. 02074 # See OMG SDO specification Section 2.3.5, "Configuration Interface," 02075 # on page 2-24 for more details about the Configuration interface. 02076 # 02077 # @return The Configuration interface of an SDO. 02078 # 02079 # @exception InterfaceNotImplemented The target SDO has no Configuration 02080 # interface. 02081 # @exception SDONotExists if the target SDO does not exist.(This exception 02082 # is mapped to CORBA standard system exception 02083 # OBJECT_NOT_EXIST.) 02084 # @exception NotAvailable The target SDO is reachable but cannot respond. 02085 # @exception InternalError The target SDO cannot execute the operation 02086 # completely due to some internal error. 02087 # @endif 02088 # virtual SDOPackage::Configuration_ptr get_configuration() 02089 def get_configuration(self): 02090 self._rtcout.RTC_TRACE("get_configuration()") 02091 if self._SdoConfig is None: 02092 raise SODPackage.InterfaceNotImplemented("InterfaceNotImplemented: get_configuration") 02093 try: 02094 return self._SdoConfig 02095 except: 02096 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02097 raise SDOPackage.InternalError("get_configuration()") 02098 return SDOPackage.Configuration._nil 02099 02100 02101 ## 02102 # @if jp 02103 # 02104 # @brief [SDO interface] Monitoring オブジェクトの取得 02105 # 02106 # このオペレーションは Monitoring interface への参照を返す。 02107 # Monitoring interface は SDO が管理するインターフェースの一つである。 02108 # このインターフェースは SDO のプロパティをモニタリングするために 02109 # 使用される。 02110 # Monitoring interface の詳細については OMG SDO specification の 02111 # 2.3.7節 "Monitoring Interface" p.2-35 を参照のこと。 02112 # 02113 # @param self 02114 # 02115 # @return SDO の Monitoring interface への参照 02116 # 02117 # @exception InterfaceNotImplemented SDOはConfigurationインターフェースを 02118 # 持たない。 02119 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 02120 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 02121 # @exception NotAvailable SDOは存在するが応答がない。 02122 # @exception InternalError 内部的エラーが発生した。 02123 # 02124 # @else 02125 # 02126 # @brief [SDO interface] Get Monitoring object 02127 # 02128 # This operation returns an object implementing the Monitoring interface. 02129 # The Monitoring interface is one of the interfaces that each SDO 02130 # maintains. The interface is used to monitor the properties of an SDO. 02131 # See OMG SDO specification Section 2.3.7, "Monitoring Interface," on 02132 # page 2-35 for more details about the Monitoring interface. 02133 # 02134 # @return The Monitoring interface of an SDO. 02135 # 02136 # @exception InterfaceNotImplemented The target SDO has no Configuration 02137 # interface. 02138 # @exception SDONotExists if the target SDO does not exist.(This exception 02139 # is mapped to CORBA standard system exception 02140 # OBJECT_NOT_EXIST.) 02141 # @exception NotAvailable The target SDO is reachable but cannot respond. 02142 # @exception InternalError The target SDO cannot execute the operation 02143 # completely due to some internal error. 02144 # @endif 02145 # virtual SDOPackage::Monitoring_ptr get_monitoring() 02146 def get_monitoring(self): 02147 self._rtcout.RTC_TRACE("get_monitoring()") 02148 raise SDOPackage.InterfaceNotImplemented("Exception: get_monitoring") 02149 return SDOPackage.Monitoring._nil 02150 02151 02152 ## 02153 # @if jp 02154 # 02155 # @brief [SDO interface] Organization リストの取得 02156 # 02157 # SDO は0個以上の Organization (組織)に所属することができる。 もし SDO が 02158 # 1個以上の Organization に所属している場合、このオペレーションは所属する 02159 # Organization のリストを返す。SDO が どの Organization にも所属していない 02160 # 場合には、空のリストが返される。 02161 # 02162 # @param self 02163 # 02164 # @return SDO が所属する Organization のリスト。 02165 # 02166 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 02167 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 02168 # @exception NotAvailable SDOは存在するが応答がない。 02169 # @exception InternalError 内部的エラーが発生した。 02170 # @else 02171 # 02172 # @brief [SDO interface] Getting Organizations 02173 # 02174 # An SDO belongs to zero or more organizations. If the SDO belongs to one 02175 # or more organizations, this operation returns the list of organizations 02176 # that the SDO belongs to. An empty list is returned if the SDO does not 02177 # belong to any Organizations. 02178 # 02179 # @return The list of Organizations that the SDO belong to. 02180 # 02181 # @exception SDONotExists if the target SDO does not exist.(This exception 02182 # is mapped to CORBA standard system exception 02183 # OBJECT_NOT_EXIST.) 02184 # @exception NotAvailable The target SDO is reachable but cannot respond. 02185 # @exception InternalError The target SDO cannot execute the operation 02186 # completely due to some internal error. 02187 # @endif 02188 # virtual SDOPackage::OrganizationList* get_organizations() 02189 def get_organizations(self): 02190 self._rtcout.RTC_TRACE("get_organizations()") 02191 self._sdoOrganizations = self._SdoConfigImpl.getOrganizations() 02192 try: 02193 return self._sdoOrganizations 02194 except: 02195 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02196 raise SDOPackage.InternalError("get_organizations()") 02197 return [] 02198 02199 02200 ## 02201 # @if jp 02202 # 02203 # @brief [SDO interface] SDO Status リストの取得 02204 # 02205 # このオペレーションは SDO のステータスを表す NVList を返す。 02206 # 02207 # @param self 02208 # 02209 # @return SDO のステータス。 02210 # 02211 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 02212 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 02213 # @exception NotAvailable SDOは存在するが応答がない。 02214 # @exception InternalError 内部的エラーが発生した。 02215 # 02216 # @else 02217 # 02218 # @brief [SDO interface] Get SDO Status 02219 # 02220 # This operation returns an NVlist describing the status of an SDO. 02221 # 02222 # @return The actual status of an SDO. 02223 # 02224 # @exception SDONotExists if the target SDO does not exist.(This exception 02225 # is mapped to CORBA standard system exception 02226 # OBJECT_NOT_EXIST.) 02227 # @exception NotAvailable The target SDO is reachable but cannot respond. 02228 # @exception InternalError The target SDO cannot execute the operation 02229 # completely due to some internal error. 02230 # 02231 # @endif 02232 # virtual SDOPackage::NVList* get_status_list() 02233 def get_status_list(self): 02234 self._rtcout.RTC_TRACE("get_status_list()") 02235 try: 02236 return self._sdoStatus 02237 except: 02238 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02239 raise SDOPackage.InternalError("get_status_list()") 02240 return [] 02241 02242 02243 ## 02244 # @if jp 02245 # 02246 # @brief [SDO interface] SDO Status の取得 02247 # 02248 # This operation returns the value of the specified status parameter. 02249 # 02250 # @param self 02251 # @param name SDO のステータスを定義するパラメータ。 02252 # 02253 # @return 指定されたパラメータのステータス値。 02254 # 02255 # @exception SDONotExists ターゲットのSDOが存在しない。(本例外は、CORBA標準 02256 # システム例外のOBJECT_NOT_EXISTにマッピングされる) 02257 # @exception NotAvailable SDOは存在するが応答がない。 02258 # @exception InvalidParameter 引数 "name" が null あるいは存在しない。 02259 # @exception InternalError 内部的エラーが発生した。 02260 # @else 02261 # 02262 # @brief [SDO interface] Get SDO Status 02263 # 02264 # @param name One of the parameters defining the "status" of an SDO. 02265 # 02266 # @return The value of the specified status parameter. 02267 # 02268 # @exception SDONotExists if the target SDO does not exist.(This exception 02269 # is mapped to CORBA standard system exception 02270 # OBJECT_NOT_EXIST.) 02271 # @exception NotAvailable The target SDO is reachable but cannot respond. 02272 # @exception InvalidParameter The parameter defined by "name" is null or 02273 # does not exist. 02274 # @exception InternalError The target SDO cannot execute the operation 02275 # completely due to some internal error. 02276 # 02277 # 02278 # @endif 02279 # virtual CORBA::Any* get_status(const char* name) 02280 def get_status(self, name): 02281 self._rtcout.RTC_TRACE("get_status(%s)", name) 02282 index = OpenRTM_aist.CORBA_SeqUtil.find(self._sdoStatus, self.nv_name(name)) 02283 if index < 0: 02284 raise SDOPackage.InvalidParameter("get_status(): Not found") 02285 02286 try: 02287 return any.to_any(self._sdoStatus[index].value) 02288 except: 02289 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02290 raise SDOPackage.InternalError("get_status()") 02291 return any.to_any("") 02292 02293 02294 #============================================================ 02295 # Local interfaces 02296 #============================================================ 02297 02298 ## 02299 # @if jp 02300 # 02301 # @brief [local interface] インスタンス名の取得 02302 # 02303 # ComponentProfile に設定されたインスタンス名を返す。 02304 # 02305 # @param self 02306 # 02307 # @return インスタンス名 02308 # 02309 # @else 02310 # 02311 # @endif 02312 # const char* getInstanceName() 02313 def getInstanceName(self): 02314 self._rtcout.RTC_TRACE("getInstanceName()") 02315 return self._profile.instance_name 02316 02317 02318 ## 02319 # @if jp 02320 # 02321 # @brief [local interface] インスタンス名の設定 02322 # 02323 # ComponentProfile に指定されたインスタンス名を設定する。 02324 # 02325 # @param self 02326 # 02327 # @param instance_name インスタンス名 02328 # 02329 # @else 02330 # 02331 # @endif 02332 # void setInstanceName(const char* instance_name); 02333 def setInstanceName(self, instance_name): 02334 self._rtcout.RTC_TRACE("setInstanceName(%s)", instance_name) 02335 self._properties.setProperty("instance_name",instance_name) 02336 self._profile.instance_name = self._properties.getProperty("instance_name") 02337 02338 02339 ## 02340 # @if jp 02341 # 02342 # @brief [local interface] 型名の取得 02343 # 02344 # ComponentProfile に設定された型名を返す。 02345 # 02346 # @param self 02347 # 02348 # @return 型名 02349 # 02350 # @else 02351 # 02352 # @endif 02353 # const char* getTypeName() 02354 def getTypeName(self): 02355 self._rtcout.RTC_TRACE("getTypeName()") 02356 return self._profile.type_name 02357 02358 02359 ## 02360 # @if jp 02361 # 02362 # @brief [local interface] Description の取得 02363 # 02364 # ComponentProfile に設定された Description を返す。 02365 # 02366 # @param self 02367 # 02368 # @return Description 02369 # 02370 # @else 02371 # 02372 # @endif 02373 # const char* getDescription() 02374 def getDescription(self): 02375 self._rtcout.RTC_TRACE("getDescription()") 02376 return self._profile.description 02377 02378 02379 ## 02380 # @if jp 02381 # 02382 # @brief [local interface] バージョン情報の取得 02383 # 02384 # ComponentProfile に設定されたバージョン情報を返す。 02385 # 02386 # @param self 02387 # 02388 # @return バージョン情報 02389 # 02390 # @else 02391 # 02392 # @endif 02393 # const char* getVersion() 02394 def getVersion(self): 02395 self._rtcout.RTC_TRACE("getVersion()") 02396 return self._profile.version 02397 02398 02399 ## 02400 # @if jp 02401 # 02402 # @brief [local interface] ベンダー情報の取得 02403 # 02404 # ComponentProfile に設定されたベンダー情報を返す。 02405 # 02406 # @param self 02407 # 02408 # @return ベンダー情報 02409 # 02410 # @else 02411 # 02412 # @endif 02413 # const char* getVendor() 02414 def getVendor(self): 02415 self._rtcout.RTC_TRACE("getVendor()") 02416 return self._profile.vendor 02417 02418 02419 ## 02420 # @if jp 02421 # 02422 # @brief [local interface] カテゴリ情報の取得 02423 # 02424 # ComponentProfile に設定されたカテゴリ情報を返す。 02425 # 02426 # @param self 02427 # 02428 # @return カテゴリ情報 02429 # 02430 # @else 02431 # 02432 # @endif 02433 # const char* getCategory() 02434 def getCategory(self): 02435 self._rtcout.RTC_TRACE("getCategory()") 02436 return self._profile.category 02437 02438 02439 ## 02440 # @if jp 02441 # 02442 # @brief [local interface] Naming Server 情報の取得 02443 # 02444 # 設定された Naming Server 情報を返す。 02445 # 02446 # @param self 02447 # 02448 # @return Naming Server リスト 02449 # 02450 # @else 02451 # 02452 # @endif 02453 # std::vector<std::string> getNamingNames(); 02454 def getNamingNames(self): 02455 self._rtcout.RTC_TRACE("getNamingNames()") 02456 return [s.strip() for s in self._properties.getProperty("naming.names").split(",")] 02457 02458 02459 ## 02460 # @if jp 02461 # 02462 # @brief [local interface] オブジェクトリファレンスの設定 02463 # 02464 # RTC の CORBA オブジェクトリファレンスを設定する。 02465 # 02466 # @param self 02467 # @param rtobj オブジェクトリファレンス 02468 # 02469 # @else 02470 # 02471 # @endif 02472 # void setObjRef(const RTObject_ptr rtobj); 02473 def setObjRef(self, rtobj): 02474 self._rtcout.RTC_TRACE("setObjRef()") 02475 self._objref = rtobj 02476 return 02477 02478 02479 ## 02480 # @if jp 02481 # 02482 # @brief [local interface] オブジェクトリファレンスの取得 02483 # 02484 # 設定された CORBA オブジェクトリファレンスを取得する。 02485 # 02486 # @param self 02487 # 02488 # @return オブジェクトリファレンス 02489 # 02490 # @else 02491 # 02492 # @endif 02493 # RTObject_ptr getObjRef() const; 02494 def getObjRef(self): 02495 self._rtcout.RTC_TRACE("getObjRef()") 02496 return self._objref 02497 02498 02499 ## 02500 # @if jp 02501 # 02502 # @brief [local interface] RTC のプロパティを設定する 02503 # 02504 # RTC が保持すべきプロパティを設定する。与えられるプロパティは、 02505 # ComponentProfile 等に設定されるべき情報を持たなければならない。 02506 # このオペレーションは通常 RTC が初期化される際に Manager から 02507 # 呼ばれることを意図している。 02508 # 02509 # @param self 02510 # @param prop RTC のプロパティ 02511 # 02512 # @else 02513 # 02514 # @brief [local interface] Set RTC property 02515 # 02516 # This operation sets the properties to the RTC. The given property 02517 # values should include information for ComponentProfile. 02518 # Generally, this operation is designed to be called from Manager, when 02519 # RTC is initialized 02520 # 02521 # @param prop Property for RTC. 02522 # 02523 # @endif 02524 # void setProperties(const coil::Properties& prop); 02525 def setProperties(self, prop): 02526 self._rtcout.RTC_TRACE("setProperties()") 02527 self._properties.mergeProperties(prop) 02528 self._profile.instance_name = self._properties.getProperty("instance_name") 02529 self._profile.type_name = self._properties.getProperty("type_name") 02530 self._profile.description = self._properties.getProperty("description") 02531 self._profile.version = self._properties.getProperty("version") 02532 self._profile.vendor = self._properties.getProperty("vendor") 02533 self._profile.category = self._properties.getProperty("category") 02534 02535 02536 ## 02537 # @if jp 02538 # 02539 # @brief [local interface] RTC のプロパティを取得する 02540 # 02541 # RTC が保持しているプロパティを返す。 02542 # RTCがプロパティを持たない場合は空のプロパティが返される。 02543 # 02544 # @param self 02545 # 02546 # @return RTC のプロパティ 02547 # 02548 # @else 02549 # 02550 # @brief [local interface] Get RTC property 02551 # 02552 # This operation returns the properties of the RTC. 02553 # Empty property would be returned, if RTC has no property. 02554 # 02555 # @return Property for RTC. 02556 # 02557 # @endif 02558 # coil::Properties& getProperties(); 02559 def getProperties(self): 02560 self._rtcout.RTC_TRACE("getProperties()") 02561 return self._properties 02562 02563 02564 ## 02565 # @if jp 02566 # 02567 # @brief コンフィギュレーションパラメータの設定 02568 # 02569 # コンフィギュレーションパラメータと変数をバインドする 02570 # <VarType>としてコンフィギュレーションパラメータのデータ型を指定する。 02571 # 02572 # @param self 02573 # @param param_name コンフィギュレーションパラメータ名 02574 # @param var コンフィギュレーションパラメータ格納用変数 02575 # @param def_val コンフィギュレーションパラメータデフォルト値 02576 # @param trans 文字列変換用関数(デフォルト値:None) 02577 # 02578 # @return 設定結果(設定成功:true，設定失敗:false) 02579 # 02580 # @else 02581 # 02582 # @endif 02583 # template <typename VarType> 02584 # bool bindParameter(const char* param_name, VarType& var, 02585 # const char* def_val, 02586 # bool (*trans)(VarType&, const char*) = coil::stringTo) 02587 def bindParameter(self, param_name, var, 02588 def_val, trans=None): 02589 self._rtcout.RTC_TRACE("bindParameter()") 02590 if trans is None: 02591 trans_ = OpenRTM_aist.stringTo 02592 else: 02593 trans_ = trans 02594 self._configsets.bindParameter(param_name, var, def_val, trans_) 02595 return True 02596 02597 02598 ## 02599 # @if jp 02600 # 02601 # @brief コンフィギュレーションパラメータの更新(ID指定) 02602 # 02603 # 指定したIDのコンフィギュレーションセットに設定した値で、 02604 # コンフィギュレーションパラメータの値を更新する 02605 # 02606 # @param self 02607 # @param config_set 設定対象のコンフィギュレーションセットID 02608 # 02609 # @else 02610 # 02611 # @endif 02612 # void updateParameters(const char* config_set); 02613 def updateParameters(self, config_set): 02614 self._rtcout.RTC_TRACE("updateParameters(%s)", config_set) 02615 self._configsets.update(config_set) 02616 return 02617 02618 02619 ## 02620 # @if jp 02621 # 02622 # @brief [local interface] Port を登録する 02623 # 02624 # RTC が保持するPortを登録する。 02625 # Port を外部からアクセス可能にするためには、このオペレーションにより 02626 # 登録されていなければならない。登録される Port はこの RTC 内部において 02627 # PortProfile.name により区別される。したがって、Port は RTC 内において、 02628 # ユニークな PortProfile.name を持たなければならない。 02629 # 登録された Port は内部で適切にアクティブ化された後、その参照と 02630 # オブジェクト参照がリスト内に保存される。 02631 # 02632 # @param self 02633 # @param port RTC に登録する Port 02634 # @param port_type if port is PortBase, port_type is None, 02635 # if port is PortService, port_type is True 02636 # 02637 # @else 02638 # 02639 # @brief [local interface] Register Port 02640 # 02641 # This operation registers a Port to be held by this RTC. 02642 # In order to enable access to the Port from outside of RTC, the Port 02643 # must be registered by this operation. The Port that is registered by 02644 # this operation would be identified by PortProfile.name in the inside of 02645 # RTC. Therefore, the Port should have unique PortProfile.name in the RTC. 02646 # The registering Port would be activated properly, and the reference 02647 # and the object reference would be stored in lists in RTC. 02648 # 02649 # @param port Port which is registered in the RTC 02650 # 02651 # @endif 02652 # void registerPort(PortBase& port); 02653 def registerPort(self, port): 02654 self._rtcout.RTC_TRACE("registerPort()") 02655 if not self.addPort(port): 02656 self._rtcout.RTC_ERROR("addPort(PortBase&) failed.") 02657 return 02658 02659 # void registerPort(PortService_ptr port); 02660 # def registerPortByReference(self, port_ref): 02661 # self._rtcout.RTC_TRACE("registerPortByReference()") 02662 # self.addPortByReference(port_ref) 02663 # return 02664 02665 # new interface. since 1.0.0-RELEASE 02666 # void addPort(PortBase& port); 02667 def addPort(self, port): 02668 self._rtcout.RTC_TRACE("addPort()") 02669 if isinstance(port, OpenRTM_aist.CorbaPort): 02670 self._rtcout.RTC_TRACE("addPort(CorbaPort)") 02671 propkey = "port.corbaport." 02672 prop = self._properties.getNode(propkey) 02673 if prop: 02674 self._properties.getNode(propkey).mergeProperties(self._properties.getNode("port.corba")) 02675 port.init(self._properties.getNode(propkey)) 02676 port.setOwner(self.getObjRef()) 02677 02678 elif isinstance(port, OpenRTM_aist.PortBase): 02679 self._rtcout.RTC_TRACE("addPort(PortBase)") 02680 port.setOwner(self.getObjRef()) 02681 port.setPortConnectListenerHolder(self._portconnListeners) 02682 self.onAddPort(port.getPortProfile()) 02683 02684 elif isinstance(port, RTC._objref_PortService): 02685 self._rtcout.RTC_TRACE("addPort(PortService)") 02686 return self._portAdmin.addPort(port) 02687 02688 02689 # new interface. since 1.0.0-RELEASE 02690 # void addPort(PortService_ptr port); 02691 # def addPortByReference(self, port_ref): 02692 # self._rtcout.RTC_TRACE("addPortByReference()") 02693 # self._portAdmin.registerPortByReference(port_ref) 02694 # return 02695 02696 02697 ## 02698 # @if jp 02699 # 02700 # @brief [local interface] DataInPort を登録する 02701 # 02702 # RTC が保持する DataInPort を登録する。 02703 # Port のプロパティにデータポートであること("port.dataport")、 02704 # TCPを使用すること("tcp_any")を設定するとともに、 DataInPort の 02705 # インスタンスを生成し、登録する。 02706 # 02707 # @param self 02708 # @param name port 名称 02709 # @param inport 登録対象 DataInPort 02710 # 02711 # @else 02712 # 02713 # @endif 02714 def registerInPort(self, name, inport): 02715 self._rtcout.RTC_TRACE("registerInPort(%s)", name) 02716 if not self.addInPort(name, inport): 02717 self._rtcout.RTC_ERROR("addInPort(%s) failed.", name) 02718 return 02719 02720 # new interface. since 1.0.0-RELEASE 02721 def addInPort(self, name, inport): 02722 self._rtcout.RTC_TRACE("addInPort(%s)", name) 02723 02724 propkey = "port.inport." + name 02725 prop_ = copy.copy(self._properties.getNode(propkey)) 02726 prop_.mergeProperties(self._properties.getNode("port.inport.dataport")) 02727 02728 ret = self.addPort(inport) 02729 02730 if not ret: 02731 self._rtcout.RTC_ERROR("addInPort() failed.") 02732 return ret 02733 02734 inport.init(self._properties.getNode(propkey)) 02735 self._inports.append(inport) 02736 return ret 02737 02738 02739 ## 02740 # @if jp 02741 # 02742 # @brief [local interface] DataOutPort を登録する 02743 # 02744 # RTC が保持する DataOutPor tを登録する。 02745 # Port のプロパティにデータポートであること("port.dataport")、 02746 # TCPを使用すること("tcp_any")を設定するとともに、 DataOutPort の 02747 # インスタンスを生成し、登録する。 02748 # 02749 # @param self 02750 # @param name port 名称 02751 # @param outport 登録対象 DataInPort 02752 # 02753 # @else 02754 # 02755 # @endif 02756 # void registerOutPort(const char* name, OutPortBase& outport); 02757 def registerOutPort(self, name, outport): 02758 self._rtcout.RTC_TRACE("registerOutPort(%s)", name) 02759 if not self.addOutPort(name, outport): 02760 self._rtcout.RTC_ERROR("addOutPort(%s) failed.", name) 02761 return 02762 02763 # new interface. since 1.0.0-RELEASE 02764 # void addOutPort(const char* name, OutPortBase& outport); 02765 def addOutPort(self, name, outport): 02766 self._rtcout.RTC_TRACE("addOutPort(%s)", name) 02767 02768 propkey = "port.outport." + name 02769 prop_ = copy.copy(self._properties.getNode(propkey)) 02770 prop_.mergeProperties(self._properties.getNode("port.outport.dataport")) 02771 02772 ret = self.addPort(outport) 02773 02774 if not ret: 02775 self._rtcout.RTC_ERROR("addOutPort() failed.") 02776 return ret 02777 02778 outport.init(self._properties.getNode(propkey)) 02779 self._outports.append(outport) 02780 return ret 02781 02782 02783 ## 02784 # @if jp 02785 # 02786 # @brief [local interface] InPort の登録を削除する 02787 # 02788 # RTC が保持するInPortの登録を削除する。 02789 # 02790 # @param port 削除対象 Port 02791 # @return 削除結果(削除成功:true，削除失敗:false) 02792 # 02793 # @else 02794 # 02795 # @brief [local interface] Unregister InPort 02796 # 02797 # This operation unregisters a InPort held by this RTC. 02798 # 02799 # @param port Port which is unregistered 02800 # @return Unregister result (Successful:true, Failed:false) 02801 # 02802 # @endif 02803 # 02804 # bool removeInPort(InPortBase& port); 02805 def removeInPort(self, port): 02806 self._rtcout.RTC_TRACE("removeInPort()") 02807 ret = self.removePort(inport) 02808 02809 if ret: 02810 for inport in self._inports: 02811 if port == inport: 02812 try: 02813 self._inports.remove(port) 02814 except: 02815 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02816 02817 return True 02818 02819 return False 02820 02821 02822 ## 02823 # @if jp 02824 # 02825 # @brief [local interface] OutPort の登録を削除する 02826 # 02827 # RTC が保持するOutPortの登録を削除する。 02828 # 02829 # @param port 削除対象 Port 02830 # @return 削除結果(削除成功:true，削除失敗:false) 02831 # 02832 # @else 02833 # 02834 # @brief [local interface] Unregister OutPort 02835 # 02836 # This operation unregisters a OutPort held by this RTC. 02837 # 02838 # @param port Port which is unregistered 02839 # @return Unregister result (Successful:true, Failed:false) 02840 # 02841 # @endif 02842 # 02843 # bool removeOutPort(OutPortBase& port); 02844 def removeOutPort(self, port): 02845 self._rtcout.RTC_TRACE("removeOutPort()") 02846 ret = self.removePort(outport) 02847 02848 if ret: 02849 for outport in self._outports: 02850 if port == outport: 02851 try: 02852 self._outports.remove(port) 02853 except: 02854 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 02855 02856 return True 02857 02858 return False 02859 02860 02861 ## 02862 # @if jp 02863 # 02864 # @brief [local interface] Port の登録を削除する 02865 # 02866 # RTC が保持するPortの登録を削除する。 02867 # 02868 # @param self 02869 # @param port 削除対象 Port 02870 # 02871 # @else 02872 # 02873 # @brief [local interface] Unregister Port 02874 # 02875 # This operation unregisters a Port to be held by this RTC. 02876 # 02877 # @param port Port which is unregistered in the RTC 02878 # 02879 # @endif 02880 # void RTObject_impl::deletePort(PortBase& port) 02881 def deletePort(self, port): 02882 self._rtcout.RTC_TRACE("deletePort()") 02883 if not self.removePort(port): 02884 self._rtcout.RTC_ERROR("removePort() failed.") 02885 return 02886 02887 # new interface. since 1.0.0-RELEASE 02888 def removePort(self, port): 02889 self._rtcout.RTC_TRACE("removePort()") 02890 if isinstance(port, OpenRTM_aist.PortBase) or isinstance(port, OpenRTM_aist.CorbaPort): 02891 self.onRemovePort(port.getPortProfile()) 02892 return self._portAdmin.removePort(port) 02893 02894 02895 ## 02896 # @if jp 02897 # 02898 # @brief [local interface] 名前指定により Port の登録を削除する 02899 # 02900 # 名称を指定して RTC が保持するPortの登録を削除する。 02901 # 02902 # @param self 02903 # @param port_name 削除対象 Port 名 02904 # 02905 # @else 02906 # 02907 # @endif 02908 def deletePortByName(self, port_name): 02909 self._rtcout.RTC_TRACE("deletePortByName(%s)", port_name) 02910 self._portAdmin.deletePortByName(port_name) 02911 return 02912 02913 02914 ## 02915 # @if jp 02916 # 02917 # @brief [local interface] 実行コンテキストを取得する 02918 # 02919 # get_context() と同じ機能のローカル版。違いはない。 02920 # この関数は以下の関数内で呼ばれることを前提としている。 02921 # 02922 # - onStartup() 02923 # - onShutdown() 02924 # - onActivated() 02925 # - onDeactivated() 02926 # - onExecute() 02927 # - onAborting() 02928 # - onError() 02929 # - onReset() 02930 # - onStateUpdate() 02931 # - onRateChanged() 02932 # 02933 # この関数の引数はこれらの関数の引数 UniquieID exec_handle でなけ 02934 # ればならない。 02935 # 02936 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 02937 # 02938 # @else 02939 # 02940 # @brief [local interface] Getting current execution context 02941 # 02942 # This function is the local version of get_context(). completely 02943 # same as get_context() function. This function is assumed to be 02944 # called from the following functions. 02945 # 02946 # - onStartup() 02947 # - onShutdown() 02948 # - onActivated() 02949 # - onDeactivated() 02950 # - onExecute() 02951 # - onAborting() 02952 # - onError() 02953 # - onReset() 02954 # - onStateUpdate() 02955 # - onRateChanged() 02956 # 02957 # The argument of this function should be the first argument 02958 # (UniqueId ec_id) of the above functions. 02959 # 02960 # @param ec_id The above functions' first argument "exec_handle." 02961 # 02962 # @endif 02963 # 02964 # ExecutionContext_ptr getExecutionContext(RTC::UniqueId ec_id); 02965 def getExecutionContext(self, ec_id): 02966 return self.get_context(ec_id) 02967 02968 ## 02969 # @if jp 02970 # 02971 # @brief [local interface] 実行コンテキストの実行レートを取得する 02972 # 02973 # 現在実行中の実行コンテキストの実行レートを取得する。実行コンテキ 02974 # ストのKindがPERIODIC以外の場合の動作は未定義である。この関数は以 02975 # 下の関数内で呼ばれることを前提としている。 02976 # 02977 # - onStartup() 02978 # - onShutdown() 02979 # - onActivated() 02980 # - onDeactivated() 02981 # - onExecute() 02982 # - onAborting() 02983 # - onError() 02984 # - onReset() 02985 # - onStateUpdate() 02986 # - onRateChanged() 02987 # 02988 # この関数の引数はこれらの関数の引数 UniquieID exec_handle でなけ 02989 # ればならない。 02990 # 02991 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 02992 # 02993 # @else 02994 # 02995 # @brief [local interface] Getting current context' execution rate 02996 # 02997 # This function returns current execution rate in this 02998 # context. If this context's kind is not PERIODC, behavior is not 02999 # defined. This function is assumed to be called from the 03000 # following functions. 03001 # 03002 # - onStartup() 03003 # - onShutdown() 03004 # - onActivated() 03005 # - onDeactivated() 03006 # - onExecute() 03007 # - onAborting() 03008 # - onError() 03009 # - onReset() 03010 # - onStateUpdate() 03011 # - onRateChanged() 03012 # 03013 # The argument of this function should be the first argument 03014 # (UniqueId ec_id) of the above functions. 03015 # 03016 # @param ec_id The above functions' first argument "exec_handle." 03017 # 03018 # @endif 03019 # 03020 # double getExecutionRate(RTC::UniqueId ec_id); 03021 def getExecutionRate(self, ec_id): 03022 ec = self.getExecutionContext(ec_id) 03023 if CORBA.is_nil(ec): 03024 return 0.0 03025 03026 return ec.get_rate() 03027 03028 03029 ## 03030 # @if jp 03031 # 03032 # @brief [local interface] 実行コンテキストの実行レートを設定する 03033 # 03034 # 現在実行中の実行コンテキストの実行レートを設定する。実行コンテキ 03035 # ストのKindがPERIODIC以外の場合の動作は未定義である。この関数は以 03036 # 下の関数内で呼ばれることを前提としている。 03037 # 03038 # - onStartup() 03039 # - onShutdown() 03040 # - onActivated() 03041 # - onDeactivated() 03042 # - onExecute() 03043 # - onAborting() 03044 # - onError() 03045 # - onReset() 03046 # - onStateUpdate() 03047 # - onRateChanged() 03048 # 03049 # この関数の引数はこれらの関数の引数 UniquieID exec_handle でなけ 03050 # ればならない。 03051 # 03052 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 03053 # @param rate 実行レートを [Hz] で与える 03054 # 03055 # @else 03056 # 03057 # @brief [local interface] Setting current context' execution rate 03058 # 03059 # This function sets a execution rate in the context. If this 03060 # context's kind is not PERIODC, behavior is not defined. This 03061 # function is assumed to be called from the following functions. 03062 # 03063 # - onStartup() 03064 # - onShutdown() 03065 # - onActivated() 03066 # - onDeactivated() 03067 # - onExecute() 03068 # - onAborting() 03069 # - onError() 03070 # - onReset() 03071 # - onStateUpdate() 03072 # - onRateChanged() 03073 # 03074 # The argument of this function should be the first argument 03075 # (UniqueId ec_id) of the above functions. 03076 # 03077 # @param ec_id The above functions' first argument "exec_handle." 03078 # @param rate Execution rate in [Hz]. 03079 # 03080 # @endif 03081 # 03082 # ReturnCode_t setExecutionRate(RTC::UniqueId ec_id, double rate); 03083 def setExecutionRate(self, ec_id, rate): 03084 ec = self.getExecutionContext(ec_id) 03085 if CORBA.is_nil(ec): 03086 return RTC.RTC_ERROR 03087 ec.set_rate(rate) 03088 return RTC.RTC_OK 03089 03090 03091 ## 03092 # @if jp 03093 # 03094 # @brief [local interface] 実行コンテキストの所有権を調べる 03095 # 03096 # 現在実行中の実行コンテキストの所有権を調べる。この関数は以下の関 03097 # 数内で呼ばれることを前提としている。 03098 # 03099 # - onStartup() 03100 # - onShutdown() 03101 # - onActivated() 03102 # - onDeactivated() 03103 # - onExecute() 03104 # - onAborting() 03105 # - onError() 03106 # - onReset() 03107 # - onStateUpdate() 03108 # - onRateChanged() 03109 # 03110 # この関数の引数はこれらの関数の引数 UniquieID exec_handle でなけ 03111 # ればならない。 03112 # 03113 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 03114 # @return true: 自身の実行コンテキスト、false: 他の実行コンテキスト 03115 # 03116 # @else 03117 # 03118 # @brief [local interface] Checking if the current context is own context 03119 # 03120 # This function checks if the current context is own execution 03121 # context. This function is assumed to be called from the 03122 # following functions. 03123 # 03124 # - onStartup() 03125 # - onShutdown() 03126 # - onActivated() 03127 # - onDeactivated() 03128 # - onExecute() 03129 # - onAborting() 03130 # - onError() 03131 # - onReset() 03132 # - onStateUpdate() 03133 # - onRateChanged() 03134 # 03135 # The argument of this function should be the first argument 03136 # (UniqueId ec_id) of the above functions. 03137 # 03138 # @param ec_id The above functions' first argument "exec_handle." 03139 # @return true: Own context, false: other's context 03140 # 03141 # @endif 03142 # 03143 # bool isOwnExecutionContext(RTC::UniqueId ec_id); 03144 def isOwnExecutionContext(self, ec_id): 03145 global ECOTHER_OFFSET 03146 if ec_id < ECOTHER_OFFSET: 03147 return True 03148 return False 03149 03150 03151 ## 03152 # @if jp 03153 # 03154 # @brief [local interface] 状態を Inactive に遷移させる 03155 # 03156 # 状態を Active から Inactive に遷移させる。この関数は以下の関 03157 # 数内で呼ばれることを前提としている。 03158 # 03159 # - onActivated() 03160 # - onExecute() 03161 # - onStateUpdate() 03162 # 03163 # この関数の引数は上記の関数の引数 UniquieID exec_handle でなけ 03164 # ればならない。 03165 # 03166 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 03167 # @return リターンコード 03168 # 03169 # @else 03170 # 03171 # @brief [local interface] Make transition to Inactive state 03172 # 03173 # This function makes transition from Active to Inactive 03174 # state. This function is assumed to be called from the following 03175 # functions. 03176 # 03177 # - onActivated() 03178 # - onExecute() 03179 # - onStateUpdate() 03180 # 03181 # The argument of this function should be the first argument 03182 # (UniqueId ec_id) of the above function. 03183 # 03184 # @param ec_id The above functions' first argument "exec_handle." 03185 # @return Return code 03186 # 03187 # @endif 03188 # 03189 # ReturnCode_t deactivate(RTC::UniqueId ec_id); 03190 def deactivate(self, ec_id): 03191 ec = self.getExecutionContext(ec_id) 03192 if CORBA.is_nil(ec): 03193 return RTC.RTC_ERROR 03194 return ec.deactivate_component(self.getObjRef()) 03195 03196 03197 ## 03198 # @if jp 03199 # 03200 # @brief [local interface] 状態を Active に遷移させる 03201 # 03202 # 状態を Inactive から Active に遷移させる。この関数は以下の関 03203 # 数内で呼ばれることを前提としている。 03204 # 03205 # - onStartup() 03206 # - onDeactivated() 03207 # 03208 # この関数の引数は上記の関数の引数 UniquieID exec_handle でなけ 03209 # ればならない。 03210 # 03211 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 03212 # @return リターンコード 03213 # 03214 # @else 03215 # 03216 # @brief [local interface] Make transition to Active state 03217 # 03218 # This function makes transition from Inactive to Active 03219 # state. This function is assumed to be called from the following 03220 # functions. 03221 # 03222 # - onStartup() 03223 # - onDeactivated() 03224 # 03225 # The argument of this function should be the first argument 03226 # (UniqueId ec_id) of the above function. 03227 # 03228 # @param ec_id The above functions' first argument "exec_handle." 03229 # @return Return code 03230 # 03231 # @endif 03232 # 03233 # ReturnCode_t activate(RTC::UniqueId ec_id); 03234 def activate(self, ec_id): 03235 ec = self.getExecutionContext(ec_id) 03236 if CORBA.is_nil(ec): 03237 return RTC.RTC_ERROR 03238 return ec.activate_component(self.getObjRef()) 03239 03240 03241 ## 03242 # @if jp 03243 # 03244 # @brief [local interface] 状態をリセットし Inactive に遷移させる 03245 # 03246 # 状態を Error から Inactive に遷移させる。この関数は以下の関 03247 # 数内で呼ばれることを前提としている。 03248 # 03249 # - onError() 03250 # 03251 # この関数の引数は上記の関数の引数 UniquieID exec_handle でなけ 03252 # ればならない。 03253 # 03254 # @param ec_id 上記関数の第1引数 exec_handle を渡す必要がある。 03255 # @return リターンコード 03256 # 03257 # @else 03258 # 03259 # @brief [local interface] Resetting and go to Inactive state 03260 # 03261 # This function reset RTC and makes transition from Error to Inactive 03262 # state. This function is assumed to be called from the following 03263 # functions. 03264 # 03265 # - onError() 03266 # 03267 # The argument of this function should be the first argument 03268 # (UniqueId ec_id) of the above function. 03269 # 03270 # @param ec_id The above functions' first argument "exec_handle." 03271 # @return Return code 03272 # 03273 # @endif 03274 # 03275 # ReturnCode_t reset(RTC::UniqueId ec_id); 03276 def reset(self, ec_id): 03277 ec = self.getExecutionContext(ec_id) 03278 if CORBA.is_nil(ec): 03279 return RTC.RTC_ERROR 03280 return ec.reset_component(self.getObjRef()) 03281 03282 03283 ## 03284 # @if jp 03285 # @brief [local interface] SDO service provider をセットする 03286 # @else 03287 # @brief [local interface] Set a SDO service provider 03288 # @endif 03289 # 03290 # bool addSdoServiceProvider(const SDOPackage::ServiceProfile& prof, 03291 # SdoServiceProviderBase* provider); 03292 def addSdoServiceProvider(self, prof, provider): 03293 return self._sdoservice.addSdoServiceProvider(prof, provider) 03294 03295 03296 ## 03297 # @if jp 03298 # @brief [local interface] SDO service provider を削除する 03299 # @else 03300 # @brief [local interface] Remove a SDO service provider 03301 # @endif 03302 # 03303 # bool removeSdoServiceProvider(const char* id); 03304 def removeSdoServiceProvider(self, id): 03305 return self._sdoservice.removeSdoServiceProvider(id) 03306 03307 03308 ## 03309 # @if jp 03310 # @brief [local interface] SDO service consumer をセットする 03311 # @else 03312 # @brief [local interface] Set a SDO service consumer 03313 # @endif 03314 # 03315 # bool addSdoServiceConsumer(const SDOPackage::ServiceProfile& prof); 03316 def addSdoServiceConsumer(self, prof): 03317 return self._sdoservice.addSdoServiceConsumer(prof) 03318 03319 03320 ## 03321 # @if jp 03322 # @brief [local interface] SDO service consumer を削除する 03323 # @else 03324 # @brief [local interface] Remove a SDO service consumer 03325 # @endif 03326 # 03327 # bool removeSdoServiceConsumer(const char* id); 03328 def removeSdoServiceConsumer(self, id): 03329 return self._sdoservice.removeSdoServiceConsumer(id) 03330 03331 03332 ## 03333 # @if jp 03334 # 03335 # @brief 全 InPort のデータを読み込む。 03336 # 03337 # RTC が保持する全ての InPort のデータを読み込む。 03338 # 03339 # @return 読み込み結果(全ポートの読み込み成功:true，失敗:false) 03340 # 03341 # @else 03342 # 03343 # @brief Readout the value from All InPorts. 03344 # 03345 # This operation read the value from all InPort 03346 # registered in the RTC. 03347 # 03348 # @return result (Successful:true, Failed:false) 03349 # 03350 # @endif 03351 # 03352 # bool readAll(); 03353 def readAll(self): 03354 self._rtcout.RTC_TRACE("readAll()") 03355 ret = True 03356 for inport in self._inports: 03357 if not inport.read(): 03358 self._rtcout.RTC_DEBUG("The error occurred in readAll().") 03359 ret = False 03360 if not self._readAllCompletion: 03361 return False 03362 03363 return ret 03364 03365 03366 ## 03367 # @if jp 03368 # 03369 # @brief 全 OutPort のwrite()メソッドをコールする。 03370 # 03371 # RTC が保持する全ての OutPort のwrite()メソッドをコールする。 03372 # 03373 # @return 読み込み結果(全ポートへの書き込み成功:true，失敗:false) 03374 # 03375 # @else 03376 # 03377 # @brief The write() method of all OutPort is called. 03378 # 03379 # This operation call the write() method of all OutPort 03380 # registered in the RTC. 03381 # 03382 # @return result (Successful:true, Failed:false) 03383 # 03384 # @endif 03385 # 03386 # bool writeAll(); 03387 def writeAll(self): 03388 self._rtcout.RTC_TRACE("writeAll()") 03389 ret = True 03390 for outport in self._outports: 03391 if not outport.write(): 03392 self._rtcout.RTC_DEBUG("The error occurred in writeAll().") 03393 ret = False 03394 if not self._writeAllCompletion: 03395 return False 03396 03397 return ret 03398 03399 03400 ## 03401 # @if jp 03402 # 03403 # @brief onExecute()実行前でのreadAll()メソッドの呼出を有効または無効にする。 03404 # 03405 # このメソッドをパラメータをtrueとして呼ぶ事により、onExecute()実行前に 03406 # readAll()が呼出されるようになる。 03407 # パラメータがfalseの場合は、readAll()呼出を無効にする。 03408 # 03409 # @param read(default:true) 03410 # (readAll()メソッド呼出あり:true, readAll()メソッド呼出なし:false) 03411 # 03412 # @param completion(default:false) 03413 # readAll()にて、どれかの一つのInPortのread()が失敗しても全てのInPortのread()を呼び出す:true, 03414 # readAll()にて、どれかの一つのInPortのread()が失敗した場合、すぐにfalseで抜ける:false 03415 # 03416 # @else 03417 # 03418 # @brief Set whether to execute the readAll() method. 03419 # 03420 # Set whether to execute the readAll() method. 03421 # 03422 # @param read(default:true) 03423 # (readAll() is called:true, readAll() isn't called:false) 03424 # 03425 # @param completion(default:false) 03426 # All InPort::read() calls are completed.:true, 03427 # If one InPort::read() is False, return false.:false 03428 # 03429 # @param completion(default:false) 03430 # 03431 # @endif 03432 # 03433 # void setReadAll(bool read=true, bool completion=false); 03434 def setReadAll(self, read=True, completion=False): 03435 self._readAll = read 03436 self._readAllCompletion = completion 03437 03438 03439 ## 03440 # @if jp 03441 # 03442 # @brief onExecute()実行後にwriteAll()メソッドの呼出を有効または無効にする。 03443 # 03444 # このメソッドをパラメータをtrueとして呼ぶ事により、onExecute()実行後に 03445 # writeAll()が呼出されるようになる。 03446 # パラメータがfalseの場合は、writeAll()呼出を無効にする。 03447 # 03448 # @param write(default:true) 03449 # (writeAll()メソッド呼出あり:true, writeAll()メソッド呼出なし:false) 03450 # 03451 # @param completion(default:false) 03452 # writeAll()にて、どれかの一つのOutPortのwrite()が失敗しても全てのOutPortのwrite()を呼び出しを行う:true, 03453 # writeAll()にて、どれかの一つのOutPortのwrite()が失敗した場合、すぐにfalseで抜ける:false 03454 # 03455 # @else 03456 # 03457 # @brief Set whether to execute the writeAll() method. 03458 # 03459 # Set whether to execute the writeAll() method. 03460 # 03461 # @param write(default:true) 03462 # (writeAll() is called:true, writeAll() isn't called:false) 03463 # 03464 # @param completion(default:false) 03465 # All OutPort::write() calls are completed.:true, 03466 # If one OutPort::write() is False, return false.:false 03467 # 03468 # @endif 03469 # 03470 # void setWriteAll(bool write=true, bool completion=false); 03471 def setWriteAll(self, write=True, completion=False): 03472 self._writeAll = write 03473 self._writeAllCompletion = completion 03474 03475 03476 ## 03477 # @if jp 03478 # 03479 # @brief 全 Port の登録を削除する 03480 # 03481 # RTC が保持する全ての Port を削除する。 03482 # 03483 # @param self 03484 # 03485 # @else 03486 # 03487 # @brief Unregister the All Portse 03488 # 03489 # This operation deactivates the all Port and deletes the all Port's 03490 # registrations in the RTC.. 03491 # 03492 # @endif 03493 def finalizePorts(self): 03494 self._rtcout.RTC_TRACE("finalizePorts()") 03495 self._portAdmin.finalizePorts() 03496 self._inports = [] 03497 self._outports = [] 03498 return 03499 03500 03501 def finalizeContexts(self): 03502 self._rtcout.RTC_TRACE("finalizeContexts()") 03503 len_ = len(self._eclist) 03504 for i in range(len_): 03505 idx = (len_ - 1) - i 03506 self._eclist[idx].stop() 03507 try: 03508 self._poa.deactivate_object(self._poa.servant_to_id(self._eclist[idx])) 03509 except: 03510 self._rtcout.RTC_TRACE(OpenRTM_aist.Logger.print_exception()) 03511 del self._eclist[idx] 03512 03513 if self._eclist: 03514 self._eclist = [] 03515 return 03516 03517 03518 ## 03519 # @if jp 03520 # @brief PreComponentActionListener リスナを追加する 03521 # 03522 # ComponentAction 実装関数の呼び出し直前のイベントに関連する各種リ 03523 # スナを設定する。 03524 # 03525 # 設定できるリスナのタイプとコールバックイベントは以下の通り 03526 # 03527 # - PRE_ON_INITIALIZE: onInitialize 直前 03528 # - PRE_ON_FINALIZE: onFinalize 直前 03529 # - PRE_ON_STARTUP: onStartup 直前 03530 # - PRE_ON_SHUTDOWN: onShutdown 直前 03531 # - PRE_ON_ACTIVATED: onActivated 直前 03532 # - PRE_ON_DEACTIVATED: onDeactivated 直前 03533 # - PRE_ON_ABORTING: onAborted 直前 03534 # - PRE_ON_ERROR: onError 直前 03535 # - PRE_ON_RESET: onReset 直前 03536 # - PRE_ON_EXECUTE: onExecute 直前 03537 # - PRE_ON_STATE_UPDATE: onStateUpdate 直前 03538 # 03539 # リスナは PreComponentActionListener を継承し、以下のシグニチャを持つ 03540 # operator() を実装している必要がある。 03541 # 03542 # PreComponentActionListener::operator()(UniqueId ec_id) 03543 # 03544 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 03545 # RTObjectに移り、RTObject解体時もしくは、 03546 # removePreComponentActionListener() により削除時に自動的に解体される。 03547 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 03548 # 数に false を指定し、自動的な解体を抑制することができる。 03549 # 03550 # @param listener_type リスナタイプ 03551 # @param memfunc 関数オブジェクト 03552 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 03553 # 03554 # @else 03555 # @brief Adding PreComponentAction type listener 03556 # 03557 # This operation adds certain listeners related to ComponentActions 03558 # pre events. 03559 # The following listener types are available. 03560 # 03561 # - PRE_ON_INITIALIZE: before onInitialize 03562 # - PRE_ON_FINALIZE: before onFinalize 03563 # - PRE_ON_STARTUP: before onStartup 03564 # - PRE_ON_SHUTDOWN: before onShutdown 03565 # - PRE_ON_ACTIVATED: before onActivated 03566 # - PRE_ON_DEACTIVATED: before onDeactivated 03567 # - PRE_ON_ABORTING: before onAborted 03568 # - PRE_ON_ERROR: before onError 03569 # - PRE_ON_RESET: before onReset 03570 # - PRE_ON_EXECUTE: before onExecute 03571 # - PRE_ON_STATE_UPDATE: before onStateUpdate 03572 # 03573 # Listeners should have the following function operator(). 03574 # 03575 # PreComponentActionListener::operator()(UniqueId ec_id) 03576 # 03577 # The ownership of the given listener object is transferred to 03578 # this RTObject object in default. The given listener object will 03579 # be destroied automatically in the RTObject's dtor or if the 03580 # listener is deleted by removePreComponentActionListener() function. 03581 # If you want to keep ownership of the listener object, give 03582 # "false" value to 3rd argument to inhibit automatic destruction. 03583 # 03584 # @param listener_type A listener type 03585 # @param memfunc member function object 03586 # @param autoclean A flag for automatic listener destruction 03587 # 03588 # @endif 03589 # 03590 # template <class Listener> 03591 # PreComponentActionListener* 03592 # addPreComponentActionListener(PreCompActionListenerType listener_type, 03593 # void (Listener::*memfunc)(UniqueId ec_id), 03594 # bool autoclean = true) 03595 def addPreComponentActionListener(self, listener_type, 03596 memfunc, autoclean = True): 03597 class Noname(OpenRTM_aist.PreComponentActionListener): 03598 def __init__(self, memfunc): 03599 self._memfunc = memfunc 03600 03601 def __call__(self, ec_id): 03602 self._memfunc(ec_id) 03603 return 03604 03605 listener = Noname(memfunc) 03606 self._actionListeners.preaction_[listener_type].addListener(listener, autoclean) 03607 return listener 03608 03609 03610 ## 03611 # @if jp 03612 # @brief PreComponentActionListener リスナを削除する 03613 # 03614 # 設定した各種リスナを削除する。 03615 # 03616 # @param listener_type リスナタイプ 03617 # @param listener リスナオブジェクトへのポインタ 03618 # 03619 # @else 03620 # @brief Removing PreComponentAction type listener 03621 # 03622 # This operation removes a specified listener. 03623 # 03624 # @param listener_type A listener type 03625 # @param listener A pointer to a listener object 03626 # 03627 # @endif 03628 # 03629 # void 03630 # removePreComponentActionListener(PreComponentActionListenerType listener_type, 03631 # PreComponentActionListener* listener); 03632 def removePreComponentActionListener(self, listener_type, listener): 03633 self._actionListeners.preaction_[listener_type].removeListener(listener) 03634 return 03635 03636 03637 ## 03638 # @if jp 03639 # @brief PostComponentActionListener リスナを追加する 03640 # 03641 # ComponentAction 実装関数の呼び出し直後のイベントに関連する各種リ 03642 # スナを設定する。 03643 # 03644 # 設定できるリスナのタイプとコールバックイベントは以下の通り 03645 # 03646 # - POST_ON_INITIALIZE: onInitialize 直後 03647 # - POST_ON_FINALIZE: onFinalize 直後 03648 # - POST_ON_STARTUP: onStartup 直後 03649 # - POST_ON_SHUTDOWN: onShutdown 直後 03650 # - POST_ON_ACTIVATED: onActivated 直後 03651 # - POST_ON_DEACTIVATED: onDeactivated 直後 03652 # - POST_ON_ABORTING: onAborted 直後 03653 # - POST_ON_ERROR: onError 直後 03654 # - POST_ON_RESET: onReset 直後 03655 # - POST_ON_EXECUTE: onExecute 直後 03656 # - POST_ON_STATE_UPDATE: onStateUpdate 直後 03657 # 03658 # リスナは PostComponentActionListener を継承し、以下のシグニチャを持つ 03659 # operator() を実装している必要がある。 03660 # 03661 # PostComponentActionListener::operator()(UniqueId ec_id, ReturnCode_t ret) 03662 # 03663 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 03664 # RTObjectに移り、RTObject解体時もしくは、 03665 # removePostComponentActionListener() により削除時に自動的に解体される。 03666 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 03667 # 数に false を指定し、自動的な解体を抑制することができる。 03668 # 03669 # @param listener_type リスナタイプ 03670 # @param memfunc 関数オブジェクト 03671 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 03672 # 03673 # @else 03674 # @brief Adding PostComponentAction type listener 03675 # 03676 # This operation adds certain listeners related to ComponentActions 03677 # post events. 03678 # The following listener types are available. 03679 # 03680 # - POST_ON_INITIALIZE: after onInitialize 03681 # - POST_ON_FINALIZE: after onFinalize 03682 # - POST_ON_STARTUP: after onStartup 03683 # - POST_ON_SHUTDOWN: after onShutdown 03684 # - POST_ON_ACTIVATED: after onActivated 03685 # - POST_ON_DEACTIVATED: after onDeactivated 03686 # - POST_ON_ABORTING: after onAborted 03687 # - POST_ON_ERROR: after onError 03688 # - POST_ON_RESET: after onReset 03689 # - POST_ON_EXECUTE: after onExecute 03690 # - POST_ON_STATE_UPDATE: after onStateUpdate 03691 # 03692 # Listeners should have the following function operator(). 03693 # 03694 # PostComponentActionListener::operator()(UniqueId ec_id, ReturnCode_t ret) 03695 # 03696 # The ownership of the given listener object is transferred to 03697 # this RTObject object in default. The given listener object will 03698 # be destroied automatically in the RTObject's dtor or if the 03699 # listener is deleted by removePostComponentActionListener() function. 03700 # If you want to keep ownership of the listener object, give 03701 # "false" value to 3rd argument to inhibit automatic destruction. 03702 # 03703 # @param listener_type A listener type 03704 # @param memfunc member function object 03705 # @param autoclean A flag for automatic listener destruction 03706 # 03707 # @endif 03708 # 03709 # template <class Listener> 03710 # PostComponentActionListener* 03711 # addPostComponentActionListener(PostCompActionListenerType listener_type, 03712 # void (Listener::*memfunc)(UniqueId ec_id, 03713 # ReturnCode_t ret), 03714 # bool autoclean = true) 03715 def addPostComponentActionListener(self, listener_type, 03716 memfunc, autoclean = True): 03717 class Noname(OpenRTM_aist.PostComponentActionListener): 03718 def __init__(self, memfunc): 03719 self._memfunc = memfunc 03720 return 03721 def __call__(self, ec_id, ret): 03722 self._memfunc(ec_id, ret) 03723 return 03724 03725 listener = Noname(memfunc) 03726 self._actionListeners.postaction_[listener_type].addListener(listener, autoclean) 03727 return listener 03728 03729 03730 ## 03731 # @if jp 03732 # @brief PostComponentActionListener リスナを削除する 03733 # 03734 # 設定した各種リスナを削除する。 03735 # 03736 # @param listener_type リスナタイプ 03737 # @param listener リスナオブジェクトへのポインタ 03738 # 03739 # @else 03740 # @brief Removing PostComponentAction type listener 03741 # 03742 # This operation removes a specified listener. 03743 # 03744 # @param listener_type A listener type 03745 # @param listener A pointer to a listener object 03746 # 03747 # @endif 03748 ## 03749 # void 03750 # removePostComponentActionListener(PostComponentActionListenerType listener_type, 03751 # PostComponentActionListener* listener); 03752 def removePostComponentActionListener(self, listener_type, listener): 03753 self._actionListeners.postaction_[listener_type].removeListener(listener) 03754 return 03755 03756 03757 ## 03758 # @if jp 03759 # @brief PortActionListener リスナを追加する 03760 # 03761 # Portの追加、削除時にコールバックされる各種リスナを設定する。 03762 # 03763 # 設定できるリスナのタイプとコールバックイベントは以下の通り 03764 # 03765 # - ADD_PORT: Port追加時 03766 # - REMOVE_PORT: Port削除時 03767 # 03768 # リスナは PortActionListener を継承し、以下のシグニチャを持つ 03769 # operator() を実装している必要がある。 03770 # 03771 # PortActionListener::operator()(PortProfile& pprof) 03772 # 03773 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 03774 # RTObjectに移り、RTObject解体時もしくは、 03775 # removePortActionListener() により削除時に自動的に解体される。 03776 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 03777 # 数に false を指定し、自動的な解体を抑制することができる。 03778 # 03779 # @param listener_type リスナタイプ 03780 # @param memfunc 関数オブジェクト 03781 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 03782 # 03783 # @else 03784 # @brief Adding PortAction type listener 03785 # 03786 # This operation adds certain listeners related to ComponentActions 03787 # post events. 03788 # The following listener types are available. 03789 # 03790 # - ADD_PORT: At adding Port 03791 # - REMOVE_PORT: At removing Port 03792 # 03793 # Listeners should have the following function operator(). 03794 # 03795 # PortActionListener::operator()(RTC::PortProfile pprof) 03796 # 03797 # The ownership of the given listener object is transferred to 03798 # this RTObject object in default. The given listener object will 03799 # be destroied automatically in the RTObject's dtor or if the 03800 # listener is deleted by removePortActionListener() function. 03801 # If you want to keep ownership of the listener object, give 03802 # "false" value to 3rd argument to inhibit automatic destruction. 03803 # 03804 # @param listener_type A listener type 03805 # @param memfunc member function object 03806 # @param autoclean A flag for automatic listener destruction 03807 # 03808 # @endif 03809 # 03810 # template <class Listener> 03811 # PortActionListener* 03812 # addPortActionListener(PortActionListenerType listener_type, 03813 # void (Listener::*memfunc)(const RTC::PortProfile&), 03814 # bool autoclean=true) 03815 def addPortActionListener(self, listener_type, 03816 memfunc, autoclean = True): 03817 class Noname(OpenRTM_aist.PortActionListener): 03818 def __init__(self, memfunc): 03819 self._memfunc = memfunc 03820 return 03821 03822 def __call__(self, pprofile): 03823 self._memfunc(pprofile) 03824 return 03825 03826 listener = Noname(memfunc) 03827 self._actionListeners.portaction_[listener_type].addListener(listener, autoclean) 03828 return listener 03829 03830 03831 ## 03832 # @if jp 03833 # @brief PortActionListener リスナを削除する 03834 # 03835 # 設定した各種リスナを削除する。 03836 # 03837 # @param listener_type リスナタイプ 03838 # @param listener リスナオブジェクトへのポインタ 03839 # 03840 # @else 03841 # @brief Removing PortAction type listener 03842 # 03843 # This operation removes a specified listener. 03844 # 03845 # @param listener_type A listener type 03846 # @param listener A pointer to a listener object 03847 # 03848 # @endif 03849 # void 03850 # removePortActionListener(PortActionListenerType listener_type, 03851 # PortActionListener* listener); 03852 def removePortActionListener(self, listener_type, listener): 03853 self._actionListeners.portaction_[listener_type].removeListener(listener) 03854 return 03855 03856 03857 ## 03858 # @if jp 03859 # @brief ExecutionContextActionListener リスナを追加する 03860 # 03861 # ExecutionContextの追加、削除時にコールバックされる各種リスナを設定する。 03862 # 03863 # 設定できるリスナのタイプとコールバックイベントは以下の通り 03864 # 03865 # - ATTACH_EC: ExecutionContext アタッチ時 03866 # - DETACH_EC: ExecutionContext デタッチ時 03867 # 03868 # リスナは ExecutionContextActionListener を継承し、以下のシグニチャを持つ 03869 # operator() を実装している必要がある。 03870 # 03871 # ExecutionContextActionListener::operator()(UniqueId ec_id) 03872 # 03873 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 03874 # RTObjectに移り、RTObject解体時もしくは、 03875 # removeExecutionContextActionListener() により削除時に自動的に解体される。 03876 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 03877 # 数に false を指定し、自動的な解体を抑制することができる。 03878 # 03879 # @param listener_type リスナタイプ 03880 # @param memfunc 関数オブジェクト 03881 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 03882 # 03883 # @else 03884 # @brief Adding ExecutionContextAction type listener 03885 # 03886 # This operation adds certain listeners related to ComponentActions 03887 # post events. 03888 # The following listener types are available. 03889 # 03890 # - ADD_PORT: At adding ExecutionContext 03891 # - REMOVE_PORT: At removing ExecutionContext 03892 # 03893 # Listeners should have the following function operator(). 03894 # 03895 # ExecutionContextActionListener::operator()(UniqueId ec_id) 03896 # 03897 # The ownership of the given listener object is transferred to 03898 # this RTObject object in default. The given listener object will 03899 # be destroied automatically in the RTObject's dtor or if the 03900 # listener is deleted by removeExecutionContextActionListener() function. 03901 # If you want to keep ownership of the listener object, give 03902 # "false" value to 3rd argument to inhibit automatic destruction. 03903 # 03904 # @param listener_type A listener type 03905 # @param memfunc member function object 03906 # @param autoclean A flag for automatic listener destruction 03907 # 03908 # @endif 03909 # 03910 # template <class Listener> 03911 # ECActionListener* 03912 # addExecutionContextActionListener(ECActionListenerType listener_type, 03913 # void (Listener::*memfunc)(UniqueId), 03914 # bool autoclean = true); 03915 def addExecutionContextActionListener(self, listener_type, 03916 memfunc, autoclean = True): 03917 class Noname(OpenRTM_aist.ExecutionContextActionListener): 03918 def __init__(self, memfunc): 03919 self._memfunc = memfunc 03920 return 03921 03922 def __call__(self, ec_id): 03923 self._memfunc(ec_id) 03924 return 03925 03926 listener = Noname(memfunc) 03927 self._actionListeners.ecaction_[listener_type].addListener(listener, autoclean) 03928 return listener 03929 03930 03931 ## 03932 # @if jp 03933 # @brief ExecutionContextActionListener リスナを削除する 03934 # 03935 # 設定した各種リスナを削除する。 03936 # 03937 # @param listener_type リスナタイプ 03938 # @param listener リスナオブジェクトへのポインタ 03939 # 03940 # @else 03941 # @brief Removing ExecutionContextAction type listener 03942 # 03943 # This operation removes a specified listener. 03944 # 03945 # @param listener_type A listener type 03946 # @param listener A pointer to a listener object 03947 # 03948 # @endif 03949 # 03950 # void 03951 # removeExecutionContextActionListener(ECActionListenerType listener_type, 03952 # ECActionListener* listener); 03953 def removeExecutionContextActionListener(self, listener_type, listener): 03954 self._actionListeners.ecaction_[listener_type].removeListener(listener) 03955 return 03956 03957 03958 ## 03959 # @if jp 03960 # @brief PortConnectListener リスナを追加する 03961 # 03962 # Portの接続時や接続解除時に呼び出される各種リスナを設定する。 03963 # 03964 # 設定できるリスナのタイプとコールバックイベントは以下の通り 03965 # 03966 # - ON_NOTIFY_CONNECT: notify_connect() 関数内呼び出し直後 03967 # - ON_NOTIFY_DISCONNECT: notify_disconnect() 呼び出し直後 03968 # - ON_UNSUBSCRIBE_INTERFACES: notify_disconnect() 内のIF購読解除時 03969 # 03970 # リスナは PortConnectListener を継承し、以下のシグニチャを持つ 03971 # operator() を実装している必要がある。 03972 # 03973 # PortConnectListener::operator()(const char*, ConnectorProfile) 03974 # 03975 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 03976 # RTObjectに移り、RTObject解体時もしくは、 03977 # removePortConnectListener() により削除時に自動的に解体される。 03978 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 03979 # 数に false を指定し、自動的な解体を抑制することができる。 03980 # 03981 # @param listener_type リスナタイプ 03982 # @param memfunc 関数オブジェクト 03983 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 03984 # 03985 # @else 03986 # @brief Adding PortConnect type listener 03987 # 03988 # This operation adds certain listeners related to Port's connect actions. 03989 # The following listener types are available. 03990 # 03991 # - ON_NOTIFY_CONNECT: right after entering into notify_connect() 03992 # - ON_NOTIFY_DISCONNECT: right after entering into notify_disconnect() 03993 # - ON_UNSUBSCRIBE_INTERFACES: unsubscribing IF in notify_disconnect() 03994 # 03995 # Listeners should have the following function operator(). 03996 # 03997 # PortConnectListener::operator()(const char*, ConnectorProfile) 03998 # 03999 # The ownership of the given listener object is transferred to 04000 # this RTObject object in default. The given listener object will 04001 # be destroied automatically in the RTObject's dtor or if the 04002 # listener is deleted by removePortConnectListener() function. 04003 # If you want to keep ownership of the listener object, give 04004 # "false" value to 3rd argument to inhibit automatic destruction. 04005 # 04006 # @param listener_type A listener type 04007 # @param memfunc member function object 04008 # @param autoclean A flag for automatic listener destruction 04009 # 04010 # @endif 04011 # 04012 # template <class Listener> 04013 # PortConnectListener* 04014 # addPortConnectListener(PortConnectListenerType listener_type, 04015 # void (Listener::*memfunc)(const char*, 04016 # ConnectorProfile&), 04017 # bool autoclean = true) 04018 def addPortConnectListener(self, listener_type, 04019 memfunc, autoclean = True): 04020 class Noname(OpenRTM_aist.PortConnectListener): 04021 def __init__(self, memfunc): 04022 self._memfunc = memfunc 04023 return 04024 04025 def __call__(self, portname, cprofile): 04026 self._memfunc(portname, cprofile) 04027 return 04028 04029 listener = Noname(memfunc) 04030 self._portconnListeners.portconnect_[listener_type].addListener(listener, autoclean) 04031 return listener 04032 04033 04034 ## 04035 # @if jp 04036 # @brief PortConnectListener リスナを削除する 04037 # 04038 # 設定した各種リスナを削除する。 04039 # 04040 # @param listener_type リスナタイプ 04041 # @param listener リスナオブジェクトへのポインタ 04042 # 04043 # @else 04044 # @brief Removing PortConnect type listener 04045 # 04046 # This operation removes a specified listener. 04047 # 04048 # @param listener_type A listener type 04049 # @param listener A pointer to a listener object 04050 # 04051 # @endif 04052 # 04053 # void 04054 # removePortConnectListener(PortConnectListenerType listener_type, 04055 # PortConnectListener* listener); 04056 def removePortConnectListener(self, listener_type, listener): 04057 self._portconnListeners.portconnect_[listener_type].removeListener(listener) 04058 return 04059 04060 04061 ## 04062 # @if jp 04063 # @brief PortConnectRetListener リスナを追加する 04064 # 04065 # Portの接続時や接続解除時に呼び出される各種リスナを設定する。 04066 # 04067 # 設定できるリスナのタイプとコールバックイベントは以下の通り 04068 # 04069 # - ON_CONNECT_NEXTPORT: notify_connect() 中のカスケード呼び出し直後 04070 # - ON_SUBSCRIBE_INTERFACES: notify_connect() 中のインターフェース購読直後 04071 # - ON_CONNECTED: nofity_connect() 接続処理完了時に呼び出される 04072 # - ON_DISCONNECT_NEXT: notify_disconnect() 中にカスケード呼び出し直後 04073 # - ON_DISCONNECTED: notify_disconnect() リターン時 04074 # 04075 # リスナは PortConnectRetListener を継承し、以下のシグニチャを持つ 04076 # operator() を実装している必要がある。 04077 # 04078 # PortConnectRetListener::operator()(const char*, ConnectorProfile) 04079 # 04080 # デフォルトでは、この関数に与えたリスナオブジェクトの所有権は 04081 # RTObjectに移り、RTObject解体時もしくは、 04082 # removePortConnectRetListener() により削除時に自動的に解体される。 04083 # リスナオブジェクトの所有権を呼び出し側で維持したい場合は、第3引 04084 # 数に false を指定し、自動的な解体を抑制することができる。 04085 # 04086 # @param listener_type リスナタイプ 04087 # @param memfunc 関数オブジェクト 04088 # @param autoclean リスナオブジェクトの自動的解体を行うかどうかのフラグ 04089 # 04090 # @else 04091 # @brief Adding PortConnectRet type listener 04092 # 04093 # This operation adds certain listeners related to Port's connect actions. 04094 # The following listener types are available. 04095 # 04096 # - ON_CONNECT_NEXTPORT: after cascade-call in notify_connect() 04097 # - ON_SUBSCRIBE_INTERFACES: after IF subscribing in notify_connect() 04098 # - ON_CONNECTED: completed nofity_connect() connection process 04099 # - ON_DISCONNECT_NEXT: after cascade-call in notify_disconnect() 04100 # - ON_DISCONNECTED: completed notify_disconnect() disconnection process 04101 # 04102 # Listeners should have the following function operator(). 04103 # 04104 # PortConnectRetListener::operator()(const char*, ConnectorProfile) 04105 # 04106 # The ownership of the given listener object is transferred to 04107 # this RTObject object in default. The given listener object will 04108 # be destroied automatically in the RTObject's dtor or if the 04109 # listener is deleted by removePortConnectRetListener() function. 04110 # If you want to keep ownership of the listener object, give 04111 # "false" value to 3rd argument to inhibit automatic destruction. 04112 # 04113 # @param listener_type A listener type 04114 # @param memfunc member function object 04115 # @param autoclean A flag for automatic listener destruction 04116 # 04117 # @endif 04118 # 04119 # template <class Listener> 04120 # PortConnectRetListener* 04121 # addPortConnectRetListener(PortConnectRetListenerType listener_type, 04122 # void (Listener::*memfunc)(const char*, 04123 # ConnectorProfile&, 04124 # ReturnCode_t)) 04125 def addPortConnectRetListener(self, listener_type, 04126 memfunc, autoclean = True): 04127 class Noname(OpenRTM_aist.PortConnectRetListener): 04128 def __init__(self, memfunc): 04129 self._memfunc = memfunc 04130 return 04131 04132 def __call__(self, portname, cprofile, ret): 04133 self._memfunc(portname, cprofile, ret) 04134 return 04135 04136 listener = Noname(memfunc) 04137 self._portconnListeners.portconnret_[listener_type].addListener(listener, autoclean) 04138 return listener 04139 04140 04141 ## 04142 # @if jp 04143 # @brief PortConnectRetListener リスナを削除する 04144 # 04145 # 設定した各種リスナを削除する。 04146 # 04147 # @param listener_type リスナタイプ 04148 # @param listener リスナオブジェクトへのポインタ 04149 # 04150 # @else 04151 # @brief Removing PortConnectRet type listener 04152 # 04153 # This operation removes a specified listener. 04154 # 04155 # @param listener_type A listener type 04156 # @param listener A pointer to a listener object 04157 # 04158 # @endif 04159 # 04160 # void 04161 # removePortConnectRetListener(PortConnectRetListenerType listener_type, 04162 # PortConnectRetListener* listener); 04163 def removePortConnectRetListener(self, listener_type, listener): 04164 self._portconnListeners.portconnret_[listener_type].removeListener(listener) 04165 return 04166 04167 04168 ## 04169 # @if jp 04170 # 04171 # @brief ConfigurationParamListener を追加する 04172 # 04173 # update(const char* config_set, const char* config_param) が呼ばれた際に 04174 # コールされるリスナ ConfigurationParamListener を追加する。 04175 # type には現在のところ ON_UPDATE_CONFIG_PARAM のみが入る。 04176 # 04177 # @param type ConfigurationParamListenerType型の値。 04178 # ON_UPDATE_CONFIG_PARAM がある。 04179 # 04180 # @param memfunc 関数オブジェクト 04181 # @param autoclean リスナオブジェクトを自動で削除するかどうかのフラグ 04182 # 04183 # @else 04184 # 04185 # @brief Adding ConfigurationParamListener 04186 # 04187 # This function adds a listener object which is called when 04188 # update(const char* config_set, const char* config_param) is 04189 # called. In the type argument, currently only 04190 # ON_UPDATE_CONFIG_PARAM is allowed. 04191 # 04192 # @param type ConfigurationParamListenerType value 04193 # ON_UPDATE_CONFIG_PARAM is only allowed. 04194 # 04195 # @param memfunc member function object 04196 # @param autoclean a flag whether if the listener object autocleaned. 04197 # 04198 # @endif 04199 # 04200 # template <class Listener> 04201 # ConfigurationParamListener* 04202 # addConfigurationParamListener(ConfigurationParamListenerType listener_type, 04203 # void (Listener::*memfunc)(const char*, 04204 # const char*), 04205 # bool autoclean = true) 04206 def addConfigurationParamListener(self, type, 04207 memfunc, autoclean = True): 04208 class Noname(OpenRTM_aist.ConfigurationParamListener): 04209 def __init__(self, memfunc): 04210 self._memfunc = memfunc 04211 return 04212 04213 def __call__(self, config_set_name, config_param_name): 04214 self._memfunc(config_set_name, config_param_name) 04215 return 04216 04217 listener = Noname(memfunc) 04218 self._configsets.addConfigurationParamListener(type, listener, autoclean) 04219 return listener 04220 04221 04222 ## 04223 # @if jp 04224 # 04225 # @brief ConfigurationParamListener を削除する 04226 # 04227 # addConfigurationParamListener で追加されたリスナオブジェクトを削除する。 04228 # 04229 # @param type ConfigurationParamListenerType型の値。 04230 # ON_UPDATE_CONFIG_PARAM がある。 04231 # @param listener 与えたリスナオブジェクトへのポインタ 04232 # 04233 # @else 04234 # 04235 # @brief Removing ConfigurationParamListener 04236 # 04237 # This function removes a listener object which is added by 04238 # addConfigurationParamListener() function. 04239 # 04240 # @param type ConfigurationParamListenerType value 04241 # ON_UPDATE_CONFIG_PARAM is only allowed. 04242 # @param listener a pointer to ConfigurationParamListener listener object. 04243 # 04244 # @endif 04245 # 04246 # void removeConfigurationParamListener(ConfigurationParamListenerType type, 04247 # ConfigurationParamListener* listener); 04248 def removeConfigurationParamListener(self, type, listener): 04249 self._configsets.removeConfigurationParamListener(type, listener) 04250 return 04251 04252 04253 ## 04254 # @if jp 04255 # 04256 # @brief ConfigurationSetListener を追加する 04257 # 04258 # ConfigurationSet が更新されたときなどに呼ばれるリスナ 04259 # ConfigurationSetListener を追加する。設定可能なイベントは以下の 04260 # 2種類がある。 04261 # 04262 # - ON_SET_CONFIG_SET: setConfigurationSetValues() で 04263 # ConfigurationSet に値が設定された場合。 04264 # - ON_ADD_CONFIG_SET: addConfigurationSet() で新しい 04265 # ConfigurationSet が追加された場合。 04266 # 04267 # @param type ConfigurationSetListenerType型の値。 04268 # @param memfunc 関数オブジェクト 04269 # @param autoclean リスナオブジェクトを自動で削除するかどうかのフラグ 04270 # 04271 # @else 04272 # 04273 # @brief Adding ConfigurationSetListener 04274 # 04275 # This function add a listener object which is called when 04276 # ConfigurationSet is updated. Available events are the followings. 04277 # 04278 # @param type ConfigurationSetListenerType value 04279 # @param memfunc member function object 04280 # @param autoclean a flag whether if the listener object autocleaned. 04281 # 04282 # @endif 04283 # 04284 # template <class Listener> 04285 # ConfigurationSetListener* 04286 # addConfigurationSetListener(ConfigurationSetListenerType listener_type, 04287 # void (Listener::*memfunc) 04288 # (const coil::Properties& config_set)) 04289 def addConfigurationSetListener(self, listener_type, 04290 memfunc, autoclean = True): 04291 class Noname(OpenRTM_aist.ConfigurationSetListener): 04292 def __init__(self, memfunc): 04293 self._memfunc = memfunc 04294 return 04295 04296 def __call__(self, config_set): 04297 self._memfunc(config_set) 04298 return 04299 04300 listener = Noname(memfunc) 04301 self._configsets.addConfigurationSetListener(listener_type, listener, autoclean) 04302 return listener 04303 04304 04305 ## 04306 # @if jp 04307 # 04308 # @brief ConfigurationSetListener を削除する 04309 # 04310 # addConfigurationSetListener で追加されたリスナオブジェクトを削除する。 04311 # 04312 # @param type ConfigurationSetListenerType型の値。 04313 # @param listener 与えたリスナオブジェクトへのポインタ 04314 # 04315 # @else 04316 # 04317 # @brief Removing ConfigurationSetListener 04318 # 04319 # This function removes a listener object which is added by 04320 # addConfigurationSetListener() function. 04321 # 04322 # @param type ConfigurationSetListenerType value 04323 # @param listener a pointer to ConfigurationSetListener listener object. 04324 # 04325 # @endif 04326 # 04327 # void removeConfigurationSetListener(ConfigurationSetListenerType type, 04328 # ConfigurationSetListener* listener); 04329 def removeConfigurationSetListener(self, type, listener): 04330 self._configsets.removeConfigurationSetListener(type, listener) 04331 return 04332 04333 04334 ## 04335 # @if jp 04336 # 04337 # @brief ConfigurationSetNameListener を追加する 04338 # 04339 # ConfigurationSetName が更新されたときなどに呼ばれるリスナ 04340 # ConfigurationSetNameListener を追加する。設定可能なイベントは以下の 04341 # 3種類がある。 04342 # 04343 # - ON_UPDATE_CONFIG_SET: ある ConfigurationSet がアップデートされた 04344 # - ON_REMOVE_CONFIG_SET: ある ConfigurationSet が削除された 04345 # - ON_ACTIVATE_CONFIG_SET: ある ConfigurationSet がアクティブ化された 04346 # 04347 # @param type ConfigurationSetNameListenerType型の値。 04348 # @param memfunc 関数オブジェクト 04349 # @param autoclean リスナオブジェクトを自動で削除するかどうかのフラグ 04350 # 04351 # @else 04352 # 04353 # @brief Adding ConfigurationSetNameListener 04354 # 04355 # This function add a listener object which is called when 04356 # ConfigurationSetName is updated. Available events are the followings. 04357 # 04358 # - ON_UPDATE_CONFIG_SET: A ConfigurationSet has been updated. 04359 # - ON_REMOVE_CONFIG_SET: A ConfigurationSet has been deleted. 04360 # - ON_ACTIVATE_CONFIG_SET: A ConfigurationSet has been activated. 04361 # 04362 # @param type ConfigurationSetNameListenerType value 04363 # @param memfunc member function object 04364 # @param autoclean a flag whether if the listener object autocleaned. 04365 # 04366 # @endif 04367 # 04368 # template <class Listener> 04369 # ConfigurationSetNameListener* 04370 # addConfigurationSetNameListener(ConfigurationSetNameListenerType type, 04371 # void (Listener::*memfunc)(const char*)) 04372 def addConfigurationSetNameListener(self, type, memfunc, autoclean = True): 04373 class Noname(OpenRTM_aist.ConfigurationSetNameListener): 04374 def __init__(self, memfunc): 04375 self._memfunc = memfunc 04376 return 04377 04378 def __call__(self, config_set_name): 04379 self._memfunc(config_set_name) 04380 return 04381 04382 listener = Noname(memfunc) 04383 self._configsets.addConfigurationSetNameListener(type, listener, autoclean) 04384 return listener 04385 04386 04387 ## 04388 # @if jp 04389 # 04390 # @brief ConfigurationSetNameListener を削除する 04391 # 04392 # addConfigurationSetNameListener で追加されたリスナオブジェクトを 04393 # 削除する。 04394 # 04395 # @param type ConfigurationSetNameListenerType型の値。 04396 # ON_UPDATE_CONFIG_PARAM がある。 04397 # @param listener 与えたリスナオブジェクトへのポインタ 04398 # 04399 # @else 04400 # 04401 # @brief Removing ConfigurationSetNameListener 04402 # 04403 # This function removes a listener object which is added by 04404 # addConfigurationSetNameListener() function. 04405 # 04406 # @param type ConfigurationSetNameListenerType value 04407 # ON_UPDATE_CONFIG_PARAM is only allowed. 04408 # @param listener a pointer to ConfigurationSetNameListener 04409 # listener object. 04410 # 04411 # @endif 04412 # void 04413 # removeConfigurationSetNameListener(ConfigurationSetNameListenerType type, 04414 # ConfigurationSetNameListener* listener); 04415 def removeConfigurationSetNameListener(self, type, listener): 04416 self._configsets.removeConfigurationSetNameListener(type, listener) 04417 return 04418 04419 04420 ## 04421 # @if jp 04422 # 04423 # @brief RTC を終了する 04424 # 04425 # RTC の終了処理を実行する。 04426 # 保持している全 Port の登録を解除するとともに、該当する CORBA オブジェクト 04427 # を非活性化し、RTC を終了する。 04428 # 04429 # @param self 04430 # 04431 # @else 04432 # 04433 # @endif 04434 def shutdown(self): 04435 self._rtcout.RTC_TRACE("shutdown()") 04436 try: 04437 self.finalizePorts() 04438 self.finalizeContexts() 04439 self._poa.deactivate_object(self._poa.servant_to_id(self._SdoConfigImpl)) 04440 self._poa.deactivate_object(self._poa.servant_to_id(self)) 04441 except: 04442 self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception()) 04443 04444 if self._manager: 04445 self._rtcout.RTC_DEBUG("Cleanup on Manager") 04446 self._manager.notifyFinalized(self) 04447 04448 return 04449 04450 # inline void preOnInitialize(UniqueId ec_id) 04451 def preOnInitialize(self, ec_id): 04452 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_INITIALIZE].notify(ec_id) 04453 return 04454 04455 # inline void preOnFinalize(UniqueId ec_id) 04456 def preOnFinalize(self, ec_id): 04457 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_FINALIZE].notify(ec_id) 04458 return 04459 04460 # inline void preOnStartup(UniqueId ec_id) 04461 def preOnStartup(self, ec_id): 04462 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_STARTUP].notify(ec_id) 04463 return 04464 04465 # inline void preOnShutdown(UniqueId ec_id) 04466 def preOnShutdown(self, ec_id): 04467 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_SHUTDOWN].notify(ec_id) 04468 return 04469 04470 # inline void preOnActivated(UniqueId ec_id) 04471 def preOnActivated(self, ec_id): 04472 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_ACTIVATED].notify(ec_id) 04473 return 04474 04475 # inline void preOnDeactivated(UniqueId ec_id) 04476 def preOnDeactivated(self, ec_id): 04477 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_DEACTIVATED].notify(ec_id) 04478 return 04479 04480 # inline void preOnAborting(UniqueId ec_id) 04481 def preOnAborting(self, ec_id): 04482 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_ABORTING].notify(ec_id) 04483 return 04484 04485 # inline void preOnError(UniqueId ec_id) 04486 def preOnError(self, ec_id): 04487 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_ERROR].notify(ec_id) 04488 return 04489 04490 # inline void preOnReset(UniqueId ec_id) 04491 def preOnReset(self, ec_id): 04492 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_RESET].notify(ec_id) 04493 return 04494 04495 # inline void preOnExecute(UniqueId ec_id) 04496 def preOnExecute(self, ec_id): 04497 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_EXECUTE].notify(ec_id) 04498 return 04499 04500 # inline void preOnStateUpdate(UniqueId ec_id) 04501 def preOnStateUpdate(self, ec_id): 04502 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_STATE_UPDATE].notify(ec_id) 04503 return 04504 04505 04506 # inline void preOnRateChanged(UniqueId ec_id) 04507 def preOnRateChanged(self, ec_id): 04508 self._actionListeners.preaction_[OpenRTM_aist.PreComponentActionListenerType.PRE_ON_RATE_CHANGED].notify(ec_id) 04509 return 04510 04511 04512 # inline void postOnInitialize(UniqueId ec_id, ReturnCode_t ret) 04513 def postOnInitialize(self, ec_id, ret): 04514 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_INITIALIZE].notify(ec_id, ret) 04515 return 04516 04517 04518 # inline void postOnFinalize(UniqueId ec_id, ReturnCode_t ret) 04519 def postOnFinalize(self, ec_id, ret): 04520 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_FINALIZE].notify(ec_id, ret) 04521 return 04522 04523 04524 # inline void postOnStartup(UniqueId ec_id, ReturnCode_t ret) 04525 def postOnStartup(self, ec_id, ret): 04526 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_STARTUP].notify(ec_id, ret) 04527 return 04528 04529 04530 # inline void postOnShutdown(UniqueId ec_id, ReturnCode_t ret) 04531 def postOnShutdown(self, ec_id, ret): 04532 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_SHUTDOWN].notify(ec_id, ret) 04533 return 04534 04535 04536 # inline void postOnActivated(UniqueId ec_id, ReturnCode_t ret) 04537 def postOnActivated(self, ec_id, ret): 04538 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_ACTIVATED].notify(ec_id, ret) 04539 return 04540 04541 04542 # inline void postOnDeactivated(UniqueId ec_id, ReturnCode_t ret) 04543 def postOnDeactivated(self, ec_id, ret): 04544 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_DEACTIVATED].notify(ec_id, ret) 04545 return 04546 04547 04548 # inline void postOnAborting(UniqueId ec_id, ReturnCode_t ret) 04549 def postOnAborting(self, ec_id, ret): 04550 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_ABORTING].notify(ec_id, ret) 04551 return 04552 04553 04554 # inline void postOnError(UniqueId ec_id, ReturnCode_t ret) 04555 def postOnError(self, ec_id, ret): 04556 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_ERROR].notify(ec_id, ret) 04557 return 04558 04559 04560 # inline void postOnReset(UniqueId ec_id, ReturnCode_t ret) 04561 def postOnReset(self, ec_id, ret): 04562 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_RESET].notify(ec_id, ret) 04563 return 04564 04565 04566 # inline void postOnExecute(UniqueId ec_id, ReturnCode_t ret) 04567 def postOnExecute(self, ec_id, ret): 04568 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_EXECUTE].notify(ec_id, ret) 04569 return 04570 04571 04572 # inline void postOnStateUpdate(UniqueId ec_id, ReturnCode_t ret) 04573 def postOnStateUpdate(self, ec_id, ret): 04574 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_STATE_UPDATE].notify(ec_id, ret) 04575 return 04576 04577 04578 # inline void postOnRateChanged(UniqueId ec_id, ReturnCode_t ret) 04579 def postOnRateChanged(self, ec_id, ret): 04580 self._actionListeners.postaction_[OpenRTM_aist.PostComponentActionListenerType.POST_ON_RATE_CHANGED].notify(ec_id, ret) 04581 return 04582 04583 04584 # inline void onAddPort(const PortProfile& pprof) 04585 def onAddPort(self, pprof): 04586 self._actionListeners.portaction_[OpenRTM_aist.PortActionListenerType.ADD_PORT].notify(pprof) 04587 return 04588 04589 04590 # inline void onRemovePort(const PortProfile& pprof) 04591 def onRemovePort(self, pprof): 04592 self._actionListeners.portaction_[OpenRTM_aist.PortActionListenerType.REMOVE_PORT].notify(pprof) 04593 return 04594 04595 04596 # inline void onAttachExecutionContext(UniqueId ec_id) 04597 def onAttachExecutionContext(self, ec_id): 04598 self._actionListeners.ecaction_[OpenRTM_aist.ExecutionContextActionListenerType.EC_ATTACHED].notify(ec_id) 04599 return 04600 04601 04602 # inline void onDetachExecutionContext(UniqueId ec_id) 04603 def onDetachExecutionContext(self, ec_id): 04604 self._actionListeners.ecaction_[OpenRTM_aist.ExecutionContextActionListenerType.EC_DETACHED].notify(ec_id) 04605 return 04606 04607 04608 ## 04609 # @if jp 04610 # @class svc_name 04611 # @brief SDOService のプロファイルリストからidでサーチするための 04612 # ファンクタクラス 04613 # @else 04614 # 04615 # @endif 04616 class svc_name: 04617 def __init__(self, _id): 04618 self._id= _id 04619 04620 def __call__(self, prof): 04621 return self._id == prof.id 04622 04623 04624 #------------------------------------------------------------ 04625 # Functor 04626 #------------------------------------------------------------ 04627 04628 ## 04629 # @if jp 04630 # @class nv_name 04631 # @brief NVList 検索用ファンクタ 04632 # @else 04633 # 04634 # @endif 04635 class nv_name: 04636 def __init__(self, _name): 04637 self._name = _name 04638 04639 def __call__(self, nv): 04640 return self._name == nv.name 04641 04642 04643 ## 04644 # @if jp 04645 # @class ec_find 04646 # @brief ExecutionContext 検索用ファンクタ 04647 # @else 04648 # 04649 # @endif 04650 class ec_find: 04651 def __init__(self, _ec): 04652 self._ec = _ec 04653 04654 def __call__(self, ecs): 04655 try: 04656 if not CORBA.is_nil(ecs): 04657 ec = ecs._narrow(RTC.ExecutionContext) 04658 return self._ec._is_equivalent(ec) 04659 except: 04660 print OpenRTM_aist.Logger.print_exception() 04661 return False 04662 04663 return False 04664 04665 04666 ## 04667 # @if jp 04668 # @class ec_copy 04669 # @brief ExecutionContext Copy用ファンクタ 04670 # @else 04671 # 04672 # @endif 04673 class ec_copy: 04674 def __init__(self, eclist): 04675 self._eclist = eclist 04676 04677 def __call__(self, ecs): 04678 if not CORBA.is_nil(ecs): 04679 self._eclist.append(ecs) 04680 04681 04682 ## 04683 # @if jp 04684 # @class deactivate_comps 04685 # @brief RTC 非活性化用ファンクタ 04686 # @else 04687 # 04688 # @endif 04689 class deactivate_comps: 04690 def __init__(self, comp): 04691 self._comp = comp 04692 04693 def __call__(self, ec): 04694 try: 04695 if not CORBA.is_nil(ec) and not ec._non_existent(): 04696 ec.deactivate_component(self._comp) 04697 ec.stop() 04698 except: 04699 print OpenRTM_aist.Logger.print_exception() 04700 04701 04702 # RtcBase = RTObject_impl