Support flashing MCUs from the command line

The command-line tool is now mostly functional.  It can't verify yet
though.

alpaca_isp/__init__.py

 import argparse
 import sys
 
+import intelhex
+
 from alpaca_isp.chips import chips
 from alpaca_isp.exceptions import *
 from alpaca_isp.lpc import *
         lpc.close()
         if verbose:
             print(" failed")
-        sys.exit(1)
+        raise
+    except KeyboardInterrupt:
+        lpc.close()
+        if verbose:
+            print()
+        raise
     if verbose:
         print()
 
     parser.add_argument("--try-sync", type=int,
             help="maximum number of tries to synchronize with the "
             "microcontroller")
-    parser.add_argument("--control", action="store_true",
+    parser.add_argument("-n", "--control", action="store_true",
             help="control RS232 lines to enter ISP mode (/RST = DTR, /ISP = "
             "RTS)")
-    parser.add_argument("--verify", action="store_true",
+    parser.add_argument("-r", "--verify", action="store_true",
             help="verify that the data were written correctly after flashing")
 
     # Parse arguments
     args = parser.parse_args()
 
     # Open the LPC
-    lpc = create_lpc(args.tty, baudrate=args.baudrate, clock=args.clock_khz,
-            timeout=args.timeout, control=args.control, try_sync=args.try_sync,
-            verbose=True)
+    try:
+        lpc = create_lpc(args.tty, baudrate=args.baudrate,
+                clock=args.clock_khz, timeout=args.timeout,
+                control=args.control, try_sync=args.try_sync, verbose=True)
+    except (RecvTimeout, KeyboardInterrupt):
+        sys.exit(1)
 
     # Unlock the chip
     lpc.unlock()
 
     # Erase the flash if we've been asked to
     if args.erase:
+        print("Erasing all flash sectors")
         lpc.prepare_write()
         lpc.erase()
 
-    # TODO: write the file to flash
+    # Write the files to flash
+    ih = intelhex.IntelHex()
+    for f in args.file:
+        ih.fromfile(f, format="hex")
+
+    try:
+        lpc.flash_hex(ih, verbose=True)
+    except ISPError as e:
+        if e.args[0] == ReturnCode.CODE_READ_PROTECTION_ENABLED:
+            print("Error: code read protection is enabled")
+        sys.exit(2)
+
+    # TODO: Verify that the flash has been written correctly if we've been
+    # asked to
 
     # Start the program if we haven't been asked not to
     if not args.no_start:

alpaca_isp/chips.py

         "sectors"])):
     __slots__ = ()
 
+    @property
+    def sector_segments(self):
+        """Returns a list of (start, end) tuples for each flash sector"""
+        sector_segments = []
+        for i in range(len(self.sectors)):
+            sector_segments.append((sum(self.sectors[:i]),
+                sum(self.sectors[:i+1])))
+
+        return sector_segments
+
     def sectors_used(self, segments):
         """Returns a list of sectors used by the given memory segments
 
         segments: a list of (start, end) tuples representing segments of used
             memory
         """
-        sector_segments = []
-        for i in range(len(self.sectors)):
-            sector_segments.append((sum(self.sectors[:i]),
-                sum(self.sectors[:i+1])))
+        sector_segments = self.sector_segments
 
         s = set()
         for dseg in segments:

alpaca_isp/lpc.py

 import time
 from enum import Enum
 
-import intelhex
 import serial
 
 from alpaca_isp.exceptions import *
         self._send_command("S {} {}\r\n".format(start, count).encode("utf-8"))
         return int(self._readline())
 
-    def flash_hex(self, ihex):
-        """Write an IntelHex object to flash"""
+    def flash_hex(self, ihex, verbose=False):
+        """Write an IntelHex object to flash
+
+        Only the sectors that have any data in ihex are changed.  These sectors
+        are erased and written with the new data, destroying anything that was
+        in the sector before.
+        """
+        # Assert that we have enough RAM to hold the largest flash sector
+        assert (((self._chip.ram_start + 0x400*self._chip.ram)
+                - self._chip.ram_base) >= max(self._chip.sectors))
+        # Assert that the largest sector is no larger than max_copy
+        assert (self._chip.max_copy >= max(self._chip.sectors))
+        # NOTE: of course both of these assertions wouldn't be necessary if we
+        # were more careful below, but for the chips I'm using they hold, so
+        # I'm in no rush to make this perfect.
+
+        # Get the sectors we're rewriting
         sectors_used = self._chip.sectors_used(ihex.segments())
 
+        # Erase the sectors that aren't already blank
+        for sector in sectors_used:
+            if self.blank_check(sector) is not None:
+                if verbose:
+                    print("Erasing sector {}".format(sector))
+                self.prepare_write(sector)
+                self.erase(sector)
+
+        # Write sectors in reversed order to make sure sector 0 is invalid
+        # until the end
+        ss = self._chip.sector_segments
+        for sector in reversed(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)
+
+            # Write data to RAM
+            bs = 0x100
+            for i in range(0, len(secdat), bs):
+                self.write_ram(self._chip.ram_base+i, secdat[i:i+bs])
+
+            # Copy RAM to flash
+            self.prepare_write(sector)
+            self.copy_ram_to_flash(ss[sector][0], self._chip.ram_base,
+                    len(secdat))
+
 
 class LPC8xx(LPC):
     """Interface for LPC8xx in-system programming"""