Raise exceptions from _send_command

Now the ISPError is raised from the _send_command method, not each
caller.  There will be a few cases where I need that to not be an
exception, but I can just wrap it in a try block then, so there's no
problem.

alpaca_isp/__init__.py

         rr = self._send_command_raw(cmd)
         lr = [int(n) for n in rr.split()]
         lr[0] = ReturnCode(lr[0])
+        if lr[0] != ReturnCode.CMD_SUCCESS:
+            raise ISPError(lr)
         return lr
 
     def enter_isp(self, delay=0.01):
 
     def unlock(self, code="23130"):
         """Unlock the flash write, erase, and go commands"""
-        r = self._send_command("U {}\r\n".format(code).encode("utf-8"))
-        if r[0] != ReturnCode.CMD_SUCCESS:
-            raise ISPError(r)
+        self._send_command("U {}\r\n".format(code).encode("utf-8"))
 
     @property
     def baudrate(self):
 
     @baudrate.setter
     def baudrate(self, br):
-        r = self._send_command("B {} {}\r\n".format(br,
+        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
 
     @stopbits.setter
     def stopbits(self, sb):
-        r = self._send_command("B {} {}\r\n".format(self._uart.baudrate,
+        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
     @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._send_command("A {}\r\n".format(int(setting)).encode("utf-8"))
         self._echo = setting
 
     def write_ram(self, start, data, count=None):
         if count is None:
             count = len(data)
         # Ask to write data
-        r = self._send_command("W {} {}\r\n".format(start, count).encode(
-            "utf-8"))
-        if r[0] != ReturnCode.CMD_SUCCESS:
-            raise ISPError(r)
-        # If the MCU is okay with what we intend to do, send the data
+        self._send_command("W {} {}\r\n".format(start, count).encode("utf-8"))
+        # Send the data
         # NOTE: this is right for LPC8xx chips, not others
-        ok = self._writeline(data[:count], plain=True)
+        self._writeline(data[:count], plain=True)
         return
 
     def read_memory(self, start, count):
 
         Start and count must be multiples of four.
         """
-        r = self._send_command("R {} {}\r\n".format(start, count).encode(
-            "utf-8"))
-        if r[0] != ReturnCode.CMD_SUCCESS:
-            raise ISPError(r)
+        self._send_command("R {} {}\r\n".format(start, count).encode("utf-8"))
         return self._uart.read(count)