Tooltron

#!/usr/bin/python -i

"""

  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 allows you to interactively send crap to tooltron

import re

import sys

import serial

import MySQLdb

import getpass

from time import *

keypadTimeout = 11 #in seconds

TT_GET_KEY = 'k'

TT_SEND_KEY = 's' ############ put this in tooltron.py

TT_ACK     = 'a'

TT_NACK    = 'n'

TT_TO      = 'f'

TT_TIMEOUT = 't'

TT_ON      = 'o'

TT_PING    = 'g'

MAX_PAYLOAD_LEN = 32

BAUD_RATE = 9600

#fails until a warning is sent

MAX_TOOL_FAILS = 5

import time

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]))

    for c in msg[1:]:

        print str(ord(c)),

    print

if len(sys.argv) < 2:

    print "usage: manualtron.py /path/to/bus/device"

else:

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

    bus.flushInput()

    print bus

    #tn is an actual tool number

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

    def sendMessage(tn, cmd, msg):

       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)

    def sendTool(t):

        tn = t

        print "seding power to tool ID",tn

        sendMessage(tn, TT_ON, "")

    def sendKeyRequest():

       print "seding key request"

       sendMessage(2, TT_GET_KEY, "")

    def sendAck(toolNum):

       print "seding ACK to",toolNum

       sendMessage(toolNum, TT_ACK, "")

    def sendNack(toolNum):

       print "seding ACK 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):

       while len(data) < 6:

          data += bus.read(1)

       plen = data[4]

       if plen > 0:

          bus.read(ord(plen))

    # Returns [src, dest, cmd, data]

    def readMessage():

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

          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 0 #TODO: error

    def readKey():

       m = readMessage()

       if m == 0:

          return 0

       [src, dest, cmd, data] = m

       if cmd == TT_SEND_KEY:

          return data[0]

       else:

          return 0

    #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 == 0:

          return []

       [src, dest, cmd, data] = m

       return [src, dest, cmd]

    def checkAck(t):

        tn = t

        m = readTool()

        if m== []:

            return False

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

    def key():

       sendMessage(2,TT_GET_KEY,"")

       print readKey()