More Pythonic API for A and B, implement W

The LPC class now has properties for getting and setting echo, baudrate,
and stopbits.  Low-level access is now private to avoid letting users
break the public properties.

Also, a new write_ram method implements the W command.  If no number of
bytes is specified, the length of the data is used.

alpaca_isp/__init__.py

     """Interface for LPC in-system programming"""
 
     def __init__(self, serport, baudrate=115200, clock=12000, timeout=0.1):
-        self.serport = serport
-        self.baudrate = baudrate
-        self.clock = clock
-        self.timeout = timeout
+        self._serport = serport
+        self._baudrate = baudrate
+        self._clock = clock
+        self._timeout = timeout
         self._echo = True
 
     def open(self):
         """Open the serial port to communicate with the microcontroller"""
-        self._uart = serial.Serial(self.serport, baudrate=self.baudrate,
-                timeout=self.timeout)
+        self._uart = serial.Serial(self._serport, baudrate=self._baudrate,
+                timeout=self._timeout)
 
-    def readline(self):
-        """Read a line terminated with '\r\n'"""
+    def _readline(self):
+        """Read a line terminated with b'\r\n'"""
         s = b""
         while True:
             c = self._uart.read(1)
             if s.endswith(b"\r\n"):
                 return s
 
-    def writeline(self, line):
-        """Write a line to the microcontroller and read the echoed response"""
+    def _writeline(self, line, plain=False):
+        """Write a line to the microcontroller and read the echoed response
+
+        If plain is True, the command is taken to be raw binary data.
+        """
         self._uart.write(line)
         self._uart.flush()
 
-        if not self._echo:
+        # If echo is disabled, don't try to read back what we sent
+        if not self.echo:
             return
+
         # Read the response, raising the exception if there is one
-        response = self.readline()
+        if plain:
+            response = self._uart.read(len(line))
+        else:
+            response = self._readline()
         # If we got the wrong response, raise an exception
         if response != line:
             raise ISPError("Wrong text echoed: {}".format(response))
 
-    def send_command_raw(self, cmd):
+    def _send_command_raw(self, cmd):
         """Send a command to the microcontroller, returning bytes"""
-        self.writeline(cmd)
-        return self.readline()
+        self._writeline(cmd)
+        return self._readline()
 
-    def send_command(self, cmd):
+    def _send_command(self, cmd):
         """Send a command to the microcontroller, returning the result"""
-        rr = self.send_command_raw(cmd)
+        rr = self._send_command_raw(cmd)
         lr = [int(n) for n in rr.split()]
         lr[0] = ReturnCode(lr[0])
         return lr
 
-    def start_isp(self, delay=0.01):
+    def enter_isp(self, delay=0.01):
         """Enter ISP mode by controlling the DTR (/RST) and RTS (/ISP) lines
 
-        This operation is performed synchronously.
+        This operation is performed synchronously, with delays.
         """
         self._uart.rts = True
         time.sleep(delay)
         time.sleep(delay)
         self._uart.rts = False
 
-    def start_comms(self, verbose=False):
-        """Start communication with the microcontroller"""
+    def synchronize(self, verbose=False):
+        """Begin communication with the microcontroller"""
         # Synchronize with the MCU
         while True:
             # Send a ?
                 print("?")
             # Receive a response
             try:
-                s = self.readline()
+                s = self._readline()
             except RecvTimeout:
                 continue
             # If we got the right response, break
             if s == b"Synchronized\r\n":
                 break
         # Tell the MCU we've synchronized
-        s = self.send_command_raw(b"Synchronized\r\n")
+        s = self._send_command_raw(b"Synchronized\r\n")
         # Next, it should say OK, at which point we're done synchronizing
         if s != b"OK\r\n":
             raise ISPError("Wrong response during synchronization")
 
         # Send clock frequency in kHz
-        s = self.send_command_raw("{:d}\r\n".format(self.clock).encode("utf-8"))
+        s = self._send_command_raw("{:d}\r\n".format(self._clock).encode(
+            "utf-8"))
         # Next, it should say OK
         if s != b"OK\r\n":
             raise ISPError("Wrong response during synchronization")
 
     def unlock(self, code="23130"):
         """Unlock the flash write, erase, and go commands"""
-        return self.send_command("U {}\r\n".format(code).encode("utf-8"))
+        return self._send_command("U {}\r\n".format(code).encode("utf-8"))
+
+    @property
+    def baudrate(self):
+        """The baud rate used for communication"""
+        return self._uart.baudrate
+
+    @baudrate.setter
+    def baudrate(self, br):
+        r = self._send_command("B {} {}\r\n".format(br,
+            self._uart.stopbits).encode("utf-8"))
+        # Update the baud rate for our UART
+        if r[0] != ReturnCode.CMD_SUCCESS:
+            raise ISPError(r)
+        self._uart.baudrate = br
+
+    @property
+    def stopbits(self):
+        """The number of stop bits used for communication"""
+        return self._uart.stopbits
+
+    @stopbits.setter
+    def stopbits(self, sb):
+        r = self._send_command("B {} {}\r\n".format(self._uart.baudrate,
+            sb).encode("utf-8"))
+        # Update the number of stop bits for our UART
+        if r[0] != ReturnCode.CMD_SUCCESS:
+            raise ISPError(r)
+        self._uart.stopbits = sb
+
+    @property
+    def echo(self):
+        """Whether the microcontroller echoes characters back to the host"""
+        return self._echo
+
+    @echo.setter
+    def echo(self, setting):
+        setting = bool(setting)
+        r = self._send_command("A {}\r\n".format(int(setting)).encode("utf-8"))
+        if r[0] != ReturnCode.CMD_SUCCESS:
+            raise ISPError(r)
+        self._echo = setting
 
-    def setbaudrate(self, baudrate, stopbits):
-        """Update the baud rate and number of stop bits"""
-        r = self.send_command("B {} {}\r\n".format(baudrate, stopbits).encode(
+    def write_ram(self, start, data, count=None):
+        """Write count bytes from data to RAM at the given start address
+        
+        Start and count must be multiples of four.  If count is not specified,
+        len(data) is used.
+        """
+        # Get the length of the data we're writing
+        if count is None:
+            count = len(data)
+        # Ask to write data
+        r = self._send_command("W {} {}\r\n".format(start, count).encode(
             "utf-8"))
-        # Update the baud rate and number of stop bits for our UART connection
+        # If the MCU is okay with what we intend to do, send the data
         if r[0] == ReturnCode.CMD_SUCCESS:
-            self._uart.baudrate = baudrate
-            self._uart.stopbits = stopbits
-        return r
-
-    def echo(self, setting):
-        """Set whether echo is enabled or disabled"""
-        r = self.send_command("A {}\r\n".format(int(setting)).encode("utf-8"))
-        self._echo = setting
+            # NOTE: this is right for LPC8xx chips, not others
+            ok = self._writeline(data[:count], plain=True)
         return r