Tooltron

#!/usr/bin/python

"""

  This file is part of Tooltron.

  Tooltron is free software: you can redistribute it and/or modify

  it under the terms of the Lesser GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  Tooltron is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  Lesser GNU General Public License for more details.

  You should have received a copy of the Lesser GNU General Public License

  along with Tooltron.  If not, see <http://www.gnu.org/licenses/>.

  Copyright 2009 Bradford Neuman <bneuman@andrew.cmu.edu>

"""

################################################################################

## dustmite.py is the main tooltron server

# It connects to the civicrm database of mysql and sends commands to

# the cardbox and tools.  It must be connected over usb to the card

# reader, and the two arguments specify the devices to use for the

# serial communication to the card and tool boxes.

#

# This script requires the modules seen below, which may not be

# present by default

#

# Because of a problem with card scans buffering in stdio, there is a

# seperate thread which stores the last swiped id. To cleanly exit the

# program type C-d

#

# email bradneuman@gmail.com if you have any questions

################################################################################

import re

import sys

import serial

import MySQLdb

import getpass

from time import *

keypad = []

keypadTimeout = 11 #in seconds

#this table maps which keypad button to press for each tool. This

#list should probably be printed next to the swipe box

tools = {

   'Bandsaw':['2','8'],

   'DrillPress':['1','9'],

   'Mill':['4'],

   'Lathe':['5'],

   #HACK: since the saw isn't used I use it for testing random boards

   'ChopMiterSaw':['3','7','0']

}

#this table maps keypad button numbers to tool IDs. The default is

#that the tool id is 10+the keypad number, but this would change if

#boards were swapped out. The tool ID number should be printed on the

#tool board, but needs to be hand coded into the toolbox code

ids = {

   '1':11,

   '2':12,

   '3':13,

   '4':14,

   '5':15,

   '6':16,

   '7':17,

   '8':18,

   '9':19,

   '0':13

}

TT_GET_KEY = 'k'

TT_ACK     = 'a'

TT_NACK    = 'n'

TT_TO      = 'f'

TT_TIMEOUT = 't'

BAUD_RATE = 9600

#fails until a warning is sent

MAX_TOOL_FAILS = 5

#################################################

#this code spawns a thread which always puts the last card id in the

#lastid variable.

#################################################

import threading

import time

lastid = None

idready = False

cv = threading.Condition()

class idThread ( threading.Thread ):

   def run ( self ):

       global lastid

       global idready

       try:

           while True:

               l = raw_input()

               cv.acquire()

               id = re.search('%([0-9]*)=.*', l)

               if id != None:

                   lastid = id

                   print "!!! setting idready"

                   idready = True

                   cv.notify()

               cv.release()

       except EOFError:

           cv.acquire()

           idready = True

           lastid=None

           cv.notify()

           cv.release()

#end thread

###############################################

flog = open("tooltron.log", "a")

def logMessage(str):

   flog.write(strftime("%Y.%m.%d %H:%M:%S ") + str + "\n")

logMessage("----- SERVER STARTED -----")

def keypad2toolID(t):

   if t in ids:

      return ids[t]

   else:

      return -1

def reverseTool(tn):

   for t in tools:

      if tn in tools[t]:

         return t

   return 'invalid'

#keep count of successive non-acks

toolFails = tools.copy()

for t in toolFails:

   toolFails[t] = 0

def get_last_id():

    global idready

    global lastid

    got = None

    print ">>> locking for last_id"

    cv.acquire()

    while not idready:

        print ">>> wait"

        cv.wait()

    print ">>> idready set"

    got = lastid

    idready = False

    cv.release()

    print ">>> done"

    return got

def clear_id():

    global idready

    global lastid

    print "=== locking to clear idready flag"

    cv.acquire()

    idready = False

    lastid = None

    cv.release()

    print "=== done"

    return

if len(sys.argv) < 3:

    print "usage: dustmite.py /path/to/keypad/device /path/to/tool/bus/device"

else:

    pw = getpass.getpass("mysql password: ")

    db = MySQLdb.connect(host="roboclub8.frc.ri.cmu.edu", user="tooltron", passwd=pw, db="civicrm")

    print "connected, now accepting input"

    logMessage("connected to database")

    #start the id scan thread AFTER the getpass prompt

    idThread().start()

    cursor = db.cursor()

    qry = "SELECT tools_6 FROM civicrm_value_roboclub_info_2 WHERE card_number_1 = "

    # user has 10 seconds to press a key, after that the keypad device

    # should send a timeout packet. This is a non-blocking serial

    # device so we can re-transmit the key request when the user

    # swipes a card instead of being stuck on a blocking read call

    keypad = serial.Serial(sys.argv[1], BAUD_RATE, timeout = 0) 

    keypad.flushInput()

    print keypad

    bus = serial.Serial(sys.argv[2], BAUD_RATE, timeout = 2)

    bus.flushInput()

    print bus

    # ^ <src> <dest> <data>

    def sendTool(t):

        tn = keypad2toolID(t)

        msg = '^' + chr(1) + chr(tn) + 'O' + chr(1 ^ tn ^ ord('O'))

        print "seding power to tool ID",tn

        bus.write(msg)

        return

    #returns [src, data] or [] on error

    def readTool():

        ret = [0,0,0]

        if bus.read(1) == '^':

            ret[0] = bus.read(1)

            ret[1] = bus.read(1)

            ret[2] = bus.read(1)

            x = bus.read(1)

            print "got packet",ret

            if chr(ord(ret[0]) ^ ord(ret[1]) ^ ord(ret[2])) == x:

                return ret

            else:

                print "xor fail. got", x, "should have been got",(ord(ret[0]) ^ ord(ret[1]) ^ ord(ret[2]))

        return []

    def checkAck(t):

        tn = keypad2toolID(t)

        m = readTool()

        if m== []:

            return False

        return m[0] == chr(tn) and m[1] == chr(1) and m[2] == 'A'

    while True:

        id = get_last_id()

        if id != None:

            print "\n-----------\nid# ", id.group(1)

            print "sending key request"

            keypad.write(TT_GET_KEY)

            cursor.execute(qry + id.group(1))

            result = cursor.fetchall()

            acl = []

            for r in result:

                tls = r[0].split("\x01")

                for t in tls:

                    if t != '':

                        try:

                            acl.extend (tools[t])

                        except KeyError:

                            #this doesn't really matter

                            pass

            print "user has access to:", acl

            user = "user"

            startTime = time.time();

            resp = ""

            while resp=="":

               resp = keypad.read(1)

               #no lock since we are just reading and we can afford to

               #miss a loop

               if idready == True:

                  #if someone swipes, break out of the loop

                  print "**swipe during read, bailing out"

                  logMessage("user swipped during keypad read")

                  break

               if time.time() - startTime > keypadTimeout:

                  print "KEYPAD TIMEOUT!"

                  logMessage("keypad timed out")

                  break

            #if we have a vaid response

            if resp != "" and resp != TT_TIMEOUT:

               toolName = reverseTool(resp)

               toolNameLong = toolName + " (k="+str(resp)+", t="+str(keypad2toolID(resp))+")"

               print "request:",resp,toolNameLong

               if acl.count(resp) > 0:

                  keypad.write(TT_ACK)

                  sendTool(resp)

                  print "ACCESS GRANTED"

                  logMessage(user+" accessed tool "+toolNameLong)

                  if checkAck(resp):

                     print "ACK"

                     toolFails[toolName] = 0

                  else:

                     print "NO ACK!!!!"

                     logMessage("tool "+toolNameLong+" did not ACK")

                     toolFails[toolName] += 1

                     if toolFails > MAX_TOOL_FAILS:

                        #TODO: send email

                        logMessage("WARNING: tool "+toolNameLong+

                                   " has failed to ACK "+

                                   str(MAX_TOOL_FAILS)+" times in a row.")

               else:

                  keypad.write(TT_NACK)

                  print "ACCESS DENIED!!"

                  logMessage(user + " denied on tool "+toolNameLong)

               clear_id()

        else:

            break