src/adafruit_blinka/microcontroller/mcp2221/mcp2221.py

   1 import time
   2 import hid
   3
   4 class MCP2221:
   5
   6     VID = 0x04D8
   7     PID = 0x00DD
   8
   9     GP_GPIO = 0b000
  10     GP_DEDICATED = 0b001
  11     GP_ALT0 = 0b010
  12     GP_ALT1 = 0b011
  13     GP_ALT2 = 0b100
  14
  15     def __init__(self):
  16         self._hid = hid.device()
  17         self._hid.open(MCP2221.VID, MCP2221.PID)
  18
  19     def _hid_xfer(self, report, response=True):
  20         # first byte is report ID, which =0 for MCP2221
  21         # remaing bytes = 64 byte report data
  22         # https://github.com/libusb/hidapi/blob/083223e77952e1ef57e6b77796536a3359c1b2a3/hidapi/hidapi.h#L185
  23         self._hid.write(b'\0' + report + b'\0'*(64-len(report)))
  24         if response:
  25             # return is 64 byte response report
  26             return self._hid.read(64)
  27
  28     #----------------------------------------------------------------
  29     # MISC
  30     #----------------------------------------------------------------
  31     def gp_get_mode(self, pin):
  32         return self._hid_xfer(bytes([0x61]))[22+pin] & 0x07
  33
  34     def gp_set_mode(self, pin, mode):
  35         # get current settings
  36         current = self._hid_xfer(bytes([0x61]))
  37         # empty report, this is safe since 0's = no change
  38         report = bytearray([0x60]+[0]*63)
  39         # set the alter GP flag byte
  40         report[7] = 0xFF
  41         # each pin can be set individually
  42         # but all 4 get set at once, so we need to
  43         # transpose current settings
  44         report[8]  = current[22]  # GP0
  45         report[9]  = current[23]  # GP1
  46         report[10] = current[24]  # GP2
  47         report[11] = current[25]  # GP3
  48         # then change only the one
  49         report[8+pin] = mode & 0x07
  50         # and make it so
  51         self._hid_xfer(report)
  52
  53     def _pretty_report(self, report):
  54         print("     0  1  2  3  4  5  6  7  8  9")
  55         index = 0
  56         for row in range(7):
  57             print("{} : ".format(row), end='')
  58             for _ in range(10):
  59                 print("{:02x} ".format(report[index]), end='')
  60                 index += 1
  61                 if index > 63:
  62                     break
  63             print()
  64
  65     def _status_dump(self):
  66         self._pretty_report(self._hid_xfer(bytes([0x10])))
  67
  68     def _sram_dump(self):
  69         self._pretty_report(self._hid_xfer(bytes([0x61])))
  70
  71     def _reset(self):
  72         self._hid_xfer(b'\x70\xAB\xCD\xEF', response=False)
  73         time.sleep(1)
  74         self._hid.open(MCP2221.VID, MCP2221.PID)
  75
  76     #----------------------------------------------------------------
  77     # GPIO
  78     #----------------------------------------------------------------
  79     def gpio_set_direction(self, pin, mode):
  80         report = bytearray([0x50]+[0]*63)  # empty set GPIO report
  81         offset = 4 * (pin + 1)
  82         report[offset] = 0x01              # set pin direction
  83         report[offset+1] = mode            # to this
  84         self._hid_xfer(report)
  85
  86     def gpio_set_pin(self, pin, value):
  87         report = bytearray([0x50]+[0]*63)  # empty set GPIO report
  88         offset = 2 + 4 * pin
  89         report[offset] = 0x01              # set pin value
  90         report[offset+1] = value           # to this
  91         self._hid_xfer(report)
  92
  93     def gpio_get_pin(self, pin):
  94         resp = self._hid_xfer(bytes([0x51]))
  95         offset = 2 + 2 * pin
  96         if resp[offset] == 0xEE:
  97             raise RuntimeError("Pin is not set for GPIO operation.")
  98         else:
  99             return resp[offset]
 100
 101     #----------------------------------------------------------------
 102     # I2C
 103     #
 104     # cribbed from the C driver:
 105     #   define RESP_ERR_NOERR          0x00
 106     #   define RESP_ADDR_NACK          0x25
 107     #   define RESP_READ_ERR           0x7F
 108     #   define RESP_READ_COMPL         0x55
 109     #   define RESP_I2C_IDLE           0x00
 110     #   define RESP_I2C_START_TOUT     0x12
 111     #   define RESP_I2C_RSTART_TOUT    0x17
 112     #   define RESP_I2C_WRADDRL_TOUT   0x23
 113     #   define RESP_I2C_WRADDRL_WSEND  0x21
 114     #   define RESP_I2C_WRADDRL_NACK   0x25
 115     #   define RESP_I2C_WRDATA_TOUT    0x44
 116     #   define RESP_I2C_RDDATA_TOUT    0x52
 117     #   define RESP_I2C_STOP_TOUT      0x62
 118     #----------------------------------------------------------------
 119     def i2c_configure(self, baudrate=100000):
 120         self._hid_xfer(bytes([0x10,  # set parameters
 121                               0x00,  # don't care
 122                               0x00,  # no effect
 123                               0x20,  # next byte is clock divider
 124                               12000000 // baudrate - 3]))
 125
 126     def i2c_writeto(self, address, buffer, *, start=0, end=None):
 127         end = end if end else len(buffer)
 128         self._hid_xfer(bytes([0x90,                    # i2c write data
 129                               end - start & 0xFF,      # xfer length lo byte
 130                               end - start >> 8 & 0xFF, # xfer length hi byte
 131                               address << 1]) +         # i2c slave address
 132                               buffer[start:end])       # user data to be sent
 133
 134     def i2c_readfrom_into(self, address, buffer, *, start=0, end=None):
 135         end = end if end else len(buffer)
 136         retries = 0
 137         while retries < 5:
 138             #
 139             # why does this require two xfers?
 140             #
 141             # 1. tell it we want to read
 142             self._hid_xfer(bytes([0x91,                     # i2c read data
 143                                   end - start & 0xFF,       # xfer length lo byte
 144                                   end - start >> 8 & 0xFF,  # xfer length hi byte
 145                                   address << 1 | 0x01]))    # i2c slave address
 146             # 2. and then actually read
 147             response = self._hid_xfer(bytes([0x40]))
 148             # check for success
 149             if response[1] == 0x00:
 150                 break
 151             retries += 1
 152         if retries >= 5:
 153             raise RuntimeError("I2C read error, max retries reached.")
 154         # move data into buffer
 155         for i in range(end - start):
 156             buffer[start + i] = response[4 + i]
 157
 158     def i2c_writeto_then_readfrom(self, address, out_buffer, in_buffer, *,
 159                                   out_start=0, out_end=None,
 160                                   in_start=0, in_end=None):
 161         out_end = out_end if out_end else len(buffer_out)
 162         in_end = in_end if in_end else len(buffer_in)
 163         self._hid_xfer(bytes([0x94,                            # i2c write data no stop
 164                               out_end - out_start & 0xFF,      # xfer length lo byte
 165                               out_end - out_start >> 8 & 0xFF, # xfer length hi byte
 166                               address << 1]) +                 # i2c slave address
 167                               out_buffer[out_start:out_end])   # user data to be sent
 168         retries = 5
 169         while retries < 5:
 170             #
 171             # why does this require two xfers?
 172             #
 173             # 1. tell it we want to read
 174             self._hid_xfer(bytes([0x93,                           # i2c read data repeated start
 175                                   in_end - in_start & 0xFF,       # xfer length lo byte
 176                                   in_end - in_start >> 8 & 0xFF,  # xfer length hi byte
 177                                   address << 1 | 0x01]))          # i2c slave address
 178             # 2. and then actually read
 179             response = self._hid_xfer(bytes([0x40]))
 180             # check for success
 181             if response[1] == 0x00:
 182                 break
 183             retries += 1
 184         if retries >= 5:
 185             raise RuntimeError("I2C read error, max retries reached.")
 186         # move data into buffer
 187         for i in range(in_end - in_start):
 188             in_buffer[in_start + i] = response[4 + i]
 189
 190     def i2c_scan(self, *, start=0, end=0x79):
 191         found = []
 192         for addr in range(start, end+1):
 193             # try a write
 194             self.i2c_writeto(addr, b'\x00')
 195             # store if success
 196             if self._hid_xfer(b'\x10')[8] == 0x00:
 197                 found.append(addr)
 198             # cancel and continue
 199             self._hid_xfer(b'\x10\x00\x10')
 200         return found
 201
 202     #----------------------------------------------------------------
 203     # ADC
 204     #----------------------------------------------------------------
 205     def adc_configure(self, vref=0):
 206         report = bytearray([0x60]+[0]*63)
 207         report[5] = 1 << 7 | (vref & 0b111)
 208         self._hid_xfer(report)
 209
 210     def adc_read(self, pin):
 211         resp = self._hid_xfer(bytes([0x10]))
 212         return resp[49 + 2 * pin] << 8 | resp[48 + 2 * pin]
 213
 214     #----------------------------------------------------------------
 215     # DAC
 216     #----------------------------------------------------------------
 217     def dac_configure(self, vref=0):
 218         report = bytearray([0x60]+[0]*63)
 219         report[3] = 1 << 7 | (vref & 0b111)
 220         self._hid_xfer(report)
 221
 222     def dac_write(self, pin, value):
 223         report = bytearray([0x60]+[0]*63)
 224         report[4] = 1 << 7 | (value & 0b11111)
 225         self._hid_xfer(report)
 226
 227 mcp2221 = MCP2221()