Moved board definition from apimote to apimote1 for versioning support.
[goodfet] / client / GoodFET.py
index a31676c..6fd0f29 100755 (executable)
 #
 # This code is being rewritten and refactored.  You've been warned!
 
-import sys, time, string, cStringIO, struct, glob, serial, os;
+import sys, time, string, cStringIO, struct, glob, os;
+import sqlite3;
 
+fmt = ("B", "<H", None, "<L")
 
+def getClient(name="GoodFET"):
+    import GoodFET, GoodFETCC, GoodFETAVR, GoodFETSPI, GoodFETMSP430, GoodFETNRF, GoodFETCCSPI;
+    if(name=="GoodFET" or name=="monitor"): return GoodFET.GoodFET();
+    elif name=="cc" or name=="cc51": return GoodFETCC.GoodFETCC();
+    elif name=="cc2420" or name=="ccspi": return GoodFETCCSPI.GoodFETCCSPI();
+    elif name=="avr": return GoodFETAVR.GoodFETAVR();
+    elif name=="spi": return GoodFETSPI.GoodFETSPI();
+    elif name=="msp430": return GoodFETMSP430.GoodFETMSP430();
+    elif name=="nrf": return GoodFETNRF.GoodFETNRF();
+    
+    print "Unsupported target: %s" % name;
+    sys.exit(0);
+
+class SymbolTable:
+    """GoodFET Symbol Table"""
+    db=sqlite3.connect(":memory:");
+    
+    def __init__(self, *args, **kargs):
+        self.db.execute("create table if not exists symbols(adr,name,memory,size,comment);");
+    def get(self,name):
+        self.db.commit();
+        c=self.db.cursor();
+        try:
+            c.execute("select adr,memory from symbols where name=?",(name,));
+            for row in c:
+                #print "Found it.";
+                sys.stdout.flush();
+                return row[0];
+            #print "No dice.";
+        except:# sqlite3.OperationalError:
+            #print "SQL error.";
+            return eval(name);
+        return eval(name);
+    def define(self,adr,name,comment="",memory="vn",size=16):
+        self.db.execute("insert into symbols(adr,name,memory,size,comment)"
+                        "values(?,?,?,?,?);", (
+                adr,name,memory,size,comment));
+        #print "Set %s=%s." % (name,adr);
+class GoodFETbtser:
+    """py-bluez class for emulating py-serial."""
+    def __init__(self,btaddr):
+        import bluetooth;
+        if btaddr==None or btaddr=="none" or btaddr=="bluetooth":
+            print "performing inquiry..."
+            nearby_devices = bluetooth.discover_devices(lookup_names = True)
+            print "found %d devices" % len(nearby_devices)
+            for addr, name in nearby_devices:
+                print "  %s - '%s'" % (addr, name)
+                #TODO switch to wildcards.
+                if name=='FireFly-A6BD':
+                    btaddr=addr;
+                if name=='RN42-A94A':
+                    btaddr=addr;
+                
+            print "Please set $GOODFET to the address of your device.";
+            sys.exit();
+        print "Identified GoodFET at %s" % btaddr;
+
+        # Manually use the portnumber.
+        port=1;
+        
+        print "Connecting to %s on port %i." % (btaddr, port);
+        sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM);
+        self.sock=sock;
+        sock.connect((btaddr,port));
+        sock.settimeout(10);  #IMPORTANT Must be patient.
+        
+        ##This is what we'd do for a normal reset.
+        #str="";
+        #while not str.endswith("goodfet.sf.net/"):
+        #    str=self.read(64);
+        #    print str;
+        
+        # Instead, just return and hope for the best.
+        return;
+        
+    def write(self,msg):
+        """Send traffic."""
+        import time;
+        self.sock.send(msg);
+        #time.sleep(0.1);
+        return;
+    def read(self,length):
+        """Read traffic."""
+        data="";
+        while len(data)<length:
+            data=data+self.sock.recv(length-len(data));
+        return data;
 class GoodFET:
     """GoodFET Client Library"""
+
+    besilent=0;
+    app=0;
+    verb=0;
+    count=0;
+    data="";
+    verbose=False
+    
+    GLITCHAPP=0x71;
+    MONITORAPP=0x00;
+    symbols=SymbolTable();
+    
     def __init__(self, *args, **kargs):
         self.data=[0];
+    def getConsole(self):
+        from GoodFETConsole import GoodFETConsole;
+        return GoodFETConsole(self);
+    def name2adr(self,name):
+        return self.symbols.get(name);
     def timeout(self):
         print "timeout\n";
-    def serInit(self, port=None):
+    def serInit(self, port=None, timeout=2, attemptlimit=None):
+        """Open a serial port of some kind."""
+        import re;
+        
+        if port==None:
+            port=os.environ.get("GOODFET");
+        if port=="bluetooth" or (port is not None and re.match("..:..:..:..:..:..",port)):
+            self.btInit(port,timeout,attemptlimit);
+        else:
+            self.pyserInit(port,timeout,attemptlimit);
+    def btInit(self, port, timeout, attemptlimit):
+        """Open a bluetooth port.""";
+        #self.verbose=True;  #For debugging BT.
+        self.serialport=GoodFETbtser(port);
+        
+    def pyserInit(self, port, timeout, attemptlimit):
         """Open the serial port"""
+        # Make timeout None to wait forever, 0 for non-blocking mode.
+        import serial;
+        
+        if os.name=='nt' and sys.version.find('64 bit')!=-1:
+            print "WARNING: PySerial requires a 32-bit Python build in Windows.";
         
         if port is None and os.environ.get("GOODFET")!=None:
             glob_list = glob.glob(os.environ.get("GOODFET"));
             if len(glob_list) > 0:
                 port = glob_list[0];
+            else:
+                port = os.environ.get("GOODFET");
         if port is None:
             glob_list = glob.glob("/dev/tty.usbserial*");
             if len(glob_list) > 0:
@@ -29,69 +158,358 @@ class GoodFET:
             glob_list = glob.glob("/dev/ttyUSB*");
             if len(glob_list) > 0:
                 port = glob_list[0];
+        if port is None:
+            glob_list = glob.glob("/dev/ttyU0");
+            if len(glob_list) > 0:
+                port = glob_list[0];
+        if port is None and os.name=='nt':
+            from scanwin32 import winScan;
+            scan=winScan();
+            for order,comport,desc,hwid in sorted(scan.comports()):
+                try:
+                    if hwid.index('FTDI')==0:
+                        port=comport;
+                        #print "Using FTDI port %s" % port
+                except:
+                    #Do nothing.
+                    a=1;
         
+        baud=115200;
+        if(os.environ.get("platform")=='arduino' or os.environ.get("board")=='arduino'):
+            baud=19200; #Slower, for now.
         self.serialport = serial.Serial(
             port,
             #9600,
-            115200,
-            parity = serial.PARITY_NONE
+            baud,
+            parity = serial.PARITY_NONE,
+            timeout=timeout
             )
-        #Drop DTR, which is !RST, low to begin the app.
-        self.serialport.setDTR(0);
-        self.serialport.flushInput()
-        self.serialport.flushOutput()
         
-        #Read and handle the initial command.
-        #time.sleep(1);
-        self.readcmd(); #Read the first command.
-        if(self.verb!=0x7F):
-            print "Verb %02x is wrong.  Incorrect firmware?" % self.verb;
-        #print "Connected."
+        self.verb=0;
+        attempts=0;
+        connected=0;
+        while connected==0:
+            while self.verb!=0x7F or self.data!="http://goodfet.sf.net/":
+            #while self.data!="http://goodfet.sf.net/":
+                #print "'%s'!=\n'%s'" % (self.data,"http://goodfet.sf.net/");
+                if attemptlimit is not None and attempts >= attemptlimit:
+                    return
+                elif attempts>2:
+                    print "Resyncing.";
+                self.serialport.flushInput()
+                self.serialport.flushOutput()
+                
+                #TelosB reset, prefer software to I2C SPST Switch.
+                if (os.environ.get("platform")=='telosb' or  os.environ.get("board")=='telosb'):
+                    #print "TelosB Reset";
+                    self.telosBReset();
+                elif (os.environ.get("board")=='zolertiaz1' or  os.environ.get("board")=='z1'):
+                    self.bslResetZ1();
+                elif (os.environ.get("board")=='apimote1'):
+                    #Explicitly set RTS and DTR to halt board.
+                    self.serialport.setRTS(1);
+                    self.serialport.setDTR(1);
+                    #RTS pin, not DTR is used for reset.
+                    self.serialport.setRTS(0);
+                    #print "Resetting Apimote not yet tested.";
+                else:
+                    #Explicitly set RTS and DTR to halt board.
+                    self.serialport.setRTS(1);
+                    self.serialport.setDTR(1);
+                    #Drop DTR, which is !RST, low to begin the app.
+                    self.serialport.setDTR(0);
+                
+                #self.serialport.write(chr(0x80));
+                #self.serialport.write(chr(0x80));
+                #self.serialport.write(chr(0x80));
+                #self.serialport.write(chr(0x80));
+                
+                
+                #self.serialport.flushInput()
+                #self.serialport.flushOutput()
+                #time.sleep(60);
+                attempts=attempts+1;
+                self.readcmd(); #Read the first command.
+                #print "Got %02x,%02x:'%s'" % (self.app,self.verb,self.data);
+            #Here we have a connection, but maybe not a good one.
+            #print "We have a connection."
+            connected=1;
+            olds=self.infostring();
+            clocking=self.monitorclocking();
+            for foo in range(1,30):
+                if not self.monitorecho():
+                    if self.verbose:
+                        print "Comm error on %i try, resyncing out of %s." % (foo,
+                                                                              clocking);
+                        connected=0;
+                        break;
+        if self.verbose: print "Connected after %02i attempts." % attempts;
+        self.mon_connected();
+        self.serialport.setTimeout(12);
+    def serClose(self):
+        self.serialport.close();
+    def telosSetSCL(self, level):
+        self.serialport.setRTS(not level)
+    def telosSetSDA(self, level):
+        self.serialport.setDTR(not level)
+
+    def telosI2CStart(self):
+        self.telosSetSDA(1)
+        self.telosSetSCL(1)
+        self.telosSetSDA(0)
+
+    def telosI2CStop(self):
+        self.telosSetSDA(0)
+        self.telosSetSCL(1)
+        self.telosSetSDA(1)
+
+    def telosI2CWriteBit(self, bit):
+        self.telosSetSCL(0)
+        self.telosSetSDA(bit)
+        time.sleep(2e-6)
+        self.telosSetSCL(1)
+        time.sleep(1e-6)
+        self.telosSetSCL(0)
+
+    def telosI2CWriteByte(self, byte):
+        self.telosI2CWriteBit( byte & 0x80 );
+        self.telosI2CWriteBit( byte & 0x40 );
+        self.telosI2CWriteBit( byte & 0x20 );
+        self.telosI2CWriteBit( byte & 0x10 );
+        self.telosI2CWriteBit( byte & 0x08 );
+        self.telosI2CWriteBit( byte & 0x04 );
+        self.telosI2CWriteBit( byte & 0x02 );
+        self.telosI2CWriteBit( byte & 0x01 );
+        self.telosI2CWriteBit( 0 );  # "acknowledge"
+
+    def telosI2CWriteCmd(self, addr, cmdbyte):
+        self.telosI2CStart()
+        self.telosI2CWriteByte( 0x90 | (addr << 1) )
+        self.telosI2CWriteByte( cmdbyte )
+        self.telosI2CStop()
+    def bslResetZ1(self, invokeBSL=0):
+        '''
+        Applies BSL entry sequence on RST/NMI and TEST/VPP pins
+        Parameters:
+            invokeBSL = 1: complete sequence
+            invokeBSL = 0: only RST/NMI pin accessed
+            
+        By now only BSL mode is accessed
+        '''
+        
+        #if DEBUG > 1: sys.stderr.write("* bslReset(invokeBSL=%s)\n" % invokeBSL)
+        if invokeBSL:
+            #sys.stderr.write("in Z1 bsl reset...\n")
+            time.sleep(0.1)
+            self.writepicROM(0xFF, 0xFF)
+            time.sleep(0.1)
+            #sys.stderr.write("z1 bsl reset done...\n")
+        else:
+            #sys.stderr.write("in Z1 reset...\n")
+            time.sleep(0.1)
+            self.writepicROM(0xFF, 0xFE)
+            time.sleep(0.1)
+            #sys.stderr.write("z1 reset done...\n")
+    def writepicROM(self, address, data):
+        ''' Writes data to @address'''
+        for i in range(7,-1,-1):
+            self.picROMclock((address >> i) & 0x01)
+        self.picROMclock(0)
+        recbuf = 0
+        for i in range(7,-1,-1):
+            s = ((data >> i) & 0x01)
+            #print s
+            if i < 1:
+                r = not self.picROMclock(s, True)
+            else:
+                r = not self.picROMclock(s)
+            recbuf = (recbuf << 1) + r
+
+        self.picROMclock(0, True)
+        #k = 1
+        #while not self.serial.getCTS():
+        #    pass 
+        #time.sleep(0.1)
+        return recbuf
+    def readpicROM(self, address):
+        ''' reads a byte from @address'''
+        for i in range(7,-1,-1):
+            self.picROMclock((address >> i) & 0x01)
+        self.picROMclock(1)
+        recbuf = 0
+        r = 0
+        for i in range(7,-1,-1):
+            r = self.picROMclock(0)
+            recbuf = (recbuf << 1) + r
+        self.picROMclock(r)
+        #time.sleep(0.1)
+        return recbuf
+        
+    def picROMclock(self, masterout, slow = False):
+        #print "setting masterout to "+str(masterout)
+        self.serialport.setRTS(masterout)
+        self.serialport.setDTR(1)
+        #time.sleep(0.02)
+        self.serialport.setDTR(0)
+        if slow:
+            time.sleep(0.02)
+        return self.serialport.getCTS()
+
+    def picROMfastclock(self, masterout):
+        #print "setting masterout to "+str(masterout)
+        self.serialport.setRTS(masterout)
+        self.serialport.setDTR(1)
+        self.serialport.setDTR(0)
+        time.sleep(0.02)
+        return self.serialport.getCTS()
+
+    def telosBReset(self,invokeBSL=0):
+        # "BSL entry sequence at dedicated JTAG pins"
+        # rst !s0: 0 0 0 0 1 1
+        # tck !s1: 1 0 1 0 0 1
+        #   s0|s1: 1 3 1 3 2 0
+
+        # "BSL entry sequence at shared JTAG pins"
+        # rst !s0: 0 0 0 0 1 1
+        # tck !s1: 0 1 0 1 1 0
+        #   s0|s1: 3 1 3 1 0 2
+
+        if invokeBSL:
+            self.telosI2CWriteCmd(0,1)
+            self.telosI2CWriteCmd(0,3)
+            self.telosI2CWriteCmd(0,1)
+            self.telosI2CWriteCmd(0,3)
+            self.telosI2CWriteCmd(0,2)
+            self.telosI2CWriteCmd(0,0)
+        else:
+            self.telosI2CWriteCmd(0,3)
+            self.telosI2CWriteCmd(0,2)
+
+        # This line was not defined inside the else: block, not sure where it
+        # should be however
+        self.telosI2CWriteCmd(0,0)
+        time.sleep(0.250)       #give MSP430's oscillator time to stabilize
+        self.serialport.flushInput()  #clear buffers
+
+
     def getbuffer(self,size=0x1c00):
         writecmd(0,0xC2,[size&0xFF,(size>>16)&0xFF]);
         print "Got %02x%02x buffer size." % (self.data[1],self.data[0]);
-    def writecmd(self, app, verb, count=0, data=[], blocks=1):
+    def writecmd(self, app, verb, count=0, data=[]):
         """Write a command and some data to the GoodFET."""
         self.serialport.write(chr(app));
         self.serialport.write(chr(verb));
-        self.serialport.write(chr(count));
-        #print "count=%02x, len(data)=%04x" % (count,len(data));
-        if count!=0:
-            for d in data:
-                self.serialport.write(chr(d));
         
-        #self.serialport.flushOutput();
-        #self.serialport.flushInput();
+        #if data!=None:
+        #    count=len(data); #Initial count ignored.
         
+        #print "TX %02x %02x %04x" % (app,verb,count);
         
-        if not self.besilent:
-            self.readcmd(blocks);
+        #little endian 16-bit length
+        self.serialport.write(chr(count&0xFF));
+        self.serialport.write(chr(count>>8));
+
+        if self.verbose:
+            print "Tx: ( 0x%02x, 0x%02x, 0x%04x )" % ( app, verb, count )
         
-    besilent=0;
-    app=0;
-    verb=0;
-    count=0;
-    data="";
+        #print "count=%02x, len(data)=%04x" % (count,len(data));
+        
+        if count!=0:
+            if(isinstance(data,list)):
+                for i in range(0,count):
+                #print "Converting %02x at %i" % (data[i],i)
+                    data[i]=chr(data[i]);
+            #print type(data);
+            outstr=''.join(data);
+            self.serialport.write(outstr);
+        if not self.besilent:
+            return self.readcmd()
+        else:
+            return []
 
-    def readcmd(self,blocks=1):
+    def readcmd(self):
         """Read a reply from the GoodFET."""
-        while 1:
-            #print "Reading...";
-            self.app=ord(self.serialport.read(1));
-            #print "APP=%2x" % self.app;
-            self.verb=ord(self.serialport.read(1));
-            #print "VERB=%02x" % self.verb;
-            self.count=ord(self.serialport.read(1));
-            #print "Waiting for %i bytes." % self.count;
-            
-            #print "READ %02x %02x %02x " % (self.app, self.verb, self.count);
+        while 1:#self.serialport.inWaiting(): # Loop while input data is available
+            try:
+                #print "Reading...";
+                self.app=ord(self.serialport.read(1));
+                #print "APP=%02x" % self.app;
+                self.verb=ord(self.serialport.read(1));
+                
+                #Fixes an obscure bug in the TelosB.
+                if self.app==0x00:
+                    while self.verb==0x00:
+                        self.verb=ord(self.serialport.read(1));
+                
+                #print "VERB=%02x" % self.verb;
+                self.count=(
+                    ord(self.serialport.read(1))
+                    +(ord(self.serialport.read(1))<<8)
+                    );
+
+                if self.verbose:
+                    print "Rx: ( 0x%02x, 0x%02x, 0x%04x )" % ( self.app, self.verb, self.count )
             
-            #Debugging string; print, but wait.
-            if self.app==0xFF and self.verb==0xFF:
-                print "DEBUG %s" % self.serialport.read(self.count);
-            else:
-                self.data=self.serialport.read(self.count*blocks);
+                #Debugging string; print, but wait.
+                if self.app==0xFF:
+                    if self.verb==0xFF:
+                        print "# DEBUG %s" % self.serialport.read(self.count)
+                           elif self.verb==0xFE:
+                        print "# DEBUG 0x%x" % struct.unpack(fmt[self.count-1], self.serialport.read(self.count))[0]
+                    elif self.verb==0xFD:
+                        #Do nothing, just wait so there's no timeout.
+                        print "# NOP.";
+                        
+                    sys.stdout.flush();
+                else:
+                    self.data=self.serialport.read(self.count);
+                    return self.data;
+            except TypeError:
+                if self.connected:
+                    print "Warning: waiting for serial read timed out (most likely).";
+                    #print "This shouldn't happen after syncing.  Exiting for safety.";                    
+                    #sys.exit(-1)
                 return self.data;
+    #Glitching stuff.
+    def glitchApp(self,app):
+        """Glitch into a device by its application."""
+        self.data=[app&0xff];
+        self.writecmd(self.GLITCHAPP,0x80,1,self.data);
+        #return ord(self.data[0]);
+    def glitchVerb(self,app,verb,data):
+        """Glitch during a transaction."""
+        if data==None: data=[];
+        self.data=[app&0xff, verb&0xFF]+data;
+        self.writecmd(self.GLITCHAPP,0x81,len(self.data),self.data);
+        #return ord(self.data[0]);
+    def glitchstart(self):
+        """Glitch into the AVR application."""
+        self.glitchVerb(self.APP,0x20,None);
+    def glitchstarttime(self):
+        """Measure the timer of the START verb."""
+        return self.glitchTime(self.APP,0x20,None);
+    def glitchTime(self,app,verb,data):
+        """Time the execution of a verb."""
+        if data==None: data=[];
+        self.data=[app&0xff, verb&0xFF]+data;
+        print "Timing app %02x verb %02x." % (app,verb);
+        self.writecmd(self.GLITCHAPP,0x82,len(self.data),self.data);
+        time=ord(self.data[0])+(ord(self.data[1])<<8);
+        print "Timed to be %i." % time;
+        return time;
+    def glitchVoltages(self,low=0x0880, high=0x0fff):
+        """Set glitching voltages. (0x0fff is max.)"""
+        self.data=[low&0xff, (low>>8)&0xff,
+                   high&0xff, (high>>8)&0xff];
+        self.writecmd(self.GLITCHAPP,0x90,4,self.data);
+        #return ord(self.data[0]);
+    def glitchRate(self,count=0x0800):
+        """Set glitching count period."""
+        self.data=[count&0xff, (count>>8)&0xff];
+        self.writecmd(self.GLITCHAPP,0x91,2,
+                      self.data);
+        #return ord(self.data[0]);
+    
     
     #Monitor stuff
     def silent(self,s=0):
@@ -99,31 +517,79 @@ class GoodFET:
         self.besilent=s;
         print "besilent is %i" % self.besilent;
         self.writecmd(0,0xB0,1,[s]);
-        
+    connected=0;
+    def mon_connected(self):
+        """Announce to the monitor that the connection is good."""
+        self.connected=1;
+        self.writecmd(0,0xB1,0,[]);
     def out(self,byte):
         """Write a byte to P5OUT."""
         self.writecmd(0,0xA1,1,[byte]);
     def dir(self,byte):
         """Write a byte to P5DIR."""
         self.writecmd(0,0xA0,1,[byte]);
-    def peekbyte(self,address):
+    def call(self,adr):
+        """Call to an address."""
+        self.writecmd(0,0x30,2,
+                      [adr&0xFF,(adr>>8)&0xFF]);
+    def execute(self,code):
+        """Execute supplied code."""
+        self.writecmd(0,0x31,2,#len(code),
+                      code);
+    def MONpeek8(self,address):
         """Read a byte of memory from the monitor."""
         self.data=[address&0xff,address>>8];
         self.writecmd(0,0x02,2,self.data);
         #self.readcmd();
         return ord(self.data[0]);
-    def peekword(self,address):
+    def MONpeek16(self,address):
+        """Read a word of memory from the monitor."""
+        return self.MONpeek8(address)+(self.MONpeek8(address+1)<<8);
+    def peek(self,address):
+        """Read a word of memory from the monitor."""
+        return self.MONpeek8(address)+(self.MONpeek8(address+1)<<8);
+    def eeprompeek(self,address):
         """Read a word of memory from the monitor."""
-        return self.peekbyte(address)+(self.peekbyte(address+1)<<8);
-    def pokebyte(self,address,value):
+        print "EEPROM peeking not supported for the monitor.";
+        #return self.MONpeek8(address)+(self.MONpeek8(address+1)<<8);
+    def peekbysym(self,name):
+        """Read a value by its symbol name."""
+        #TODO include memory in symbol.
+        reg=self.symbols.get(name);
+        return self.peek8(reg,"data");
+    def pokebysym(self,name,val):
+        """Write a value by its symbol name."""
+        #TODO include memory in symbol.
+        reg=self.symbols.get(name);
+        return self.pokebyte(reg,val);
+    def pokebyte(self,address,value,memory="vn"):
         """Set a byte of memory by the monitor."""
         self.data=[address&0xff,address>>8,value];
         self.writecmd(0,0x03,3,self.data);
         return ord(self.data[0]);
+    def poke16(self,address,value):
+        """Set a word of memory by the monitor."""
+        self.pokebyte(address,value&0xFF);
+        self.pokebyte(address,(value>>8)&0xFF);
+        return value;
+    def setsecret(self,value):
+        """Set a secret word for later retreival.  Used by glitcher."""
+        #self.eeprompoke(0,value);
+        #self.eeprompoke(1,value);
+        print "Secret setting is not yet suppored for this target.";
+        print "Aborting.";
+        
+    def getsecret(self):
+        """Get a secret word.  Used by glitcher."""
+        #self.eeprompeek(0);
+        print "Secret getting is not yet suppored for this target.";
+        print "Aborting.";
+        sys.exit();
+    
     def dumpmem(self,begin,end):
         i=begin;
         while i<end:
-            print "%04x %04x" % (i, self.peekword(i));
+            print "%04x %04x" % (i, self.MONpeek16(i));
             i+=2;
     def monitor_ram_pattern(self):
         """Overwrite all of RAM with 0xBEEF."""
@@ -177,168 +643,134 @@ class GoodFET:
     def monitortest(self):
         """Self-test several functions through the monitor."""
         print "Performing monitor self-test.";
-        
-        if self.peekword(0x0c00)!=0x0c04 and self.peekword(0x0c00)!=0x0c06:
-            print "ERROR Fetched wrong value from 0x0c04.";
-        self.pokebyte(0x0021,0); #Drop LED
-        if self.peekbyte(0x0021)!=0:
-            print "ERROR, P1OUT not cleared.";
-        self.pokebyte(0x0021,1); #Light LED
-        
+        self.monitorclocking();
+        for f in range(0,3000):
+            a=self.MONpeek16(0x0c00);
+            b=self.MONpeek16(0x0c02);
+            if a!=0x0c04 and a!=0x0c06:
+                print "ERROR Fetched %04x, %04x" % (a,b);
+            self.pokebyte(0x0021,0); #Drop LED
+            if self.MONpeek8(0x0021)!=0:
+                print "ERROR, P1OUT not cleared.";
+            self.pokebyte(0x0021,1); #Light LED
+            if not self.monitorecho():
+                print "Echo test failed.";
         print "Self-test complete.";
-    
-    
+        self.monitorclocking();
+    def monitorecho(self):
+        data="The quick brown fox jumped over the lazy dog.";
+        self.writecmd(self.MONITORAPP,0x81,len(data),data);
+        if self.data!=data:
+            print "Comm error recognized by monitorecho(), got:\n%s" % self.data;
+            return 0;
+        return 1;
 
-    def I2Csetup(self):
-        """Move the FET into the I2C application."""
-        self.writecmd(0x02,0x10,0,self.data); #SPI/SETUP
-    def I2Cstart(self):
-        """Start an I2C transaction."""
-        self.writecmd(0x02,0x20,0,self.data); #SPI/SETUP
-    def I2Cstop(self):
-        """Stop an I2C transaction."""
-        self.writecmd(0x02,0x21,0,self.data); #SPI/SETUP
-    def I2Cread(self,len=1):
-        """Read len bytes by I2C."""
-        self.writecmd(0x02,0x00,1,[len]); #SPI/SETUP
-        return self.data;
-    def I2Cwrite(self,bytes):
-        """Write bytes by I2C."""
-        self.writecmd(0x02,0x01,len(bytes),bytes); #SPI/SETUP
-        return ord(self.data[0]);
-class GoodFETCC(GoodFET):
-    """A GoodFET variant for use with Chipcon 8051 Zigbe SoC."""
-    def CChaltcpu(self):
-        """Halt the CPU."""
-        self.writecmd(0x30,0x86,0,self.data);
-    def CCreleasecpu(self):
-        """Resume the CPU."""
-        self.writecmd(0x30,0x87,0,self.data);
-    def CCtest(self):
-        self.CCreleasecpu();
-        self.CChaltcpu();
-        #print "Status: %s" % self.CCstatusstr();
-        
-        #Grab ident three times, should be equal.
-        ident1=self.CCident();
-        ident2=self.CCident();
-        ident3=self.CCident();
-        if(ident1!=ident2 or ident2!=ident3):
-            print "Error, repeated ident attempts unequal."
-            print "%04x, %04x, %04x" % (ident1, ident2, ident3);
-        
-        #Single step, printing PC.
-        print "Tracing execution at startup."
-        for i in range(1,15):
-            pc=self.CCgetPC();
-            byte=self.CCpeekcodebyte(i);
-            #print "PC=%04x, %02x" % (pc, byte);
-            self.CCstep_instr();
-        
-        print "Verifying that debugging a NOP doesn't affect the PC."
-        for i in range(1,15):
-            pc=self.CCgetPC();
-            self.CCdebuginstr([0x00]);
-            if(pc!=self.CCgetPC()):
-                print "ERROR: PC changed during CCdebuginstr([NOP])!";
-        
-        
-        #print "Status: %s." % self.CCstatusstr();
-        #Exit debugger
-        self.CCstop();
-        print "Done.";
+    def monitor_info(self):
+        print "GoodFET with %s MCU" % self.infostring();
+        print "Clocked at %s" % self.monitorclocking();
+        return 1;
 
-    def CCsetup(self):
-        """Move the FET into the CC2430/CC2530 application."""
-        #print "Initializing Chipcon.";
-        self.writecmd(0x30,0x10,0,self.data);
-    def CCrd_config(self):
-        """Read the config register of a Chipcon."""
-        self.writecmd(0x30,0x82,0,self.data);
-        return ord(self.data[0]);
-    def CCwr_config(self,config):
-        """Write the config register of a Chipcon."""
-        self.writecmd(0x30,0x81,1,[config&0xFF]);
-    
-    CCversions={0x0100:"CC1110",
-                0x8500:"CC2430",
-                0x8900:"CC2431",
-                0x8100:"CC2510",
-                0x9100:"CC2511",
-                0xFF00:"CCmissing"};
-    def CCidentstr(self):
-        ident=self.CCident();
-        chip=self.CCversions.get(ident&0xFF00);
-        return "%s/r%02x" % (chip, ident&0xFF); 
-    def CCident(self):
-        """Get a chipcon's ID."""
-        self.writecmd(0x30,0x8B,0,None);
-        chip=ord(self.data[0]);
-        rev=ord(self.data[1]);
-        return (chip<<8)+rev;
-    def CCgetPC(self):
-        """Get a chipcon's PC."""
-        self.writecmd(0x30,0x83,0,None);
-        hi=ord(self.data[0]);
-        lo=ord(self.data[1]);
-        return (hi<<8)+lo;
-    def CCdebuginstr(self,instr):
-        self.writecmd(0x30,0x88,len(instr),instr);
-        return ord(self.data[0]);
-    def CCpeekcodebyte(self,adr):
-        """Read the contents of code memory at an address."""
-        self.data=[adr&0xff, (adr&0xff00)>>8];
-        self.writecmd(0x30,0x90,2,self.data);
-        return ord(self.data[0]);
-    def CCpeekdatabyte(self,adr):
-        """Read the contents of data memory at an address."""
-        self.data=[adr&0xff, (adr&0xff00)>>8];
-        self.writecmd(0x30,0x91, 2, self.data);
-        return ord(self.data[0]);
-    def CCpokedatabyte(self,adr,val):
-        """Write a byte to data memory."""
-        self.data=[adr&0xff, (adr&0xff00)>>8, val];
-        self.writecmd(0x30, 0x92, 3, self.data);
-        return ord(self.data[0]);
-    def CCchiperase(self):
-        """Erase all of the target's memory."""
-        self.writecmd(0x30,0x80,0,None);
-    def CCstatus(self):
-        """Check the status."""
-        self.writecmd(0x30,0x84,0,None);
-        return ord(self.data[0])
-    CCstatusbits={0x80 : "erased",
-                  0x40 : "pcon_idle",
-                  0x20 : "halted",
-                  0x10 : "pm0",
-                  0x08 : "halted",
-                  0x04 : "locked",
-                  0x02 : "oscstable",
-                  0x01 : "overflow"};
-    def CCstatusstr(self):
-        """Check the status as a string."""
-        status=self.CCstatus();
-        str="";
-        i=1;
-        while i<0x100:
-            if(status&i):
-                str="%s %s" %(self.CCstatusbits[i],str);
-            i*=2;
-        return str;
-    def CCstart(self):
-        """Start debugging."""
-        self.writecmd(0x30,0x20,0,self.data);
-        ident=self.CCidentstr();
-        print "Target identifies as %s." % ident;
-        #print "Status: %s." % self.CCstatusstr();
-        self.CCreleasecpu();
-        self.CChaltcpu();
-        #print "Status: %s." % self.CCstatusstr();
+    def testleds(self):
+        print "Flashing LEDs"
+        self.writecmd(self.MONITORAPP,0xD0,0,"");
+        try:
+            print "Flashed %d LED." % ord(self.data)
+        except:
+            print "Unable to process response:", self.data
+
+    def monitor_list_apps(self, full=False): 
+        self.monitor_info()
+        old_value = self.besilent
+        self.besilent = True    # turn off automatic call to readcmd
+        self.writecmd(self.MONITORAPP, 0x82, 1, [int(full)]);
+        self.besilent = old_value
         
-    def CCstop(self):
-        """Stop debugging."""
-        self.writecmd(0x30,0x21,0,self.data);
-    def CCstep_instr(self):
-        """Step one instruction."""
-        self.writecmd(0x30,0x89,0,self.data);
+        # read the build date string 
+        self.readcmd()
+        print "Build Date: %s" % self.data
+        print "Firmware apps:"
+        while True:
+            self.readcmd()
+            if self.count == 0:
+                break
+            print self.data
+        return 1;
 
+    def monitorclocking(self):
+        """Return the 16-bit clocking value."""
+        return "0x%04x" % self.monitorgetclock();
+    
+    def monitorsetclock(self,clock):
+        """Set the clocking value."""
+        self.MONpoke16(0x56, clock);
+    def monitorgetclock(self):
+        """Get the clocking value."""
+        if(os.environ.get("platform")=='arduino' or os.environ.get("board")=='arduino'):
+            return 0xDEAD;
+        #Check for MSP430 before peeking this.
+        return self.MONpeek16(0x56);
+    # The following functions ought to be implemented in
+    # every client.
+    
+    def infostring(self):
+        if(os.environ.get("platform")=='arduino' or os.environ.get("board")=='arduino'):
+            return "Arduino";
+        else:
+            a=self.MONpeek8(0xff0);
+            b=self.MONpeek8(0xff1);
+            return "%02x%02x" % (a,b);
+    def lock(self):
+        print "Locking Unsupported.";
+    def erase(self):
+        print "Erasure Unsupported.";
+    def setup(self):
+        return;
+    def start(self):
+        return;
+    def test(self):
+        print "Unimplemented.";
+        return;
+    def status(self):
+        print "Unimplemented.";
+        return;
+    def halt(self):
+        print "Unimplemented.";
+        return;
+    def resume(self):
+        print "Unimplemented.";
+        return;
+    def getpc(self):
+        print "Unimplemented.";
+        return 0xdead;
+    def flash(self,file):
+        """Flash an intel hex file to code memory."""
+        print "Flash not implemented.";
+    def dump(self,file,start=0,stop=0xffff):
+        """Dump an intel hex file from code memory."""
+        print "Dump not implemented.";
+    def peek32(self,address, memory="vn"):
+        """Peek 32 bits."""
+        return (self.peek16(address,memory)+
+                (self.peek16(address+2,memory)<<16));
+    def peek16(self,address, memory="vn"):
+        """Peek 16 bits of memory."""
+        return (self.peek8(address,memory)+
+                (self.peek8(address+1,memory)<<8));
+    def peek8(self,address, memory="vn"):
+        """Peek a byte of memory."""
+        return self.MONpeek8(address); #monitor
+    def peekblock(self,address,length,memory="vn"):
+        """Return a block of data."""
+        data=range(0,length);
+        for foo in range(0,length):
+            data[foo]=self.peek8(address+foo,memory);
+        return data;
+    def pokeblock(self,address,bytes,memory="vn"):
+        """Poke a block of a data into memory at an address."""
+        for foo in bytes:
+            self.pokebyte(address,foo,memory);
+            address=address+1;
+        return;
+    def loadsymbols(self):
+        """Load symbols from a file."""
+        return;