i2c: PEP8 compliance.

Author: peterhinch

i2c/asi2c.py

@@ -37,6 +37,7 @@
 # Initiator sets up first.
 _DELAY = const(20)  # μs
 
+
 # Base class provides user interface and send/receive object buffers
 class Channel(io.IOBase):
     def __init__(self, i2c, own, rem, verbose, rxbufsize):
@@ -80,7 +81,7 @@ def _txdone(self):
         self.txsiz[0] = 0
         self.txsiz[1] = 0
 
-# Stream interface
+    # Stream interface
 
     def ioctl(self, req, arg):
         ret = _MP_STREAM_ERROR
@@ -102,7 +103,7 @@ def readline(self):
             self.rxbyt = b''
         else:
             t = self.rxbyt[: n + 1]
-            self.rxbyt = self.rxbyt[n + 1 :]
+            self.rxbyt = self.rxbyt[n + 1:]
         return t.decode()
 
     def read(self, n):
@@ -120,7 +121,7 @@ def write(self, buf, off, sz):
             if off == 0 and sz == len(buf):
                 d = buf
             else:
-                d = buf[off : off + sz]
+                d = buf[off: off + sz]
             d = d.encode()
             l = len(d)
             self.txbyt = d
@@ -129,7 +130,7 @@ def write(self, buf, off, sz):
             return l
         return 0
 
-# User interface
+    # User interface
 
     # Wait for sync
     async def ready(self):
@@ -140,27 +141,29 @@ async def ready(self):
     def close(self):
         self.own(1)
 
+
 # Responder is I2C master. It is cross-platform and uses machine.
 # It does not handle errors: if I2C fails it dies and awaits reset by initiator.
 # send_recv is triggered by Interrupt from Initiator.
 
 class Responder(Channel):
     addr = 0x12
     rxbufsize = 200
+
     def __init__(self, i2c, pin, pinack, verbose=True):
         super().__init__(i2c, pinack, pin, verbose, self.rxbufsize)
         loop = asyncio.get_event_loop()
         loop.create_task(self._run())
 
     async def _run(self):
         await self._sync()  # own pin ->0, wait for remote pin == 0
-        self.rem.irq(handler = self._handler, trigger = machine.Pin.IRQ_RISING)
+        self.rem.irq(handler=self._handler, trigger=machine.Pin.IRQ_RISING)
 
     # Request was received: immediately read payload size, then payload
     # On Pyboard blocks for 380μs to 1.2ms for small amounts of data
     def _handler(self, _, sn=bytearray(2), txnull=bytearray(2)):
         addr = Responder.addr
-        self.rem.irq(handler = None, trigger = machine.Pin.IRQ_RISING)
+        self.rem.irq(handler=None, trigger=machine.Pin.IRQ_RISING)
         utime.sleep_us(_DELAY)  # Ensure Initiator has set up to write.
         self.i2c.readfrom_into(addr, sn)
         self.own(1)
@@ -173,7 +176,7 @@ def _handler(self, _, sn=bytearray(2), txnull=bytearray(2)):
         if n:
             self.waitfor(1)
             utime.sleep_us(_DELAY)
-            mv = memoryview(self.rx_mv[0 : n])  # allocates
+            mv = memoryview(self.rx_mv[0: n])  # allocates
             self.i2c.readfrom_into(addr, mv)
             self.own(1)
             self.waitfor(0)
@@ -200,4 +203,4 @@ def _handler(self, _, sn=bytearray(2), txnull=bytearray(2)):
             self.own(0)
             self.waitfor(0)
             self._txdone()  # Invalidate source
-        self.rem.irq(handler = self._handler, trigger = machine.Pin.IRQ_RISING)
+        self.rem.irq(handler=self._handler, trigger=machine.Pin.IRQ_RISING)

i2c/asi2c_i.py

@@ -29,6 +29,7 @@
 import gc
 from asi2c import Channel
 
+
 # The initiator is an I2C slave. It runs on a Pyboard. I2C uses pyb for slave
 # mode, but pins are instantiated using machine.
 # reset (if provided) is a means of resetting Responder in case of error: it
@@ -46,7 +47,7 @@ def __init__(self, i2c, pin, pinack, reset=None, verbose=True,
         self.cr_fail = cr_fail
         self.f_args = f_args
         if reset is not None:
-            reset[0].init(mode=machine.Pin.OUT, value = not(reset[1]))
+            reset[0].init(mode=machine.Pin.OUT, value=not (reset[1]))
         # Self measurement
         self.nboots = 0  # No. of reboots of Responder
         self.block_max = 0  # Blocking times: max
@@ -109,7 +110,7 @@ def _sendrx(self, sn=bytearray(2), txnull=bytearray(2)):
         # send. Send must start before RX begins. Fast responders may need to
         # do a short blocking wait to guarantee this.
         self.own(1)  # Trigger interrupt.
-        self.i2c.send(siz) # Blocks until RX complete.
+        self.i2c.send(siz)  # Blocks until RX complete.
         self.waitfor(1)
         self.own(0)
         self.waitfor(0)
@@ -132,9 +133,9 @@ def _sendrx(self, sn=bytearray(2), txnull=bytearray(2)):
         self.cantx = not bool(sn[1] & 0x80)
         if n:
             self.waitfor(1)  # Wait for responder to request send
-            #print('setting up receive', n,' bytes')
+            # print('setting up receive', n,' bytes')
             self.own(1)  # Acknowledge
-            mv = memoryview(self.rx_mv[0 : n])
+            mv = memoryview(self.rx_mv[0: n])
             self.i2c.recv(mv)
             self.waitfor(0)
             self.own(0)