def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) #self._d_cam_in = OpenRTM_aist.instantiateDataType(Img.CameraImage) self._d_cam_in = RTC.CameraImage(RTC.Time(0,0),0,0,0,"", 0.0,[]) """ """ self._cam_inIn = OpenRTM_aist.InPort("cam_in", self._d_cam_in) self._d_result = OpenRTM_aist.instantiateDataType(RTC.TimedLong) """ """ self._resultOut = OpenRTM_aist.OutPort("result", self._d_result) # initialize of configuration-data. # <rtc-template block="init_conf_param"> """ - Name: modelname - DefaultValue: None """ self._modelname = ['applebanana']
def setUp(self): OpenRTM_aist.Manager.instance() self._buffer = BufferMock() self._ipn = InPort("in", RTC.TimedLong(RTC.Time(0, 0), 0), self._buffer) self._connector = ConnectorMock(self._buffer) self._ipn._connectors = [self._connector]
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0, 0), 0) self._outport = OpenRTM_aist.CSPOutPort("out", self._data) # Set OutPort buffer self.addOutPort("out", self._outport) return RTC.RTC_OK
def test_OnRead(self): self._connector.write(RTC.TimedLong(RTC.Time(0, 0), 456)) self._ipn.setOnRead(OnRWTest().echo) self._ipn.setOnReadConvert(OnRWConvertTest().echo) read_data = self._ipn.read() self.assertEqual(read_data.data, 456) return
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0,0),0) self._outport = OpenRTM_aist.OutPort("out", self._data) # Set OutPort buffer self.addOutPort("out", self._outport) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_WRITE, DataListener("ON_BUFFER_WRITE")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_FULL, DataListener("ON_BUFFER_FULL")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_WRITE_TIMEOUT, DataListener("ON_BUFFER_WRITE_TIMEOUT")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_OVERWRITE, DataListener("ON_BUFFER_OVERWRITE")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_READ, DataListener("ON_BUFFER_READ")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_SEND, DataListener("ON_SEND")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVED, DataListener("ON_RECEIVED")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_FULL, DataListener("ON_RECEIVER_FULL")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_TIMEOUT, DataListener("ON_RECEIVER_TIMEOUT")) self._outport.addConnectorDataListener(OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVER_ERROR, DataListener("ON_RECEIVER_ERROR")) self._outport.addConnectorListener(OpenRTM_aist.ConnectorListenerType.ON_CONNECT, ConnListener("ON_CONNECT")) self._outport.addConnectorListener(OpenRTM_aist.ConnectorListenerType.ON_DISCONNECT, ConnListener("ON_DISCONNECT")) return RTC.RTC_OK
def onExecute(self, ec_id): # 前進指定 print "Front" self._d_Vel.data = RTC.Velocity2D(0.2, 0.0, 0.0) self._VelOut.write() time.sleep(1) # 停止指定 print "Stop" self._d_Vel.data = RTC.Velocity2D(0.0, 0.0, 0.0) self._VelOut.write() time.sleep(1) # 後退指定 print "Back" self._d_Vel.data = RTC.Velocity2D(-0.2, 0.0, 0.0) self._VelOut.write() time.sleep(1) # 右旋回指定 print "roll" self._d_Vel.data = RTC.Velocity2D(0.0, 0.0, -5) self._VelOut.write() time.sleep(1) return RTC.RTC_OK
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) data_arg0 = [None] * ((len(RTC._d_TimedString) - 4) / 2) self._d_w_data = RTC.TimedString(*data_arg0) """ """ self._writeDataIn = OpenRTM_aist.InPort("writeData", self._d_w_data) data_arg1 = [None] * ((len(RTC._d_TimedString) - 4) / 2) self._d_r_data = RTC.TimedString(*data_arg1) """ """ self._readDataOut = OpenRTM_aist.OutPort("readData", self._d_r_data) # initialize of configuration-data. # <rtc-template block="init_conf_param"> """ - Name: key - DefaultValue: nao_memory """ self._insert_key = ['nao_memory_from_RTM'] self._extract_key = [''] self._ipaddress = ['192.168.252.116'] self._port = [9559]
def test_put(self): self._con = ConnectorMock(self._buffer) self._prov._connector = self._con self._prov.setBuffer(self._buffer) data = RTC.TimedLong(RTC.Time(0, 0), 123) cdr = cdrMarshal(any.to_any(data).typecode(), data, 1) self._prov.write(cdr) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) self.assertEqual(self._prov.put(), OpenRTM.PORT_OK) val = [] self.assertEqual(self._buffer.read(val), OpenRTM_aist.BufferStatus.BUFFER_OK) get_data = cdrUnmarshal(any.to_any(data).typecode(), val[0], 1) self.assertEqual(get_data.data, 123) return
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._data = RTC.TimedString(RTC.Time(0, 0), "") self._outport = OpenRTM_aist.OutPort("out", self._data) self.wordList = ["これは", "OpenOffice Writer", "を操作するRTCです"] self.count = 0
def __call__(self, info, cdrdata): guard = OpenRTM_aist.ScopedLock(self._mutex) if self.start_flag: data = OpenRTM_aist.ConnectorDataListenerT.__call__( self, info, cdrdata, RTC.TimedVelocity2D(RTC.Time(0, 0), RTC.Velocity2D(0, 0, 0))) tm = time.time() dt = tm - self.tm self.tm = tm if dt < 0.5: lx = data.data.vx * dt self.px = self.px + lx * math.cos(self.rot) self.py = self.py + lx * math.sin(self.rot) self.rot = self.rot + data.data.va * dt #print(self.px,self.py,self.rot) else: self.tm = time.time() self.start_flag = True del guard
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 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 setUp(self): self.queue = multiprocessing.Queue() sys.argv.extend(['-o', 'manager.preload.modules:SSLTransport.py']) sys.argv.extend(['-o', 'manager.modules.load_path:./,../']) sys.argv.extend( ['-o', 'corba.ssl.certificate_authority_file:root.crt']) sys.argv.extend(['-o', 'corba.ssl.key_file:server.pem']) sys.argv.extend(['-o', 'corba.ssl.key_file_password:password']) os.environ['ORBsslVerifyMode'] = "none" self.outport_process = multiprocessing.Process(target=RunOutPort, args=(self.queue, )) self.outport_process.start() time.sleep(1) os.environ['ORBtraceLevel'] = '25' self.manager = OpenRTM_aist.Manager.init(sys.argv) self.manager.activateManager() self._d_in = RTC.TimedLong(RTC.Time(0, 0), 0) self._inIn = OpenRTM_aist.InPort("in", self._d_in) prop = OpenRTM_aist.Properties() self._inIn.init(prop) self.inport_obj = self._inIn.getPortRef() orb = self.manager.getORB() #outport_name = "corbaloc:iiop:localhost:2810/test" outport_name = "corbaname::localhost:2809/NameService#test" oobj = orb.string_to_object(outport_name) self.outport_obj = oobj._narrow(RTC.PortService)
def __init__(self): self._rtobj = None self._profile = None self._fsmState = "" structure = """ <scxml xmlns=\"http://www.w3.org/2005/07/scxml\ version=\"1.0\" initial=\"airline-ticket\"> <state id=\"state0\"> <datamodel> <data id=\"data0\"> </data> </datamodel> <transition event=\"toggle\" target=\"state1\" /> </state> <state id=\"state1\"> <datamodel>" <data id=\"data1\"> </data> </datamodel> <transition event=\"toggle\" target=\"state0\" /> </state> </scxml> """ event_profile = RTC.FsmEventProfile("toggle", "TimedShort") nv = OpenRTM_aist.NVUtil.newNV("fsm_structure.format", "scxml") self._fsmStructure = RTC.FsmStructure("dummy_name", "", [event_profile], [nv])
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0, 0), 0) self._inport = OpenRTM_aist.CSPInPort("in", self._data) # Set InPort buffer self.addInPort("in", self._inport) return RTC.RTC_OK
def RunOutPort(q): argv = sys.argv[:] #argv.extend(['-o', 'corba.endpoint::2810']) manager = OpenRTM_aist.Manager.init(argv) manager.activateManager() _d_out = RTC.TimedLong(RTC.Time(0, 0), 0) _outOut = OpenRTM_aist.OutPort("out", _d_out) prop = OpenRTM_aist.Properties() _outOut.init(prop) """orb = manager.getORB() poa = orb.resolve_initial_references("omniINSPOA") poa._get_the_POAManager().activate() id = "test" poa.activate_object_with_id(id, _outOut)""" manager._namingManager.bindPortObject("test", _outOut) q.get() _d_out.data = 100 _outOut.write() q.get() manager.shutdown()
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 __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)
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._d_in = RTC.TimedBoolean(RTC.Time(0, 0), 0) """ """ self._inIn = OpenRTM_aist.InPort("in", self._d_in)
def setUp(self): InPortCorbaCdrConsumerInit() self._cons = OpenRTM_aist.InPortConsumerFactory.instance( ).createObject("corba_cdr") self._inp = OpenRTM_aist.InPort("in", RTC.TimedLong(RTC.Time(0, 0), 0)) self._orb = OpenRTM_aist.Manager.instance().getORB() return
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._d_frame = ssr.Frame(0, 0, [], []) self._d_vel = RTC.TimedVelocity2D(RTC.Time(0, 0), RTC.Velocity2D(0, 0, 0)) """ """ self._frameIn = OpenRTM_aist.InPort("frame", self._d_frame) self._velOut = OpenRTM_aist.OutPort("vel", self._d_vel) #circle = ssr.CircleGesture(0, 0, 0, ssr.Vector(0,0,0), ssr.Vector(0,0,0), 0) #swipe = ssr.SwipeGesture(0, ssr.Vector(0, 0,0 ), 0) #key = ssr.KeyTapGesture(0, ssr.Vector(0, 0, 0), ssr.Vector(0, 0, 0)) #screen = ssr.ScreenTapGesture(0, ssr.Vector(0, 0, 0), ssr.Vector(0, 0, 0)) #self._d_gesture = ssr.GestureFrame(0, 0, ssr.TYPE_INVALID, circle, swipe, key, screen) """ """ #self._gestureIn = OpenRTM_aist.InPort("gesture", self._d_gesture) # initialize of configuration-data. # <rtc-template block="init_conf_param"> """ - Name: debug - DefaultValue: 0 """ self._debug = [0]
def mainFunc(): try: startTime = time.time() monitorTime = startTime + logFileTime resBuffer = [] client.write_register(address=85, value=0, unit=1) while client.connect(): result = client.read_holding_registers(address=85,count=1,unit=1) decoder = BinaryPayloadDecoder.fromRegisters(result.registers, Endian.Big, wordorder=Endian.Little) startSignal = decoder.decode_16bit_int() currentTime = time.time() if startSignal == 1: result = client.read_holding_registers(address=100,count=70,unit=1) resBuffer.append(result.registers) result = client.read_holding_registers(address=100+70,count=70,unit=1) resBuffer.append(result.registers) client.write_register(address=85, value=0, unit=1) startSignal = 0 if currentTime >= monitorTime: result = client.read_holding_registers(address=87,count=1,unit=1) decoder = BinaryPayloadDecoder.fromRegisters(result.registers, Endian.Big, wordorder=Endian.Little) TimeMes = decoder.decode_16bit_int() name = input("Enter the File Name: ") if name == '': name = "Reading" filename = "{2}-{3} {0} {1}.csv".format(name,str(RTC.RTC().date()),str(RTC.RTC().hour),str(RTC.RTC().minute)) ex_jalvis = excel.excel_edit(filepath,filename) ex_headers=['Date','ms','Weight'] ex_jalvis.write_excel_header(ex_headers) fltBuffer = [] for i in range(len(resBuffer)): for z in range(0,70,2): decoder = BinaryPayloadDecoder.fromRegisters(resBuffer[i][z:z+3], Endian.Big, wordorder=Endian.Little) fltBuffer.append(decoder.decode_32bit_float()) TempSingleSampleTime = 0 SingleSampleTime = 0 for o in range(len(fltBuffer)): TempSingleSampleTime = SingleSampleTime + TempSingleSampleTime SingleSampleTime = TimeMes/len(fltBuffer) ex_data=[RTC.RTC().date(),TempSingleSampleTime,fltBuffer[o]] # print(ex_data) ex_headers=['Date','ms','Weight'] ex_jalvis.append_excel(ex_data,ex_headers) break feedBack = "Log successfull." print("Close tnhe graph window for next reading!\n thank you.") plt.figure(num="Graph", figsize=(13, 6), edgecolor='red', facecolor='grey', frameon =True) plt.plot([i*SingleSampleTime for i in range(len(fltBuffer))],fltBuffer) plt.xlabel('Time in ms') plt.ylabel('Weight in g') plt.title('Load cell Graph') plt.yscale('linear') plt.axis([0, TimeMes, minWeight, maxWeight]) # plt.yticks([yVal for yVal in range(0,maxWeight,int(maxWeight/20))],rotation=0) plt.grid(True) plt.show() return feedBack except: feedBack = "Log Fail. Check Plc Communication." return feedBack
def test_write(self): wdata = RTC.TimedLong(RTC.Time(0, 0), 123) self._oc.write(wdata) val = self._buffer.read() rdata = RTC.TimedLong(RTC.Time(0, 0), 0) get_data = cdrUnmarshal(any.to_any(rdata).typecode(), val, 1) self.assertEqual(get_data.data, 123) return
def __call__(self, info, cdrdata): data = OpenRTM_aist.ConnectorDataListenerT.__call__( self, info, cdrdata, RTC.TimedLong(RTC.Time(0, 0), 0)) print "------------------------------" print "Listener: ", self._name print "------------------------------" self._data = data return
def onInitialize(self): self._data = RTC.TimedLong(RTC.Time(0, 0), 0) self._inport = OpenRTM_aist.InPort('in', self._data) self.addInPort('in', self._inport) self.bindParameter('param', self._param, "0") if os.path.exists(self._df): os.remove(self._df) return RTC.RTC_OK
def _output_pose(self): # output pose information pose = self._controller.getl() self._log.RTC_DEBUG("out_pose: " + str(pose)) self._d_out_pose.data = RTC.Pose3D( RTC.Point3D(pose[0], pose[1], pose[2]), RTC.Orientation3D(pose[3], pose[4], pose[5])) self._out_poseOut.write()
def test_OnWrite(self): self._connector = ConnectorMock() self._op._connectors = [self._connector] self._op.setOnWrite(OnRWTest().echo) self._op.setOnWriteConvert(OnRWConvertTest().echo) self.assertEqual(self._op.write(RTC.TimedLong(RTC.Time(0, 0), 123)), True) return
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._d_image = RTC.CameraImage(RTC.Time(0, 0), 0, 0, 0, [], 0, []) self._imageIn = OpenRTM_aist.InPort("image", self._d_image) self._d_sensor = RTC.TimedShortSeq(RTC.Time(0, 0), []) self._sensorIn = OpenRTM_aist.InPort("sensor", self._d_sensor)
def onInitialize(self): self._in_data = RTC.TimedLong(RTC.Time(0, 0), 0) self._inport = OpenRTM_aist.InPort('in', self._in_data) self.addInPort('in', self._inport) self._out_data = RTC.TimedLong(RTC.Time(0, 0), 0) self._outport = OpenRTM_aist.OutPort('out', self._out_data) self.addOutPort('out', self._outport) return RTC.RTC_OK
def onActivated(self, ec_id): self.buttons = [False] * 11 self.accel = RTC.AngularAcceleration3D(0, 0, 0) self.orientation = RTC.Orientation3D(0, 0, 0) self.cursor = RTC.Point2D(0, 0) self.distance = 0 self.ir = RTC.Point2D(0, 0) return RTC.RTC_OK