import time
import board
import alarm
import displayio
import adafruit_lis3dh
# get the display
epd = board.DISPLAY
# set up accelerometer
lis = adafruit_lis3dh.LIS3DH_I2C(board.I2C(), address=0x19)
# See: ST Design Tip DT0008 - Simple screen rotation using
# the accelerometer built-in 4D detection interrupt
# pylint: disable=protected-access
lis._write_register_byte(0x20, 0x3F) # low power mode with ODR = 25Hz
lis._write_register_byte(
0x22, 0x40) # AOI1 interrupt generation is routed to INT1 pin
lis._write_register_byte(0x23,
0x80) # FS = ±2g low power mode with BDU bit enabled
lis._write_register_byte(
0x24,
0x0C) # Interrupt signal on INT1 pin is latched with D4D_INT1 bit enabled
lis._write_register_byte(
0x32, 0x20) # Threshold = 32LSBs * 15.625mg/LSB = 500mg. (~30 deg of tilt)
lis._write_register_byte(0x33, 0x01) # Duration = 1LSBs * (1/25Hz) = 0.04s
# read to clear
_ = lis._read_register_byte(0x31)
# get current accel values
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT
"""This example uses the LIS3DH accelerometer. Debug_I2C can be used with any I2C device."""
import board
import digitalio
import adafruit_lis3dh
from adafruit_debug_i2c import DebugI2C
i2c = DebugI2C(board.I2C())
int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)
accelerometer = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19, int1=int1)
print(accelerometer.acceleration)
for i in range(2):
print(accelerometer.acceleration)
# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT
import time
import board
import busio
import adafruit_lis3dh
# Hardware I2C setup. Use the CircuitPlayground built-in accelerometer if available;
# otherwise check I2C pins.
if hasattr(board, "ACCELEROMETER_SCL"):
i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19)
else:
i2c = busio.I2C(board.SCL, board.SDA)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c)
# Hardware SPI setup:
# spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
# cs = digitalio.DigitalInOut(board.D5) # Set to correct CS pin!
# lis3dh = adafruit_lis3dh.LIS3DH_SPI(spi, cs)
# PyGamer or MatrixPortal I2C Setup:
# i2c = busio.I2C(board.SCL, board.SDA)
# lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19)
# Set range of accelerometer (can be RANGE_2_G, RANGE_4_G, RANGE_8_G or RANGE_16_G).
lis3dh.range = adafruit_lis3dh.RANGE_2_G
# Loop forever printing accelerometer values
while True:
# Set up NeoPixels
neopixels = neopixel.NeoPixel(NEOPIXEL_PIN, NUM_PIXELS, brightness=1)
neopixels.fill((0,0,0))
#neopixels.show()
# Set up on/off button
button = digitalio.DigitalInOut(SWITCH_PIN)
button.switch_to_input(pull=digitalio.Pull.UP)
prevPress = False
on = False
clashNum = 2
# Set up accelerometer on I2C bus, 4G range:
i2c = busio.I2C(board.SCL, board.SDA)
int1 = digitalio.DigitalInOut(board.D6)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)
lis3dh.range = adafruit_lis3dh.RANGE_8_G
lis3dh.set_tap(1, 90, time_limit=4, time_latency=50, time_window=255)
enable = digitalio.DigitalInOut(POWER_PIN)
enable.direction = digitalio.Direction.OUTPUT
enable.value = False
redled = digitalio.DigitalInOut(board.D13)
redled.direction = digitalio.Direction.OUTPUT
led = neopixel.NeoPixel(board.NEOPIXEL, 1);
led.brightness = 0.2
redled.value = False
def play_file(filename):
print("Playing file: " + filename)
def __init__(self, i2c=None):
"""
:param i2c: The I2C bus to use, will try board.I2C()
if not supplied
"""
displayio.release_displays()
if i2c is None:
i2c = board.I2C()
# set up on-board seesaw
self._ss = Seesaw(i2c)
# set up seesaw pins
self._ss.pin_mode(SS_TFTRESET_PIN, self._ss.OUTPUT) # left sceen reset
# buttons abolve left eye
self._ss.pin_mode(SS_SWITCH1_PIN, self._ss.INPUT_PULLUP)
self._ss.pin_mode(SS_SWITCH2_PIN, self._ss.INPUT_PULLUP)
self._ss.pin_mode(SS_SWITCH3_PIN, self._ss.INPUT_PULLUP)
# light sensor near left eye
self._ss.pin_mode(SS_LIGHTSENSOR_PIN, self._ss.INPUT)
# Manual reset for left screen
self._ss.digital_write(SS_TFTRESET_PIN, False)
time.sleep(0.01)
self._ss.digital_write(SS_TFTRESET_PIN, True)
time.sleep(0.01)
# Left backlight pin, on the seesaw
self._ss.pin_mode(SS_BACKLIGHT_PIN, self._ss.OUTPUT)
# backlight on full brightness
self._ss.analog_write(SS_BACKLIGHT_PIN, 255)
# Left screen spi bus
left_spi = busio.SPI(board.LEFT_TFT_SCK, MOSI=board.LEFT_TFT_MOSI)
left_tft_cs = board.LEFT_TFT_CS
left_tft_dc = board.LEFT_TFT_DC
left_display_bus = displayio.FourWire(
left_spi,
command=left_tft_dc,
chip_select=left_tft_cs # Reset on Seesaw
)
self.left_display = ST7789(left_display_bus,
width=240,
height=240,
rowstart=80)
# right backlight on board
self.right_backlight = pulseio.PWMOut(board.RIGHT_TFT_LITE,
frequency=5000,
duty_cycle=0)
# full brightness
self.right_backlight.duty_cycle = 65535
# right display spi bus
right_spi = busio.SPI(board.RIGHT_TFT_SCK, MOSI=board.RIGHT_TFT_MOSI)
right_tft_cs = board.RIGHT_TFT_CS
right_tft_dc = board.RIGHT_TFT_DC
right_display_bus = displayio.FourWire(
right_spi,
command=right_tft_dc,
chip_select=right_tft_cs,
reset=board.RIGHT_TFT_RST, # reset on board
)
self.right_display = ST7789(right_display_bus,
width=240,
height=240,
rowstart=80)
# setup accelerometer
if i2c is not None:
int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)
try:
self._accelerometer = adafruit_lis3dh.LIS3DH_I2C(i2c,
address=0x19,
int1=int1)
except ValueError:
self._accelerometer = adafruit_lis3dh.LIS3DH_I2C(i2c,
int1=int1)
# touchio on nose
self.nose = touchio.TouchIn(board.NOSE)
# can be iffy, depending on environment and person.
# User code can tweak if needed.
self.nose.threshold = 180
def acceleration(self):
"""Obtain acceleration as a tuple with 3 elements: (x, y, z)"""
if not self._lis3dh:
import adafruit_lis3dh
self._lis3dh = adafruit_lis3dh.LIS3DH_I2C(self.i2c, address=0x18)
return self._lis3dh.acceleration
