removed redundant methods and rename register variables.

Author: mrmcwethy

adafruit_apds9960/apds9960.py

@@ -100,17 +100,10 @@ class APDS9960:
     APDS9900 provide basic driver services for the ASDS9960 breakout board
     """
 
-    _enable = RWBit(APDS9960_ENABLE, 0)
-    _color_enable = RWBit(APDS9960_ENABLE, 1)
-    _proximity_enable = RWBit(APDS9960_ENABLE, 2)
     _gesture_enable = RWBit(APDS9960_ENABLE, 6)
-    _gesture_fifo_threshold = RWBits(2, APDS9960_GCONF1, 6)
-    _gesture_gain = RWBits(2, APDS9960_GCONF2, 5)
-    _color_gain = RWBits(2, APDS9960_CONTROL, 0)
     _gesture_valid = RWBit(APDS9960_GSTATUS, 0)
     _gesture_mode = RWBit(APDS9960_GCONF4, 0)
     _proximity_persistance = RWBits(4, APDS9960_PERS, 4)
-    _proximity_enable_interrupt = RWBit(APDS9960_ENABLE, 5)
 
     def __init__(self,
                  i2c, *,
@@ -124,23 +117,21 @@ def __init__(self,
         if interrupt_pin:
             self._interrupt_pin.switch_to_input(pull=digitalio.Pull.UP)
 
-        if self.read8(APDS9960_ID) != 0xAB:
+        if self._read8(APDS9960_ID) != 0xAB:
             raise RuntimeError()
 
         self.enable_gesture = False
         self.enable_proximity = False
         self.enable_color = False
-        self._enable_proximity_interrupt = False
-        self.enable_color_interrupt = False
-        self.proximity_interrupt = False
+        self.enable_proximity_interrupt = False
         self.clear_interrupt()
 
         self.enable = False
         time.sleep(0.010)
         self.enable = True
         time.sleep(0.010)
 
-        self._color_gain = gain
+        self.color_gain = gain
         self.integration_time = integration_time
         self.gesture_dimensions = 0x00 # all
         self.gesture_fifo_threshold = 0x01 # fifo 4
@@ -149,32 +140,41 @@ def __init__(self,
         self._reset_counts()
 
         # gesture pulse length=0x2 pulse count=0x3
-        self.write8(APDS9960_GPULSE, (0x2 << 6) | 0x3)
+        self._write8(APDS9960_GPULSE, (0x2 << 6) | 0x3)
 
 
     ## BOARD
-    @property
-    def enable(self):
-        """Set or get board enable.  True to enable, False to disable"""
-        return self._enable
-
-    @enable.setter
-    def enable(self, enable_flag):
-        self._enable = enable_flag
-
     def _reset_counts(self):
         """Gesture detection internal counts"""
         self._saw_down_start = 0
         self._saw_up_start = 0
         self._saw_left_start = 0
         self._saw_right_start = 0
 
+
+    enable = RWBit(APDS9960_ENABLE, 0)
+    """Board enable.  True to enable, False to disable"""
+    enable_color = RWBit(APDS9960_ENABLE, 1)
+    """Color detection enable flag.
+        True when color detection is enabled, else False"""
+    enable_proximity = RWBit(APDS9960_ENABLE, 2)
+    """Enable of proximity mode"""
+    gesture_fifo_threshold = RWBits(2, APDS9960_GCONF1, 6)
+    """Gesture fifo threshold value: range 0-3"""
+    gesture_gain = RWBits(2, APDS9960_GCONF2, 5)
+    """Gesture gain value: range 0-3"""
+    color_gain = RWBits(2, APDS9960_CONTROL, 0)
+    """Color gain value"""
+    enable_proximity_interrupt = RWBit(APDS9960_ENABLE, 5)
+    """Proximity interrupt enable flag.  True if enabled,
+        False to disable"""
+
     ## GESTURE DETECTION
     @property
     def enable_gesture(self):
-        """Set ot get gesture detection enable flag
-            Note that when disabled, the gesture mode is turned off"""
-        return self._gesture_mode, self._gesture_enable
+        """Gesture detection enable flag. True to enable, False to disable.
+            Note that when disabled, gesture mode is turned off"""
+        return self._gesture_enable
 
     @enable_gesture.setter
     def enable_gesture(self, enable_flag):
@@ -183,7 +183,7 @@ def enable_gesture(self, enable_flag):
         self._gesture_enable = enable_flag
 
     def gesture(self): #pylint: disable-msg=too-many-branches
-        """Return a gesture code if detected. =0 if no gesture
+        """Returns gesture code if detected. =0 if no gesture detected
         =1 if an UP, =2 if a DOWN, =3 if an LEFT, =4 if a RIGHT
         """
         # buffer to read of contents of device FIFO buffer
@@ -256,144 +256,95 @@ def gesture(self): #pylint: disable-msg=too-many-branches
 
         return gesture_received
 
-
     @property
     def gesture_dimensions(self):
-        """Set of get gesture dimension value: range 0-3"""
-        return self.read8(APDS9960_GCONF3)
+        """Gesture dimension value: range 0-3"""
+        return self._read8(APDS9960_GCONF3)
 
     @gesture_dimensions.setter
     def gesture_dimensions(self, dims):
-        self.write8(APDS9960_GCONF3, dims & 0x03)
-
-    @property
-    def gesture_fifo_threshold(self):
-        """Set or get gesture fifo threshold value: range 0-3"""
-        return self._gesture_fifo_threshold
-
-    @gesture_fifo_threshold.setter
-    def gesture_fifo_threshold(self, thresh):
-        self._gesture_fifo_threshold = thresh & 0x03
-
-    @property
-    def gesture_gain(self):
-        """Set or get gesture gain value: range 0-3"""
-        return self._gesture_gain
-
-    @gesture_gain.setter
-    def gesture_gain(self, gain):
-        self._gesture_gain = gain
-
-
-    ## COLOR DETECTION
-    @property
-    def enable_color(self):
-        """Set of get color detection enable flag.
-            True when color detection is enabled, else False"""
-        return self._color_enable
-
-    @enable_color.setter
-    def enable_color(self, enable_flag):
-        self._color_enable = enable_flag
+        self._write8(APDS9960_GCONF3, dims & 0x03)
 
     @property
     def color_data_ready(self):
-        """Get color data ready flag.  zero if not ready, 1 is ready"""
-        return self.read8(APDS9960_STATUS) & 0x01
+        """Color data ready flag.  zero if not ready, 1 is ready"""
+        return self._read8(APDS9960_STATUS) & 0x01
 
     @property
     def color_data(self):
-        """Returns tuple containing r, g, b, c values"""
+        """Tuple containing r, g, b, c values"""
         return self._color_data16(APDS9960_CDATAL + 2), \
                self._color_data16(APDS9960_CDATAL + 4), \
                self._color_data16(APDS9960_CDATAL + 6), \
                self._color_data16(APDS9960_CDATAL)
-    ### PROXIMITY
-    @property
-    def enable_proximity(self):
-        """Returns or sets the enablement of proximity mode"""
-        return self._proximity_enable
-
-    @enable_proximity.setter
-    def enable_proximity(self, enable_flag):
-        self._proximity_enable = enable_flag
 
+    ### PROXIMITY
     @property
     def proximity_interrupt_threshold(self):
-        """Returns a tuple containing low and high threshold
+        """Tuple containing low and high threshold
         followed by the proximity interrupt persistance.
-        Set the proximity interrupt threshold values using a tuple of zero to
-        three values: low threshold, high threshold, persistance.
+        When setting the proximity interrupt threshold values using a tuple of
+        zero to three values: low threshold, high threshold, persistance.
         persistance defaults to 4 if not provided"""
-        return self.read8(APDS9960_PILT), \
-               self.read8(APDS9960_PIHT), \
+        return self._read8(APDS9960_PILT), \
+               self._read8(APDS9960_PIHT), \
                self._proximity_persistance
 
     @proximity_interrupt_threshold.setter
     def proximity_interrupt_threshold(self, setting_tuple):
         if setting_tuple:
-            self.write8(APDS9960_PILT, setting_tuple[0])
+            self._write8(APDS9960_PILT, setting_tuple[0])
         if len(setting_tuple) > 1:
-            self.write8(APDS9960_PIHT, setting_tuple[1])
+            self._write8(APDS9960_PIHT, setting_tuple[1])
         persist = 4 # default 4
         if len(setting_tuple) > 2:
             persist = min(setting_tuple[2], 7)
         self._proximity_persistance = persist
 
 
-    @property
-    def enable_proximity_interrupt(self):
-        """Set or get proximity interrupt enable flag.  True if enabled,
-            False to disable"""
-        return self._proximity_enable_interrupt
-
-    @enable_proximity_interrupt.setter
-    def enable_proximity_interrupt(self, enable_flag):
-        self._proximity_enable_interrupt = enable_flag
-
     @property
     def gesture_proximity_threshold(self):
-        """Set or get proximity threshold value: range 0-255"""
-        return self.read8(APDS9960_GPENTH)
+        """Proximity threshold value: range 0-255"""
+        return self._read8(APDS9960_GPENTH)
 
     @gesture_proximity_threshold.setter
     def gesture_proximity_threshold(self, thresh):
-        self.write8(APDS9960_GPENTH, thresh & 0xff)
+        self._write8(APDS9960_GPENTH, thresh & 0xff)
 
     def proximity(self):
-        """Set or get proximity value: range 0-255"""
-        return self.read8(APDS9960_PDATA)
+        """proximity value: range 0-255"""
+        return self._read8(APDS9960_PDATA)
 
     def clear_interrupt(self):
         """Clear all interrupts"""
-        self.writecmdonly(APDS9960_AICLEAR)
+        self._writecmdonly(APDS9960_AICLEAR)
 
     @property
     def integration_time(self):
-        """Set or get the proximity integration time: range 0-255"""
-        return self.read8(APDS9960_ATIME)
+        """Proximity integration time: range 0-255"""
+        return self._read8(APDS9960_ATIME)
 
     @integration_time.setter
     def integration_time(self, int_time):
-        self.write8(APDS9960_ATIME, int_time & 0xff)
+        self._write8(APDS9960_ATIME, int_time & 0xff)
 
     # method for reading and writing to I2C
-    def write8(self, command, abyte):
+    def _write8(self, command, abyte):
         """Write a command and 1 byte of data to the I2C device"""
         buf = bytearray(2)
         buf[0] = command
         buf[1] = abyte
         with self.i2c_device as i2c:
             i2c.write(buf)
 
-    def writecmdonly(self, command):
+    def _writecmdonly(self, command):
         """Writes a command and 0 bytes of data to the I2C device"""
         buf = bytearray(1)
         buf[0] = command
         with self.i2c_device as i2c:
             i2c.write(buf)
 
-    def read8(self, command):
+    def _read8(self, command):
         """Sends a command and reads 1 byte of data from the I2C device"""
         buf = bytearray(1)
         buf[0] = command
@@ -403,7 +354,7 @@ def read8(self, command):
         return buf[0]
 
     def _color_data16(self, command):
-        """Sends a command and reads 2 byte of data from the I2C device
+        """Sends a command and reads 2 bytes of data from the I2C device
             The returned data is low byte first followed by high byte"""
         buf = bytearray(2)
         buf[0] = command