def __init__(self, serialPortName): SerialPort.__init__(self, serialPortName) Renderer.__init__(self) #turn screen on, if needed time.sleep(0.1) self.write('screenon')
def __init__(self, serialPortName): self.serialPort = SerialPort(serialPortName) self.serialPort.startReadThread() #thresholds (reasonable defaults given) self.lickThreshold = 1000 self.tapThreshold = 1000 self.irThreshold = 100 #sensor state variables self._lick = False self._tap = False #sensor history entries are tuples of (booleanState, timestamp). self.historyLick = [] self.historyTap = [] #full sensor data, not really used except for debugging self.lickRaw = [] self.tapRaw = [] #reference to objects we need to talk to self.task = None self.tracer = None
def __init__(self, portName): self.ser = None if portName is None or portName == "None": return self.ser = SerialPort(serialPortName=portName, baudRate=57600) self.ser.startReadThread()
class AirPuff(): def __init__(self, portName): self.ser = None if portName is None or portName == "None": return self.ser = SerialPort(serialPortName=portName, baudRate=57600) self.ser.startReadThread() def puff(self): if self.ser is None: print "No air puff connected." return self.ser.write("x") def open_valve(self): if self.ser is None: print "No air puff connected." return self.ser.write("1") def close_valve(self): if self.ser is None: print "No air puff connected." return self.ser.write("0")
def portScan(self): portList = SerialPort.getDeviceList() self.main_ui.combox_serialPortList.clear() for portInfo, port in portList: self.main_ui.combox_serialPortList.addItem(portInfo, port) # default select the first one self.port = self.main_ui.combox_serialPortList.currentData() self.baudrate = self.main_ui.spinBox_baudrate.value()
def portOpen(self): if self.portOpened == False: try: self.serial = SerialPort(self.port, self.baudrate) self.portOpened = True self.main_ui.pbt_serialOpen.setText('Close') self.imageModeWindow.addSendMethod(self.serial) self.videoModeWindow.addSendMethod(self.serial) self.screenModeWindow.addSendMethod(self.serial) except Exception: print('Serial port open false.') else: try: self.serial.close() self.serial = None self.portOpened = False self.main_ui.pbt_serialOpen.setText('Open') self.imageModeWindow.addSendMethod(None) except Exception: print('Serial port close false.')
def generate_serial_obj(port_name): '''create a seiral port object and return param :port_name: serial port name , `str` ''' buffer_size = pars.get_section(port_name,"buffer_size") baudrate = pars.get_section(port_name,"baudrate") stopbits = pars.get_section(port_name,"stopbits") parity = pars.get_section(port_name,"parity") writeTimeout = pars.get_section(port_name,"writeTimeout") timeout = pars.get_section(port_name,"timeout") serial = SerialPort(port=port_name,baudrate=baudrate,stopbits=stopbits,parity=parity,writeTimeout=writeTimeout,timeout=timeout) return serial
def main(): parser = argparse.ArgumentParser(description='Test JSON packetizer', ) parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='Turn on verbose messages', default=False) parser.add_argument('--socket', dest='socket', action='store_true', help='Send data over a socket', default=False) parser.add_argument('--serial', dest='serial', help='Send data over a serial port', default=None) args = parser.parse_args(sys.argv[1:]) if args.socket: import socket from socket_port import SocketPort IP_ADDR = '127.0.0.1' IP_PORT = 7788 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((IP_ADDR, IP_PORT)) port = SocketPort(s) elif args.serial: from serial_port import SerialPort port = SerialPort(args.serial) else: print('No comms method specified') return test(port, args.verbose)
def linux_main(): import argparse default_baud = 1000000 default_port = os.getenv("BIOLOID_PORT") or '/dev/ttyUSB0' parser = argparse.ArgumentParser( prog="test", usage="%(prog)s [options] [command]", description="Send commands to bioloid devices", epilog=("You can specify the default serial port using the " + "BIOLOID_PORT environment variable.")) parser.add_argument("-b", "--baud", dest="baud", action="store", type=int, help="Set the baudrate used (default = %d)" % default_baud, default=default_baud) default_port_help = "" if default_port: default_port_help = " (default '%s')" % default_port parser.add_argument("-p", "--port", dest="port", help="Set the serial port to use" + default_port_help, default=default_port) parser.add_argument("-n", "--net", dest="net", action="store_true", help="Connect to a device using TCP/IP", default=False) parser.add_argument("-v", "--verbose", dest="verbose", action="store_true", help="Turn on verbose messages", default=False) parser.add_argument("--dummy", dest="dummy", action="store_true", help="Uses DummyPort", default=False) parser.add_argument("--show-commands", dest="show_commands", action="store_true", help="Show commands being sent/received", default=False) parser.add_argument("--show-packets", dest="show_packets", action="store_true", help="Show packets being sent/received", default=False) args = parser.parse_args(sys.argv[1:]) show = Bus.SHOW_NONE if args.show_commands: show |= Bus.SHOW_COMMANDS if args.show_packets: show |= Bus.SHOW_PACKETS if args.dummy: from dummy_port import DummyPort dev_port = DummyPort() show = Bus.SHOW_COMMANDS | Bus.SHOW_PACKETS elif args.net: import socket from socket_port import SocketPort IP_ADDR = '127.0.0.1' IP_PORT = 8888 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((IP_ADDR, IP_PORT)) dev_port = SocketPort(s) else: import serial from serial_port import SerialPort try: dev_port = SerialPort(args.port, args.baud) except serial.serialutil.SerialException: print("Unable to open port '{}'".format(port)) sys.exit() bus = Bus(dev_port, show=show) scan(bus)
import array import os import struct import sys import time from commander_rx import CommanderRx sysname = os.uname().sysname if sysname == 'Linux' or sysname == 'Darwin': import serial from serial_port import SerialPort from serial_bus import SerialBus port = '/dev/ttyUSB0' try: port = SerialPort(port, 38400) except serial.serialutil.SerialException: print("Unable to open port '{}'".format(port)) sys.exit() elif sysname == 'pyboard': from stm_uart_port import UART_Port port = UART_Port(6, 38400) else: print("Unrecognized sysname: {}".format(sysname)) sys.exit() crx = CommanderRx() while True: byte = port.read_byte()
from flask import Flask, render_template from flask_socketio import SocketIO from serial_port import SerialPort app = Flask(__name__) socketio = SocketIO(app) serialport = SerialPort() @app.route('/') def index(): return render_template('index.html') @socketio.on('open_port') def on_open_port(message): try: serialport.open(message['port'], message['baudrate']) socketio.emit('receive_data', 'Serial port is opened\n') except: socketio.emit('receive_data', 'Could not open port\n') @socketio.on('close_port') def on_close_port(message): try: if serialport.isOpen(): serialport.close() socketio.emit('receive_data', 'Serial port is closed\n') except: socketio.emit('receive_data', 'Error closing port\n') @socketio.on('send_message')
def main(self): parser = OptionParser() parser.add_option('-f', '--fake', default='False', help='Fake microbits') (options,args) = parser.parse_args() print('options:{} args: {}'.format(options, args)) if options.fake: print('Fake microbit option detected') # serial = open_serial_port() Microbit_Serial_Port = SerialPort() serial_port = Microbit_Serial_Port.get_serial_port() print('serial_port: {}'.format(serial_port)) if not serial_port: system_exit('microbit not found connected to a serial port') # df_dict is a dict of pandas DataFrames, one for each microbit self.df_dict = self.create_df_dict() microbits = [a for a in sorted(self.df_dict.keys())] print('microbit id\'s: {}'.format(microbits)) old_time = datetime.now() while (1): # have base station act as controller and poll each of the sensor microbits now_time = datetime.now() # time_delta = now_time - old_time # old_time = now_time # print(time_delta.total_seconds()) # print(text_all_scan(df_dict)) for mb_id in microbits: # poll each microbit in turn by transmitting their id self.poll_microbit(mb_id, serial_port) # scan = '' # requested data, now wait for data, then read data # This sleep command controls the frequency of data collection. sleep(SCAN_DELAY) # logging.info('polling: {}'.format(mb_id)) read_bytes = Microbit_Serial_Port.get_serial_data(serial_port) # logging.info('poll: {} read_bytes: {}'.format(mb_id, read_bytes)) if not read_bytes: logging.info('*** {} no read_bytes mb_id: {}'.format(self.now_time(), mb_id)) continue try: scan = self.get_single_scan(read_bytes) except (TypeError, ValueError, AttributeError) as e: logging.info('get_single_scan error: {}'.format(e)) scan = self.create_blank_scan(mb_id) if len(scan.split(',')) != len(SCAN_COL_NAMES)+2: logging.info('*** short scan: {} mb_id: {} read_bytes: {}'.format( scan, mb_id, read_bytes)) continue df_scan = self.create_df_scan(scan, now_time) if df_scan.empty: logging.info('*** failed to create df_scan') continue # get microbit id from scan ident = 'mb_{}'.format(df_scan['id'].values[0]) # check_for_duplicate_counts(df_scan, df_dict[ident]) logging.info('{} scan: {} polled: {} received: {}'.format( self.now_time(), scan, mb_id, ident)) self.df_dict[ident] = self.update_df_dict(df_scan, self.df_dict[ident])
def portScan(self): portList = SerialPort.getDeviceList() self.main_ui.combox_serialPortList.clear() for portInfo, port in portList: self.main_ui.combox_serialPortList.addItem(portInfo, port)
class MainWindow(object): def __init__(self): # setup window self.window = QMainWindow() self.main_ui = Ui_mainWindow() self.main_ui.setupUi(self.window) self.main_ui.retranslateUi(self.window) self.imageModeWindow = ImageModeWindow(self.window, self.main_ui) self.videoModeWindow = VideoModeWindow(self.window, self.main_ui) self.screenModeWindow = ScreenModeWindow(self.window, self.main_ui) # BW image to bytes instance self.image_to_bw = BWImageToBytes() # image processing self.image_translator = ImageTranslate() self.image_translator.start() self.connectSignal() # show window self.window.show() def connectSignal(self): # connect serial port widgets self.main_ui.pbt_scanSerialPort.clicked.connect(self.portScan) self.main_ui.combox_serialPortList.activated.connect(self.portSelect) self.main_ui.pbt_serialOpen.clicked.connect(self.portOpen) self.portOpened = False # connect display setting self.main_ui.spinBox_displayRow.valueChanged.connect(self.displayColumnRowSetting) self.main_ui.spinBox_displayCol.valueChanged.connect(self.displayColumnRowSetting) self.main_ui.checkBox_displayFlipH.clicked.connect(self.displayFlipModeSetting) self.main_ui.checkBox_displayFlipV.clicked.connect(self.displayFlipModeSetting) self.main_ui.comboBox_displayScanDirection.activated.connect(self.displayScanDirectionSetting) self.main_ui.comboBox_displayByteDirection.activated.connect(self.displayByteDirectionSetting) self.main_ui.comboBox_displaySignBit.activated.connect(self.displaySignBitSetting) self.displaySettingInit() # connect binarization setting self.main_ui.radioButton_binarizationThreshold.clicked.connect(self.binarizationSetting) self.main_ui.radioButton_binarizationDither.clicked.connect(self.binarizationSetting) self.main_ui.comboBox_ditherBayerSize.activated.connect(self.binarizationSetting) self.binarizationSetting() def portScan(self): portList = SerialPort.getDeviceList() self.main_ui.combox_serialPortList.clear() for portInfo, port in portList: self.main_ui.combox_serialPortList.addItem(portInfo, port) def portSelect(self): self.port = self.main_ui.combox_serialPortList.currentData() self.baudrate = self.main_ui.spinBox_baudrate.value() def portOpen(self): if self.portOpened == False: try: self.serial = SerialPort(self.port, self.baudrate) self.portOpened = True self.main_ui.pbt_serialOpen.setText('Close') self.imageModeWindow.addSendMethod(self.serial) self.videoModeWindow.addSendMethod(self.serial) self.screenModeWindow.addSendMethod(self.serial) except Exception: print('Serial port open false.') else: try: self.serial.close() self.serial = None self.portOpened = False self.main_ui.pbt_serialOpen.setText('Open') self.imageModeWindow.addSendMethod(None) except Exception: print('Serial port close false.') def binarizationSetting(self): if self.main_ui.radioButton_binarizationThreshold.isChecked(): self.image_translator.set_dither_enable(False) else: self.image_translator.set_dither_enable(True) size_str = self.main_ui.comboBox_ditherBayerSize.currentText() size = int(size_str[:-1]) self.image_translator.set_dither_size(size) def displaySettingInit(self): self.displayColumnRowSetting() self.displayFlipModeSetting() self.displayScanDirectionSetting() self.displayByteDirectionSetting() self.displaySignBitSetting() def displayColumnRowSetting(self): col = self.main_ui.spinBox_displayCol.value() row = self.main_ui.spinBox_displayRow.value() self.image_translator.set_output_size(col, row) def displayFlipModeSetting(self): flip_h = self.main_ui.checkBox_displayFlipH.isChecked() flip_v = self.main_ui.checkBox_displayFlipV.isChecked() self.image_to_bw.setHorizontalFlip(flip_h) self.image_to_bw.setVerticalFlip(flip_v) def displayScanDirectionSetting(self): scan_direction = self.main_ui.comboBox_displayScanDirection.currentText() if scan_direction == 'Horizontal': dir = 'H' else: dir = 'V' self.image_to_bw.setScanDirection(dir) def displayByteDirectionSetting(self): byte_direction = self.main_ui.comboBox_displayByteDirection.currentText() if byte_direction == 'Horizontal': dir = 'H' else: dir = 'V' self.image_to_bw.setByteDirection(dir) def displaySignBitSetting(self): sign_bit = self.main_ui.comboBox_displaySignBit.currentText() self.image_to_bw.setSignBit(sign_bit) def exit(self): if self.portOpened: self.serial.close() self.imageModeWindow.exit() self.videoModeWindow.exit() self.screenModeWindow.exit() self.image_translator.stop()
self.p.param('Pulse Width Modulation Options')['Duty Cycle'] / 100., 'current': current, 'voltage': voltage } self.jpkt = JSON_Packet(self.serial_port, show_packets=False) print('Sending', params) self.jpkt.send(params) while True: byte = self.serial_port.read_byte() if byte is not None: obj = self.jpkt.process_byte(byte) if obj is not None: print(' Rcvd', obj) break if __name__ == '__main__': sp = SerialPort(port='/dev/ttyACM1') pg.mkQApp() win = QCLAPP(serial_port=sp) win.show() win.resize(1100, 700) if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): QtGui.QApplication.instance().exec_()
def main(): port = SerialPort("/dev/acrobat/radio") monitor = DockerMonitor() print("Sending start up lights") port.send_start() time.sleep(1) print("Done. Ready for user input") while True: user_input = port.read() tokens = user_input.split() if len(tokens) == 0: continue cmd = tokens[0] if cmd == 'run': exec_run(port, monitor, tokens) elif cmd == 'pull': exec_pull(port, monitor, tokens) elif cmd == 'tags': exec_tags(port, monitor) elif cmd == 'clean': exec_clean(port, monitor) elif cmd == 'reboot': exec_reboot(port, monitor) else: port.write('Unknown command: {}'.format(cmd)) # End of command execution port.send_end_of_command() port.close() monitor.close()
import array import os import struct import sys import time from serial_port import SerialPort from commander_rx import CommanderRx sysname = os.uname().sysname if sysname == 'Linux': import serial from serial_bus import SerialBus port = '/dev/ttyUSB0' try: port = SerialPort(port, 38400) except serial.serialutil.SerialException: print("Unable to open port '{}'".format(port)) sys.exit() elif sysname == 'pyboard': from stm_uart_bus import UART_Bus bus = UART_Bus(6, 38400) else: print("Unrecognized sysname: {}".format(sysname)) sys.exit() crx = CommanderRx() while True: byte = port.read_byte()
class ArduinoSensor(): def __init__(self, serialPortName): self.serialPort = SerialPort(serialPortName) self.serialPort.startReadThread() #thresholds (reasonable defaults given) self.lickThreshold = 1000 self.tapThreshold = 1000 self.irThreshold = 100 #sensor state variables self._lick = False self._tap = False #sensor history entries are tuples of (booleanState, timestamp). self.historyLick = [] self.historyTap = [] #full sensor data, not really used except for debugging self.lickRaw = [] self.tapRaw = [] #reference to objects we need to talk to self.task = None self.tracer = None def checkSensors(self): # Read from serial updates = self.serialPort.getUpdates() # Add sensor data to log for update in updates: (data, t) = update toks = data.rstrip().split() if len(toks) < 2 or not toks[1].isdigit: continue try: level = int(toks[1]) if toks[0] == "L": self.lickRaw.append((level,t)) self.reportChange("lick " + str(level), t) self.set_lick_state(level,t) if toks[0] == "T": self.tapRaw.append((level,t)) self.reportChange("tap " + str(level), t) self.set_tap_state(level,t) except: continue # parse / update state as needed for update in updates: (evt, t) = update if evt == "Lx": self.lick = True self.historyLick.append(update) elif evt == "Lo": self.lick = False self.historyLick.append(update) elif evt == "Tx": self.tap = True self.historyTap.append(update) elif evt == "To": self.tap = False self.historyTap.append(update) return updates def set_lick_state(self, level, t): """ Sets the state of the lick sensor. If the state has changed (crossed threshold), change the state and note it in the log. """ if not self.lick and level > self.lickThreshold: self.lick = True self.historyLick.append(("Lx", t)) elif self.lick and level < self.lickThreshold: self.lick = False self.historyLick.append(("Lo", t)) def set_tap_state(self, level, t): """ Sets the state of the tap sensor. If the state has changed (crossed threshold), change the state and note it in the log. """ if not self.tap and level > self.tapThreshold: self.tap = True self.historyTap.append(("Tx", t)) elif self.tap and level < self.tapThreshold: self.tap = False self.historyTap.append(("To", t)) def reportChange(self, evt, timestamp): """ Reports lick and tap events to the task. Sends sensor readings to tracer. """ if self.task is not None: self.task.notify(evt, timestamp) if self.tracer is not None: self.tracer.notify(evt, timestamp) ''' Properties. All setters call reportChange(). ''' @property def lick(self): return _lick @lick.setter def lick(self, value): self._lick = value if self._lick: self.reportChange("Lx", time.time()) else: self.reportChange("Lo", time.time()) @property def tap(self): return _tap @tap.setter def tap(self, value): self._tap = value if self._tap: self.reportChange("Tx", time.time()) else: self.reportChange("To", time.time()) ''' OK, now we have some boolean functions. These are used by CauseEffect objects, which poll sensor states to determine task progression. ''' # lick sensor def isLicking(self): return self.lick def isNotLicking(self): return not self.lick def isTapping(self): return self.tap def isNotTapping(self): return not self.tap def hasLickedSince(self, secondsAgo): #checks whether there was a recent lick (no more than secondsAgo) if self.isLicking: #is licking right now return True if len(self.historyLick) == 0: #never licked return False #last event must have been an offset; check when it happened (state, lickOffsetTime) = self.historyLick[-1] return (time.time() - lickOffsetTime) <= secondsAgo def hasNotLickedSinceAtLeast(self, secondsAgo): return not hasLickedSince(self, secondsAgo)
def main(serial_id): port = SerialPort(serial_id) monitor = DockerMonitor() signal.signal(signal.SIGINT, signal_handler) print('Welcome to TX') print_help() readline.parse_and_bind("tab:complete") readline.set_completer(completer) while True: user_input = input('#: ') tokens = user_input.split() global commands commands = commands + monitor.get_tags() if len(tokens) == 0: continue cmd = tokens[0] if cmd == 'help': print_help() elif cmd == 'tags': port.write(cmd) elif cmd == 'exit': break elif cmd == 'run': if len(tokens) < 2: tag = 'latest' else: tag = tokens[1] port.write(cmd + ' ' + tag) elif cmd == 'pull': if len(tokens) < 2: tag = 'latest' else: tag = tokens[1] port.write(cmd + ' ' + tag) elif cmd == 'clean': port.write(cmd) elif cmd == 'reboot': port.write(cmd) else: print('Unknown command: {}'.format(cmd)) continue # Wait for and print all messages received from rx wait_for_end_of_message_or_print(port) # Close port on exit port.close() monitor.close()
class ArduinoSensor(): def __init__(self, serialPortName): self.serialPort = SerialPort(serialPortName) self.serialPort.startReadThread() #thresholds (reasonable defaults given) self.lickThreshold = 1000 self.tapThreshold = 1000 self.irThreshold = 100 #sensor state variables self._lick = False self._tap = False #sensor history entries are tuples of (booleanState, timestamp). self.historyLick = [] self.historyTap = [] #full sensor data, not really used except for debugging self.lickRaw = [] self.tapRaw = [] #reference to objects we need to talk to self.task = None self.tracer = None def checkSensors(self): # Read from serial updates = self.serialPort.getUpdates() # Add sensor data to log for update in updates: (data, t) = update toks = data.rstrip().split() if len(toks) < 2 or not toks[1].isdigit: continue try: level = int(toks[1]) if toks[0] == "L": self.lickRaw.append((level, t)) self.reportChange("lick " + str(level), t) self.set_lick_state(level, t) if toks[0] == "T": self.tapRaw.append((level, t)) self.reportChange("tap " + str(level), t) self.set_tap_state(level, t) except: continue # parse / update state as needed for update in updates: (evt, t) = update if evt == "Lx": self.lick = True self.historyLick.append(update) elif evt == "Lo": self.lick = False self.historyLick.append(update) elif evt == "Tx": self.tap = True self.historyTap.append(update) elif evt == "To": self.tap = False self.historyTap.append(update) return updates def set_lick_state(self, level, t): """ Sets the state of the lick sensor. If the state has changed (crossed threshold), change the state and note it in the log. """ if not self.lick and level > self.lickThreshold: self.lick = True self.historyLick.append(("Lx", t)) elif self.lick and level < self.lickThreshold: self.lick = False self.historyLick.append(("Lo", t)) def set_tap_state(self, level, t): """ Sets the state of the tap sensor. If the state has changed (crossed threshold), change the state and note it in the log. """ if not self.tap and level > self.tapThreshold: self.tap = True self.historyTap.append(("Tx", t)) elif self.tap and level < self.tapThreshold: self.tap = False self.historyTap.append(("To", t)) def reportChange(self, evt, timestamp): """ Reports lick and tap events to the task. Sends sensor readings to tracer. """ if self.task is not None: self.task.notify(evt, timestamp) if self.tracer is not None: self.tracer.notify(evt, timestamp) ''' Properties. All setters call reportChange(). ''' @property def lick(self): return _lick @lick.setter def lick(self, value): self._lick = value if self._lick: self.reportChange("Lx", time.time()) else: self.reportChange("Lo", time.time()) @property def tap(self): return _tap @tap.setter def tap(self, value): self._tap = value if self._tap: self.reportChange("Tx", time.time()) else: self.reportChange("To", time.time()) ''' OK, now we have some boolean functions. These are used by CauseEffect objects, which poll sensor states to determine task progression. ''' # lick sensor def isLicking(self): return self.lick def isNotLicking(self): return not self.lick def isTapping(self): return self.tap def isNotTapping(self): return not self.tap def hasLickedSince(self, secondsAgo): #checks whether there was a recent lick (no more than secondsAgo) if self.isLicking: #is licking right now return True if len(self.historyLick) == 0: #never licked return False #last event must have been an offset; check when it happened (state, lickOffsetTime) = self.historyLick[-1] return (time.time() - lickOffsetTime) <= secondsAgo def hasNotLickedSinceAtLeast(self, secondsAgo): return not hasLickedSince(self, secondsAgo)