Reduce jitter in pulse timing

Author: dcyoung

Adafruit_GPIO/I2C.py

@@ -28,13 +28,14 @@
 def reverseByteOrder(data):
     """Reverses the byte order of an int (16-bit) or long (32-bit) value."""
     # Courtesy Vishal Sapre
-    byteCount = len(hex(data)[2:].replace('L','')[::2])
-    val       = 0
+    byteCount = len(hex(data)[2:].replace('L', '')[::2])
+    val = 0
     for i in range(byteCount):
-        val    = (val << 8) | (data & 0xff)
+        val = (val << 8) | (data & 0xff)
         data >>= 8
     return val
 
+
 def get_default_bus():
     """Return the default bus number based on the device platform.  For a
     Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned.
@@ -49,11 +50,13 @@ def get_default_bus():
             # Revision 2 Pi uses I2C bus 1.
             return 1
     elif plat == Platform.BEAGLEBONE_BLACK:
-        # Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and P9_20).
+        # Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and
+        # P9_20).
         return 1
     else:
         raise RuntimeError('Could not determine default I2C bus for platform.')
 
+
 def get_i2c_device(address, busnum=None, i2c_interface=None, **kwargs):
     """Return an I2C device for the specified address and on the specified bus.
     If busnum isn't specified, the default I2C bus for the platform will attempt
@@ -63,6 +66,7 @@ def get_i2c_device(address, busnum=None, i2c_interface=None, **kwargs):
         busnum = get_default_bus()
     return Device(address, busnum, i2c_interface, **kwargs)
 
+
 def require_repeated_start():
     """Enable repeated start conditions for I2C register reads.  This is the
     normal behavior for I2C, however on some platforms like the Raspberry Pi
@@ -76,8 +80,10 @@ def require_repeated_start():
         # repeated start condition like the kernel smbus I2C driver functions
         # define.  As a workaround this bit in the BCM2708 driver sysfs tree can
         # be changed to enable I2C repeated starts.
-        subprocess.check_call('chmod 666 /sys/module/i2c_bcm2708/parameters/combined', shell=True)
-        subprocess.check_call('echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined', shell=True)
+        subprocess.check_call(
+            'chmod 666 /sys/module/i2c_bcm2708/parameters/combined', shell=True)
+        subprocess.check_call(
+            'echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined', shell=True)
     # Other platforms are a no-op because they (presumably) have the correct
     # behavior and send repeated starts.
 
@@ -87,6 +93,7 @@ class Device(object):
     python smbus library, or other smbus compatible I2C interface. Allows reading
     and writing 8-bit, 16-bit, and byte array values to registers
     on the device."""
+
     def __init__(self, address, busnum, i2c_interface=None):
         """Create an instance of the I2C device at the specified address on the
         specified I2C bus number."""
@@ -98,56 +105,60 @@ def __init__(self, address, busnum, i2c_interface=None):
         else:
             # Otherwise use the provided class to create an smbus interface.
             self._bus = i2c_interface(busnum)
-        self._logger = logging.getLogger('Adafruit_I2C.Device.Bus.{0}.Address.{1:#0X}' \
-                                .format(busnum, address))
+        self._logger = logging.getLogger('Adafruit_I2C.Device.Bus.{0}.Address.{1:#0X}'
+                                         .format(busnum, address))
+        self.regvals = [None] * 256
 
     def writeRaw8(self, value):
         """Write an 8-bit value on the bus (without register)."""
         value = value & 0xFF
         self._bus.write_byte(self._address, value)
         self._logger.debug("Wrote 0x%02X",
-                     value)
+                           value)
 
     def write8(self, register, value):
         """Write an 8-bit value to the specified register."""
-        value = value & 0xFF
-        self._bus.write_byte_data(self._address, register, value)
-        self._logger.debug("Wrote 0x%02X to register 0x%02X",
-                     value, register)
+        if self.regvals[register] is None or self.regvals[register] != value:
+            value = value & 0xFF
+            self._bus.write_byte_data(self._address, register, value)
+            self.regvals[register] = value
+            self._logger.debug(
+                "Wrote 0x%02X to register 0x%02X", value, register)
 
     def write16(self, register, value):
         """Write a 16-bit value to the specified register."""
         value = value & 0xFFFF
         self._bus.write_word_data(self._address, register, value)
         self._logger.debug("Wrote 0x%04X to register pair 0x%02X, 0x%02X",
-                     value, register, register+1)
+                           value, register, register + 1)
 
     def writeList(self, register, data):
         """Write bytes to the specified register."""
         self._bus.write_i2c_block_data(self._address, register, data)
         self._logger.debug("Wrote to register 0x%02X: %s",
-                     register, data)
+                           register, data)
 
     def readList(self, register, length):
         """Read a length number of bytes from the specified register.  Results
         will be returned as a bytearray."""
-        results = self._bus.read_i2c_block_data(self._address, register, length)
+        results = self._bus.read_i2c_block_data(
+            self._address, register, length)
         self._logger.debug("Read the following from register 0x%02X: %s",
-                     register, results)
+                           register, results)
         return results
 
     def readRaw8(self):
         """Read an 8-bit value on the bus (without register)."""
         result = self._bus.read_byte(self._address) & 0xFF
         self._logger.debug("Read 0x%02X",
-                    result)
+                           result)
         return result
 
     def readU8(self, register):
         """Read an unsigned byte from the specified register."""
         result = self._bus.read_byte_data(self._address, register) & 0xFF
         self._logger.debug("Read 0x%02X from register 0x%02X",
-                     result, register)
+                           result, register)
         return result
 
     def readS8(self, register):
@@ -161,9 +172,9 @@ def readU16(self, register, little_endian=True):
         """Read an unsigned 16-bit value from the specified register, with the
         specified endianness (default little endian, or least significant byte
         first)."""
-        result = self._bus.read_word_data(self._address,register) & 0xFFFF
+        result = self._bus.read_word_data(self._address, register) & 0xFFFF
         self._logger.debug("Read 0x%04X from register pair 0x%02X, 0x%02X",
-                           result, register, register+1)
+                           result, register, register + 1)
         # Swap bytes if using big endian because read_word_data assumes little
         # endian on ARM (little endian) systems.
         if not little_endian: