def onDeactivated(self, ec_id): """ The deactivated action (Active state exit action) former rtc_active_exit() \param ec_id target ExecutionContext Id \return RTC::ReturnCode_t """ # Servo Motor: Torque OFF self._d_on_off.data = [0, self.servo_id, 0] OpenRTM_aist.setTimestamp(self._d_on_off) self._on_offOut.write() # URG: Measurement stop self._d_urg.data = [0] OpenRTM_aist.setTimestamp(self._d_urg) self._urgOut.write() print('onDeactivated') return RTC.RTC_OK
def onExecute(self, ec_id): """ The execution action that is invoked periodically former rtc_active_do() \param ec_id target ExecutionContext Id \return RTC::ReturnCode_t """ if self._commandIn.isNew(): self._d_command = self._commandIn.read() if self._d_command.data[0] == 2: self.cw_angle = self._d_command.data[1] self.ccw_angle = self._d_command.data[2] self.move_time = self._d_command.data[3] # Servo: Moving CW self._d_motion.data = [0, self.servo_id, self.servo_offset + self.ccw_angle, self.move_time_ccw] OpenRTM_aist.setTimestamp(self._d_motion) self._motionOut.write() time.sleep(self.move_time_ccw / 100.0 + self.margin_time / 1000.0) # Servo: Moving CCW self._d_motion.data = [0, self.servo_id, self.servo_offset + self.cw_angle, self.move_time_cw] OpenRTM_aist.setTimestamp(self._d_motion) self._motionOut.write() time.sleep(self.move_time_cw / 100.0 + self.margin_time / 1000.0) return RTC.RTC_OK
def initConsumers(self): self._rtcout.RTC_TRACE("initConsumers()") # create OuPort consumers factory = OpenRTM_aist.OutPortConsumerFactory.instance() consumer_types = factory.getIdentifiers() self._rtcout.RTC_DEBUG("available consumers: %s", OpenRTM_aist.flatten(consumer_types)) if self._properties.hasKey("consumer_types") and \ OpenRTM_aist.normalize(self._properties.getProperty("consumer_types")) != "all": self._rtcout.RTC_DEBUG("allowed consumers: %s", self._properties.getProperty("consumer_types")) temp_types = consumer_types consumer_types = [] active_types = OpenRTM_aist.split(self._properties.getProperty("consumer_types"), ",") temp_types.sort() active_types.sort() set_ctypes = set(temp_types).intersection(set(active_types)) consumer_types = consumer_types + list(set_ctypes) # OutPortConsumer supports "pull" dataflow type if len(consumer_types) > 0: self._rtcout.RTC_PARANOID("dataflow_type pull is supported") self.appendProperty("dataport.dataflow_type", "pull") self.appendProperty("dataport.interface_type", OpenRTM_aist.flatten(consumer_types)) self._consumerTypes = consumer_types return
def initProviders(self): self._rtcout.RTC_TRACE("initProviders()") # create InPort providers factory = OpenRTM_aist.InPortProviderFactory.instance() provider_types = factory.getIdentifiers() self._rtcout.RTC_DEBUG("available providers: %s", OpenRTM_aist.flatten(provider_types)) if self._properties.hasKey("provider_types") and \ OpenRTM_aist.normalize(self._properties.getProperty("provider_types")) != "all": self._rtcout.RTC_DEBUG("allowed providers: %s", self._properties.getProperty("provider_types")) temp_types = provider_types provider_types = [] active_types = OpenRTM_aist.split(self._properties.getProperty("provider_types"), ",") temp_types.sort() active_types.sort() set_ptypes = set(temp_types).intersection(set(active_types)) provider_types = provider_types + list(set_ptypes) # InPortProvider supports "push" dataflow type if len(provider_types) > 0: self._rtcout.RTC_DEBUG("dataflow_type push is supported") self.appendProperty("dataport.dataflow_type", "push") self.appendProperty("dataport.interface_type", OpenRTM_aist.flatten(provider_types)) self._providerTypes = provider_types return
def createProvider(self, cprof, prop): if not prop.getProperty("interface_type") and \ not OpenRTM_aist.includes(self._providerTypes, prop.getProperty("interface_type")): self._rtcout.RTC_ERROR("no provider found") self._rtcout.RTC_DEBUG("interface_type: %s", prop.getProperty("interface_type")) self._rtcout.RTC_DEBUG("interface_types: %s", OpenRTM_aist.flatten(self._providerTypes)) return 0 self._rtcout.RTC_DEBUG("interface_type: %s", prop.getProperty("interface_type")) provider = OpenRTM_aist.InPortProviderFactory.instance().createObject(prop.getProperty("interface_type")) if provider != 0: self._rtcout.RTC_DEBUG("provider created") provider.init(prop.getNode("provider")) if not provider.publishInterface(cprof.properties): self._rtcout.RTC_ERROR("publishing interface information error") OpenRTM_aist.InPortProviderFactory.instance().deleteObject(provider) return 0 return provider self._rtcout.RTC_ERROR("provider creation failed") return 0
def onExecute(self, ec_id): print "Please input number: ", self._data.data = long(sys.stdin.readline()) OpenRTM_aist.setTimestamp(self._data) print "Sending to subscriber: ", self._data.data self._outport.write() return RTC.RTC_OK
def onExecute(self, ec_id): #データを新規に受信した場合に、データをm_last_sensor_dataを格納する if self._distance_sensorIn.isNew(): data = self._distance_sensorIn.read() if len(data.data) == 4: self._last_sensor_data = data.data[:] #センサの計測値がstop_distance以上の時に前進しないようにする if self._forward_velocity[0] > 0: for d in self._last_sensor_data: if d > self._stop_distance[0]: self._d_target_velocity.data.vx = 0 self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = 0 OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write() return RTC.RTC_OK #コンフィギュレーションパラメータで設定した速度を送信する self._d_target_velocity.data.vx = self._forward_velocity[0] self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = self._rotate_velocity[0] OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write() return RTC.RTC_OK
def load(self, file_name, init_func=None): if not self._rtcout: self._rtcout = self._mgr.getLogbuf("ModuleManager") self._rtcout.RTC_TRACE("load(fname = %s)", file_name) if file_name == "": raise ModuleManager.InvalidArguments, "Invalid file name." if OpenRTM_aist.isURL(file_name): if not self._downloadAllowed: raise ModuleManager.NotAllowedOperation, "Downloading module is not allowed." else: raise ModuleManager.NotFound, "Not implemented." import_name = os.path.split(file_name)[-1] pathChanged=False file_path = None if OpenRTM_aist.isAbsolutePath(file_name): if not self._absoluteAllowed: raise ModuleManager.NotAllowedOperation, "Absolute path is not allowed" else: splitted_name = os.path.split(file_name) save_path = sys.path[:] sys.path.append(splitted_name[0]) pathChanged = True import_name = splitted_name[-1] file_path = file_name else: file_path = self.findFile(file_name, self._loadPath) if not file_path: raise ModuleManager.InvalidArguments, "Invalid file name." if not self.fileExist(file_path): raise ModuleManager.FileNotFound, file_name if not pathChanged: splitted_name = os.path.split(file_path) sys.path.append(splitted_name[0]) ext_pos = import_name.find(".py") if ext_pos > 0: import_name = import_name[:ext_pos] mo = __import__(str(import_name)) if pathChanged: sys.path = save_path dll = self.DLLEntity(mo,OpenRTM_aist.Properties()) dll.properties.setProperty("file_path",file_path) self._modules.registerObject(dll) if init_func is None: return file_name self.symbol(file_path,init_func)(self._mgr) return file_name
def updateExportedPortsList(self): plist = self._rtobj.getProperties().getProperty("conf.default.exported_ports") if plist: p = [plist] OpenRTM_aist.eraseBlank(p) self._expPorts = p[0].split(",") return
def onExecute(self, ec_id): #self._data.data = "Guten tag" #self._data.data = "Einen schönen Tag." self._data.data = "Ich habe Zwillinge, Danke, Danke." OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) return RTC.RTC_OK
def __call__(self, info, cdrdata): data = OpenRTM_aist.ConnectorDataListenerT.__call__(self, info, cdrdata, RTC.TimedFloatSeq(RTC.Time(0,0),[])) if len(data.data) >= 2: self._out.data.vx = data.data[1] * self._velocity_by_position[0] self._out.data.vy = 0 self._out.data.va = data.data[0] * self._rotation_by_position[0] OpenRTM_aist.setTimestamp(self._out) self._outOut.write()
def onDeactivated(self, ec_id): #停止する self._d_target_velocity.data.vx = 0 self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = 0 OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write() return RTC.RTC_OK
def onExecute(self, ec_id): sys.stdin.readline() OpenRTM_aist.setTimestamp(self._data) self._data.data = "Base" self._outport.write() return RTC.RTC_OK
def send_data(self, data): if len(data) == 4: self.motion_data = data elif len(data) == 3: print('Servo ON/OFF: %s' % data) self._d_on_off.data = data OpenRTM_aist.setTimestamp(self._d_on_off) self._on_offOut.write()
def onExecute(self, ec_id): self._data.data = "good morning" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) self._data.data = "good afternoon" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) return RTC.RTC_OK
def onExecute(self, ec_id): self._data.data = "guten morgen" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) self._data.data = "guten tag" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) return RTC.RTC_OK
def onExecute(self, ec_id): self._data.data = "おはよう" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) self._data.data = "こんにちは" OpenRTM_aist.setTimestamp(self._data) self._outport.write() time.sleep(5) return RTC.RTC_OK
def onCreate(self, obj): self._num += 1 pos = 0 try: pos = self.find(None) self._objects[pos] = obj return OpenRTM_aist.otos(pos) except NumberingPolicy.ObjectNotFound: self._objects.append(obj) return OpenRTM_aist.otos(int(len(self._objects) - 1))
def test_addRemoveSdoServiceConsumer(self): import MySdoServiceConsumer OpenRTM_aist.Manager.instance().load("MySdoServiceConsumer.py", "MySdoServiceConsumerInit") rtobj = TestComp(self._orb, self._poa) prof = SDOPackage.ServiceProfile(OpenRTM_aist.toTypename(OpenRTM.ComponentObserver),OpenRTM_aist.toTypename(OpenRTM.ComponentObserver), [OpenRTM_aist.NVUtil.newNV("test","any")], SDOPackage.SDOService._nil) self.assertEqual(rtobj.addSdoServiceConsumer(prof),True) self.assertEqual(rtobj.removeSdoServiceConsumer(OpenRTM_aist.toTypename(OpenRTM.ComponentObserver)),True) return
def createTask(self, prop): factory = OpenRTM_aist.PeriodicTaskFactory.instance() th = factory.getIdentifiers() self._rtcout.RTC_DEBUG("available task types: %s", OpenRTM_aist.flatten(th)) self._task = factory.createObject(prop.getProperty("thread_type", "default")) if not self._task: self._rtcout.RTC_ERROR("Task creation failed: %s", prop.getProperty("thread_type", "default")) return self.INVALID_ARGS self._rtcout.RTC_PARANOID("Task creation succeeded.") # setting task function self._task.setTask(self.svc) # Task execution rate rate = prop.getProperty("publisher.push_rate") if rate != "": hz = float(rate) if hz == 0: hz = 1000.0 self._rtcout.RTC_DEBUG("Task period %f [Hz]", hz) else: hz = 1000.0 self._task.setPeriod(1.0/hz) # Measurement setting mprop = prop.getNode("measurement") self._task.executionMeasure(OpenRTM_aist.toBool(mprop.getProperty("exec_time"), "enable", "disable", True)) ecount = [0] if OpenRTM_aist.stringTo(ecount, mprop.getProperty("exec_count")): self._task.executionMeasureCount(ecount[0]) self._task.periodicMeasure(OpenRTM_aist.toBool(mprop.getProperty("period_time"), "enable", "disable", True)) pcount = [0] if OpenRTM_aist.stringTo(pcount, mprop.getProperty("period_count")): self._task.periodicMeasureCount(pcount[0]) # Start task in suspended mode self._task.suspend() self._task.activate() self._task.suspend() return self.PORT_OK
def move_initial(self, grip, order = [3, 2, 1]): data = [] pos = self.ik.calc_ik(140, 0, 50) data.append([0, order[0], pos[order[0] - 1], self.move_time]) data.append([0, order[1], pos[order[1] - 1], self.move_time]) data.append([0, order[2], pos[order[2] - 1], self.move_time]) data.append([0, 4, grip + int(self.ik.calb_4), self.move_time]) for temp in data: self._d_motion.data = temp OpenRTM_aist.setTimestamp(self._d_motion) self._motionOut.write() time.sleep(self.move_time / 100.0)
def onExecute(self, ec_id): for i in range(self._intnum): pname = "intport%s" % (i,) self._intdata[pname].data = randint(1, 10) OpenRTM_aist.setTimestamp(self._intdata[pname]) self._intports[pname].write(self._intdata[pname]) if randint(1, 10) > 3: self._strdata.data = "normal" else: self._strdata.data = "emergency" OpenRTM_aist.setTimestamp(self._strdata) self._strport.write(self._strdata) return RTC.RTC_OK
def onDeactivated(self, ec_id): #停止する self._d_velocity_out.data.vx = 0 self._d_velocity_out.data.vy = 0 self._d_velocity_out.data.va = 0 OpenRTM_aist.setTimestamp(self._d_velocity_out) self._velocity_outOut.write() #ブザーを止める self._d_buzzer.data = 0 OpenRTM_aist.setTimestamp(self._d_buzzer) self._buzzerOut.write() return RTC.RTC_OK
def onExecute(self, ec_id): if self._StringInport.isNew(): data = self._StringInport.read() ans = data.data w_ans = data.data.decode(self.InputCode[0]) if self.InputCode[0] != self.OutputCode[0]: ans = w_ans.encode(self.OutputCode[0]) self._StringOutdata.data = ans OpenRTM_aist.setTimestamp(self._StringOutdata) self._StringOutport.write() self._WStringOutdata.data = w_ans OpenRTM_aist.setTimestamp(self._WStringOutdata) self._WStringOutport.write() if self._WStringInport.isNew(): data = self._WStringInport.read() ans = data.data.encode(self.OutputCode[0]) w_ans = data.data self._StringOutdata.data = ans OpenRTM_aist.setTimestamp(self._StringOutdata) self._StringOutport.write() self._WStringOutdata.data = w_ans OpenRTM_aist.setTimestamp(self._WStringOutdata) self._WStringOutport.write() return RTC.RTC_OK
def __call__(self, info, cdrdata, data): endian = info.properties.getProperty("serializer.cdr.endian","little") if endian is not "little" and endian is not None: endian = OpenRTM_aist.split(endian, ",") # Maybe endian is ["little","big"] endian = OpenRTM_aist.normalize(endian) # Maybe self._endian is "little" or "big" if endian == "little": endian = True elif endian == "big": endian = False else: endian = True _data = cdrUnmarshal(any.to_any(data).typecode(), cdrdata, endian) return _data
def __initLength(self, prop): if prop.getProperty("length"): n = [0] if OpenRTM_aist.stringTo(n, prop.getProperty("length")): n = n[0] if n > 0: self.length(n)
def __init__(self, name, data_type): OpenRTM_aist.PortBase.__init__(self,name) self._rtcout.RTC_DEBUG("Port name: %s", name) self._rtcout.RTC_DEBUG("setting port.port_type: DataOutPort") self.addProperty("port.port_type", "DataOutPort") self._rtcout.RTC_DEBUG("setting dataport.data_type: %s", data_type) self.addProperty("dataport.data_type", data_type) # publisher list factory = OpenRTM_aist.PublisherFactory.instance() pubs = OpenRTM_aist.flatten(factory.getIdentifiers()) # blank characters are deleted for RTSE's bug pubs = pubs.lstrip() self._rtcout.RTC_DEBUG("available subscription_type: %s", pubs) self.addProperty("dataport.subscription_type", pubs) self._properties = OpenRTM_aist.Properties() self._name = name self._connectors = [] self._consumers = [] self._providerTypes = "" self._consumerTypes = "" self._connector_mutex = threading.RLock() self._listeners = OpenRTM_aist.ConnectorListeners()
def getConnectorNames(self): names = [] for con in self._connectors: names.append(con.name()) self._rtcout.RTC_TRACE("getConnectorNames(): %s", OpenRTM_aist.flatten(names)) return names
def main(): orb = CORBA.ORB_init(sys.argv) poa = orb.resolve_initial_references("RootPOA") poa._get_the_POAManager().activate() naming = OpenRTM_aist.CorbaNaming(orb, "localhost") servant = ComponentObserver_i() oid = poa.servant_to_id(servant) provider = poa.id_to_reference(oid) rtc = naming.resolve("ConsoleIn0.rtc")._narrow(RTC.RTObject) config = rtc.get_configuration() properties = [OpenRTM_aist.NVUtil.newNV("heartbeat.enable","YES"), OpenRTM_aist.NVUtil.newNV("heartbeat.interval","10"), OpenRTM_aist.NVUtil.newNV("observed_status","ALL")] id = OpenRTM_aist.toTypename(servant) sprof = SDOPackage.ServiceProfile("test_id", id, properties, provider) ret = config.add_service_profile(sprof) flag = True print "If you exit program, please input 'q'." sys.stdin.readline() ret = config.remove_service_profile("test_id") print "test program end. ret : ", ret return
def update(self): self._rtcout.RTC_TRACE("NamingManager::update()") guard = OpenRTM_aist.ScopedLock(self._namesMutex) rebind = OpenRTM_aist.toBool(self._manager.getConfig().getProperty("naming.update.rebind"), "YES","NO",False) for i in range(len(self._names)): if self._names[i].ns is None: self._rtcout.RTC_DEBUG("Retrying connection to %s/%s", (self._names[i].method, self._names[i].nsname)) self.retryConnection(self._names[i]) else: try: if rebind: self.bindCompsTo(self._names[i].ns) if not self._names[i].ns.isAlive(): self._rtcout.RTC_INFO("Name server: %s (%s) disappeared.", (self._names[i].nsname, self._names[i].method)) del self._names[i].ns self._names[i].ns = None except: self._rtcout.RTC_INFO("Name server: %s (%s) disappeared.", (self._names[i].nsname, self._names[i].method)) del self._names[i].ns self._names[i].ns = None return
def ConvertToVelInit(manager): profile = OpenRTM_aist.Properties(defaults_str=converttovel_spec) manager.registerFactory(profile, ConvertToVel, OpenRTM_aist.Delete)
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.TimedLong) """ """ 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 CompInit(manager): profile = OpenRTM_aist.Properties(defaults_str=comp_spec) manager.registerFactory(profile, MPComp, OpenRTM_aist.Delete)
def RACDTimerControllerTestInit(manager): profile = OpenRTM_aist.Properties( defaults_str=racdtimercontrollertest_spec) manager.registerFactory(profile, RACDTimerControllerTest, OpenRTM_aist.Delete)
def AizuRoboInit(manager): profile = OpenRTM_aist.Properties(defaults_str=aizurobo_spec) manager.registerFactory(profile, AizuRobo, OpenRTM_aist.Delete)
def ListRecursive(context, rtclist, name, oParent, oTreeDataModel): m_blLength = 100 bl = context.list(m_blLength) cont = True while cont: for i in bl[0]: if i.binding_type == CosNaming.ncontext: next_context = context.resolve(i.binding_name) name_buff = name[:] name.append(i.binding_name[0].id) if oTreeDataModel == None: oChild = None else: oChild = oTreeDataModel.createNode(i.binding_name[0].id, False) oParent.appendChild(oChild) ListRecursive(next_context, rtclist, name, oChild, oTreeDataModel) name = name_buff elif i.binding_type == CosNaming.nobject: if oTreeDataModel == None: oChild = None else: oChild = oTreeDataModel.createNode(i.binding_name[0].id, False) oParent.appendChild(oChild) if len(rtclist) > m_blLength: break if i.binding_name[0].kind == 'rtc': name_buff = name[:] name_buff.append(i.binding_name[0].id) tkm = OpenRTM_aist.CorbaConsumer() tkm.setObject(context.resolve(i.binding_name)) inobj = tkm.getObject()._narrow(RTC.RTObject) try: pin = inobj.get_ports() for p in pin: name_buff2 = name_buff[:] profile = p.get_port_profile() #props = nvlist_to_dict(profile.properties) tp_n = profile.name.split('.')[1] name_buff2.append(tp_n) if oTreeDataModel == None: pass else: oChild_port = oTreeDataModel.createNode( tp_n, False) oChild.appendChild(oChild_port) rtclist.append([name_buff2, p]) except: pass else: pass if CORBA.is_nil(bl[1]): cont = False else: bl = i.next_n(m_blLength)
def test_init(self): _pn = PublisherNew() prop = OpenRTM_aist.Properties() # Propertiesが空の状態でも正常に動作することを確認する ret = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, ret) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","new") prop.setProperty("thread_type","bar") prop.setProperty("measurement.exec_time","default") prop.setProperty("measurement.period_count","1") #thread_type が不正の場合 INVALID_ARGS を返すことを確認する。 ret = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.INVALID_ARGS, ret) _pn.__del__() _pn = PublisherNew() #以下のpropertiesの設定で動作することを確認する。 prop.setProperty("publisher.push_policy","all") prop.setProperty("publisher.skip_count","0") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","enable") prop.setProperty("measurement.exec_count","0") prop.setProperty("measurement.period_time","enable") prop.setProperty("measurement.period_count","0") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","fifo") prop.setProperty("publisher.skip_count","1") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","disable") prop.setProperty("measurement.exec_count","1") prop.setProperty("measurement.period_time","disable") prop.setProperty("measurement.period_count","0") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","fifo") prop.setProperty("publisher.skip_count","1") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","disable") prop.setProperty("measurement.exec_count","1") prop.setProperty("measurement.period_time","disable") prop.setProperty("measurement.period_count","1") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","skip") prop.setProperty("publisher.skip_count","-1") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","bar") prop.setProperty("measurement.exec_count","-1") prop.setProperty("measurement.period_time","bar") prop.setProperty("measurement.period_count","-1") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","new") prop.setProperty("publisher.skip_count","1") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","enable") prop.setProperty("measurement.exec_count","1") prop.setProperty("measurement.period_time","enable") prop.setProperty("measurement.period_count","1") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() _pn = PublisherNew() prop.setProperty("publisher.push_policy","bar") prop.setProperty("publisher.skip_count","0") prop.setProperty("thread_type","default") prop.setProperty("measurement.exec_time","enable") prop.setProperty("measurement.exec_count","0") prop.setProperty("measurement.period_time","enable") prop.setProperty("measurement.period_count","0") retcode = _pn.init(prop) self.assertEqual(OpenRTM_aist.DataPortStatus.PORT_OK, retcode) _pn.__del__() return
def __init__(self): buff = OpenRTM_aist.CdrRingBuffer() prop = OpenRTM_aist.Properties() prop.setProperty("write.full_policy","do_nothing") buff.init(prop) self._buffer = buff
def test_setBuffer(self): _pn = PublisherNew() self.assertEqual(_pn.setBuffer(None),OpenRTM_aist.DataPortStatus.INVALID_ARGS) self.assertEqual(_pn.setBuffer(OpenRTM_aist.RingBuffer()),OpenRTM_aist.DataPortStatus.PORT_OK) _pn.__del__() return
def InputbuttonInit(manager): profile = OpenRTM_aist.Properties(defaults_str=inputbutton_spec) manager.registerFactory(profile, Inputbutton, OpenRTM_aist.Delete)
def NXTRTC_callbackInit(manager): profile = OpenRTM_aist.Properties(defaults_str=nxtrtc_spec) manager.registerFactory(profile, NXTRTC, OpenRTM_aist.Delete)
def moduleInit(self, manager): profile=OpenRTM_aist.Properties(defaults_str=SoarRTC_spec) manager.registerFactory(profile, SoarRTC, OpenRTM_aist.Delete) self._comp = manager.createComponent("SoarRTC?exec_cxt.periodic.rate=1")
def fooInit(manager): profile = OpenRTM_aist.Properties(defaults_str=foo_spec) manager.registerFactory(profile, foo, OpenRTM_aist.Delete)
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._d_vel = OpenRTM_aist.instantiateDataType(RTC.TimedVelocity2D) """ 前後進と左右 """ self._velIn = OpenRTM_aist.InPort("vel", self._d_vel) self._d_arm = OpenRTM_aist.instantiateDataType(RTC.TimedBoolean) """ armのopen/close """ self._armIn = OpenRTM_aist.InPort("arm", self._d_arm) self._d_camera = OpenRTM_aist.instantiateDataType(RTC.TimedBoolean) """ camera 1 or 2 """ self._cameraIn = OpenRTM_aist.InPort("camera", self._d_camera) self._d_display = OpenRTM_aist.instantiateDataType(RTC.TimedBoolean) """ 距離表示 あり or なし """ self._displayIn = OpenRTM_aist.InPort("display", self._d_display) self._d_in = OpenRTM_aist.instantiateDataType(RTC.TimedBooleanSeq) """ Joy stickからの入力 それぞれのボタンの情報がboolの配列で """ self._inOut = OpenRTM_aist.OutPort("in", self._d_in) self._d_stop = OpenRTM_aist.instantiateDataType(RTC.TimedBoolean) """ 終わったらTrueが返ってくる """ self._stopOut = OpenRTM_aist.OutPort("stop", self._d_stop) # initialize of configuration-data. # <rtc-template block="init_conf_param"> """ 移動速度 - Name: speed_x speed_x - DefaultValue: 0.1 """ self._speed_x = [0.1] """ 回転速度 - Name: speed_r speed_r - DefaultValue: 0.5 """ self._speed_r = [0.5]
def testInit(manager): profile = OpenRTM_aist.Properties(defaults_str=test_spec) manager.registerFactory(profile, test, OpenRTM_aist.Delete)
def FloatSeqToVelocityInit(manager): profile = OpenRTM_aist.Properties(defaults_str=floatseqtovelocity_spec) manager.registerFactory(profile, FloatSeqToVelocity, OpenRTM_aist.Delete)
def svc(self): self._rtcout.RTC_TRACE("svc()") count_ = 0 owner = self.getOwner() self._ownersm = self._worker.findComponent(owner) #if len(self._cpu) > 0: # ret = OpenRTM_aist.setThreadAffinity(self._cpu) # if ret == False: # self._rtcout.RTC_ERROR("CPU affinity mask setting failed") while self.threadRunning(): self._ownersm.workerPreDo() #OpenRTM_aist.ExecutionContextBase.invokeWorkerPreDo(self) # Thread will stopped when all RTCs are INACTIVE. # Therefore WorkerPreDo(updating state) have to be invoked # before stopping thread. guard = OpenRTM_aist.ScopedLock(self._workerthread._mutex) while not self._workerthread._running: self._workerthread._cond.wait() del guard t0_ = OpenRTM_aist.Time() #OpenRTM_aist.ExecutionContextBase.invokeWorkerDo(self) self._ownersm.workerDo() #OpenRTM_aist.ExecutionContextBase.invokeWorkerPostDo(self) self._ownersm.workerPostDo() for task in self._tasklist: task.signal() #time.sleep(0.1) for task in self._tasklist: task.join() #print task._task.getExecStat()._max_interval #print task._task.getExecStat()._min_interval #print task._task.getExecStat()._mean_interval #print task._task.getExecStat()._std_deviation t1_ = OpenRTM_aist.Time() period_ = self.getPeriod() if count_ > 1000: exctm_ = (t1_ - t0_).getTime().toDouble() slptm_ = period_.toDouble() - exctm_ self._rtcout.RTC_PARANOID("Period: %f [s]", period_.toDouble()) self._rtcout.RTC_PARANOID("Execution: %f [s]", exctm_) self._rtcout.RTC_PARANOID("Sleep: %f [s]", slptm_) for i in range(len(self._tasklist)): task = self._tasklist[i] stat = task.getExecStat() self._rtcout.RTC_PARANOID("MAX(%d): %f [s]", (i,stat._max_interval)) self._rtcout.RTC_PARANOID("MIN(%d): %f [s]", (i,stat._min_interval)) self._rtcout.RTC_PARANOID("MEAN(%d): %f [s]", (i,stat._mean_interval)) self._rtcout.RTC_PARANOID("SD(%d): %f [s]", (i,stat._std_deviation)) t2_ = OpenRTM_aist.Time() if not self._nowait and period_.toDouble() > ((t1_ - t0_).getTime().toDouble()): if count_ > 1000: self._rtcout.RTC_PARANOID("sleeping...") slptm_ = period_.toDouble() - (t1_ - t0_).getTime().toDouble() time.sleep(slptm_) if count_ > 1000: t3_ = OpenRTM_aist.Time() self._rtcout.RTC_PARANOID("Slept: %f [s]", (t3_ - t2_).getTime().toDouble()) count_ = 0 count_ += 1 self._rtcout.RTC_DEBUG("Thread terminated.") return 0
def get_component_object_rtc(corba_naming, rtcname): comp = OpenRTM_aist.CorbaConsumer() comp.setObject(corba_naming.resolve(rtcname)) return comp.getObject()._narrow(RTC.RTObject)
def RobotARM_RTCInit(manager): print("RobotARM init") profile = OpenRTM_aist.Properties(defaults_str=robotarm_rtc_spec) manager.registerFactory(profile, RobotARM_RTC, OpenRTM_aist.Delete)
def ConsoleOutInit(manager): profile = OpenRTM_aist.Properties(defaults_str=consoleout_spec) manager.registerFactory(profile, ConsoleOut, OpenRTM_aist.Delete)
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0, 0), 0) self._outport = OpenRTM_aist.OutPort('out', self._data) self.addOutPort('out', self._outport) self._count = 0 return RTC.RTC_OK
def ModuleNameInit(manager): profile = OpenRTM_aist.Properties(defaults_str=modulename_spec) manager.registerFactory(profile, ModuleName, OpenRTM_aist.Delete)
def RobotControllerInit(manager): profile = OpenRTM_aist.Properties(defaults_str=robotcontroller_spec) manager.registerFactory(profile, RobotController, OpenRTM_aist.Delete)
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0, 0), 0) self._inport = OpenRTM_aist.InPort("in", self._data) # Set InPort buffer self.addInPort("in", self._inport) return RTC.RTC_OK
def __init__(self): self._prop = OpenRTM_aist.Properties()
def MyModuleInit(manager): profile = OpenRTM_aist.Properties(defaults_str=consoleout_spec) manager.registerFactory(profile, ConsoleOut, OpenRTM_aist.Delete) # Create a component comp = manager.createComponent("ConsoleOut")
def AutoTestInInit(manager): profile = OpenRTM_aist.Properties(defaults_str=AutoTestIn_spec) manager.registerFactory(profile, AutoTestIn, OpenRTM_aist.Delete)
def MicrowaveInit(manager): profile = OpenRTM_aist.Properties(defaults_str=microwave_spec) manager.registerFactory(profile, Microwave, OpenRTM_aist.Delete)
def setTimestamp(data): # set timestamp tm = OpenRTM_aist.Time() data.tm.sec = tm.sec data.tm.nsec = tm.usec * 1000
def get_organization_property(self): self.__rtcout.RTC_TRACE("get_organization_property()") guard = OpenRTM_aist.ScopedLock(self._org_mutex) prop = SDOPackage.OrganizationProperty(self._orgProperty.properties) return prop