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):
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")
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 __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()
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)
