class InterfaceSource(Source):
def __init__(self):
Source.__init__(self)
try:
self._device = InterfaceKit()
except RuntimeError as e:
print("Runtime Error: %s" % e.message)
try:
self._device.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.detail))
self._device.setOnSensorChangeHandler(self.sensor_changed)
print("Phidget: Waiting for Connection")
self._device.waitForAttach(10000)
self._device.setSensorChangeTrigger(0, 0)
self._device.setDataRate(0, 1)
print("Phidget: Connected")
def sensor_changed(self, e):
if self.sink is not None:
self.sink([e.value])
def setup_phidgets():
global interfaceKits
interfaceKits = InterfaceKits()
"Print Creating phidget manager"
try:
manager = Manager()
except RuntimeError as e:
output("Runtime Exception: %s" % e.details)
output("Exiting....")
exit(1)
try:
manager.setOnAttachHandler(ManagerDeviceAttached)
manager.setOnDetachHandler(ManagerDeviceDetached)
manager.setOnErrorHandler(ManagerError)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output("Opening phidget manager....")
logging.info("Opening phidget manager....")
try:
manager.openManager()
#manager.openRemote("hydropi","hydropi")
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
logging.error("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
logging.error("Exiting....")
exit(1)
# Wait a moment for devices to attache......
output("\nWaiting one sec for devices to attach....\n\n")
logging.info("Waiting one sec for devices to attach....")
time.sleep(1)
output("Phidget manager opened.")
attachedDevices = manager.getAttachedDevices()
for attachedDevice in attachedDevices:
output("Found %30s - SN %10d" % (attachedDevice.getDeviceName(), attachedDevice.getSerialNum()))
if attachedDevice.getDeviceClass() == PhidgetClass.INTERFACEKIT:
output(" %s/%d is an InterfaceKit" % ( attachedDevice.getDeviceName(),attachedDevice.getSerialNum()))
#Create an interfacekit object
try:
newInterfaceKit = InterfaceKit()
except RuntimeError as e:
output("Runtime Exception: %s" % e.details)
output("Exiting....")
exit(1)
output(" Opening...")
try:
newInterfaceKit.openPhidget()
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
output(" Setting handlers...")
try:
newInterfaceKit.setOnAttachHandler(interfaceKitAttached)
newInterfaceKit.setOnDetachHandler(interfaceKitDetached)
newInterfaceKit.setOnErrorhandler(interfaceKitError)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output(" Attaching...")
try:
newInterfaceKit.waitForAttach(5000)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
try:
newInterfaceKit.closePhidget()
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output("Exiting....")
exit(1)
output(" Setting the data rate for each sensor index to 1000ms....")
for i in range(newInterfaceKit.getSensorCount()):
try:
newInterfaceKit.setDataRate(i, 1000)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
interfaceKits.kitList.append(newInterfaceKit)
display_device_info(manager)
return manager
class PhidgetSensorHandler(AbstractSensorHandler):
def __init__(self):
self.device = None
self._attach_timeout = None
self._data_rate = None
self._sensors = None
def _try_init(self):
if all([self._data_rate, self._attach_timeout, self._sensors]):
try:
from Phidgets.Devices.InterfaceKit import InterfaceKit
from Phidgets.PhidgetException import PhidgetException
self.interface_kit = InterfaceKit()
self.interface_kit.setOnAttachHandler(lambda e: self._attach(e))
self.interface_kit.setOnDetachHandler(lambda e: self._detach(e))
self.interface_kit.setOnErrorhandler(lambda e: self._error(e))
self.interface_kit.setOnSensorChangeHandler(lambda e: self._sensor_change(e))
self.interface_kit.openPhidget()
self.interface_kit.waitForAttach(self._attach_timeout)
for i in range(self.interface_kit.getSensorCount()):
self.interface_kit.setDataRate(i, self._data_rate)
logging.info("Phidget Sensor Handler Initalized")
for s in self._sensors:
if s.port_num is not None:
s.current_data = self.interface_kit.getSensorValue(s.port_num)
logging.debug("Setting Initial Value for Sensor {} to {}".format(s.port_num, s.current_data))
else:
logging.warn("Cannot set Initial Value for Sensor {}".format(s.port_num))
except ImportError:
self.interface_kit = None
logging.error('Phidget Python Module not found. Did you install python-phidget?')
except PhidgetException as e:
self.interface_kit = None
logging.error("Could not Initalize Phidget Kit: {}".format(e.details))
def _read_sensors(self):
ready_sensors = []
for s in self._sensors:
if s.data is not None:
ready_sensors.append(s)
return ready_sensors
def _set_sensors(self, v):
logging.debug('Adding Phidget Sensors :: {}'.format(v))
self._sensors = v
self._try_init()
sensors = property(_read_sensors, _set_sensors)
attach_timeout = property(lambda self: self._attach_timeout,
lambda self, v: self._set_config('attach_timeout', v))
data_rate = property(lambda self: self._data_rate,
lambda self, v: self._set_config('data_rate', v))
def _set_config(self, prop, value):
if prop == 'data_rate':
self._data_rate = value
elif prop == 'attach_timeout':
self._attach_timeout = value
self._try_init()
def _attach(self, e):
self.device = e.device
logging.info("Phidget InterfaceKit {} Attached".format(self.device.getSerialNum()))
def _detach(self, e):
logging.warn("Phidget InterfaceKit {} Removed".format(e.device.getSerialNum()))
self.device = None
def _error(self, e):
logging.error("Phidget Error {} :: {}".format(e.eCode, e.description))
def _sensor_change(self, e):
# logging.debug("Phidget Analog Sensor Change :: Port: {} / Data: {}".format(e.index, e.value))
for s in self._sensors:
if s.port_type == 'analog' and s.port_num == e.index:
# Set a default ID if none given in config file
if s.id is None:
# Default ID is kit serial number::port
s.id = '{}:{}:{}'.format(self.device.getSerialNum(),
s.port_type, s.port_num)
s.current_data = e.value
class InterfaceKitHelper:
__inputs = np.zeros(8)
__sensors = np.zeros(8)
attached = False
led = None
def __init__(self):
# Create an interfacekit object
try:
self.__interfaceKit = InterfaceKit()
except RuntimeError as e:
print('Runtime Exception: %s' % e.details)
return 1
try:
# logging example, uncomment to generate a log file
#self.__interfaceKit.enableLogging(PhidgetLogLevel.PHIDGET_LOG_VERBOSE, 'phidgetlog.log')
self.__interfaceKit.setOnAttachHandler(self.__interfaceKitAttached)
self.__interfaceKit.setOnDetachHandler(self.__interfaceKitDetached)
self.__interfaceKit.setOnErrorhandler(self.__interfaceKitError)
self.__interfaceKit.setOnInputChangeHandler(
self.__interfaceKitInputChanged)
self.__interfaceKit.setOnOutputChangeHandler(
self.__interfaceKitOutputChanged)
self.__interfaceKit.setOnSensorChangeHandler(
self.__interfaceKitSensorChanged)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
print('[INFO] [InterfaceKitHelper] Opening phidget object....')
try:
self.__interfaceKit.openPhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
print('[INFO] [InterfaceKitHelper] Waiting for attach....')
try:
self.__interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
try:
self.__interfaceKit.closePhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
return 1
else:
# self.__displayDeviceInfo()
pass
print(
'[INFO] [InterfaceKitHelper] Setting the data rate for each sensor index to 4ms....'
)
for i in range(self.__interfaceKit.getSensorCount()):
try:
self.__interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
self.led = LED(self)
def getInputs(self):
return InterfaceKitHelper.__inputs[:]
def getSensors(self):
return InterfaceKitHelper.__sensors[:]
def setOutputState(self, *args):
if self.attached:
self.__interfaceKit.setOutputState(*args)
def destroy(self):
self.attached = False
self.led.destroy()
try:
print(
'[INFO] [InterfaceKitHelper] Closing interface kit phidget...')
self.__interfaceKit.closePhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
def __displayDeviceInfo(self):
"""
Information Display Function
"""
print(
'|------------|----------------------------------|--------------|------------|'
)
print(
'|- Attached -|- Type -|- Serial No. -|- Version -|'
)
print(
'|------------|----------------------------------|--------------|------------|'
)
print('|- %8s -|- %30s -|- %10d -|- %8d -|' %
(self.__interfaceKit.isAttached(),
self.__interfaceKit.getDeviceName(),
self.__interfaceKit.getSerialNum(),
self.__interfaceKit.getDeviceVersion()))
print(
'|------------|----------------------------------|--------------|------------|'
)
print('Number of Digital Inputs: %i' %
(self.__interfaceKit.getInputCount()))
print('Number of Digital Outputs: %i' %
(self.__interfaceKit.getOutputCount()))
print('Number of Sensor Inputs: %i' %
(self.__interfaceKit.getSensorCount()))
def __interfaceKitAttached(self, e):
"""
Event Handler Callback Functions
"""
attached = e.device
print('[INFO] [InterfaceKitHelper] InterfaceKit %i Attached!' %
(attached.getSerialNum()))
self.attached = True
def __interfaceKitDetached(self, e):
detached = e.device
print('[INFO] [InterfaceKitHelper] InterfaceKit %i Detached!' %
(detached.getSerialNum()))
self.attached = False
def __interfaceKitError(self, e):
try:
source = e.device
print(
'[INFO] [InterfaceKitHelper] InterfaceKit %i: Phidget Error %i: %s'
% (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
def __interfaceKitInputChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Input %i: %s' % (source.getSerialNum(), e.index, e.state))
InterfaceKitHelper.__inputs[e.index] = e.state
def __interfaceKitSensorChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Sensor %i: %i' % (source.getSerialNum(), e.index, e.value))
InterfaceKitHelper.__sensors[e.index] = e.value
def __interfaceKitOutputChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Output %i: %s' % (source.getSerialNum(), e.index, e.state))
pass
interfaceKitHUB.closePhidget()
#interfaceKitLCD.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
#print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKitHUB.getSensorCount()):
try:
interfaceKitHUB.setDataRate(i, 2)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print "\n"
#Make sure the ratiometric setting is set (required by sonar)
if not interfaceKitHUB.getRatiometric:
interfaceKitHUB.setRatiometric(True)
#Register interupt callback
signal.signal(signal.SIGINT, signal_handler)
#Setup zmq sockets
context = zmq.Context()
distance_socket = context.socket(zmq.PUB)
class Phidgets:
def __init__(self):
self.V1 = 0.0
self.V2list = [
0, 0, 0, 0, 0, 0, 0
] #lista dei valori associati alle porte analogiche, corrispondenza porta analogica posizione nella lista
self.running = True
def ponteDiWheatstone(self):
R1 = 1000.0 #1KOhm
R2 = 1000.0 #1KOhm
R3 = 1000.0 #1KOhm
Vs = 5.0
for pos, v in enumerate(self.V2list):
if v == 0:
continue
Vm = v - self.V1 #ingresso differenziale
print Vm
#formula per il calcolo della resistenza
p1 = R3 / (R1 + R3) + (Vm / Vs)
p2 = 1 - p1
Rx = R2 * (p1 / p2)
#
date = datetime.now().strftime('%Y-%m-%d')
time = datetime.now().strftime('%H:%M:%S')
self.monitoring.insertValue(Rx, pos + 1, date, time)
#
print("la resistenza sull'input %d vale %f: " % (pos + 1, Rx))
def partitoreDiTensione(self, val):
if val != 1:
r1 = 1000
Vref = 12 #5V tensione applicata al partitore
V2 = (5.0 / 1023.0) * val #tensione letta ai capi della resistenza
r2 = r1 * V2 / (Vref - V2)
print("la resistenza vale %f: " % r2)
def interfaceKitSensorChanged(self, e):
source = e.device
if e.value == 1: #1 indica che non sta nulla collegato e resetto anche il suo valore nella lista
if e.index == 0:
self.V1 = 0
else:
self.V2list[e.index - 1] = 0
return
if e.index == 0: #V1 va collegato sempre sul pin 0
self.V1 = (5.0 / 1023.0) * e.value
print self.V1
else:
val = (5.0 / 1023.0) * e.value
self.V2list[
e.index -
1] = val #corrispondenza porta analogica posizione nella lista
print str(self.V2list)
self.ponteDiWheatstone()
#if e.value != 1:
# self.monitoring.insertPos(e.index)
#print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value))
def run(self):
try:
self.interfaceKit = InterfaceKit(
) #instanzio la classe per interfacciarmi con la scheda di acquisizione
self.monitoring = sm.SensorMonitoring(
) #tabella dove sono memorizzati i valori dei sensori collegati
self.monitoring.open()
self.monitoring.create()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.setOnSensorChangeHandler(
self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
exit(1)
print(
"Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting...."
)
exit(1)
else:
print "Scheda di acquisizione rilevata."
for i in range(self.interfaceKit.getSensorCount()):
try:
self.interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
pass
def close(self):
self.running = False
self.monitoring.close()
print("Closing...")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
class SitwPhidgetsKey(wx.Frame):
def __init__(self, image, parent = None, id = -1,
pos = wx.DefaultPosition, title = sitwPara.Title):
wx.Frame.__init__(self, parent, id, title)
self.SetBackgroundColour((0, 0, 0))
self.SetSize((360, 80))
self.Center()
self.Iconize()
self.panel = wx.Panel(self, size=(320, 336))
self.panel.Bind(wx.EVT_PAINT, self.OnPaint)
#self.panel.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
self.Fit()
self.SampleCount = 12 #for detecting environment 12 x 10sec = 2min
self.KeyPressed = ''
self.CurAction = ''
self.CurPos = win32api.GetCursorPos()
self.PreAction = ''
self.PrePos = win32api.GetCursorPos()
self.bKeyIntervalOK = True
self.KeyMatReady = False
self.ListValMat = []
self.ListValEnv = []
self.ListValBrt = []
self.KeySearch = False
self.dtSearchStart = datetime.datetime.now()
self.dtAction = datetime.datetime.now()
self.dtRefresh = datetime.datetime.now()
self.ChannelCount = 0
self.bNight = False
self.ctEvn = 0
#self.edgeTop = 50
#self.edgeBottom = sitwPara.MoveEdgeBottom1
#self.edgeLeft = 50
#self.edgeRight = 50
self.edgeTop = 18
self.edgeBottom = 18
self.edgeLeft = 18
self.edgeRight = 18
self.strLogAction = ''
self.strLogBrightness = ''
self.subp = None
self.List_ProgramFile = []
self.List_Program = []
self.OnScreenApp = ''
#self.utSchedule = SitwScheduleTools(self)
self.utLogAction = SitwLog(self, 'logAction')
self.utLogBrightness = SitwLog(self, 'logBrightness')
#self.Bind(wx.EVT_SIZE, self.OnResize)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.Bind(wx.EVT_IDLE, self.OnIdle)
self.prtMsg('PhidgetsKey Starting...')
self.readIniFile()
self.initPhidgets()
self.initKeys()
'''collect ambient light info'''
self.timer1 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.CheckEnv, self.timer1)
self.timer1.Start(sitwPara.SampleInterval_Env) #1000 = 1 second
'''check if there is any key has been covered'''
self.timer2 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.CheckKey, self.timer2)
self.timer2.Start(sitwPara.SampleInterval_Key) #1000 = 1 second
'''find current on screen experience according to schedule file'''
''' -- removed --'''
'''collect sensor readings for analysis'''
if sitwPara.Log_Brightness == 'Yes':
print '<Log_Brightness On>'
self.timer5 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.logBrightness, self.timer5)
self.timer5.Start(60 * 1000) #1000 = 1 second
self.utLogBrightness.logMsg('------ log is starting ------\t' + sitwPara.Title)
self.logBrightness(None)
else:
print '<Log_Brightness Off>'
'''collect keypad actions for analysis'''
if sitwPara.Log_Action == 'Yes':
print '<Log_Action On>'
self.timer6 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.logActions, self.timer6)
self.timer6.Start(9 * 1000) #1000 = 1 second
self.utLogAction.logMsg('------ log is starting ------\t' + sitwPara.Title)
else:
print '<Log_Action Off>'
###Change Cursor
###http://converticon.com/
### http://stackoverflow.com/questions/7921307/temporarily-change-cursor-using-python
self.SetSystemCursor = windll.user32.SetSystemCursor #reference to function
self.SetSystemCursor.restype = c_int #return
self.SetSystemCursor.argtype = [c_int, c_int] #arguments
self.LoadCursorFromFile = windll.user32.LoadCursorFromFileA #reference to function
self.LoadCursorFromFile.restype = c_int #return
self.LoadCursorFromFile.argtype = c_char_p #arguments
CursorPath ='../pic/handr.cur'
NewCursor = self.LoadCursorFromFile(CursorPath)
if NewCursor is None:
print "Error loading the cursor"
elif self.SetSystemCursor(NewCursor, win32con.IDC_ARROW) == 0:
print "Error in setting the cursor"
###Change Cursor
self.DimScreen = wx.DisplaySize()
print 'Screen Dimensions: ' + str(self.DimScreen[0]) + ' x ' + str(self.DimScreen[1])
##########################################
'''m,b parameters for each sensor'''
for i in range(len(sitwPara.List_mb)):
print '===== ', sitwPara.List_mb[i][0], sitwPara.List_mb[i][1]
##########################################
### not in use at the moment
def OnEraseBackground(self, event):
return True
def OnPaint(self, event):
'''
# establish the painting surface
dc = wx.PaintDC(self.panel)
dc.SetPen(wx.Pen('blue', 4))
# draw a blue line (thickness = 4)
dc.DrawLine(50, 20, 300, 20)
dc.SetPen(wx.Pen('red', 1))
# draw a red rounded-rectangle
rect = wx.Rect(50, 50, 100, 100)
dc.DrawRoundedRectangleRect(rect, 8)
# draw a red circle with yellow fill
dc.SetBrush(wx.Brush('yellow'))
x = 250
y = 100
r = 50
dc.DrawCircle(x, y, r)
'''
#dc = wx.PaintDC(self.panel)
dc = wx.BufferedPaintDC(self.panel)
dc.SetBackground(wx.BLUE_BRUSH)
dc.Clear()
self.onDraw(dc)
def onDraw(self, dc):
strColorPen1 = 'red'
strColorPen2 = 'blue'
for i in range(sitwPara.KeyCount):
rect = sitwPara.List_ButtonPos[i]
dc.SetBrush(wx.Brush((0, 255*self.ListValBrt[i], 255*self.ListValBrt[i])))
if self.KeyPressed == sitwPara.List_Action[i]:
dc.SetPen(wx.Pen(strColorPen1, 5))
else:
dc.SetPen(wx.Pen(strColorPen2, 1))
#dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRoundedRectangleRect(rect, 8)
def initPhidgets(self):
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.setOnAttachHandler(self.inferfaceKitAttached)
self.interfaceKit.setOnDetachHandler(self.interfaceKitDetached)
self.interfaceKit.setOnErrorhandler(self.interfaceKitError)
self.interfaceKit.setOnInputChangeHandler(self.interfaceKitInputChanged)
self.interfaceKit.setOnOutputChangeHandler(self.interfaceKitOutputChanged)
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
self.closePhidgets()
else:
self.displayDeviceInfo()
#get sensor count
try:
self.ChannelCount = self.interfaceKit.getSensorCount()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
self.closePhidgets()
sitwPara.KeyCount = 0 #no sensor has been detected
self.prtMsg(' ****** No sensor has been detected !!!\n')
print("Setting the data rate for each sensor index to 4ms....")
for i in range(sitwPara.KeyCount):
try:
self.interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
### depends on the low light performance of the sensor
print("Setting the sensitivity for each sensor index to ???....")
for i in range(sitwPara.KeyCount):
try:
self.interfaceKit.setSensorChangeTrigger(i, 2) #~~~~*YL*~~~~
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def closePhidgets(self):
#print("Press Enter to quit....")
#chr = sys.stdin.read(1)
#print("Closing...")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
#print("Done.")
#exit(1)
def initKeys(self):
self.KeyPressed = ''
self.ListValMat = []
for i in range(sitwPara.KeyCount):
self.ListValEnv = []
for j in range(self.SampleCount):
self.ListValEnv.append(self.readSensorValue(i))
self.ListValMat.append(self.ListValEnv)
self.KeyMatReady = True
self.ListValBrt = []
for i in range(sitwPara.KeyCount):
self.ListValBrt.append(0)
def readIniFile(self):
self.prtMsg('Read system ini file...')
try:
config = ConfigParser.ConfigParser()
config.readfp(open(sitwPara.FilePath_Ini))
for eachIniData in self.iniData():
Section = eachIniData[0]
Keys = eachIniData[1]
for Key in Keys:
val = config.get(Section, Key)
if (Section == "General"):
if (Key == "KeyCount"):
sitwPara.KeyCount = int(val)
elif (Key == "Sensitivity"):
sitwPara.Sensitivity = float(val)
elif (Key == "MovingPace"):
sitwPara.MovingPace = int(val)
elif (Key == "SampleInterval_Key"):
sitwPara.SampleInterval_Key = int(val)
elif (Key == "SampleInterval_Env"):
sitwPara.SampleInterval_Env = int(val)
elif (Key == "Log_Action"):
sitwPara.Log_Action = str(val)
elif (Key == "Log_Brightness"):
sitwPara.Log_Brightness = str(val)
else:
pass
print('[' + Section + '] ' + Key + ' = ' + val)
continue
except: #IOError
self.prtMsg('Error: readIniFile()')
finally:
pass
def iniData(self):
return (("General",
("KeyCount",
"Sensitivity",
"MovingPace",
"SampleInterval_Key",
"SampleInterval_Env",
"Log_Action",
"Log_Brightness")),)
#Information Display Function
def displayDeviceInfo(self):
print("|------------|----------------------------------|--------------|------------|")
print("|- Attached -|- Type -|- Serial No. -|- Version -|")
print("|------------|----------------------------------|--------------|------------|")
print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (self.interfaceKit.isAttached(), self.interfaceKit.getDeviceName(), self.interfaceKit.getSerialNum(), self.interfaceKit.getDeviceVersion()))
print("|------------|----------------------------------|--------------|------------|")
print("Number of Digital Inputs: %i" % (self.interfaceKit.getInputCount()))
print("Number of Digital Outputs: %i" % (self.interfaceKit.getOutputCount()))
print("Number of Sensor Inputs: %i" % (self.interfaceKit.getSensorCount()))
#Event Handler Callback Functions
def inferfaceKitAttached(self, e):
attached = e.device
print("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
print("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def interfaceKitInputChanged(self, e):
source = e.device
print("InterfaceKit %i: Input %i: %s" % (source.getSerialNum(), e.index, e.state))
def interfaceKitSensorChanged(self, e):
if not self.KeyMatReady:
return
#source = e.device
#print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value))
if not self.KeySearch:
self.KeySearch = True
self.dtSearchStart = datetime.datetime.now()
def interfaceKitOutputChanged(self, e):
source = e.device
print("InterfaceKit %i: Output %i: %s" % (source.getSerialNum(), e.index, e.state))
def readSensorValue(self, channel_id):
val = 0.0
try:
val = self.interfaceKit.getSensorValue(channel_id)
#val = self.interfaceKit.getSensorRawValue(channel_id) / 4.095
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
#val = 1.478777 * float(val) + 33.67076 #------ for 1142_0: Lux = m * SensorValue + b
#val = math.exp(0.02385 * float(val) - 0.56905) #------ for 1143_0: Lux = math.exp(m * SensorValue + b)
#val = math.exp(sitwPara.List_mb[channel_id][0] * float(val) + sitwPara.List_mb[channel_id][1]) #------ for 1143_0: Lux = math.exp(m * SensorValue + b)
return val
def CheckEnv(self, event):
for i in range(sitwPara.KeyCount):
ValIns = self.readSensorValue(i)
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
if (float(ValIns) / float(ValEnv)) > 0.70 or self.ctEvn >= 2: #natural change or the big change keeps for long time
self.ListValMat[i].pop(0)
self.ListValMat[i].append(ValIns)
self.ctEvn = 0
else:
self.ctEvn += 1 #ignore those suddenly changes
###test
#for val in self.ListValMax:
# print val, '->', sum(val)/len(val)
#print '-------------------------------------------------------'
def CheckKey(self, event):
if not self.KeySearch:
return
dtCurrentTime = datetime.datetime.now()
if dtCurrentTime - self.dtSearchStart > datetime.timedelta(microseconds = 6000000): # =6s ; 1000000 = 1s
self.KeySearch = False
if dtCurrentTime - self.dtAction > datetime.timedelta(microseconds = 500000): # =0.5s ; 1000000 = 1s
self.bKeyIntervalOK = True
else:
self.bKeyIntervalOK = False
self.bNight = True
for i in range(sitwPara.KeyCount):
ValIns = self.readSensorValue(i)
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
if ValEnv > 20.0:
self.bNight = False
self.ListValBrt[i] = float(ValIns) / float(ValEnv)
if self.ListValBrt[i] > 1.0:
self.ListValBrt[i] = 1.0
#sort
#self.ListValBrt.sort(cmp = None, key = None, reverse = False)
if self.bNight == False:
NightFactor = 1.0
else:
NightFactor = 1.8
#KeyID = self.ListValBrt.index(min(self.ListValBrt))
for i in range(sitwPara.KeyCount):
KeyID = sitwPara.List_KeyCheckOrder[i]
if self.ListValBrt[KeyID] < (sitwPara.Sensitivity * NightFactor):
bKey = True
break
else:
bKey = False
if bKey == True:
if KeyID == 1:
if self.KeyPressed == 'left' or self.bKeyIntervalOK == True:
self.KeyPressed = 'left'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 2:
if self.KeyPressed == 'right' or self.bKeyIntervalOK == True:
self.KeyPressed = 'right'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 3:
if self.KeyPressed == 'up' or self.bKeyIntervalOK == True:
self.KeyPressed = 'up'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 4:
if self.KeyPressed == 'down' or self.bKeyIntervalOK == True:
self.KeyPressed = 'down'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 0:
if self.KeyPressed != 'click' and self.KeyPressed != 'clicked' and self.KeyPressed != 'dclick' and self.KeyPressed != 'dclicked' and self.bKeyIntervalOK == True:
self.KeyPressed = 'click'
self.dtAction = datetime.datetime.now()
elif self.KeyPressed != 'dclick' and self.KeyPressed != 'dclicked' and (dtCurrentTime - self.dtAction > datetime.timedelta(microseconds = 2200000)): # =2.2s ; 1000000 = 1s
self.KeyPressed = 'dclick'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
if len(self.KeyPressed) > 0:
###filter
#-- removed ---
###filter
pos = win32api.GetCursorPos()
if self.KeyPressed == 'up':
if pos[1] >= self.edgeTop:
#nx = (pos[0]) * 65535.0 / self.DimScreen[0]
#ny = (pos[1] - sitwPara.MovingPace) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, 0, -sitwPara.MovingPace)
#win32api.SetCursorPos((pos[0], pos[1] - sitwPara.MovingPace))
elif self.KeyPressed == 'down':
if pos[1] <= self.DimScreen[1] - self.edgeBottom:
#nx = (pos[0]) * 65535.0 / self.DimScreen[0]
#ny = (pos[1] + sitwPara.MovingPace) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, 0, +sitwPara.MovingPace)
#win32api.SetCursorPos((pos[0], pos[1] + sitwPara.MovingPace))
elif self.KeyPressed == 'left':
if pos[0] >= self.edgeLeft:
#nx = (pos[0] - sitwPara.MovingPace) * 65535.0 / self.DimScreen[0]
#ny = (pos[1]) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, -sitwPara.MovingPace, 0)
#win32api.SetCursorPos((pos[0] - sitwPara.MovingPace, pos[1]))
elif self.KeyPressed == 'right':
if pos[0] <= self.DimScreen[0] - self.edgeRight:
#nx = (pos[0] + sitwPara.MovingPace) * 65535.0 / self.DimScreen[0]
#ny = (pos[1]) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, +sitwPara.MovingPace, 0)
#win32api.SetCursorPos((pos[0] + sitwPara.MovingPace, pos[1]))
elif self.KeyPressed == 'click':
self.click(pos[0], pos[1])
#print '**********click**************'
self.KeyPressed = 'clicked'
elif self.KeyPressed == 'dclick':
self.dclick(pos[0], pos[1])
#print '**********dclick**************'
self.KeyPressed = 'dclicked'
###Action Log
if sitwPara.Log_Action == 'Yes':
self.CurAction = self.KeyPressed
self.CurPos = win32api.GetCursorPos()
if self.CurAction != self.PreAction and len(self.PreAction) > 0:
#dtCurrentTime = datetime.datetime.now()
#strTimeTag = datetime.datetime.strftime(dtCurrentTime, '%Y-%m-%d %H:%M:%S')
#pos = win32api.GetCursorPos()
strLog = self.PreAction + '\t(' + str(self.PrePos[0]) + ',' + str(self.PrePos[1]) + ')' \
+ '\t' + self.OnScreenApp
self.utLogAction.logMsg(strLog)
self.PreAction = self.CurAction
self.PrePos = self.CurPos
def click(self, x,y):
win32api.SetCursorPos((x,y))
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
def dclick(self, x,y):
win32api.SetCursorPos((x,y))
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
def logBrightness(self, event):
strValEnv = ''
for i in range(sitwPara.KeyCount):
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
strValEnv += str('%06.2f'%(ValEnv)) + '\t'
self.utLogBrightness.logMsg(strValEnv)
self.utLogBrightness.wrtLog(False)
def logActions(self, event):
self.utLogAction.wrtLog(False)
def GetSchedule(self, event):
# --removed --
pass
def FindAppName(self, event):
# --removed --
pass
def prtMsg(self, strMsg):
dtCurrentTime = datetime.datetime.now()
strTimeTag = datetime.datetime.strftime(dtCurrentTime, '%Y-%m-%d %H:%M:%S')
#strTimeTag += str('%03d'%(int(datetime.datetime.strftime(dtCurrentTime, '%f'))/1000))
print(strTimeTag + ' ' + strMsg + "\n")
def OnIdle(self, event):
if not self.KeySearch:
return
dtCurrentTime = datetime.datetime.now()
if dtCurrentTime - self.dtRefresh > datetime.timedelta(microseconds = 200000): #1000000 = 1s
self.dtRefresh = dtCurrentTime
self.panel.Refresh(eraseBackground = False)
pass
def OnCloseWindow(self, event):
print "Do something b4 closing..."
###Change Cursor
CursorPath = "../pic/arrow.cur"
NewCursor = self.LoadCursorFromFile(CursorPath)
if NewCursor is None:
print "Error loading the cursor"
elif self.SetSystemCursor(NewCursor, win32con.IDC_ARROW) == 0:
print "Error in setting the cursor"
###Change Cursor
self.closePhidgets()
self.prtMsg('Destroy Phidgets Key')
if sitwPara.Log_Action == 'Yes':
self.utLogAction.wrtLog(True) #force to log all messages
if sitwPara.Log_Brightness == 'Yes':
self.utLogBrightness.wrtLog(True) #force to log all messages
#time.sleep(1)
self.Destroy()
class Phidgets:
def __init__(self):
self.V1 = 0.0
self.V2list = [0,0,0,0,0,0,0] #lista dei valori associati alle porte analogiche, corrispondenza porta analogica posizione nella lista
self.running = True
def ponteDiWheatstone(self):
R1 = 1000.0#1KOhm
R2 = 1000.0#1KOhm
R3 = 1000.0#1KOhm
Vs = 5.0
for pos, v in enumerate(self.V2list):
if v==0:
continue
Vm = v-self.V1 #ingresso differenziale
print Vm
#formula per il calcolo della resistenza
p1 = R3/(R1+R3) + (Vm/Vs)
p2 = 1 - p1
Rx = R2*(p1/p2);
#
date = datetime.now().strftime('%Y-%m-%d')
time = datetime.now().strftime('%H:%M:%S')
self.monitoring.insertValue(Rx, pos+1, date,time)
#
print ("la resistenza sull'input %d vale %f: " % (pos+1, Rx))
def partitoreDiTensione(self, val):
if val != 1:
r1 = 1000
Vref = 12 #5V tensione applicata al partitore
V2 = (5.0/1023.0)*val #tensione letta ai capi della resistenza
r2 = r1*V2/(Vref-V2)
print ("la resistenza vale %f: " % r2)
def interfaceKitSensorChanged(self, e):
source = e.device
if e.value == 1:#1 indica che non sta nulla collegato e resetto anche il suo valore nella lista
if e.index==0:
self.V1=0
else:
self.V2list[e.index-1]=0
return
if e.index == 0:#V1 va collegato sempre sul pin 0
self.V1 = (5.0/1023.0)*e.value
print self.V1
else:
val = (5.0/1023.0)*e.value
self.V2list[e.index-1]=val #corrispondenza porta analogica posizione nella lista
print str(self.V2list)
self.ponteDiWheatstone()
#if e.value != 1:
# self.monitoring.insertPos(e.index)
#print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value))
def run(self):
try:
self.interfaceKit = InterfaceKit() #instanzio la classe per interfacciarmi con la scheda di acquisizione
self.monitoring = sm.SensorMonitoring() #tabella dove sono memorizzati i valori dei sensori collegati
self.monitoring.open()
self.monitoring.create()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
exit(1)
print("Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting....")
exit(1)
else:
print "Scheda di acquisizione rilevata."
for i in range(self.interfaceKit.getSensorCount()):
try:
self.interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
pass
def close(self):
self.running = False
self.monitoring.close()
print("Closing...")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
def setupSensorHandlers():
global interfaceKit, batteryPublisher, rangePublisher
global batteryVoltageChannel, batteryFullLevel, batteryDepletedLevel, batteryRange, frontRangeChannel, backRangeChannel
global batteryInfo, rangeInfo
try:
interfaceKit = InterfaceKit()
except RuntimeError as e:
rospy.logfatal('Failed to create InterfaceKit: %s' % (e.details))
rospy.signal_shutdown('Failed to connect to InterfaceKit')
try:
interfaceKit.setOnAttachHandler(attachHandler)
interfaceKit.setOnDetachHandler(detachHandler)
interfaceKit.setOnErrorhandler(errorHandler)
interfaceKit.setOnInputChangeHandler(inputChangeHandler)
interfaceKit.setOnOutputChangeHandler(outputChangeHandler)
interfaceKit.setOnSensorChangeHandler(sensorChangeHandler)
except PhidgetException as e:
rospy.logfatal('Failed to set handlers: %i, %s' % (e.code, e.details))
rospy.signal_shutdown('Failed to connect to InterfaceKit')
try:
interfaceKit.openPhidget()
except PhidgetException as e:
rospy.logfatal("Failed to openPhidget() %i: %s" % (e.code, e.details))
rospy.signal_shutdown('Failed to openPhidget()')
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
rospy.logfatal("Failed on waitForAttach() %i: %s" %
(e.code, e.details))
interfaceKit.closePhidget()
rospy.signal_shutdown('Failed on waitForAttach()')
for sensor in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(sensor, 16)
except PhidgetException as e:
rospy.logwarn("Failed to setDateRate() %i: %s" %
(e.code, e.details))
batteryPublisher = rospy.Publisher('batteryInfo', Battery)
rangePublisher = rospy.Publisher('rangeInfo', Range)
batteryVoltageChannel = rospy.get_param('RoverState/battery/channel')
batteryFullLevel = float(rospy.get_param('RoverState/battery/fullCharge'))
batteryDepletedLevel = rospy.get_param('RoverState/battery/depletedCharge')
batteryRange = batteryFullLevel - batteryDepletedLevel
frontRangeChannel = rospy.get_param('RoverState/range/front/channel')
backRangeChannel = rospy.get_param('RoverState/range/back/channel')
sendRange()
sendBattery()
return
class Node(object):
name = None
sensors = []
outputs = []
inputs = []
triggers = []
clocks = []
repeaters = []
interface_kit = None
def __init__(self, name, *args, **kwargs):
self.name = name
self.initializing = True
if LIVE: self.interface_kit = InterfaceKit()
self.manager = PubSub(self, pub_port=settings.NODE_PUB, sub_port=settings.NODE_SUB, sub_filter=self.name)
self.logger = util.get_logger("%s.%s" % (self.__module__, self.__class__.__name__))
self.initialize()
self.run()
def initialize(self):
while self.initializing:
self.logger.info("Waiting for manager")
json = dict(name=self.name, method='add_node')
self.publish(json)
gevent.sleep(1)
return
def publish(self, message):
message['name'] = self.name
message['method'] = message.get('method', 'node_change')
self.manager.publish(aes.encrypt(json.dumps(message, cls=ComplexEncoder), settings.KEY))
self.test_triggers(message)
def test_triggers(self, message):
for t in self.triggers:
t.handle_event(message)
def initialize_rpc(self, obj, **kwargs):
rpc = zmq.Context()
rpc_socket = rpc.socket(zmq.REP)
rpc_socket.bind("tcp://*:%s" % obj.get('port'))
self.logger.info("RPC listening on: %s" % obj.get('port'))
settings.KEY = base64.urlsafe_b64decode(str(obj.get('key')))
self.logger.info("%s Initialized" % self.name)
while True:
if self.initializing:
self.initializing = False
self.publish(dict(method='initialized'))
message = aes.decrypt(rpc_socket.recv(), settings.KEY)
ob = json.loads(message)
try:
res = getattr(self, ob.get("method"))(ob)
st = json.dumps(res, cls=ComplexEncoder)
rpc_socket.send(aes.encrypt(st, settings.KEY))
except Exception as e:
self.logger.exception(e)
gevent.sleep(.1)
def hello(self, obj):
return self.json()
def get_sensor(self, index):
for sensor in self.sensors:
if sensor.index == index: return sensor
return False
def get_output(self, index):
for output in self.outputs:
if output.index == index: return output
return False
def get_input(self, index):
for input in self.inputs:
if input.index == index: return input
return False
def get_sensor_values(self, ob):
res = {}
for sensor in self.sensors:
res[sensor.id] = sensor.json()
return res
def get_output_values(self):
res = {}
for output in self.outputs:
res[ouput.id] = output.json()
return res
def set_output_state(self, ob):
output = self.get_output(ob.get('index'))
if output:
self.logger.info("%s: turning %s to %s index: %s" % (self.name, ob.get('type'), ob.get('state'), output.index))
output.set_state(ob.get('state'))
return dict(state=output.current_state)
def json(self, ob=None):
return dict(
name=self.name,
sensors=[s.json() for s in self.sensors],
outputs=[o.json() for o in self.outputs],
inputs=[i.json() for i in self.inputs],
triggers=[t.json() for t in self.triggers],
repeaters=[r.json() for r in self.repeaters],
clocks=[c.json() for c in self.clocks],
cls=self.__class__.__name__
)
def __conform__(self, protocol):
return json.dumps(self.json(), cls=ComplexEncoder)
def displayDeviceInfo(self):pass
#Event Handler Callback Functions
def inferfaceKitAttached(self, e):
attached = e.device
self.logger.info("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
self.logger.info("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
if e.eCode not in (36866,):
source = e.device
self.logger.info("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
self.logger.exception(e)
def interfaceKitInputChanged(self, e):
input = self.get_input(e.index)
if not input: return
val = input.do_conversion(e.value)
ob = input.json()
self.publish(ob)
self.logger.info("%s Input: %s" % (input.display, val))
def interfaceKitSensorChanged(self, e):
sensor = self.get_sensor(e.index)
if not sensor: return
val = sensor.do_conversion(float(e.value)) if sensor else 0
ob = sensor.json()
self.publish(ob)
self.logger.info("%s Sensor: %s" % (sensor.display, val))
def interfaceKitOutputChanged(self, e):
output = self.get_output(e.index)
if not output: return
output.current_state = e.state
ob = output.json()
self.publish(ob)
self.logger.info("%s Output: %s" % (output.display, output.current_state))
def run(self):
if LIVE: self.init_kit()
while True: gevent.sleep(.1)
def init_kit(self):
try:
self.interface_kit.setOnAttachHandler(self.inferfaceKitAttached)
self.interface_kit.setOnDetachHandler(self.interfaceKitDetached)
self.interface_kit.setOnErrorhandler(self.interfaceKitError)
self.interface_kit.setOnInputChangeHandler(self.interfaceKitInputChanged)
self.interface_kit.setOnOutputChangeHandler(self.interfaceKitOutputChanged)
self.interface_kit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Opening phidget object....")
try:
self.interface_kit.openPhidget()
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Waiting for attach....")
try:
self.interface_kit.waitForAttach(10000)
except PhidgetException as e:
self.logger.exception(e)
try:
self.interface_kit.closePhidget()
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Exiting....")
exit(1)
self.logger.info("Exiting....")
else:
self.displayDeviceInfo()
self.logger.info("Initializing Sensors")
for i in range(self.interface_kit.getSensorCount()):
try:
sensor = self.get_sensor(i)
if sensor:
self.logger.info("Setting Up: %s" % sensor.display)
self.logger.info("Change: %s" % sensor.change)
self.logger.info("Data Rate: %s" % sensor.data_rate)
self.interface_kit.setSensorChangeTrigger(i, sensor.change)
self.interface_kit.setDataRate(i, sensor.data_rate)
except PhidgetException as e:
self.logger.exception(e)
class force_glove:
def __init__(self, log_file):
self.interfaceKit = InterfaceKit()
self.log_file = log_file
try:
self.interfaceKit.setOnAttachHandler(self.interfaceKitAttached)
self.interfaceKit.setOnDetachHandler(self.interfaceKitDetached)
self.interfaceKit.setOnErrorhandler(self.interfaceKitError)
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Turning on glove....")
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for glove to attach....")
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
print "Glove connected..."
# self.displayDeviceInfo()
return
def setSensorRates(self):
for i in range(self.interfaceKit.getSensorCount()):
try:
self.interfaceKit.setDataRate(i, 2)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
return
def closeForceGlove(self):
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
print("Closed force glove...")
return
# Information Display Function
#def displayDeviceInfo(self):
# print("Glove " + self.interfaceKit.getDeviceName() + " found")
# print("Number of Sensor Inputs: %i" % (self.interfaceKit.getSensorCount()))
# Event Handler Callback Functions
def interfaceKitAttached(self, e):
attached = e.device
print("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
print("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def interfaceKitSensorChanged(self, e):
force_data = "%i,%i" % (e.index, e.value)
self.write_log(force_data)
print("Sensor %i: %i" % (e.index, e.value))
def write_log(self, glove_data):
if glove_data is not None:
to_log = ('%f,%s\r\n') % (time.time(), glove_data)
if not self.log_file.closed:
self.log_file.write(to_log)
class Pot:
__sensorPort = 1
__sampleRate = 4 # Maybe too high?
__potMin = 242
__potZero = 490
__potMax = 668
def __init__(self):
#Create an interfacekit object
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
self.interfaceKit.waitForAttach(10000)
self.interfaceKit.setDataRate(self.__sensorPort, self.__sampleRate)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def __del__(self):
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def getRawPot(self):
try:
resp = self.interfaceKit.getSensorValue(self.__sensorPort)
except PhidgetException as e:
# suppress print (makes testing harder) #TODO restore!!
resp = float('nan')
#print("Skipping reading - phidget Exception %i: %s" % (e.code, e.details))
return resp
#def recconect(self):
def getPot(self):
rawSensor = self.getRawPot()
value = 0.0
if rawSensor > self.__potMax:
#warnings.warn("Pot measuremens out of bounds.")
return 1.0
if rawSensor < self.__potMin:
#warnings.warn("Pot measuremens out of bounds.")
return -1.0
if rawSensor >= self.__potZero:
value = float(rawSensor - self.__potZero) / (self.__potMax - self.__potZero)
else:
value = float(rawSensor - self.__potZero) / (self.__potZero - self.__potMin)
return value
class PhidgetSensorHandler(AbstractSensorHandler):
def __init__(self):
self.device = None
self._attach_timeout = None
self._data_rate = None
self._sensors = None
def _try_init(self):
if all([self._data_rate, self._attach_timeout, self._sensors]):
try:
from Phidgets.Devices.InterfaceKit import InterfaceKit
from Phidgets.PhidgetException import PhidgetException
self.interface_kit = InterfaceKit()
self.interface_kit.setOnAttachHandler(
lambda e: self._attach(e))
self.interface_kit.setOnDetachHandler(
lambda e: self._detach(e))
self.interface_kit.setOnErrorhandler(lambda e: self._error(e))
self.interface_kit.setOnSensorChangeHandler(
lambda e: self._sensor_change(e))
self.interface_kit.openPhidget()
self.interface_kit.waitForAttach(self._attach_timeout)
for i in range(self.interface_kit.getSensorCount()):
self.interface_kit.setDataRate(i, self._data_rate)
logging.info("Phidget Sensor Handler Initalized")
for s in self._sensors:
if s.port_num is not None:
s.current_data = self.interface_kit.getSensorValue(
s.port_num)
logging.debug(
"Setting Initial Value for Sensor {} to {}".format(
s.port_num, s.current_data))
else:
logging.warn(
"Cannot set Initial Value for Sensor {}".format(
s.port_num))
except ImportError:
self.interface_kit = None
logging.error(
'Phidget Python Module not found. Did you install python-phidget?'
)
except PhidgetException as e:
self.interface_kit = None
logging.error("Could not Initalize Phidget Kit: {}".format(
e.details))
def _read_sensors(self):
ready_sensors = []
for s in self._sensors:
if s.data is not None:
ready_sensors.append(s)
return ready_sensors
def _set_sensors(self, v):
logging.debug('Adding Phidget Sensors :: {}'.format(v))
self._sensors = v
self._try_init()
sensors = property(_read_sensors, _set_sensors)
attach_timeout = property(
lambda self: self._attach_timeout,
lambda self, v: self._set_config('attach_timeout', v))
data_rate = property(lambda self: self._data_rate,
lambda self, v: self._set_config('data_rate', v))
def _set_config(self, prop, value):
if prop == 'data_rate':
self._data_rate = value
elif prop == 'attach_timeout':
self._attach_timeout = value
self._try_init()
def _attach(self, e):
self.device = e.device
logging.info("Phidget InterfaceKit {} Attached".format(
self.device.getSerialNum()))
def _detach(self, e):
logging.warn("Phidget InterfaceKit {} Removed".format(
e.device.getSerialNum()))
self.device = None
def _error(self, e):
logging.error("Phidget Error {} :: {}".format(e.eCode, e.description))
def _sensor_change(self, e):
# logging.debug("Phidget Analog Sensor Change :: Port: {} / Data: {}".format(e.index, e.value))
for s in self._sensors:
if s.port_type == 'analog' and s.port_num == e.index:
# Set a default ID if none given in config file
if s.id is None:
# Default ID is kit serial number::port
s.id = '{}:{}:{}'.format(self.device.getSerialNum(),
s.port_type, s.port_num)
s.current_data = e.value
# print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
interfaceKit.setOutputState(7, 1)
val = interfaceKit.getSensorValue(5)
print(val)
#print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
pass
#print("Phidget Exception %i: %s" % (e.code, e.details))
print("Closing...")
interfaceKit.setOutputState(7, 0)
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
print iii+1
interfaceKit.setOutputState (7, True)
interfaceKit.setOutputState (0, True)
sleep(0.38)
interfaceKit.setOutputState (7, False)
interfaceKit.setOutputState (0, False)
sleep(0.38)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Setting the data rate for each sensor index to 16ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(0, 16)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Closing program")
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
HOST = ''
PORT = 20000
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen(1)
print("Press Enter to quit....")
except PhidgetException as e:
print("InterfaceKit Close: Phidget Exception %i: %s" % (e.code, e.details))
try:
textLCD.closePhidget()
except PhidgetException as e:
print("LCD Close: Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
else:
DisplayInterfaceKitDeviceInfo()
print("Setting the data rate for each sensor index to 128ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 128)
except PhidgetException as e:
print("InterfaceKit SetDataRate: Phidget Exception %i: %s" % (e.code, e.details))
while (1):
try:
if textLCD.getDeviceID()==PhidgetID.PHIDID_TEXTLCD_ADAPTER:
textLCD.setScreenIndex(0)
textLCD.setScreenSize(TextLCD_ScreenSize.PHIDGET_TEXTLCD_SCREEN_2x8)
textLCD.setBacklight(True)
# print("Writing to first row....")
# textLCD.setDisplayString(0, " Cisco Live 2014 ")
# sleep(2)
class Pot:
__sensorPort = 1
__sampleRate = 4 # Maybe too high?
__potMin = 242
__potZero = 490
__potMax = 668
def __init__(self):
#Create an interfacekit object
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
self.interfaceKit.waitForAttach(10000)
self.interfaceKit.setDataRate(self.__sensorPort, self.__sampleRate)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def __del__(self):
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def getRawPot(self):
try:
resp = self.interfaceKit.getSensorValue(self.__sensorPort)
except PhidgetException as e:
# suppress print (makes testing harder) #TODO restore!!
resp = float('nan')
#print("Skipping reading - phidget Exception %i: %s" % (e.code, e.details))
return resp
#def recconect(self):
def getPot(self):
rawSensor = self.getRawPot()
value = 0.0
if rawSensor > self.__potMax:
#warnings.warn("Pot measuremens out of bounds.")
return 1.0
if rawSensor < self.__potMin:
#warnings.warn("Pot measuremens out of bounds.")
return -1.0
if rawSensor >= self.__potZero:
value = float(rawSensor - self.__potZero) / (self.__potMax - self.__potZero)
else:
value = float(rawSensor - self.__potZero) / (self.__potZero - self.__potMin)
return value
def main():
try:
interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
interfaceKit.setOnAttachHandler(inferfaceKitAttached)
interfaceKit.setOnDetachHandler(interfaceKitDetached)
interfaceKit.setOnErrorhandler(interfaceKitError)
interfaceKit.setOnInputChangeHandler(interfaceKitInputChanged)
interfaceKit.setOnOutputChangeHandler(interfaceKitOutputChanged)
interfaceKit.setOnSensorChangeHandler(interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
sys.exit(app.exec_())
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
