creates a common API for the touch/pointer drivers

Author: kdschlosser

README.md

@@ -16,6 +16,28 @@ for the binding.
 ### *New changes*
 ___________________________
 
+ALL MCU's
+I have started to nail down a commoin API for the indev drivers, specifically the pointer/touch drivers.
+In order to do this I had to change the handling of the type of bus being used. Just like the displays the 
+touch/pointer driver IC's can sometimes accept an SPI bus or an I2C bus as the way to communicate.
+Instead of having to duplicate code for these driver IC's I decided to make the software driver completely
+unaware of the bus that is being used. To do this i made the I2C driver work in the same manner as the SPI driver.
+
+Here is a code example of how to use the I2C bus with a touch driver.
+
+
+    from i2c import I2C
+    import ft5x06
+
+    i2c_bus = I2C.Bus(host=1, sda=10, sdl=11)
+    touch_i2c = I2C.Device(i2c_bus, ft5x06.I2C_ADDR, ft5x06.BITS)
+    touch = ft5x06.FT5x06(touch_i2c)
+
+
+If a touch driver doesn't have the variable `I2C_ADDR` or `BITS` then that driver 
+doesn't support the I2C bus.
+
+
 ESP32-ALL
 * `--optimize-size`: If you are having an issue with getting the firmware to fit into your esp32
   or if space is more of a concern than speed you can set this command line option. This will tell the compiler that the 
@@ -35,23 +57,23 @@ ESP32-ALL
   They exactly what they seem. It is easier to show a code example then it is to explain it.
 
 
-    import machine
+    from machine import SPI
 
-    spi_bus = machine.SPI.Bus(
+    spi_bus = SPI.Bus(
         host=1,
         mosi=15,
         miso=16,
         sck=10
     )
 
-    spi_device = machine.SPI.Device(
+    spi_device = SPI.Device(
         spi_bus=spi_bus,
         freq=10000000,
         cs=3,
         polarity=0,
         phase=0,
         bits=8,
-        first_bit=machine.SPI.MSB
+        first_bit=SPI.MSB
     )
 
     # if you want to delete a device from being used you have to deinit it first
@@ -66,6 +88,7 @@ ESP32-ALL
     # The SPI.Bus instance you need to pass to machine.SDCard, lcd_bus.SPIBus
     # and any of the touch drivers that use SPI. 
 
+
 All methods that existed for the original `machine.SPI` are available in 
 the `machine.SPI.Device` class. They work exactly how they did before.
 

api_drivers/common_api_drivers/frozen/other/i2c.py

@@ -1,130 +1,132 @@
 import machine
 
 
-class I2CBus(object):
+class I2C(object):
+    class Bus(object):
+
+        def __init__(self, host, scl, sda, freq=400000, use_locks=False):
+            self._bus = machine.I2C(
+                host,
+                scl=machine.Pin(scl),
+                sda=machine.Pin(sda),
+                freq=freq
+            )
 
-    def __init__(self, scl, sda, freq=400000, host=None, use_locks=False):
-        if host is None:
-            if (scl, sda) == (19, 18):
-                host = 0
+            if use_locks:
+                import _thread
+                self._lock = _thread.allocate_lock()
             else:
-                host = 1
-
-        self._bus = machine.I2C(
-            host,
-            scl=machine.Pin(scl),
-            sda=machine.Pin(sda),
-            freq=freq
-        )
-
-        if use_locks:
-            import _thread
-            self._lock = _thread.allocate_lock()
-        else:
-            class Lock(object):
+                class Lock(object):
 
-                def acquire(self):
-                    pass
+                    def acquire(self):
+                        pass
 
-                def release(self):
-                    pass
+                    def release(self):
+                        pass
 
-                def is_locked(self):
-                    return False
+                    def is_locked(self):
+                        return False
 
-            self._lock = Lock()
+                self._lock = Lock()
 
-    def __enter__(self):
-        self._lock.acquire()
-        return self
+        def __enter__(self):
+            self._lock.acquire()
+            return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._lock.release()
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            self._lock.release()
 
-    def scan(self):
-        self._lock.acquire()
-        data = self._bus.scan()
-        self._lock.release()
-        return data
+        def scan(self):
+            self._lock.acquire()
+            data = self._bus.scan()
+            self._lock.release()
+            return data
 
-    def start(self):
-        self._bus.start()
+        def start(self):
+            self._bus.start()
 
-    def stop(self):
-        self._bus.stop()
+        def stop(self):
+            self._bus.stop()
 
-    def readinto(self, buf, nack=True):
-        self._bus.readinto(buf, nack)
+        def readinto(self, buf, nack=True):
+            self._bus.readinto(buf, nack)
 
-    def write(self, buf):
-        self._bus.write(buf)
+        def write(self, buf):
+            self._bus.write(buf)
 
-    def readfrom(self, addr, nbytes, stop=True):
-        return self._bus.readfrom(addr, nbytes, stop)
+        def readfrom(self, addr, nbytes, stop=True):
+            return self._bus.readfrom(addr, nbytes, stop)
 
-    def readfrom_into(self, addr, buf, stop=True):
-        self._bus.readfrom_into(addr, buf, stop)
+        def readfrom_into(self, addr, buf, stop=True):
+            self._bus.readfrom_into(addr, buf, stop)
 
-    def writeto(self, addr, buf, stop=True):
-        self._bus.writeto(addr, buf, stop)
+        def writeto(self, addr, buf, stop=True):
+            self._bus.writeto(addr, buf, stop)
 
-    def writevto(self, addr, vector, stop=True):
-        self._bus.writevto(addr, vector, stop)
+        def writevto(self, addr, vector, stop=True):
+            self._bus.writevto(addr, vector, stop)
 
-    def readfrom_mem(self, addr, memaddr, nbytes, addrsize=8):
-        return self._bus.readfrom_mem(addr, memaddr, nbytes, addrsize=addrsize)
+        def readfrom_mem(self, addr, memaddr, nbytes, addrsize=8):
+            return self._bus.readfrom_mem(addr, memaddr, nbytes, addrsize=addrsize)
 
-    def readfrom_mem_into(self, addr, memaddr, buf, addrsize=8):
-        self._bus.readfrom_mem_into(addr, memaddr, buf, addrsize=addrsize)
+        def readfrom_mem_into(self, addr, memaddr, buf, addrsize=8):
+            self._bus.readfrom_mem_into(addr, memaddr, buf, addrsize=addrsize)
 
-    def writeto_mem(self, addr, memaddr, buf, addrsize=8):
-        self._bus.writeto_mem(addr, memaddr, buf, addrsize=addrsize)
+        def writeto_mem(self, addr, memaddr, buf, addrsize=8):
+            self._bus.writeto_mem(addr, memaddr, buf, addrsize=addrsize)
 
-    def add_device(self, dev_id, reg_bits=8):
-        return I2CDevice(self, dev_id, reg_bits)
+    class Device(object):
 
+        def __init__(self, bus, dev_id, reg_bits=8):
+            self._bus = bus
+            self.dev_id = dev_id
+            self._reg_bits = reg_bits
 
-class I2CDevice(object):
+        def write_readinto(self, write_buf, read_buf):
+            memaddr = 0
+            for i in range(int(self._reg_bits / 8)):
+                memaddr |= write_buf[i] << i
+            self.read_mem(memaddr, buf=read_buf)
 
-    def __init__(self, bus, dev_id, reg_bits=8):
-        self._bus = bus
-        self.dev_id = dev_id
-        self._reg_bits = reg_bits
+        def read_mem(self, memaddr, num_bytes=None, buf=None):
+            with self._bus:
+                if num_bytes is not None:
+                    return self._bus.readfrom_mem(
+                        self.dev_id,
+                        memaddr,
+                        num_bytes,
+                        addrsize=self._reg_bits
+                    )
+                else:
+                    self._bus.readfrom_mem_into(
+                        self.dev_id,
+                        memaddr,
+                        buf,
+                        addrsize=self._reg_bits
+                    )
+                    return
 
-    def read_mem(self, memaddr, num_bytes=None, buf=None):
-        with self._bus:
-            if num_bytes is not None:
-                return self._bus.readfrom_mem(
-                    self.dev_id,
-                    memaddr,
-                    num_bytes,
-                    addrsize=self._reg_bits
-                )
-            else:
-                self._bus.readfrom_mem_into(
+        def write_mem(self, memaddr, buf):
+            with self._bus:
+                self._bus.writeto_mem(
                     self.dev_id,
                     memaddr,
                     buf,
                     addrsize=self._reg_bits
                 )
-                return
-
-    def write_mem(self, memaddr, buf):
-        with self._bus:
-            self._bus.writeto_mem(
-                self.dev_id,
-                memaddr,
-                buf,
-                addrsize=self._reg_bits
-            )
 
-    def read(self, num_bytes=None, buf=None):
-        with self._bus:
-            if num_bytes is not None:
-                return self._bus.readfrom(self.dev_id, num_bytes)
+        def read(self, num_bytes=None, buf=None):
+            with self._bus:
+                if num_bytes is not None:
+                    return self._bus.readfrom(self.dev_id, num_bytes)
+                else:
+                    self._bus.readfrom_into(self.dev_id, buf)
+
+        def write(self, buf):
+            memaddr = 0
+            for i in range(int(self._reg_bits / 8)):
+                memaddr |= buf[i] << i
             else:
-                self._bus.readfrom_into(self.dev_id, buf)
+                i = int(self._reg_bits / 8) - 1
 
-    def write(self, buf):
-        with self._bus:
-            self._bus.writeto(self.dev_id, buf)
+            self.write_mem(memaddr, buf=buf[i + 1:])