src/adafruit_blinka/microcontroller/nova/i2c.py

   1 """I2C Class for Binho Nova"""
   2
   3 from adafruit_blinka.microcontroller.nova import Connection
   4
   5
   6 class I2C:
   7     """Custom I2C Class for Binho Nova"""
   8
   9     WHR_PAYLOAD_MAX_LENGTH = 1024
  10
  11     def __init__(self, *, frequency=400000):
  12         self._nova = Connection.getInstance()
  13         self._nova.setNumericalBase(10)
  14         self._nova.setOperationMode(0, "I2C")
  15         self._nova.setPullUpStateI2C(0, "EN")
  16         self._nova.setClockI2C(0, frequency)
  17
  18         self._novaCMDVer = "0"
  19         if hasattr(self._nova, "getCommandVer"):
  20             response = self._nova.getCommandVer().split(" ")
  21             if response[0] != "-NG":
  22                 self._novaCMDVer = response[1]
  23
  24     def __del__(self):
  25         """Close Nova on delete"""
  26         self._nova.close()
  27
  28     def scan(self):
  29         """Perform an I2C Device Scan"""
  30         scanResults = []
  31
  32         for i in range(8, 121):
  33             result = self._nova.scanAddrI2C(0, i << 1)
  34
  35             resp = result.split(" ")
  36
  37             if resp[3] == "OK":
  38                 scanResults.append(i)
  39
  40         return scanResults
  41
  42     def writeto(self, address, buffer, *, start=0, end=None, stop=True):
  43         """Write data from the buffer to an address"""
  44         end = end if end else len(buffer)
  45         readBytes = 0
  46         if int(self._novaCMDVer) >= 1:
  47             chunks, rest = divmod(end - start, self.WHR_PAYLOAD_MAX_LENGTH)
  48             for i in range(chunks):
  49                 chunk_start = start + i * self.WHR_PAYLOAD_MAX_LENGTH
  50                 chunk_end = chunk_start + self.WHR_PAYLOAD_MAX_LENGTH
  51                 self._nova.writeToReadFromI2C(
  52                     0,
  53                     address << 1,
  54                     stop,
  55                     readBytes,
  56                     chunk_end - chunk_start,
  57                     buffer[chunk_start:chunk_end],
  58                 )
  59             if rest:
  60                 self._nova.writeToReadFromI2C(
  61                     0, address << 1, stop, readBytes, rest, buffer[-1 * rest :]
  62                 )
  63         else:
  64             self._nova.startI2C(0, address << 1)
  65
  66             for i in range(start, end):
  67                 self._nova.writeByteI2C(0, buffer[i])
  68
  69             if stop:
  70                 self._nova.endI2C(0)
  71             else:
  72                 self._nova.endI2C(0, True)
  73
  74     # pylint: disable=unused-argument
  75     def readfrom_into(self, address, buffer, *, start=0, end=None, stop=True):
  76         """Read data from an address and into the buffer"""
  77         end = end if end else len(buffer)
  78         result = self._nova.readBytesI2C(0, address << 1, len(buffer[start:end]))
  79
  80         if result != "-NG":
  81             resp = result.split(" ")
  82
  83             for i in range(len(buffer[start:end])):
  84                 buffer[start + i] = int(resp[2 + i])
  85         else:
  86             raise RuntimeError(
  87                 "Received error response from Binho Nova, result = " + result
  88             )
  89
  90     def writeto_then_readfrom(
  91         self,
  92         address,
  93         buffer_out,
  94         buffer_in,
  95         *,
  96         out_start=0,
  97         out_end=None,
  98         in_start=0,
  99         in_end=None,
 100         stop=False
 101     ):
 102         """Write data from buffer_out to an address and then
 103         read data from an address and into buffer_in
 104         """
 105         out_end = out_end if out_end else len(buffer_out)
 106         in_end = in_end if in_end else len(buffer_in)
 107         if int(self._novaCMDVer) >= 1:
 108             totalIn = in_end - in_start
 109             totalOut = out_end - out_start
 110             totalBytes = totalIn
 111             if totalOut > totalIn:
 112                 totalBytes = totalOut
 113             chunks, rest = divmod(totalBytes, self.WHR_PAYLOAD_MAX_LENGTH)
 114             if rest > 0:
 115                 chunks += 1
 116
 117             for i in range(chunks):
 118                 # calculate the number of bytes to be written and read
 119                 numInBytes = self.WHR_PAYLOAD_MAX_LENGTH
 120                 if totalIn < self.WHR_PAYLOAD_MAX_LENGTH:
 121                     numInBytes = totalIn
 122                 numOutBytes = self.WHR_PAYLOAD_MAX_LENGTH
 123                 if totalOut < self.WHR_PAYLOAD_MAX_LENGTH:
 124                     numOutBytes = totalOut
 125
 126                 # setup the buffer out chunk offset
 127                 buffer = "0"
 128                 if numOutBytes > 0:
 129                     chunk_start = out_start + i * self.WHR_PAYLOAD_MAX_LENGTH
 130                     chunk_end = chunk_start + numOutBytes
 131                     buffer = buffer_out[chunk_start:chunk_end]
 132
 133                 result = self._nova.writeToReadFromI2C(
 134                     0, address << 1, stop, numInBytes, numOutBytes, buffer
 135                 )
 136                 totalIn -= numInBytes
 137                 totalOut -= numOutBytes
 138
 139                 if result != "-NG":
 140                     if numInBytes:
 141                         resp = result.split(" ")
 142                         resp = resp[2]
 143
 144                         for j in range(numInBytes):
 145                             buffer_in[
 146                                 in_start + i * self.WHR_PAYLOAD_MAX_LENGTH + j
 147                             ] = int(resp[j * 2] + resp[j * 2 + 1], 16)
 148                 else:
 149                     raise RuntimeError(
 150                         "Received error response from Binho Nova, result = " + result
 151                     )
 152         else:
 153             self._nova.startI2C(0, address << 1)
 154
 155             for i in range(out_start, out_end):
 156                 self._nova.writeByteI2C(0, buffer_out[i])
 157
 158             if stop:
 159                 self._nova.endI2C(0)
 160             else:
 161                 self._nova.endI2C(0, True)
 162
 163             result = self._nova.readBytesI2C(
 164                 0, address << 1, len(buffer_in[in_start:in_end])
 165             )
 166
 167             if result != "-NG":
 168                 resp = result.split(" ")
 169
 170                 for i in range(len(buffer_in[in_start:in_end])):
 171                     buffer_in[in_start + i] = int(resp[2 + i])
 172             else:
 173                 raise RuntimeError(
 174                     "Received error response from Binho Nova, result = " + result
 175                 )
 176
 177
 178 # pylint: enable=unused-argument