def __init__(self,*args,**kwargs):
if 'debug' in kwargs:
self.debug = kwargs['debug']
else:
kwargs.update({'debug': DEBUG})
self.debug = DEBUG
if 'baudrate' not in kwargs:
kwargs.update({'baudrate': BAUDRATE})
elif (kwargs['baudrate'] is None) or (str(kwargs['baudrate']).lower() == 'default'):
kwargs.update({'baudrate': BAUDRATE})
if 'timeout' not in kwargs:
kwargs.update({'timeout': self._TIMEOUT})
if 'write_write_delay' not in kwargs:
kwargs.update({'write_write_delay': self._WRITE_WRITE_DELAY})
if ('port' not in kwargs) or (kwargs['port'] is None):
err_string = 'Specify port.\n'
raise RuntimeError(err_string)
else:
self.port = kwargs['port']
t_start = time.time()
self._serial_device = SerialInterface(*args,**kwargs)
atexit.register(self._exit_mettler_toledo_device)
time.sleep(self._RESET_DELAY)
t_end = time.time()
self._debug_print('Initialization time =', (t_end - t_start))
def connectDevice(self):
if not self.iface:
self.iface = self.ifaces[self.listDevices.currentRow()]
if self.iface:
if not self.iface.isConnected():
self.iface = SerialInterface(self.port, self.baud)
self.iface.connectToArduino()
if not self.iface.serial_conn.isOpen():
self.iface.serial_conn.open()
if self.iface.isConnected():
if self.iface_thread:
del self.iface_thread
self.iface_thread = SerialThread(self.iface)
self.iface_thread.n_samples = 1000
self.iface_thread.gotSamples[tuple, int].connect(
self.plotWindow.plotSamples)
#self.iface_thread.deviceDisconnected.connect(self.disconnectFromCurrentDevice)
self.startSampling()
return True
return False
def __init__(self, server_com_port, baudrate):
# Setup serial interface.
self._serial_interface = SerialInterface(server_com_port, baudrate, 50)
self._serial_interface.set_read_callback(self._on_serial_read)
# The byte parser analyses the byte string from the sensor
# and divides it into individual sentences.
self._byte_parser = ByteParser()
self._current_sentence = bytearray()
# If set, all raw data from serial port will be stored to this file.
self._log_file = None
# Locks
#self._ack_lock = threading.Condition()
self._wait_for_sentence_lock = threading.Condition()
self._wait_for_sentence_type = None
self._wait_for_sentence_data = None
# Callbacks for NMEA sentences.
self._GGA_cb = None
self._RMC_cb = None
self._GSV_cb = None
self._GST_cb = None
# Callbacks for ASCII sentences.
self._BESTPOS_cb = None
self._BESTVEL_cb = None
self._TIME_cb = None
self._PSRDOP_cb = None
# Special callbacks.
self._reset_cb = None
# GSV information is sometimes split up into multiple sentences.
# Need to gather all informations before calling callback.
self._GSV_data = None
# Total number of sentences until the GSV data we are currently
# waiting for is complete
self._received_GSV_sentences = 0
def run(self):
while True:
for port in self.ports:
if port in self.found: continue
try:
serial = SerialInterface(port, 115200)
serial.connectToArduino()
if serial.isConnected():
serial.serial_conn.timeout = 0.2 # read timeout of 200 millisecond
samples = serial.getSamples(20)
if samples:
serial.serial_conn.timeout = None
self.foundDevice.emit(port, serial)
self.found.append(port)
else:
serial.disconnect()
except Exception, e:
#print port, e
continue
finally:
if serial.isConnected() and not port in self.found:
import serial
import socketio
import struct
import eventlet
from serial_interface import SerialInterface
# If no params reply with G
# TIME OUT SET TO NONE SO when reading, will only read once done.
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=None)
sio = socketio.Server()
app = socketio.WSGIApp(sio)
thread = None
PORT = 5000
serial_interface = SerialInterface(ser, sio)
@sio.on('connect')
def connect(sid, message):
global thread
global serial_interface
print('connected')
if thread == None:
thread = sio.start_background_task(target=serial_interface.background_process)
def set_params_to_send(sid, params):
parameter_names = [
"mode",
"fiO2",
"peep",
"inspiratoryPressure",
from serial_interface import SerialInterface
PORT_NAME = '/dev/panachrome'
BAUD_RATE = 115200
# Set this variable to "threading", "eventlet" or "gevent" to test the
# different async modes, or leave it set to None for the application to choose
# the best option based on installed packages.
async_mode = None
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode=async_mode)
thread = None
serial_port = SerialInterface()
def serial_event(data):
"""
Data received form the serial port
"""
if data:
socketio.emit('rx_data', {'data': data}, namespace='/test')
def serial_listener():
"""
Continuously poll the serial port, replies from the controller
"""
import wx
import thread
import time
import Queue
from Tkinter import Tk, Canvas, Frame, BOTH
from serial_interface import SerialInterface
ser = SerialInterface("/dev/ttyUSB0")
packets = Queue.Queue()
commands = Queue.Queue()
root = Tk()
# FE FE E0 94 27 00 00 02 11
# 3D 41 3E 39 40 47 4B 3D 32 3A 3E 34 31 40 3B 4D 4A 48 38 3A 43 52 4D 38 2C
# 33 3D 3C 2E 24 40 33 25 11 31 3C 3E 3F 33 2D 48 5E 6D 5E 3B 27 41 3C 42 47 FD
def task():
canvas.delete("all")
root.after(1000, task)
#print "frame"
while (not packets.empty()):
pkt = packets.get()
print(' '.join("{:02X}".format(ord(i)) for i in pkt))
if (pkt[0:4] == "\xfe\xe0\x94\x27"):
if pkt[6] != chr(0x01):
a = pkt.split(chr(0x11))[1]
values = [ord(i) for i in a]
def setUp(self):
# Create instance
self.serial_interface = SerialInterface("test")
# Start
self.serial_interface.start()
import sys
import error
#sds python libraries
sys.path.append('..\libraries')
from logger import _print, _print_bytes, APP, ERROR, WARNING, DEBUG
from serial_interface import SerialInterface
SERIAL_PREAMBLE = b'\xee'
SERIAL_TRAILER = b'\x0a\x0d'
g_serial = SerialInterface()
class SerialPacket:
"""
Serial Packet Structure:
Serial Preamble
Notification Length
Notification Data
Trailer
"""
def __init__(self):
self.bytes = None
def set(self, _bytes):
#calculate length of remaining bytes
length = len(_bytes)
length_hex = length.to_bytes(1, byteorder='little')
