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
