# Create a client to use the protocol encoder
client = Pyload.Client(protocol)
# Connect!
transport.open()
print "Login", client.login(user, passwd)
bench(client.getServerVersion)
bench(client.statusServer)
bench(client.statusDownloads)
# bench(client.getQueue)
# bench(client.getCollector)
print
print client.getServerVersion()
print client.statusServer()
print client.statusDownloads()
q = client.getQueue()
for p in q:
data = client.getPackageData(p.pid)
print data
print "Package Name: ", data.name
# Close!
transport.close()
except Thrift.TException, tx:
print 'ThriftExpection: %s' % tx.message
# Create a client to use the protocol encoder
client = Pyload.Client(protocol)
# Connect!
transport.open()
print "Login", client.login(user, passwd)
bench(client.getServerVersion)
bench(client.statusServer)
bench(client.statusDownloads)
#bench(client.getQueue)
#bench(client.getCollector)
print
print client.getServerVersion()
print client.statusServer()
print client.statusDownloads()
q = client.getQueue()
for p in q:
data = client.getPackageData(p.pid)
print data
print "Package Name: ", data.name
# Close!
transport.close()
except Thrift.TException, tx:
print 'ThriftExpection: %s' % tx.message
#!/usr/bin/python
# -*- coding: UTF-8 -*-
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#|R|a|s|p|b|e|r|r|y|P|i|.|c|o|m|.|t|w|
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
# Copyright (c) 2018, raspberrypi.com.tw
# All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# test_lora_send.py
# The simple test program for lora module to send file
#
# Author : sosorry
# Date : 10/03/2017
#
from Logger import Logger
from Socket import Socket
from LoRa import LoRa
rn = LoRa("RN2483")
socket=Socket(rn)
fd=socket.open("lena8rgb.jpg")
ack=socket.send_syn(fd)
while ack == True:
ack = socket.send_data(fd)
socket.close()
class DepthInfo(QObject):
"""
*DepthInfo* class for firing system driver
"""
def __init__(self, port="/dev/ttyUSB0", baudrate=38400):
"""
:param port:
:param baudrate: Baud rate, 115200 by default (can be 9600-115200)
"""
self.port = port
self.baudrate = baudrate
self.conn = None
self.initialized = False
self.configured = False
# Create TransformStamped message
self.transf = geometry_msgs.msg.TransformStamped()
self.transf.header.frame_id = 'world'
self.transf.child_frame_id = 'sonar'
# Initialize values to publish
self.transf.transform.translation.x = 0
self.transf.transform.translation.y = 0
self.transf.transform.translation.z = 0
self.transf.transform.rotation.x = 0.0
self.transf.transform.rotation.y = 0.0
self.transf.transform.rotation.z = 0.0
self.transf.transform.rotation.w = 1.0
self.tfbroad = tf2_ros.TransformBroadcaster()
def __enter__(self):
"""
Initializes for first use
"""
self.open()
srv = Server(WinchConfig, self.config_callback)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
Cleans up
:param exc_type:
:param exc_val:
:param exc_tb:
:return:
"""
self.close()
rospy.loginfo("Closed depth reader on %s", self.port)
def open(self):
"""
Initializes connection
:return:
"""
# Initialize the port
if not self.conn:
try:
self.conn = Socket(port=self.port, baudrate=self.baudrate)
self.conn.conn.open()
except OSError as e:
raise SonarNotFound(self.port, e)
rospy.loginfo("Initializing connection with depth board on %s",
self.port)
self.initialized = True
#self.read()
def close(self):
self.conn.close()
def config_callback(self, config, level):
rospy.loginfo(
"""Reconfigure request: {winch_port_baudrate}, {winch_port}""".
format(**config))
self.set_params(**config)
return config
def set_params(self,
winch_port_baudrate=None,
winch_port=None,
groups=None):
self.port = winch_port
self.baudrate = winch_port_baudrate
self.close()
self.conn = None
self.open()
#self.read()
return self
def send(self, message=None):
self.conn.send(message)
rospy.logdebug('%s sent', message)
def read(self):
"""
Receives information form port
:return:
"""
# send here something to verify sonar is connected?
if not self.initialized:
raise SonarNotConfigured(self.initialized)
# Timeout count
timeout_count = 0
MAX_TIMEOUT_COUNT = 5
# Scan until stopped
self.preempted = False
while not self.preempted:
# Preempt on ROS shutdown
if rospy.is_shutdown():
self.preempt()
return
# Get the scan data
try:
data = self.get(wait=1)
self.transf.header.stamp = rospy.Time.now()
self.transf.transform.translation.z = data
self.tfbroad.sendTransform(self.transf)
timeout_count = 0
except TimeoutError:
timeout_count += 1
rospy.logdebug("Timeout count: %d", timeout_count)
if timeout_count >= MAX_TIMEOUT_COUNT:
timeout_count = 0
rospy.sleep(0.5)
# Try again
continue
def get(self, wait=2):
"""
Sends command and returns reply
:param message: Message to expect
:param wait: Seconds to wait until received
:return:
"""
# Verify if sonar is initialized
if not self.initialized:
raise SonarNotConfigured
#rospy.logdebug("Waiting for depth message")
# Determine end time
end = datetime.datetime.now() + datetime.timedelta(seconds=wait)
# Wait until received
while datetime.datetime.now() < end:
try:
reply = self.conn.conn.read(4)
inhex = int(reply.encode('hex'), 16)
return inhex
except:
break
# Timeout
rospy.logerr("Timed out before receiving depth message")
raise TimeoutError()
def preempt(self):
"""
Preempts the process
:return:
"""
rospy.logwarn("Preempting depth reader process...")
self.preempted = True
class Firing_Sys(object):
"""
*Firing_Sys* class for firing system driver
"""
def __init__(self, port="/dev/ttyUSB0", baudrate=115200):
"""
:param port:
:param baudrate: Baud rate, 115200 by default (can be 9600-115200)
"""
self.port = port
self.baudrate = baudrate
self.conn = None
self.initialized = False
self.configured = False
self.range = 0
self.max_range = 0
self.min_range = 0
def __enter__(self):
"""
Initializes for first use
"""
self.open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
Cleans up
:param exc_type:
:param exc_val:
:param exc_tb:
:return:
"""
self.close()
rospy.loginfo("Closed firing mechanism on %s", self.port)
def open(self):
"""
Initializes sonar connection
:return:
"""
# Initialize the port
if not self.conn:
try:
self.conn = Socket(self.port, self.baudrate)
except OSError as e:
raise SonarNotFound(self.port, e)
rospy.loginfo("Initializing connection with firing mechanism on %s",
self.port)
self.initialized = True
self.read()
def close(self):
self.conn.close()
def send(self, message=None):
self.conn.send(message)
rospy.logdebug('%s sent', message)
def read(self):
"""
Receives information form port
:return:
"""
# send here something to verify sonar is connected?
if not self.initialized:
raise SonarNotConfigured(self.initialized)
# Timeout count
timeout_count = 0
MAX_TIMEOUT_COUNT = 5
# Scan until stopped
self.preempted = False
while not self.preempted:
# Preempt on ROS shutdown
if rospy.is_shutdown():
self.preempt()
return
# Get the scan data
try:
data = self.get('AFS', wait=1).payload
self.range = float(data)
timeout_count = 0
except TimeoutError:
timeout_count += 1
rospy.logdebug("Timeout count: %d", timeout_count)
if timeout_count >= MAX_TIMEOUT_COUNT:
timeout_count = 0
# Try again
continue
def get(self, message=None, wait=2):
"""
Sends command and returns reply
:param message: Message to expect
:param wait: Seconds to wait until received
:return:
"""
# Verify if sonar is initialized
if not self.initialized:
raise SonarNotConfigured
rospy.logdebug("Waiting for limit switches state message")
# Determine end time
end = datetime.datetime.now() + datetime.timedelta(seconds=wait)
# Wait until received
while datetime.datetime.now() < end:
try:
reply = self.conn.get_reply(expected_reply=message,
enabled=True)
return reply
except:
break
# Timeout
rospy.logerr("Timed out before receiving limit switches message")
raise TimeoutError()
def preempt(self):
"""
Preempts the process
:return:
"""
rospy.logwarn("Preempting fixing process...")
self.preempted = True
class StreamReader :
def __init__(self) :
self._server = None
self._capturedDevice = None
pass
def connect(self, addr = '127.0.0.1', port = 4242) :
try:
self._server = Socket()
statusCode = self._server.connect_ex((addr, port))
if statusCode != 0 :
raise statusCode
except :
self.connectLocalCamera()
def connectLocalCamera(self) :
self.close()
qem = QErrorMessage()
qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера')
qem.exec()
self._capturedDevice = cv2.VideoCapture(0)
def releseLocalCamera(self) :
self._capturedDevice.relese()
self._capturedDevice = None
def __del__(self) :
self.close()
def getFrame(self) :
if self._server is not None :
try:
return self._getFrameFromRemoteCamera()
except:
self.connectLocalCamera()
if self._capturedDevice is not None :
try:
return self._getFrameFromLocalCamera()
except:
raise CannotReadFrame
raise CannotReadFrame
def _getFrameFromRemoteCamera(self) :
self._server.sendObject('get_frame')
frame = self._server.recvObject()
return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
def _getFrameFromLocalCamera(self) :
retVal, frame = self._capturedDevice.read()
if retVal == False :
raise CannotReadFrame
return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
def readable(self) :
#заглушка
return True
def recvall(self, sock, size) :
binary = sock.recv(size)
diff = size - len(binary)
while diff :
buf = sock.recv(diff)
diff = diff - len(buf)
binary = binary + buf
return binary
def close(self) :
if self._capturedDevice is not None :
self._capturedDevice.release()
self._capturedDevice = None
if self._server is not None :
try:
#self._server.sendObject('close_conection')
self._server.sendObject('exit')
self._server.close()
except:
pass
finally:
self._server = None
