Adding active, dropped, and tapped for #3

Author: siddacious

adafruit_adxl34x.py

@@ -58,36 +58,41 @@
 _ADXL345_MG2G_MULTIPLIER = 0.004 # 4mg per lsb
 _STANDARD_GRAVITY = 9.80665 # earth standard gravity
 
-_ADXL345_REG_DEVID               = const(0x00) # Device ID
-_ADXL345_REG_THRESH_TAP          = const(0x1D) # Tap threshold
-_ADXL345_REG_OFSX                = const(0x1E) # X-axis offset
-_ADXL345_REG_OFSY                = const(0x1F) # Y-axis offset
-_ADXL345_REG_OFSZ                = const(0x20) # Z-axis offset
-_ADXL345_REG_DUR                 = const(0x21) # Tap duration
-_ADXL345_REG_LATENT              = const(0x22) # Tap latency
-_ADXL345_REG_WINDOW              = const(0x23) # Tap window
-_ADXL345_REG_THRESH_ACT          = const(0x24) # Activity threshold
-_ADXL345_REG_THRESH_INACT        = const(0x25) # Inactivity threshold
-_ADXL345_REG_TIME_INACT          = const(0x26) # Inactivity time
-_ADXL345_REG_ACT_INACT_CTL       = const(0x27) # Axis enable control for [in]activity detection
-_ADXL345_REG_THRESH_FF           = const(0x28) # Free-fall threshold
-_ADXL345_REG_TIME_FF             = const(0x29) # Free-fall time
-_ADXL345_REG_TAP_AXES            = const(0x2A) # Axis control for single/double tap
-_ADXL345_REG_ACT_TAP_STATUS      = const(0x2B) # Source for single/double tap
-_ADXL345_REG_BW_RATE             = const(0x2C) # Data rate and power mode control
-_ADXL345_REG_POWER_CTL           = const(0x2D) # Power-saving features control
-_ADXL345_REG_INT_ENABLE          = const(0x2E) # Interrupt enable control
-_ADXL345_REG_INT_MAP             = const(0x2F) # Interrupt mapping control
-_ADXL345_REG_INT_SOURCE          = const(0x30) # Source of interrupts
-_ADXL345_REG_DATA_FORMAT         = const(0x31) # Data format control
-_ADXL345_REG_DATAX0              = const(0x32) # X-axis data 0
-_ADXL345_REG_DATAX1              = const(0x33) # X-axis data 1
-_ADXL345_REG_DATAY0              = const(0x34) # Y-axis data 0
-_ADXL345_REG_DATAY1              = const(0x35) # Y-axis data 1
-_ADXL345_REG_DATAZ0              = const(0x36) # Z-axis data 0
-_ADXL345_REG_DATAZ1              = const(0x37) # Z-axis data 1
-_ADXL345_REG_FIFO_CTL            = const(0x38) # FIFO control
-_ADXL345_REG_FIFO_STATUS         = const(0x39) # FIFO status
+_REG_DEVID               = const(0x00) # Device ID
+_REG_THRESH_TAP          = const(0x1D) # Tap threshold
+_REG_OFSX                = const(0x1E) # X-axis offset
+_REG_OFSY                = const(0x1F) # Y-axis offset
+_REG_OFSZ                = const(0x20) # Z-axis offset
+_REG_DUR                 = const(0x21) # Tap duration
+_REG_LATENT              = const(0x22) # Tap latency
+_REG_WINDOW              = const(0x23) # Tap window
+_REG_THRESH_ACT          = const(0x24) # Activity threshold
+_REG_THRESH_INACT        = const(0x25) # Inactivity threshold
+_REG_TIME_INACT          = const(0x26) # Inactivity time
+_REG_ACT_INACT_CTL       = const(0x27) # Axis enable control for [in]activity detection
+_REG_THRESH_FF           = const(0x28) # Free-fall threshold
+_REG_TIME_FF             = const(0x29) # Free-fall time
+_REG_TAP_AXES            = const(0x2A) # Axis control for single/double tap
+_REG_ACT_TAP_STATUS      = const(0x2B) # Source for single/double tap
+_REG_BW_RATE             = const(0x2C) # Data rate and power mode control
+_REG_POWER_CTL           = const(0x2D) # Power-saving features control
+_REG_INT_ENABLE          = const(0x2E) # Interrupt enable control
+_REG_INT_MAP             = const(0x2F) # Interrupt mapping control
+_REG_INT_SOURCE          = const(0x30) # Source of interrupts
+_REG_DATA_FORMAT         = const(0x31) # Data format control
+_REG_DATAX0              = const(0x32) # X-axis data 0
+_REG_DATAX1              = const(0x33) # X-axis data 1
+_REG_DATAY0              = const(0x34) # Y-axis data 0
+_REG_DATAY1              = const(0x35) # Y-axis data 1
+_REG_DATAZ0              = const(0x36) # Z-axis data 0
+_REG_DATAZ1              = const(0x37) # Z-axis data 1
+_REG_FIFO_CTL            = const(0x38) # FIFO control
+_REG_FIFO_STATUS         = const(0x39) # FIFO status
+_INT_SINGLE_TAP          = const(0b01000000) # SINGLE_TAP bit
+_INT_DOUBLE_TAP          = const(0b00100000) # DOUBLE_TAP bit
+_INT_ACT                 = const(0b00010000) # ACT bit
+_INT_INACT               = const(0b00001000) # INACT bit
+_INT_FREE_FALL           = const(0b00000100) # FREE_FALL  bit
 
 class DataRate: #pylint: disable=too-few-public-methods
     """An enum-like class representing the possible data rates.
@@ -153,42 +158,148 @@ class ADXL345:
         :param address: The I2C device address for the sensor. Default is ``0x53``.
 
     """
-    def __init__(self, i2c, address=_ADXL345_DEFAULT_ADDRESS):
+    def __init__(self, i2c, address=_ADXL345_DEFAULT_ADDRESS, int1=None, int2=None):
 
         self._i2c = i2c_device.I2CDevice(i2c, address)
         self._buffer = bytearray(6)
         # set the 'measure' bit in to enable measurement
-        self._write_register_byte(_ADXL345_REG_POWER_CTL, 0x08)
+        self._write_register_byte(_REG_POWER_CTL, 0x08)
+        self._int1 = int1
+        self._int2 = int2
+        self._tap = None
 
     @property
     def acceleration(self):
         """The x, y, z acceleration values returned in a 3-tuple in m / s ^ 2."""
-        x, y, z = unpack('<hhh', self._read_register(_ADXL345_REG_DATAX0, 6))
+        x, y, z = unpack('<hhh', self._read_register(_REG_DATAX0, 6))
         x = x * _ADXL345_MG2G_MULTIPLIER * _STANDARD_GRAVITY
         y = y * _ADXL345_MG2G_MULTIPLIER * _STANDARD_GRAVITY
         z = z * _ADXL345_MG2G_MULTIPLIER * _STANDARD_GRAVITY
         return (x, y, z)
 
+    @property
+    def tapped(self):
+        """
+        True if a tap was detected recently. Whether it's looking for a single or double tap is
+        determined by the tap param on ``tap_parameters``.
+
+        """
+        if self._int2 and not self._int2.value:
+            return False
+
+        interrupt_source_register = self._read_clear_interrupt_source()
+        if self._tap == 1:
+            return interrupt_source_register & _INT_SINGLE_TAP > 0
+        if self._tap == 2:
+            return interrupt_source_register & _INT_DOUBLE_TAP > 0
+
+        return False
+
+    @property
+    def dropped(self):
+        """True if the sensor was in freefall"""
+
+        return self._read_clear_interrupt_source() & _INT_FREE_FALL > 0
+
+    @property
+    def active(self):
+        """True if the sensor has seen acceleration above the threshold set with
+        ``active_parameters``."""
+        return self._read_clear_interrupt_source() & _INT_ACT > 0
+
+    def active_parameters(self, threshold=0x5):
+        """
+        The activity detection parameters.
+
+        :param int threshold: The value that acceleration on any axis must exceed to\
+        register as active. The scale factor is 62.5 mg/LSB.
+
+        """
+        self._write_register_byte(_REG_INT_ENABLE, 0x0) # disable interrupts for setup
+        self._write_register_byte(_REG_ACT_INACT_CTL, 0b01110000) # enable activity on X,Y,Z
+        self._write_register_byte(_REG_THRESH_ACT, threshold)
+        self._write_register_byte(_REG_INT_ENABLE, _INT_ACT) # Inactive interrupt only
+
+    def dropped_parameters(self, threshold=0x5, time=0x14):
+        """
+        Freefall detection parameters:
+
+        :param int threshold: The value that acceleration on all axes must be under to\
+        register as dropped. The scale factor is 62.5 mg/LSB.
+
+        :param int time: The amount of time that acceleration on all axes must be less than\
+        ``threshhold`` to register as dropped. The scale factor is 5 ms/LSB. Values between 100 ms\
+        and 350 ms (0x14 to 0x46) are recommended.
+        """
+        self._write_register_byte(_REG_INT_ENABLE, 0x0) # disable interrupts for setup
+        self._write_register_byte(_REG_THRESH_FF, threshold)
+        self._write_register_byte(_REG_TIME_FF, time)
+        self._write_register_byte(_REG_INT_ENABLE, 0b00000100) # FREE_FALL interrupt only
+
+    def tap_parameters(self, tap, threshold, *, time_duration=10, time_latency=20, time_window=255):
+        """
+        The tap detection parameters.
+
+        :param int tap: 0 to disable tap detection, 1 to detect only single taps, and 2 to detect\
+        only double taps.
+
+        :param int threshold: A threshold for the tap detection. The scale factor is 62.5 mg/LSB\
+        The higher the value the less sensitive the detection. This changes based on the\
+        accelerometer range.
+
+        :param int time_duration: This caps the duration of the impulse above ``threshhold``.\
+        Anything above ``time_duration`` won't register as a tap. The scale factor is 625 µs/LSB
+
+        :param int time_latency(double tap only): The length of time after the initial impulse falls below\
+        ``threshold`` to start the window looking for a second impulse.\
+        The scale factor is 1.25 ms/LSB.
+
+        :param int time_window(double tap only): The length of the window in which to look for a\
+        second tap. The scale factor is 1.25 ms/LSB
+        """
+        if tap == 0:
+            self._write_register_byte(_REG_INT_ENABLE, 0x0) # disable all interrupts
+            self._write_register_byte(_REG_TAP_AXES, 0x0) # disable all axes for tap
+            return
+        self._write_register_byte(_REG_INT_ENABLE, 0x0) # disable interrupts for setup
+        self._write_register_byte(_REG_TAP_AXES, 0b00000111) # enable X, Y, Z axes for tap
+        self._write_register_byte(_REG_THRESH_TAP, threshold)
+        self._write_register_byte(_REG_DUR, time_duration)
+
+        self._tap = tap # save to determine which register to check later
+        if tap == 1:
+            if self._int2:
+                self._write_register_byte(_REG_INT_MAP, _INT_SINGLE_TAP) # send SINGLE_TAP to INT2
+            self._write_register_byte(_REG_INT_ENABLE, _INT_SINGLE_TAP) # DOUBLE_TAP interrupt only
+        elif tap == 2:
+            self._write_register_byte(_REG_LATENT, time_latency)
+            self._write_register_byte(_REG_WINDOW, time_window)
+            if self._int2:
+                self._write_register_byte(_REG_INT_MAP, _INT_DOUBLE_TAP) # send DOUBLE_TAP to INT2
+            self._write_register_byte(_REG_INT_ENABLE, _INT_DOUBLE_TAP) # DOUBLE_TAP interrupt only
+        else:
+            raise ValueError("tap must be 0 to disable, 1 for single tap, or 2 for double tap")
+
     @property
     def data_rate(self):
         """The data rate of the sensor."""
-        rate_register = unpack("<b", self._read_register(_ADXL345_REG_BW_RATE, 1))[0]
+        rate_register = unpack("<b", self._read_register(_REG_BW_RATE, 1))[0]
         return rate_register & 0x0F
 
     @data_rate.setter
     def data_rate(self, val):
-        self._write_register_byte(_ADXL345_REG_BW_RATE, val)
+        self._write_register_byte(_REG_BW_RATE, val)
 
     @property
     def range(self):
         """The measurement range of the sensor."""
-        range_register = unpack("<b", self._read_register(_ADXL345_REG_DATA_FORMAT, 1))[0]
+        range_register = unpack("<b", self._read_register(_REG_DATA_FORMAT, 1))[0]
         return range_register & 0x03
 
     @range.setter
     def range(self, val):
         # read the current value of the data format register
-        format_register = unpack("<b", self._read_register(_ADXL345_REG_DATA_FORMAT, 1))[0]
+        format_register = unpack("<b", self._read_register(_REG_DATA_FORMAT, 1))[0]
 
         # clear the bottom 4 bits and update the data rate
         format_register &= ~0x0F
@@ -198,7 +309,10 @@ def range(self, val):
         format_register |= 0x08
 
         # write the updated values
-        self._write_register_byte(_ADXL345_REG_DATA_FORMAT, format_register)
+        self._write_register_byte(_REG_DATA_FORMAT, format_register)
+
+    def _read_clear_interrupt_source(self):
+        return unpack("<b", self._read_register(_REG_INT_SOURCE, 1))[0]
 
     def _read_register(self, register, length):
         self._buffer[0] = register & 0xFF

examples/adxl34x_active_test.py

@@ -0,0 +1,16 @@
+import time
+import audioio
+import board
+import busio
+import digitalio
+import adafruit_adxl34x
+
+i2c = busio.I2C(board.SCL, board.SDA)
+
+accelerometer = adafruit_adxl34x.ADXL345(i2c)
+accelerometer.active_parameters()
+while True:
+    print("%f %f %f"%accelerometer.acceleration)
+
+    print("Active: %s"%accelerometer.active)
+    time.sleep(0.5)

examples/adxl34x_dropped_test.py

@@ -0,0 +1,16 @@
+import time
+import audioio
+import board
+import busio
+import digitalio
+import adafruit_adxl34x
+
+i2c = busio.I2C(board.SCL, board.SDA)
+
+accelerometer = adafruit_adxl34x.ADXL345(i2c)
+accelerometer.dropped_parameters()
+while True:
+    print("%f %f %f"%accelerometer.acceleration)
+
+    print("Dropped: %s"%accelerometer.dropped)
+    time.sleep(0.5)

examples/adxl34x_tapped_test.py

@@ -0,0 +1,16 @@
+import time
+import audioio
+import board
+import busio
+import digitalio
+import adafruit_adxl34x
+
+i2c = busio.I2C(board.SCL, board.SDA)
+
+accelerometer = adafruit_adxl34x.ADXL345(i2c)
+accelerometer.tap_parameters(1, 10)
+while True:
+    print("%f %f %f"%accelerometer.acceleration)
+
+    print("Tapped: %s"%accelerometer.tapped)
+    time.sleep(0.5)