コード例 #1
0
	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
コード例 #2
0
	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
コード例 #3
0
  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
コード例 #4
0
  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
コード例 #5
0
  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
コード例 #6
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
コード例 #7
0
	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
コード例 #8
0
  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
コード例 #10
0
ファイル: ConsoleIn.py プロジェクト: SeishoIrie/OpenHRIVoice
 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
コード例 #11
0
 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()
コード例 #12
0
	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
コード例 #13
0
ファイル: TestComp.py プロジェクト: Nobu19800/OOoBaseRTC
    def onExecute(self, ec_id):
        sys.stdin.readline()

        OpenRTM_aist.setTimestamp(self._data)
        self._data.data = "Base"
        
        self._outport.write()
        
        return RTC.RTC_OK
コード例 #14
0
ファイル: RsMotion.py プロジェクト: HiroakiMatsuda/RsMotion
 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()
コード例 #15
0
 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
コード例 #16
0
 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
コード例 #17
0
ファイル: ConsoleIn.py プロジェクト: deepukr85/OpenHRIVoice
 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
コード例 #18
0
  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))
コード例 #19
0
 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
コード例 #20
0
  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
コード例 #21
0
ファイル: ArmISIK.py プロジェクト: HiroakiMatsuda/ArmISIK
	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)
コード例 #22
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
コード例 #23
0
	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
コード例 #24
0
    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
コード例 #25
0
  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
コード例 #26
0
 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)
コード例 #27
0
  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()
コード例 #28
0
  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
コード例 #30
0
  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
コード例 #31
0
ファイル: ConvertToVel.py プロジェクト: takeshimc15/Education
def ConvertToVelInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=converttovel_spec)
    manager.registerFactory(profile, ConvertToVel, OpenRTM_aist.Delete)
コード例 #32
0
	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)
コード例 #33
0
ファイル: mp1_comp.py プロジェクト: n-kawauchi/rtshell
def CompInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=comp_spec)
    manager.registerFactory(profile, MPComp, OpenRTM_aist.Delete)
コード例 #34
0
def RACDTimerControllerTestInit(manager):
    profile = OpenRTM_aist.Properties(
        defaults_str=racdtimercontrollertest_spec)
    manager.registerFactory(profile, RACDTimerControllerTest,
                            OpenRTM_aist.Delete)
コード例 #35
0
def AizuRoboInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=aizurobo_spec)
    manager.registerFactory(profile, AizuRobo, OpenRTM_aist.Delete)
コード例 #36
0
ファイル: OOoRTC.py プロジェクト: MasutaniLab/PowerPointRTCpy
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)
コード例 #37
0
 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
コード例 #38
0
 def __init__(self):
   buff = OpenRTM_aist.CdrRingBuffer()
   prop = OpenRTM_aist.Properties()
   prop.setProperty("write.full_policy","do_nothing")
   buff.init(prop)
   self._buffer = buff
コード例 #39
0
 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
コード例 #40
0
def InputbuttonInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=inputbutton_spec)
    manager.registerFactory(profile, Inputbutton, OpenRTM_aist.Delete)
コード例 #41
0
def NXTRTC_callbackInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=nxtrtc_spec)
    manager.registerFactory(profile, NXTRTC, OpenRTM_aist.Delete)
コード例 #42
0
 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")
コード例 #43
0
def fooInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=foo_spec)
    manager.registerFactory(profile,
                            foo,
                            OpenRTM_aist.Delete)
コード例 #44
0
    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]
コード例 #45
0
def testInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=test_spec)
    manager.registerFactory(profile, test, OpenRTM_aist.Delete)
コード例 #46
0
def FloatSeqToVelocityInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=floatseqtovelocity_spec)
    manager.registerFactory(profile, FloatSeqToVelocity, OpenRTM_aist.Delete)
コード例 #47
0
  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
コード例 #48
0
ファイル: myfunc.py プロジェクト: uyaponz/AirHockeyRTCs
def get_component_object_rtc(corba_naming, rtcname):
    comp = OpenRTM_aist.CorbaConsumer()
    comp.setObject(corba_naming.resolve(rtcname))
    return comp.getObject()._narrow(RTC.RTObject)
コード例 #49
0
def RobotARM_RTCInit(manager):
    print("RobotARM init")
    profile = OpenRTM_aist.Properties(defaults_str=robotarm_rtc_spec)
    manager.registerFactory(profile, RobotARM_RTC, OpenRTM_aist.Delete)
コード例 #50
0
def ConsoleOutInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=consoleout_spec)
    manager.registerFactory(profile, ConsoleOut, OpenRTM_aist.Delete)
コード例 #51
0
ファイル: output_comp.py プロジェクト: win-katami/rtshell
 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
コード例 #52
0
def ModuleNameInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=modulename_spec)
    manager.registerFactory(profile, ModuleName, OpenRTM_aist.Delete)
コード例 #53
0
def RobotControllerInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=robotcontroller_spec)
    manager.registerFactory(profile, RobotController, OpenRTM_aist.Delete)
コード例 #54
0
 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
コード例 #55
0
 def __init__(self):
     self._prop = OpenRTM_aist.Properties()
コード例 #56
0
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")
コード例 #57
0
def AutoTestInInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=AutoTestIn_spec)
    manager.registerFactory(profile, AutoTestIn, OpenRTM_aist.Delete)
コード例 #58
0
def MicrowaveInit(manager):
    profile = OpenRTM_aist.Properties(defaults_str=microwave_spec)
    manager.registerFactory(profile, Microwave, OpenRTM_aist.Delete)
コード例 #59
0
def setTimestamp(data):
  # set timestamp
  tm = OpenRTM_aist.Time()
  data.tm.sec  = tm.sec
  data.tm.nsec = tm.usec * 1000
コード例 #60
0
 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