def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._NAO_motionSrvPort = OpenRTM_aist.CorbaPort("NAO_motion")
self._NAO_speechSrvPort = OpenRTM_aist.CorbaPort("NAO_speech")
"""
"""
self._motion = OpenRTM_aist.CorbaConsumer(interfaceType=ssr.ALMotion)
"""
"""
self._textToSpeech = OpenRTM_aist.CorbaConsumer(
interfaceType=ssr.ALTextToSpeech)
"""
"""
#self._behaviorManager = OpenRTM_aist.CorbaConsumer(interfaceType=ssr.ALBehaviorManager)
"""
"""
self._videoDevice = OpenRTM_aist.CorbaConsumer(
interfaceType=ssr.ALVideoDevice)
"""
"""
self._memory = OpenRTM_aist.CorbaConsumer(interfaceType=ssr.ALMemory)
"""
"""
self._leds = OpenRTM_aist.CorbaConsumer(interfaceType=ssr.ALLeds)
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_InP1 = OpenRTM_aist.instantiateDataType(RTC.TimedShort)
"""
"""
self._InP1In = OpenRTM_aist.InPort("InP1", self._d_InP1)
self._d_InP2 = OpenRTM_aist.instantiateDataType(RTC.TimedLong)
"""
"""
self._InP2In = OpenRTM_aist.InPort("InP2", self._d_InP2)
self._d_OutP1 = OpenRTM_aist.instantiateDataType(RTC.TimedInt)
"""
"""
self._OutP1Out = OpenRTM_aist.OutPort("OutP1", self._d_OutP1)
self._d_OutP2 = OpenRTM_aist.instantiateDataType(RTC.TimedFloat)
"""
"""
self._OutP2Out = OpenRTM_aist.OutPort("OutP2", self._d_OutP2)
"""
"""
self._svPortPort = OpenRTM_aist.CorbaPort("svPort")
"""
"""
self._cmPortPort = OpenRTM_aist.CorbaPort("cmPort")
"""
"""
self._acc = MyService_i()
"""
"""
self._rate = OpenRTM_aist.CorbaConsumer(
interfaceType=_GlobalIDL.DAQService)
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_vel_out = OpenRTM_aist.instantiateDataType(RTC.TimedVelocity2D)
"""
"""
self._vel_outIn = OpenRTM_aist.InPort("vel_out", self._d_vel_out)
self._d_vel_in = OpenRTM_aist.instantiateDataType(RTC.TimedVelocity2D)
"""
"""
self._vel_inOut = OpenRTM_aist.OutPort("vel_in", self._d_vel_in)
"""
"""
self._gameStateSwitcherPort = OpenRTM_aist.CorbaPort("gameStateSwitcher")
"""
"""
self._colorSwitcherPort = OpenRTM_aist.CorbaPort("colorSwitcher")
"""
"""
self._gameStateSwitcherService = OpenRTM_aist.CorbaConsumer(interfaceType=KanamuraRobotics.VelocitySwitcherService)
"""
"""
self._colorSwitcherService = OpenRTM_aist.CorbaConsumer(interfaceType=KanamuraRobotics.VelocitySwitcherService)
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_stringdata = OpenRTM_aist.instantiateDataType(RTC.TimedString)
"""
"""
self._stringoutIn = OpenRTM_aist.InPort("stringout",
self._d_stringdata)
"""
"""
self._speechmanagePort = OpenRTM_aist.CorbaPort("speechmanage")
"""
"""
self._actionmanagePort = OpenRTM_aist.CorbaPort("actionmanage")
"""
"""
self._interactivemanagePort = OpenRTM_aist.CorbaPort(
"interactivemanage")
"""
"""
self._LiftermanagePort = OpenRTM_aist.CorbaPort("Liftermanage")
"""
"""
self._ActionManageRequire = ActionManage_i()
"""
"""
self._lifterRequired = LifterPoseInterface_i()
"""
"""
self._SpeechManageProvider = OpenRTM_aist.CorbaConsumer(
interfaceType=Manage.SpeechManage)
"""
"""
self._InteractiveManageProvider = OpenRTM_aist.CorbaConsumer(
interfaceType=Manage.InteractiveManage)
def __init__(self, manager, rtc_dataports, rtc_services, rtc_params):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._dataports = rtc_dataports
self._services = rtc_services
self._params = rtc_params
#
# set dataport
for k in self._dataports.keys():
_d, _p = init_dataport(k, self._dataports)
if self._dataports[k]['direction'] == 'in':
self.__dict__['_d_' + k] = _d
self.__dict__['_' + k + 'In'] = _p
elif self._dataports[k]['direction'] == 'out':
self.__dict__['_d_' + k] = _d
self.__dict__['_' + k + 'Out'] = _p
else:
pass
# set service port
for k in self._services.keys():
if self._services[k]['direction'] == 'provider':
self.__dict__['_' + k + 'Port'] = OpenRTM_aist.CorbaPort(k)
self.__dict__['_' + k +
'_service'] = self._services[k]['impl']()
elif self._services[k]['direction'] == 'consumer':
self.__dict__['_' + k + 'Port'] = OpenRTM_aist.CorbaPort(k)
self.__dict__['_' + k +
'_service'] = OpenRTM_aist.CorbaConsumer(
interfaceType=self._services[k]['if_type'])
# initialize of configuration-data.
for x in init_params(self._params):
self.__dict__['_' + x[0]] = [x[1]]
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_camera = OpenRTM_aist.instantiateDataType(Img.CameraImage)
"""
"""
self._cameraOut = OpenRTM_aist.OutPort("camera", self._d_camera)
"""
"""
self._manipCommonPort = OpenRTM_aist.CorbaPort("manipCommon")
"""
"""
self._manipMiddlePort = OpenRTM_aist.CorbaPort("manipMiddle")
"""
"""
self._pickerPort = OpenRTM_aist.CorbaPort("picker")
"""
"""
self._manipCommon = ManipulatorCommonInterface_Common_i()
"""
"""
self._manipMiddle = ManipulatorCommonInterface_Middle_i()
"""
"""
self._TidyUpManager = OpenRTM_aist.CorbaConsumer(
interfaceType=ogata.Picker)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: debug
- DefaultValue: 1
"""
self._debug = [1]
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
camera_arg = [None] * ((len(Img._d_TimedCameraImage) - 4) / 2)
self._d_camera = Img.TimedCameraImage(*camera_arg)
"""
"""
self._cameraIn = OpenRTM_aist.InPort("camera", self._d_camera)
"""
"""
self._manipCommonPort = OpenRTM_aist.CorbaPort("manipCommon")
"""
"""
self._manipMiddlePort = OpenRTM_aist.CorbaPort("manipMiddle")
"""
"""
self._manipCommon = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM.ManipulatorCommonInterface_Common)
"""
"""
self._manipMiddle = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM.ManipulatorCommonInterface_Middle)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: debug
- DefaultValue: 1
"""
self._debug = [1]
self._model = None
"""
- Name: gripper_close_ratio
- DefaultValue: 0.1
"""
self._gripper_close_ratio = [0.1]
#self._model = None
# the position for taking a picture
self._camera_jointPos0 = [1.57076]
self._camera_jointPos1 = [0]
self._camera_jointPos2 = [1.57076]
self._camera_jointPos3 = [0]
self._camera_jointPos4 = [1.57076]
self._camera_jointPos5 = [0]
#the initial position
self._initial_jointPos0 = [1.57076]
self._initial_jointPos1 = [0]
self._initial_jointPos2 = [1.57076]
self._initial_jointPos3 = [0]
self._initial_jointPos4 = [1.57076]
self._initial_jointPos5 = [0]
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_joints = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._jointsIn = OpenRTM_aist.InPort("joints", self._d_joints)
self._d_mode = RTC.TimedOctet(RTC.Time(0, 0), 0)
self._modeIn = OpenRTM_aist.InPort("mode", self._d_mode)
self._d_status = RTC.TimedOctet(RTC.Time(0, 0), 0)
self._statusOut = OpenRTM_aist.OutPort("status", self._d_status)
self._d_out_joints = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_jointsOut = OpenRTM_aist.OutPort("out_joints",
self._d_out_joints)
self._d_out_vel = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_velOut = OpenRTM_aist.OutPort("out_vel",
self._d_out_vel)
self._d_out_trq = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_trqOut = OpenRTM_aist.OutPort("out_trq",
self._d_out_trq)
self._d_out_cur = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_curOut = OpenRTM_aist.OutPort("out_cur",
self._d_out_cur)
self._d_out_tmp = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_tmpOut = OpenRTM_aist.OutPort("out_tmp",
self._d_out_tmp)
self._d_is_moving = RTC.TimedBoolean(RTC.Time(0, 0), False)
self._is_movingOut = OpenRTM_aist.OutPort("is_moving",
self._d_is_moving)
self._commonPort = OpenRTM_aist.CorbaPort("common")
self._common = ManipulatorCommonInterface_Common_i()
self._middlePort = OpenRTM_aist.CorbaPort("middle")
self._middle = ManipulatorCommonInterface_Middle_i()
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: stub_mode
- DefaultValue: off
"""
self._stub_mode = ['off']
# </rtc-template>
self._controller = ToroboArmController.ToroboArmController()
self._monitor = ToroboArmMonitor.ToroboArmMonitor()
self._log = OpenRTM_aist.Manager.instance().getLogbuf("ToroboArmController")
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
camera_arg = [None] * ((len(Img._d_TimedCameraImage) - 4) / 2)
self._d_camera = Img.TimedCameraImage(*camera_arg)
"""
"""
self._cameraIn = OpenRTM_aist.InPort("camera", self._d_camera)
"""
"""
self._manipCommon_RPort = OpenRTM_aist.CorbaPort("manipCommon_R")
"""
"""
self._manipMiddle_RPort = OpenRTM_aist.CorbaPort("manipMiddle_R")
self._manipCommon_LPort = OpenRTM_aist.CorbaPort("manipCommon_L")
"""
"""
self._manipMiddle_LPort = OpenRTM_aist.CorbaPort("manipMiddle_L")
"""
"""
self._manipCommon_R = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM.ManipulatorCommonInterface_Common)
"""
"""
self._manipMiddle_R = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM.ManipulatorCommonInterface_Middle)
"""
"""
self._manipCommon_L = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM_LEFT.ManipulatorCommonInterface_Common)
"""
"""
self._manipMiddle_L = OpenRTM_aist.CorbaConsumer(
interfaceType=JARA_ARM_LEFT.ManipulatorCommonInterface_Middle)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: debug
- DefaultValue: 1
"""
self._debug = [1]
self._model = None
"""
- Name: gripper_close_ratio
- DefaultValue: 0.1
"""
self._gripper_close_ratio = [0.1]
self._model = None
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_Facedetectionposition = RTC.TimedDoubleSeq(RTC.Time(0, 0), "")
"""
"""
self._FacedetectionpositionIn = OpenRTM_aist.InPort(
"Facedetectionposition", self._d_Facedetectionposition)
self._d_presentationop = RTC.TimedShort(RTC.Time(0, 0), "")
"""
"""
self._presentationopOut = OpenRTM_aist.OutPort("presentationop",
self._d_presentationop)
self._d_waistmovement = RTC.TimedDouble(RTC.Time(0, 0), "")
"""
"""
self._waistmovementOut = OpenRTM_aist.OutPort("waistmovement",
self._d_waistmovement)
"""
"""
self._actionmanagePort = OpenRTM_aist.CorbaPort("actionmanage")
"""
"""
self._speechconsumerPort = OpenRTM_aist.CorbaPort("speechconsumer")
"""
"""
self._speechproviderPort = OpenRTM_aist.CorbaPort("speechprovider")
"""
"""
self._SpeechConsumerProvider = SpeechConsumer_i()
"""
"""
self._ActionManageRequire = OpenRTM_aist.CorbaConsumer(
interfaceType=Action.ActionManage)
"""
"""
self._SpeechProviderRequire = OpenRTM_aist.CorbaConsumer(
interfaceType=Provider.SpeechProvider)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: PresentationMode
- DefaultValue: OneSet
"""
self._PresentationMode = ['OneSet']
"""
- Name: PresemtationData
- DefaultValue: data.csv
"""
self._PresemtationData = ['data.csv']
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_mode = RTC.TimedOctet(RTC.Time(0, 0), 0)
self._modeIn = OpenRTM_aist.InPort("mode", self._d_mode)
self._d_in_joint = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._in_jointIn = OpenRTM_aist.InPort("in_joint", self._d_in_joint)
self._d_in_pose = RTC.TimedPose3D(
RTC.Time(0, 0),
RTC.Pose3D(RTC.Point3D(0, 0, 0), RTC.Orientation3D(0, 0, 0)))
self._in_poseIn = OpenRTM_aist.InPort("in_pose", self._d_in_pose)
self._d_grip = RTC.TimedOctet(RTC.Time(0, 0), 0)
self._gripIn = OpenRTM_aist.InPort("grip", self._d_grip)
self._d_out_joint = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._out_jointOut = OpenRTM_aist.OutPort("out_joint",
self._d_out_joint)
self._d_out_pose = RTC.TimedPose3D(
RTC.Time(0, 0),
RTC.Pose3D(RTC.Point3D(0, 0, 0), RTC.Orientation3D(0, 0, 0)))
self._out_poseOut = OpenRTM_aist.OutPort("out_pose", self._d_out_pose)
self._d_is_moving = RTC.TimedBoolean(RTC.Time(0, 0), False)
self._is_movingOut = OpenRTM_aist.OutPort("is_moving",
self._d_is_moving)
self._d_force = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._forceOut = OpenRTM_aist.OutPort("force", self._d_force)
self._middlePort = OpenRTM_aist.CorbaPort("middle")
self._commonPort = OpenRTM_aist.CorbaPort("common")
self._middle = ManipulatorCommonInterface_Middle_i()
self._common = ManipulatorCommonInterface_Common_i()
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: ip_address
- DefaultValue: 192.168.1.101
"""
self._ip_address = ['192.168.1.101']
# </rtc-template>
self._controller = None
instance = OpenRTM_aist.Manager.instance()
self._log = instance.getLogbuf("URRobotController")
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._MySVPro0Port = OpenRTM_aist.CorbaPort("MySVPro0")
"""
"""
self._MySVPro1Port = OpenRTM_aist.CorbaPort("MySVPro1")
"""
"""
self._myservice0 = MyService_i()
"""
"""
self._myservice = MyService_i()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_out = RTC.TimedLong(RTC.Time(0, 0), 0)
self._outOut = OpenRTM_aist.OutPort("out", self._d_out)
self._servicePort_provided = OpenRTM_aist.CorbaPort("service")
self._Service_provided = Test_i()
self._d_topic_out = RTC.TimedLong(RTC.Time(0, 0), 0)
self._topic_outOut = OpenRTM_aist.OutPort("topic_out",
self._d_topic_out)
self._topic_servicePort_provided = OpenRTM_aist.CorbaPort(
"topic_service")
self._topic_Service_provided = Test_i()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_Instruction = RTC.TimedString(RTC.Time(0, 0), 0)
"""
"""
self._InstructionIn = OpenRTM_aist.InPort("Instruction",
self._d_Instruction)
self._d_LEDState = RTC.TimedChar(RTC.Time(0, 0), 0)
"""
"""
self._LEDStateIn = OpenRTM_aist.InPort("LEDState", self._d_LEDState)
self._d_Speechout = RTC.TimedString(RTC.Time(0, 0), 0)
"""
"""
self._SpeechoutOut = OpenRTM_aist.OutPort("Speechout",
self._d_Speechout)
self._d_IRSignal = RTC.TimedLongSeq(RTC.Time(0, 0), [])
"""
"""
self._IRSignalOut = OpenRTM_aist.OutPort("IRSignal", self._d_IRSignal)
"""
"""
self._ModelPort = OpenRTM_aist.CorbaPort("Model")
"""
"""
self._ModelAcceptor = OpenRTM_aist.CorbaConsumer(
interfaceType=_GlobalIDL.AcceptModelService)
def createProviderPort(self, name, if_name, type_name, impl_class):
self._ProviderPort[name] = OpenRTM_aist.CorbaPort(name)
service = impl_class()
service._seat = self
self._ProviderPort[name].registerProvider(if_name, type_name, service)
self.addPort(self._ProviderPort[name])
return RTC_OK
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._MyServiceProviderPort = OpenRTM_aist.CorbaPort(
"MyServiceProvider")
"""
"""
self._MyServiceRequirePort = OpenRTM_aist.CorbaPort("MyServiceRequire")
"""
"""
self._MyServiceProvider = MyServiceChild_i()
"""
"""
self._MyServiceRequire = OpenRTM_aist.CorbaConsumer(
interfaceType=_GlobalIDL.MyServiceChild)
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
self._d_cameraImage = OpenRTM_aist.instantiateDataType(Img.TimedCameraImage)
"""
"""
self._cameraImageIn = OpenRTM_aist.InPort("cameraImage", self._d_cameraImage)
self._d_color = OpenRTM_aist.instantiateDataType(RTC.TimedLong)
"""
"""
self._colorOut = OpenRTM_aist.OutPort("color", self._d_color)
"""
"""
self._colorSwitcherPort = OpenRTM_aist.CorbaPort("colorSwitcher")
"""
"""
self._colorSwitcherService = OpenRTM_aist.CorbaConsumer(interfaceType=KanamuraRobotics.VelocitySwitcherService)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
- Name: team_color
- DefaultValue: red
"""
self._team_color = ["red"]
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._DataBasePort = OpenRTM_aist.CorbaPort("DataBase")
"""
"""
self._database = OpenRTM_aist.CorbaConsumer(
interfaceType=DataBase.mDataBase)
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
# </rtc-template>
self._d_m_in = RTC.TimedString(RTC.Time(0, 0), 0)
self._m_inIn = OpenRTM_aist.InPort("in", self._d_m_in)
self._d_m_out = RTC.TimedStringSeq(RTC.Time(0, 0), 0)
self._m_outOut = OpenRTM_aist.OutPort("out", self._d_m_out)
self.DataBase_Name = ["None"]
self.Table_Name = ["None"]
self.row_out = ["None"]
self.row_in = ["None"]
self.OutPortDataType = ["TimedStringSeq"]
self.InPortDataType = ["TimedString"]
self.conditional = ["="]
self.currentOutPortDataType = "TimedStringSeq"
self.currentInPortDataType = "TimedString"
self.DSName = "None"
def onInitialize(self):
self._d_dp_vIn = RTC.TimedFloat(RTC.Time(0, 0), 0)
self._d_dp_vSeqIn = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._InIn = OpenRTM_aist.InPort(
"in", self._d_dp_vIn, OpenRTM_aist.RingBuffer(8))
self._SeqInIn = OpenRTM_aist.InPort(
"seqin", self._d_dp_vSeqIn, OpenRTM_aist.RingBuffer(8))
# Set InPort buffers
self.addInPort("in", self._InIn)
self.addInPort("seqin", self._SeqInIn)
# Set OutPort buffers
self._MyServicePort = OpenRTM_aist.CorbaPort("MyService")
#self._myservice0_var = MyService_i()
# initialization of Provider
self._myservice0_var = MyServiceSVC_impl()
# Set service provider to Ports
self._MyServicePort.registerProvider(
"myservice0", "MyService", self._myservice0_var)
# Set CORBA Service Ports
self.addPort(self._MyServicePort)
return RTC.RTC_OK
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._servicePort = OpenRTM_aist.CorbaPort("service")
"""
"""
self._interface = Echo_i()
# initialize of configuration-data.
# <rtc-template block="init_conf_param">
"""
起動直後にonInitialize関数から別プロセスにCORBA通信により通知を行うためのIOR
文字列
- Name: ior_str ior_str
- DefaultValue: 0
"""
self._ior_str = ['0']
"""
0：onExecute関数では何もしない
1：onExecute関数内で10000回の矩形当たり判定を行う
- Name: exe_enable exe_enable
- DefaultValue: 0
"""
self._exe_enable = [0]
"""
onExecute関数呼び出し回数。設定回数を超えるとエラーに遷移。
- Name: max_count max_count
- DefaultValue: 1000
"""
self._max_count = [1000]
def onInitialize(self):
self._d_dp_vOut = RTC.TimedFloat(RTC.Time(0, 0), 0)
self._d_dp_vSeqOut = RTC.TimedFloatSeq(RTC.Time(0, 0), [])
self._OutOut = OpenRTM_aist.OutPort("out", self._d_dp_vOut,
OpenRTM_aist.RingBuffer(8))
self._SeqOutOut = OpenRTM_aist.OutPort("seqout", self._d_dp_vSeqOut,
OpenRTM_aist.RingBuffer(8))
# Set OutPort buffers
self.addOutPort("out", self._OutOut)
self.addOutPort("seqout", self._SeqOutOut)
self._MyServicePort = OpenRTM_aist.CorbaPort("MyService")
self._myservice0_var = OpenRTM_aist.CorbaConsumer(
interfaceType=AutoTest.MyService)
# Set service consumers to Ports
self._MyServicePort.registerConsumer("myservice0", "MyService",
self._myservice0_var)
# Set CORBA Service Ports
self.addPort(self._MyServicePort)
return RTC.RTC_OK
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._sv_namePort = OpenRTM_aist.CorbaPort("sv_name")
"""
"""
self._if_name = MyService_i()
def createConsumerPort(self, name, if_name, type_name, if_type):
self._ConsumerPort[name] = OpenRTM_aist.CorbaPort(name)
self._consumer[name] = OpenRTM_aist.CorbaConsumer(
interfaceType=if_type)
self._ConsumerPort[name].registerConsumer(if_name, type_name,
self._consumer[name])
self.addPort(self._ConsumerPort[name])
return RTC_OK
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._servicePort = OpenRTM_aist.CorbaPort("service")
"""
"""
self._sampleinterface = SampleInterface_i()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._sV1Port = OpenRTM_aist.CorbaPort("sV1")
"""
"""
self._sIFv = ComFk_i()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._switcherTestPort = OpenRTM_aist.CorbaPort("switcherTest")
"""
"""
self._switcherTestService = VelocitySwitcherService_i()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._sv_namePort = OpenRTM_aist.CorbaPort("sv_name")
"""
"""
self._if_name = OpenRTM_aist.CorbaConsumer(interfaceType=SimpleService.MyService)
def setUp(self):
self.manager = OpenRTM_aist.Manager.init(sys.argv)
#self.manager.setModuleInitProc(MyModuleInit)
self.manager.activateManager()
self._servicePort_provided = OpenRTM_aist.CorbaPort("service")
self._testService_provided = Test_i()
self._servicePort_required = OpenRTM_aist.CorbaPort("service")
self._testService_required = OpenRTM_aist.CorbaConsumer(
interfaceType=OpenRTM.InPortCdr)
self._servicePort_provided.registerProvider("service", "TestService",
self._testService_provided)
self._servicePort_required.registerConsumer("service", "TestService",
self._testService_required)
self._servicePort_provided.activateInterfaces()
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._rtcconfPort = OpenRTM_aist.CorbaPort("rtcconf")
"""
"""
self._rtcconf = OpenRTM_aist.CorbaConsumer(
interfaceType=RTCConfData.ConfDataInterface)
def __init__(self, manager):
OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
"""
"""
self._switcherTestPort = OpenRTM_aist.CorbaPort("switcherTest")
"""
"""
self._switcherTestService = OpenRTM_aist.CorbaConsumer(
interfaceType=KanamuraRobotics.VelocitySwitcherService)
