Tooltron

"""

  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>

"""

####

# This file contains common code for both manualTron and the real tooltron server

import serial

import sys

import time

import re

keypadTimeout = 31 #in seconds

TT_ACK     = 'a'

TT_NACK    = 'n'

TT_TIMEOUT = 't'

TT_KC        = 'x' # A transaction containing a key and a card number

TT_GRANT     = 'q' # Tool access granted

TT_DENY      = 'f' # Tool access denied

TT_PING    = 'g'

TT_BOOT    = 'b'

TT_PROGRAM_MODE = 'p'

TT_RESET = 'r'

TT_PING = 'g'

TT_BAD = 0

TT_PROGM = 'p'

TT_PROGD = 'd'

#depricated

TT_ON = 'o'

TT_MAX_RETRY = 3

MAX_PAYLOAD_LEN = 32

BAUD_RATE = 9600

# cardbox id

CARDBOX_ID = 2

#fails until a warning is sent

MAX_TOOL_FAILS = 5

bus = None

class BusException(Exception):

    def __str__(self):

        return "Bus Not Init'd"

class TimeoutException(Exception):

    def __init__(self, val):

        Exception.__init__(self)

        self.str = val

    def __str__(self):

        return "TimeoutException: " + self.str

def printMsg(msg):

    if len(msg) < 5:

        print "ERROR: trying to print message thats too small!"

        return

    if msg[0] == '^':

        print '^',

    else:

        print str(ord(msg[0]))

    print str(ord(msg[1])), str(ord(msg[2])),

    print msg[3],

    for c in msg[4:]:

        print str(ord(c)),

    print

#tn is an actual tool number

# ^ <src> <dest> <cmd> <plen> <payload> <crc>

def sendMessage(tn, cmd, msg):

    global bus

    if bus == None:

        raise BusException

    if len(msg) > MAX_PAYLOAD_LEN:

        print "ERROR: message too long! max size is " + str(MAX_PAYLOAD_LEN)

    else:

        body = chr(1) + chr(tn) + cmd + chr(len(msg)) + msg

        crc = 0

        for c in body:

            crc = crc ^ ord(c)

        msg = '^' + body + chr(crc)

        print "sending packet to tool",tn

        printMsg(msg)

        bus.write(msg)

    #time.sleep(0.05) #TODO: do I still need this?

def sendTool(t):

    tn = t

    print "sending power to tool ID",tn

    sendMessage(tn, TT_ON, "") #TT_GRANT, "")

def sendGrant():

    print "seding grant to cardbox (",CARDBOX_ID,")"

    sendMessage(CARDBOX_ID, TT_GRANT, "")

def sendDeny():

    print "seding deny to cardbox (",CARDBOX_ID,")"

    sendMessage(CARDBOX_ID, TT_DENY, "")

def sendAck(toolNum):

   print "seding ACK to",toolNum

   sendMessage(toolNum, TT_ACK, "")

def sendNack(toolNum):

   print "seding NACK to",toolNum

   sendMessage(toolNum, TT_NACK, "")

# This function eats the rest of the packet where data is what we have so far

def flushPacket(data):

    global bus

    if bus == None:

        raise BusException

    while len(data) < 6:

        c = bus.read(1)

        #print "("+str(ord(c))+")"

        data += c

    plen = data[4]

    if plen > 0:

        bus.read(ord(plen))

#reads until a timeout

def readInf():

    c = ' '

    while c != '':

        c = bus.read(1)

        if c != '':

            print "<" + str(ord(c)) + ">"

# Returns [src, dest, cmd, data]

def readMessage():

    global bus

    if bus == None:

        raise BusException

    start = bus.read(1)

    if start == '^':

        src = bus.read(1)

        if src == chr(1): #reflection

            print "(reflection)"

            flushPacket('^' + src)

            return readMessage()

        dest = bus.read(1)

        cmd = bus.read(1)

        plen = bus.read(1)

        data = bus.read(ord(plen))

        x = bus.read(1)

        print "got packet"

        printMsg('^' + src + dest + cmd + plen + data + x)

        crc = ord(src) ^ ord(dest) ^ ord(cmd) ^ ord(plen)

        for d in data:

            crc ^= ord(d)

        if crc == ord(x):

            return [src, dest, cmd, data]

        else:

            print "xor fail. got", str(ord(x)), "should have been got",crc

            return None

    else:

        if start == '':

            #print "ERROR: timeout on start delim"

            pass #TODO: do I need this printout for other (non-transaction reading) cases???

        else:

            print "ERROR: did not get start delimiter: "+str(ord(start))

        return None

# This function keeps trying to read the message until it gets something

def readMessageBlocking():

    print "blocking on read"

    m = None

    while m == None:

        m = readMessage();

    return m

#returns [key, cardnum] pair

def readTransaction():

    m = readMessageBlocking()

    if m != None:

        print "got a message:"

        [src, dest, cmd, data] = m

        src = ord(src)

        dest = ord(dest)

        print "src:", src, " (should be:",CARDBOX_ID,")"

        print "dest:", dest

        print "cmd:", cmd, " (should be:",TT_KC,")"

        print "len(data)", len(data)

        print "data:", data

        if src == CARDBOX_ID and cmd == TT_KC and len(data) >= 2:

            print "looks like a transaction"

            card = re.search('%([0-9]*)=.*', data[1:])

            if card != None:

                print "got a card number!"

                sendAck(CARDBOX_ID)

                return [data[0], card.group(1)] #return the key and parsed out cardnum

    # send nack if things didn't look right

    sendNack(CARDBOX_ID)

    return None

#returns [src, dest, command] or [] on error

# because of reflection, this will quietly ignore packets send by the server

def readTool():

    m = readMessage()

    if m == None:

        return None

    [src, dest, cmd, data] = m

    return [src, dest, cmd]

def checkAck(t):

    tn = t

    m = readTool()

    if m==None:

        print "timeout"

        return False

    [src,dest,cmd] = m

    return cmd == TT_ACK

def initBus(filename):

    global bus

    bus = serial.Serial(filename, BAUD_RATE, timeout = 1)

    bus.flushInput()

    print bus

    return True