src/adafruit_blinka/microcontroller/nxp_lpc4330/spi.py

   1 """SPI Class for NXP LPC4330"""
   2 from greatfet import GreatFET
   3
   4
   5 class SPI:
   6     """Custom I2C Class for NXP LPC4330"""
   7
   8     MSB = 0
   9
  10     def __init__(self):
  11         self._gf = GreatFET()
  12         self._frequency = None
  13         self.buffer_size = 255
  14         self._presets = {
  15             204000: (100, 9),
  16             408000: (100, 4),
  17             680000: (100, 2),
  18             1020000: (100, 1),
  19             2040000: (50, 1),
  20             4250000: (24, 1),
  21             8500000: (12, 1),
  22             12750000: (8, 1),
  23             17000000: (6, 1),
  24             20400000: (2, 4),
  25             25500000: (4, 1),
  26             34000000: (2, 2),
  27             51000000: (2, 1),
  28             102000000: (2, 0),
  29         }
  30
  31     # pylint: disable=too-many-arguments
  32     def init(
  33         self,
  34         baudrate=100000,
  35         polarity=0,
  36         phase=0,
  37         bits=8,
  38         firstbit=MSB,
  39         sck=None,
  40         mosi=None,
  41         miso=None,
  42     ):
  43         """Initialize the Port"""
  44         # Figure out the mode based on phase and polarity
  45         polarity = int(polarity)
  46         phase = int(phase)
  47         self._mode = (polarity << 1) | phase
  48
  49         # Using API due to possible interface change
  50         self._spi = self._gf.apis.spi
  51         # Check baudrate against presets and adjust to the closest one
  52         if self._frequency is None:
  53             preset = self._find_closest_preset(baudrate)
  54         else:
  55             preset = self._presets[self._frequency]
  56         clock_prescale_rate, serial_clock_rate = preset
  57         self._spi.init(serial_clock_rate, clock_prescale_rate)
  58
  59         # Set the polarity and phase (the "SPI mode").
  60         self._spi.set_clock_polarity_and_phase(self._mode)
  61
  62     # pylint: enable=too-many-arguments
  63
  64     def _find_closest_preset(self, target_frequency):
  65         """Loop through self._frequencies and find the closest
  66         setting. Return the preset values and set the frequency
  67         to the found value
  68         """
  69         closest_preset = None
  70         for frequency in self._presets:
  71             preset = self._presets[frequency]
  72             if self._frequency is None or abs(frequency - target_frequency) < abs(
  73                 self._frequency - target_frequency
  74             ):
  75                 self._frequency = frequency
  76                 closest_preset = preset
  77
  78         return closest_preset
  79
  80     @property
  81     def frequency(self):
  82         """Return the current frequency"""
  83         return self._frequency
  84
  85     def write(self, buf, start=0, end=None):
  86         """Write data from the buffer to SPI"""
  87         end = end if end else len(buf)
  88         self._transmit(buf[start:end])
  89
  90     # pylint: disable=unused-argument
  91     def readinto(self, buf, start=0, end=None, write_value=0):
  92         """Read data from SPI and into the buffer"""
  93         end = end if end else len(buf)
  94         result = self._transmit([], end - start)
  95         for i, b in enumerate(result):
  96             buf[start + i] = b
  97
  98     # pylint: enable=unused-argument
  99
 100     # pylint: disable=too-many-arguments
 101     def write_readinto(
 102         self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
 103     ):
 104         """Perform a half-duplex write from buffer_out and then
 105         read data into buffer_in
 106         """
 107         out_end = out_end if out_end else len(buffer_out)
 108         in_end = in_end if in_end else len(buffer_in)
 109
 110         result = self._transmit(buffer_out[out_start:out_end], in_end - in_start)
 111         for i, b in enumerate(result):
 112             buf[start + i] = b
 113         for i, b in enumerate(result):
 114             buffer_in[in_start + i] = b
 115
 116     # pylint: enable=too-many-arguments
 117
 118     def _transmit(self, data, receive_length=None):
 119         data_to_transmit = bytearray(data)
 120         data_received = bytearray()
 121
 122         if receive_length is None:
 123             receive_length = len(data)
 124
 125         # If we need to receive more than we've transmitted, extend the data out.
 126         if receive_length > len(data):
 127             padding = receive_length - len(data)
 128             data_to_transmit.extend([0] * padding)
 129
 130         # Transmit our data in chunks of the buffer size.
 131         while data_to_transmit:
 132             # Extract a single data chunk from the transmit buffer.
 133             chunk = data_to_transmit[0 : self.buffer_size]
 134             del data_to_transmit[0 : self.buffer_size]
 135
 136             # Finally, exchange the data.
 137             response = self._spi.clock_data(len(chunk), bytes(chunk))
 138             data_received.extend(response)
 139
 140         # Once we're done, return the data received.
 141         return bytes(data_received)