Flash LPC8xx chips so they can actually run

Previously, I didn't realize that lpc21isp calculated the checksum in
the interrupt table, so I didn't make Alpaca ISP do that.  This caused a
few hours of confusion, followed by a quick change to make Alpaca ISP
calculate the checksum and insert it into the right part of sector 0.
Now programs flashed with Alpaca ISP actually run, so that's good.

A few other changes have been made as well.  Flash sectors are now
written in the order that lpc21isp uses, first counting up from sector 1
then ending with sector 0.  The first 64 bytes are not compared when
verifying flash.  If verification fails, an exception is raised, and if
the package was run as a program, it exits before launching the code on
the microcontroller.

alpaca_isp/__init__.py

         except ISPError as e:
             if e.args[0] == ReturnCode.CODE_READ_PROTECTION_ENABLED:
                 print("Error: code read protection is enabled")
-                print("Unalbe to verify, continuing")
+                print("Unable to verify, continuing")
+            else:
+                print("Flash verification failed, exiting")
+                sys.exit(3)
 
     # Start the program if we haven't been asked not to
     if not args.no_start:

alpaca_isp/lpc.py

         self._send_command("C {} {} {}\r\n".format(flash, ram, count).encode(
             "utf-8"))
 
-    def go(self, address=0, mode=b"T"):
+    def go(self, address=0, mode="T"):
         """Jump to the given address, in the given mode of execution
 
         Of course, this function generally causes the ISP command handler to
                 self.prepare_write(sector)
                 self.erase(sector)
 
-        # Write sectors in reversed order to make sure sector 0 is invalid
-        # until the end
+        # Write sectors, with 0 at the end
         ss = self._chip.sector_segments
-        for sector in reversed(sectors_used):
+        if 0 in sectors_used:
+            sectors_used.remove(0)
+            sectors_used.append(0)
+        for sector in sectors_used:
             if verbose:
                 print("Writing sector {}".format(sector))
             # Get the data we'll be writing
             secdat = ihex.tobinstr(start=ss[sector][0], end=ss[sector][1]-1)
 
+            # If we're writing sector 0, set the checksum
+            if sector == 0:
+                iv = struct.unpack('<7I', secdat[0:28])
+                cs = struct.pack('<i', -sum(iv))
+                secdat = secdat[:28] + cs + secdat[32:]
+
             # Write data to RAM
             bs = 0x100
             for i in range(0, len(secdat), bs):
                 raise
 
             # Verify the sector
+            if sector == 0:
+                # Avoid comparing first 64 bytes of sector 0 because these are
+                # remapped to flash boot sector
+                secdat = secdat[64:]
+                flash = flash[64:]
             if secdat != flash:
                 print("failed!")
+                raise ISPError("Flash verification failed")
             else:
                 print()