def soil(name): #Thread 4
i2c_bus = busio.I2C(board.SCL, board.SDA)
ss = Seesaw(i2c_bus, addr=0x36)
countStemma = 0
while True:
# read moisture level through capacitive touch pad
touch = ss.moisture_read()
if touch is not None:
satPercent = 200*(touch-200)/1800
try:
logging.info("Thread %s: Logging soil info into MariaDB",name)
cur.execute("INSERT INTO soil_moisture (moisture,taken_at) VALUES (?,?)", (satPercent,datetime.datetime.now()))
conn.commit()
except mariadb.Error as e:
print(f"Error: {e}")
dataStorageFail("Soil Moisture Sensor")
else:
print("Stemma Data could not be collected")
countStemma += 1
#Didn't collect value
if satPercent >= 60:
#drip off
GPIO.output(12,False)
elif satPercent <= 40:
#drip on
GPIO.output(12,True)
dataPasser.action[0] += 1
else:
continue
#no change drip
if countStemma >= 5:
noData("Stemma Soil Moisture Sensor")
time.sleep(30)
def __init__(self, address=0x5E, i2c=None, spi=None):
if i2c is None:
i2c = board.I2C()
if spi is None:
spi = board.SPI()
self._ss = Seesaw(i2c, address)
self._backlight = PWMOut(self._ss, 5)
self._backlight.duty_cycle = 0
displayio.release_displays()
while not spi.try_lock():
pass
spi.configure(baudrate=24000000)
spi.unlock()
self._ss.pin_mode(8, self._ss.OUTPUT)
self._ss.digital_write(8, True) # Reset the Display via Seesaw
display_bus = displayio.FourWire(spi,
command=board.D6,
chip_select=board.D5)
self.display = ST7735R(display_bus,
width=160,
height=80,
colstart=24,
rotation=270,
bgr=True)
self._ss.pin_mode_bulk(self._button_mask, self._ss.INPUT_PULLUP)
class SoilSensor:
# initialize needed values for communication
def __init__(self):
self.i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
self.ss = Seesaw(self.i2c_bus, addr=0x36)
# get the soil moisture from the sensor
def get_moisture(self):
#i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
#ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level through capacitive touch pad
moisture = self.ss.moisture_read()
print("Soil Moisture Reading:", moisture)
return moisture
# get the soil temperature from the sensor
def get_temperature(self):
#i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
#ss = Seesaw(i2c_bus, addr=0x36)
# read temperature from the temperature sensor
temp = self.ss.get_temp()
print("Soil Temperatured Reading:", temp)
return temp
def __init__(self, config, i2c):
self._name = config.get('Name', '')
self._dht = adafruit_dht.DHT22(int(config.get('DhtPin', 0)))
self._light_pin = int(config.get('LightPin', 0))
self._water_pin = int(config.get('WaterPin', 0))
if config.getboolean('UseSS'):
self._useSS = True
self._soil_sensor = Seesaw(i2c, addr=int(config.get('SSAddr', 0x0), 16))
self._soil_min = int(config.get('SSMin', 0))
self._soil_max = int(config.get('SSMax', 0))
else:
self._useSS = False
self._light_on = False
self._water_on = False
self._turn_light_on = int(config.get('LightOn', 0))
self._turn_light_off = int(config.get('LightOff', 0))
self._water_on_pct = int(config.get('MoistureOnPct',25))
self._water_off_pct = int(config.get('MoistureOffPct', 75))
self._water_on_time = datetime.strptime(config.get('WaterOnTime', '00:00'), '%H:%M').time()
self._water_off_time = datetime.strptime(config.get('WaterOffTime', '00:00'), '%H:%M').time()
self._prefix = config.get('Prefix', '')
GPIO.setup(self._light_pin, GPIO.OUT, initial=GPIO.HIGH)
GPIO.setup(self._water_pin, GPIO.OUT, initial=GPIO.HIGH)
self.temperature = 0.0
self.humidity = 0.0
self.soil_temp = 0.0
self.moisture = 0
self.prev_temperature = 0.0
self.prev_humidity = 0.0
self.prev_moisture = 0.0
self.prev_soil_temp = 0
self.water = 0
self.light = 0
class InputModule(AbstractInput):
""" A sensor support class that measures soil moisture using adafruit's i2c soil sensor """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev, testing=testing, name=__name__)
self.sensor = None
if not testing:
self.initialize_input()
def initialize_input(self):
from adafruit_seesaw.seesaw import Seesaw
from adafruit_extended_bus import ExtendedI2C
try:
self.sensor = Seesaw(
ExtendedI2C(self.input_dev.i2c_bus),
addr=int(str(self.input_dev.i2c_location), 16))
except:
self.logger.exception("Setting up sensor")
def get_measurement(self):
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.moisture_read())
if self.is_enabled(1):
self.value_set(1, self.sensor.get_temp())
return self.return_dict
def __init__(
self,
address: int = 0x5E,
i2c: Optional[I2C] = None,
spi: Optional[SPI] = None,
cs: Optional[Pin] = None,
dc: Optional[Pin] = None,
):
displayio.release_displays()
if i2c is None:
i2c = board.I2C()
if spi is None:
spi = board.SPI()
if cs is None:
cs = board.D5
if dc is None:
dc = board.D6
self._ss = Seesaw(i2c, address)
self._ss.pin_mode_bulk(self._button_mask, self._ss.INPUT_PULLUP)
self._ss.pin_mode(8, self._ss.OUTPUT)
self._ss.digital_write(8, True) # Reset the Display via Seesaw
self._backlight = PWMOut(self._ss, 5)
self._backlight.duty_cycle = 0
display_bus = displayio.FourWire(spi, command=dc, chip_select=cs)
self.display = ST7735R(display_bus,
width=160,
height=80,
colstart=24,
rotation=270,
bgr=True)
def reading():
# Soil Moisture Sensor Readings
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level through capacitive touch pad
touch = ss.moisture_read()
return touch
def get_temperature(self):
i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
ss = Seesaw(i2c_bus, addr=0x36)
# read temperature from the temperature sensor
temp = ss.get_temp()
print("Soil Temperatured Reading:", temp)
return temp
def get_moisture(self):
i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level through capacitive touch pad
moisture = ss.moisture_read()
print("Soil Moisture Reading:", moisture)
return moisture
def initialize_input(self):
from adafruit_seesaw.seesaw import Seesaw
from adafruit_extended_bus import ExtendedI2C
try:
self.sensor = Seesaw(ExtendedI2C(self.input_dev.i2c_bus),
addr=int(str(self.input_dev.i2c_location),
16))
except:
self.logger.exception("Setting up sensor")
def get_temp():
try:
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
# read temperature from the temperature sensor
temp = ss.get_temp()
print("Temperature: {0}".format(temp))
return round(temp, 2)
except Exception as e:
return 0
def get_soil():
try:
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level through capacitive touch pad
touch = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
print("Soil moisture: {0}".format(touch))
return touch
except Exception as e:
return 0
def moisture_setup(addrresses):
sensors = []
for addr in addrresses:
i2c_bus = busio.I2C(SCL, SDA)
sensor = Seesaw(i2c_bus, addr)
sensors.append(sensor)
return sensors
def main():
"""Primary entry point for the application"""
log_format = '[%(asctime)s] %(levelname)s %(message)s'
logging.basicConfig(format=log_format, level=logging.INFO)
logging.info('** GardenPI Soil Moisture Test Utility Starting **')
start_time = time.time()
i2c = board.I2C()
sensors = []
mins = []
maxs = []
# load the config
config = utils.load_config()
if config['General'].getboolean('UseShelf1'):
sensors.append(
Seesaw(i2c, addr=int(config['Shelf1'].get('SSAddr', 0x0), 16)))
mins.append(int(config['Shelf1'].get('SSMin', 200)))
maxs.append(int(config['Shelf1'].get('SSMax', 2000)))
if config['General'].getboolean('UseShelf2'):
sensors.append(
Seesaw(i2c, addr=int(config['Shelf2'].get('SSAddr', 0x0), 16)))
mins.append(int(config['Shelf2'].get('SSMin', 200)))
maxs.append(int(config['Shelf2'].get('SSMax', 2000)))
if config['General'].getboolean('UseShelf3'):
sensors.append(
Seesaw(i2c, addr=int(config['Shelf3'].get('SSAddr', 0x0), 16)))
mins.append(int(config['Shelf3'].get('SSMin', 200)))
maxs.append(int(config['Shelf3'].get('SSMax', 2000)))
# NOTE: 200 == very dry; 2000 == very wet
while True:
for idx, ss in enumerate(sensors):
try:
temp = utils.ctof(ss.get_temp())
touch = ss.moisture_read()
scaled = utils.scale_to_percent(touch, mins[idx], maxs[idx])
print("Device: {}\tTemp: {:.1f} *F\tRaw: {}\tScaled: {:.2f}%".
format(idx, temp, touch, scaled))
except RuntimeError as e:
print("Reading from SS failure: ", e.args)
time.sleep(2)
logging.info("Script Finished")
logging.info("Elapsed Time: %s seconds ", (time.time() - start_time))
def set_sensors():
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
GPIO.cleanup()
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
return ss
class SeesawSoilSensor(drivers.Sensor):
i2c_address = 54 # 0x36
moisture_metric = 'soil-moisture'
t9e_metric = 'soil-temp'
def setup(self):
i2c_bus = busio.I2C(SCL, SDA)
self.ss = Seesaw(i2c_bus, addr=int(self.i2c_address))
def read(self):
# read moisture level through capacitive touch pad
moisture = self.ss.moisture_read()
metrics.create_metric_log(self.moisture_metric, moisture)
# read temperature from the temperature sensor
t9e = self.ss.get_temp()
metrics.create_metric_log(self.t9e_metric, t9e)
def __init__(self,
gpio_relay,
gpio_flow,
ip_address=None,
humid_temp="DHT22",
moisture="I2C"):
IotDevice.__init__(self)
if gpio_relay == "SIM":
self.gpio_relay = None
else:
if ip_address is not None:
self.gpio_relay = LED(gpio_relay,
PiGPIOFactory(host=ip_address))
else:
self.gpio_relay = LED(gpio_relay)
# For now we want to leave the DHT sensor (measures temperature and humidity)
# connected to pin 18.
if humid_temp == "BME280":
i2c = board.I2C()
self.ht_sensor = Bme280(i2c)
self.ht_sensor.set_sea_level_pressure(1022.2)
elif humid_temp == "DHT11":
self.ht_sensor = adafruit_dht.DHT11(board.D18)
elif humid_temp == "DHT22":
self.ht_sensor = adafruit_dht.DHT22(board.D18)
else:
self.ht_sensor = None
# For now we want to leave SCL to pin 3 and SDA to pin 2 for i2c interface.
# meaning moisture sensor will need to be connected to these pins
if moisture == "SIM":
self.moisture_sensor = None
else:
self.moisture_sensor = Seesaw(busio.I2C(board.D3, board.D2),
addr=0x36)
if gpio_flow == "SIM":
self.gpio_flow = None
else:
self.gpio_flow = FrequencySignal(gpio_flow)
def soil_reading():
#read moisture level through capacitive touch pad
ss = Seesaw(i2c_bus, addr=0x36)
touch = ss.moisture_read()
time.sleep(1)
touch2 = ss.moisture_read()
difference = touch - touch2
#check sensor for daily errors
if (difference > 3 or difference < -3):
print("moisture warning", difference)
#read temperature from the temperature from the temperature sensor
temp = ss.get_temp()
time.sleep(1)
temp2 = ss.get_temp()
temp_difference = temp - temp2
#check sensor for daily errors
if (temp_difference > 3 or temp_difference < -3):
print("tempurature warning", temp_difference)
print("temp: ",temp, " moisture: ",touch)
time.sleep(1)
class InputModule(AbstractInput):
"""A sensor support class that measures soil moisture using adafruit's i2c soil sensor."""
def __init__(self, input_dev, testing=False):
super().__init__(input_dev, testing=testing, name=__name__)
self.sensor = None
if not testing:
self.try_initialize()
def initialize(self):
from adafruit_seesaw.seesaw import Seesaw
from adafruit_extended_bus import ExtendedI2C
try:
self.sensor = Seesaw(ExtendedI2C(self.input_dev.i2c_bus),
addr=int(str(self.input_dev.i2c_location),
16))
except:
self.logger.exception("Setting up sensor")
def get_measurement(self):
if not self.sensor:
self.logger.error(
"Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info."
)
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.moisture_read())
if self.is_enabled(1):
self.value_set(1, self.sensor.get_temp())
return self.return_dict
class SoilSensor:
i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
ss = Seesaw(i2c_bus, addr=0x36)
def get_moisture(self):
i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level through capacitive touch pad
moisture = ss.moisture_read()
print("Soil Moisture Reading:", moisture)
return moisture
def get_temperature(self):
i2c_bus = busio.I2C(SCL, SDA)
# Need to put the address into the sensor constructor for each
ss = Seesaw(i2c_bus, addr=0x36)
# read temperature from the temperature sensor
temp = ss.get_temp()
print("Soil Temperatured Reading:", temp)
return temp
#This is the tutorial testing for the soil sensor
#Just wired all my sensors and tested them individually
#Tomorrow I wire them all on the same board if I can and run it on a cron command
# to start dumping data into a database with SQLite-
#I will have photos posted on how I wired each sensor up to the bread board
import time
from board import SCL, SDA
import busio
from adafruit_seesaw.seesaw import Seesaw
i2c_bus =busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
while True:
#read moisture level through capacitive touch pad
touch = ss.moisture_read()
#read temperature from the temperature from the temperature sensor
temp = ss.get_temp()
print("temp: " + str(temp) + " moisture: " + str(touch))
time.sleep(1)
# Simple seesaw test using an LED attached to Pin 15.
#
# See the seesaw Learn Guide for wiring details:
# https://learn.adafruit.com/adafruit-seesaw-atsamd09-breakout?view=all#circuitpython-wiring-and-test
import time
from board import SCL, SDA
import busio
from adafruit_seesaw.seesaw import Seesaw
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus)
ss.pin_mode(15, ss.OUTPUT)
while True:
ss.digital_write(15, True) # turn the LED on (True is the voltage level)
time.sleep(1) # wait for a second
ss.digital_write(15, False) # turn the LED off by making the voltage LOW
time.sleep(1)
background, a smaller purple rectangle, and some yellow text.
"""
import board
import displayio
import terminalio
from adafruit_display_text import label
from adafruit_seesaw.seesaw import Seesaw
from adafruit_st7735r import ST7735R
# Release any resources currently in use for the displays
displayio.release_displays()
reset_pin = 8
i2c = board.I2C()
ss = Seesaw(i2c, 0x5E)
ss.pin_mode(reset_pin, ss.OUTPUT)
spi = board.SPI()
tft_cs = board.D5
tft_dc = board.D6
display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs)
ss.digital_write(reset_pin, True)
display = ST7735R(display_bus,
width=160,
height=80,
colstart=24,
rotation=270,
bgr=True)
dht_pin = 4
air_humidity, air_temperature = Adafruit_DHT.read_retry(dht_sensor, dht_pin)
# Current plant that is being monitored
plant = 'palm'
# connnect to database
con = psycopg2.connect(database=target_db,
user=db_user,
password=user_password,
host='localhost')
cur = con.cursor()
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
# read moisture level several times and take average to limit measure error
measurements = 0
max_moisture = 0
min_moisture = 2000
for i in range(15):
moisture_measurement = ss.moisture_read()
measurements = measurements + moisture_measurement
if moisture_measurement > max_moisture:
max_moisture = moisture_measurement
if moisture_measurement < min_moisture:
min_moisture = moisture_measurement
esp.set_certificate(DEVICE_CERT)
# Set AWS RSA Private Key
esp.set_private_key(DEVICE_KEY)
# Connect to WiFi
print("Connecting to WiFi...")
wifi.connect()
print("Connected!")
# Initialize MQTT interface with the esp interface
MQTT.set_socket(socket, esp)
# Soil Sensor Setup
i2c_bus = busio.I2C(board.SCL, board.SDA)
ss = Seesaw(i2c_bus, addr=0x36)
# Define callback methods which are called when events occur
# pylint: disable=unused-argument, redefined-outer-name
def connect(client, userdata, flags, rc):
# This function will be called when the client is connected
# successfully to the broker.
print('Connected to AWS IoT!')
print('Flags: {0}\nRC: {1}'.format(flags, rc))
# Subscribe client to all shadow updates
print("Subscribing to shadow updates...")
aws_iot.shadow_subscribe()
| (1 << BUTTON_SEL))
numbers = {
'0': [0x1E, 0x21, 0x1E],
'1': [0x11, 0x3F, 0x01],
'2': [0x13, 0x25, 0x19],
'3': [0x21, 0x29, 0x16],
'4': [0x38, 0x08, 0x3F],
'5': [0x39, 0x29, 0x26],
'6': [0x1E, 0x29, 0x06],
'7': [0x23, 0x2C, 0x30],
'8': [0x16, 0x29, 0x16],
'9': [0x10, 0x29, 0x1E],
}
i2c_bus = busio.I2C(board.SCL, board.SDA)
ss = Seesaw(i2c_bus)
ss.pin_mode_bulk(button_mask, ss.INPUT_PULLUP)
wing = dotstar_featherwing.DotStarFeatherWing()
wing.auto_write = False
# wing.brightness = 0.2
purple = (100, 0, 100)
black = (0, 0, 0)
flash = (250, 220, 220)
turquoise = (0, 100, 50)
red = (220, 0, 0)
green = (0, 220, 0)
blueish = (0, 0, 150)
wall = turquoise
import time
from board import SCL, SDA
import busio
from adafruit_seesaw.seesaw import Seesaw
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus, addr=0x36)
while True:
# read moisture level through capacitive touch pad
touch = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
print("temp: " + str(temp) + " moisture: " + str(touch))
time.sleep(1)
# CircuitPython 3.0 CRICKIT demo
from adafruit_seesaw.seesaw import Seesaw
from adafruit_seesaw.pwmout import PWMOut
from adafruit_motor import servo
from busio import I2C
import audioio
import microcontroller
import board
import time
i2c = I2C(board.SCL, board.SDA)
ss = Seesaw(i2c)
print("Yanny or Laurel data logging!")
LOOKATPERSON = 90
LOOKLEFT = 60
LOOKRIGHT = 120
#################### 1 Servo
pwm = PWMOut(ss, 17)
pwm.frequency = 50
myservo = servo.Servo(pwm)
myservo.angle = LOOKATPERSON # introduce yourself
#################### 2 buttons w/2 LEDs
BUTTON_1 = 2
BUTTON_2 = 3
LED_1 = 8
LED_2 = 9
from board import SCL, SDA import busio from adafruit_seesaw.seesaw import Seesaw from adafruit_seesaw.pwmout import PWMOut from adafruit_motor import servo #from analogio import AnalogOut #import board i2c_bus = busio.I2C(SCL, SDA) ss = Seesaw(i2c_bus) pwm1 = PWMOut(ss, 17) pwm2 = PWMOut(ss, 16) pwm3 = PWMOut(ss, 15) pwm4 = PWMOut(ss, 14) pwm1.frequency = 50 pwm2.frequency = 50 pwm3.frequency = 50 pwm4.frequency = 50 S1 = servo.Servo(pwm1) S2 = servo.Servo(pwm2) S3 = servo.Servo(pwm3) S4 = servo.Servo(pwm4) servos = (S1, S2, S3, S4) CRCKIT_NUM_ADC = 8 CRCKit_adc = (2, 3, 40, 41, 11, 10, 9, 8)
# pylint: disable=bad-whitespace
BUTTON_RIGHT = const(6)
BUTTON_DOWN = const(7)
BUTTON_LEFT = const(9)
BUTTON_UP = const(10)
BUTTON_SEL = const(14)
# pylint: enable=bad-whitespace
button_mask = const((1 << BUTTON_RIGHT) |
(1 << BUTTON_DOWN) |
(1 << BUTTON_LEFT) |
(1 << BUTTON_UP) |
(1 << BUTTON_SEL))
i2c_bus = busio.I2C(SCL, SDA)
ss = Seesaw(i2c_bus)
ss.pin_mode_bulk(button_mask, ss.INPUT_PULLUP)
last_x = 0
last_y = 0
while True:
x = ss.analog_read(2)
y = ss.analog_read(3)
if (abs(x - last_x) > 3) or (abs(y - last_y) > 3):
print(x, y)
last_x = x
last_y = y
return ~self.ss.digital_read_bulk(self.mask)
class DummyAudio:
def play(self, f, loop=False):
pass
def stop(self):
pass
def mute(self, mute):
pass
i2c = board.I2C()
ss = Seesaw(i2c, 0x5E)
spi = board.SPI()
displayio.release_displays()
while not spi.try_lock():
pass
spi.configure(baudrate=24000000)
spi.unlock()
ss.pin_mode(8, ss.OUTPUT)
ss.digital_write(8, True) # reset display
display_bus = displayio.FourWire(spi, command=board.D6, chip_select=board.D5)
display = displayio.Display(display_bus, _INIT_SEQUENCE, width=160, height=80,
rowstart=24)
del _INIT_SEQUENCE
buttons = GamePadSeesaw(ss)
audio = DummyAudio()
backlight = PWMOut(ss, 5)
from busio import I2C
from adafruit_seesaw.seesaw import Seesaw
from adafruit_seesaw.pwmout import PWMOut
from adafruit_motor import motor
import board
import time
# Create seesaw object
i2c = I2C(board.SCL, board.SDA)
seesaw = Seesaw(i2c)
# Create one motor on seesaw PWM pins 22 & 23
motor_a = motor.DCMotor(PWMOut(seesaw, 22), PWMOut(seesaw, 23))
motor_a.throttle = 0.5 # half speed forward
# Create drive (PWM) object
my_drive = PWMOut(seesaw, 13) # Drive 1 is on s.s. pin 13
my_drive.frequency = 1000 # Our default frequency is 1KHz
while True:
my_drive.duty_cycle = 32768 # half on
time.sleep(0.8)
my_drive.duty_cycle = 16384 # dim
time.sleep(0.1)
# and repeat!
BUTTON_UP = const(2)
BUTTON_SEL = const(11)
BUTTON_A = const(10)
BUTTON_B = const(9)
button_mask = const((1 << BUTTON_RIGHT)
| (1 << BUTTON_DOWN)
| (1 << BUTTON_LEFT)
| (1 << BUTTON_UP)
| (1 << BUTTON_SEL)
| (1 << BUTTON_A)
| (1 << BUTTON_B))
i2c_bus = board.I2C()
ss = Seesaw(i2c_bus, 0x5E)
ss.pin_mode_bulk(button_mask, ss.INPUT_PULLUP)
while True:
buttons = ss.digital_read_bulk(button_mask)
if not buttons & (1 << BUTTON_RIGHT):
print("Button RIGHT pressed")
if not buttons & (1 << BUTTON_DOWN):
print("Button DOWN pressed")
if not buttons & (1 << BUTTON_LEFT):
print("Button LEFT pressed")
if not buttons & (1 << BUTTON_UP):
