# 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)
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)
backlight.duty_cycle = 0
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
# Two buttons are pullups, connect to ground to activate
ss.pin_mode(BUTTON_1, ss.INPUT_PULLUP)
ss.pin_mode(BUTTON_2, ss.INPUT_PULLUP)
# Two LEDs are outputs, on by default
ss.pin_mode(LED_1, ss.OUTPUT)
ss.pin_mode(LED_2, ss.OUTPUT)
ss.digital_write(LED_1, True)
ss.digital_write(LED_2, True)
#################### log files
logfile = "/log.csv"
# check that we could append if wanted to
try:
fp = open(logfile, "a")
fp.close
except:
print("File system not writable, halting")
"""
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)
class MiniTFTFeatherWing:
"""Class representing an `Mini Color TFT with Joystick FeatherWing
<https://www.adafruit.com/product/3321>`_.
Automatically uses the feather's I2C bus."""
_button_mask = ((1 << BUTTON_RIGHT) | (1 << BUTTON_DOWN) |
(1 << BUTTON_LEFT) | (1 << BUTTON_UP) | (1 << BUTTON_SEL) |
(1 << BUTTON_A) | (1 << BUTTON_B))
#pylint: disable-msg=too-many-arguments
def __init__(self, address=0x5E, i2c=None, spi=None, cs=None, dc=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)
#pylint: enable-msg=too-many-arguments
@property
def backlight(self):
"""
Return the current backlight duty cycle value
"""
return self._backlight.duty_cycle / 255
@backlight.setter
def backlight(self, brightness):
"""
Set the backlight duty cycle
"""
self._backlight.duty_cycle = int(255 * min(max(brightness, 0.0), 1.0))
@property
def buttons(self):
"""
Return a set of buttons with current push values
"""
try:
button_values = self._ss.digital_read_bulk(self._button_mask)
except OSError:
return Buttons(*[
False
for button in (BUTTON_UP, BUTTON_DOWN, BUTTON_LEFT,
BUTTON_RIGHT, BUTTON_A, BUTTON_B, BUTTON_SEL)
])
return Buttons(*[
not button_values & (1 << button)
for button in (BUTTON_UP, BUTTON_DOWN, BUTTON_LEFT, BUTTON_RIGHT,
BUTTON_A, BUTTON_B, BUTTON_SEL)
])
class MonsterM4sk:
"""Class representing a `MONSTER M4SK`
<https://www.adafruit.com/product/4343>`_.
The terms "left" and "right" are always used from the
perspective of looking out of the mask.
The right screen is the one USB port directly above it.
"""
def __init__(self, i2c=None):
displayio.release_displays()
if i2c is None:
i2c = board.I2C()
# set up on-board seesaw
self._ss = Seesaw(i2c)
# left screen
self._ss.pin_mode(SS_TFTRESET_PIN, self._ss.OUTPUT)
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)
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)
self.left_display = ST7789(left_display_bus,
width=240,
height=240,
rowstart=80)
self.right_backlight = pulseio.PWMOut(board.RIGHT_TFT_LITE,
frequency=5000,
duty_cycle=0)
self.right_backlight.duty_cycle = 65535
# right display
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,
)
self.right_display = ST7789(right_display_bus,
width=240,
height=240,
rowstart=80)
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)
self.nose = touchio.TouchIn(board.NOSE)
self.nose.threshold = 180
@property
def acceleration(self):
"""Accelerometer data, +/- 2G sensitivity."""
return (self._accelerometer.acceleration
if self._accelerometer is not None else None)
@property
def light(self):
"""Light sensor data."""
return self._ss.analog_read(SS_LIGHTSENSOR_PIN)
@property
def boop(self):
"""Nose touch sense."""
return self.nose.value
seesaw = Seesaw(i2c)
led = DigitalInOut(board.D13)
led.direction = Direction.OUTPUT
buttona = DigitalInOut(board.BUTTON_A)
buttona.direction = Direction.INPUT
buttona.pull = Pull.DOWN
buttonb = DigitalInOut(board.BUTTON_B)
buttonb.direction = Direction.INPUT
buttonb.pull = Pull.DOWN
BOTTOM_SENSOR = 2
TOP_SENSOR = 3
seesaw.pin_mode(BOTTOM_SENSOR, seesaw.INPUT_PULLUP)
seesaw.pin_mode(TOP_SENSOR, seesaw.INPUT_PULLUP)
# Create one stepper motor using the 4 'drive' PWM pins 13, 43, 12 and 42
pwms = [PWMOut(seesaw, 13), PWMOut(seesaw, 43), PWMOut(seesaw, 12), PWMOut(seesaw, 42)]
for p in pwms:
p.frequency = 2000
stepper_motor = stepper.StepperMotor(pwms[0], pwms[1], pwms[2], pwms[3])
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=1)
pixels.fill((0,0,0))
def rainbow():
pixels.fill((20,0,0))
time.sleep(0.05)
led.direction = Direction.OUTPUT
# Two onboard CPX buttons for FOG
buttona = DigitalInOut(board.BUTTON_A)
buttona.direction = Direction.INPUT
buttona.pull = Pull.DOWN
buttonb = DigitalInOut(board.BUTTON_B)
buttonb.direction = Direction.INPUT
buttonb.pull = Pull.DOWN
# Use the signal port for potentiometer w/switch
MORECOW = 2 # A switch on Signal #1
SWITCH = 3 # A potentiometer on Signal #2
# Add a pullup on the switch
seesaw.pin_mode(SWITCH, seesaw.INPUT_PULLUP)
# Servo angles
BELL_START = 60
BELL_END = 75
MOUTH_START = 95
MOUTH_END = 105
# Create servos list
servos = []
for ss_pin in (17, 16): #17 is labeled 1 on CRICKIT, 16 is labeled 2
pwm = PWMOut(seesaw, ss_pin)
pwm.frequency = 50 #must be 50 cannot change
_servo = servo.Servo(pwm, min_pulse=400, max_pulse=2500)
servos.append(_servo)
# Starting servo locations
class MiniTFTFeatherWing:
"""Class representing an `Mini Color TFT with Joystick FeatherWing
<https://www.adafruit.com/product/3321>`_.
Automatically uses the feather's I2C bus."""
_button_mask = ((1 << BUTTON_RIGHT) | (1 << BUTTON_DOWN) |
(1 << BUTTON_LEFT) | (1 << BUTTON_UP) | (1 << BUTTON_SEL) |
(1 << BUTTON_A) | (1 << BUTTON_B))
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)
@property
def backlight(self):
"""
Return the current backlight duty cycle value
"""
return self._backlight.duty_cycle / 255
@backlight.setter
def backlight(self, brightness):
"""
Set the backlight duty cycle
"""
self._backlight.duty_cycle = int(255 *
min(max(1 - brightness, 0.0), 1.0))
@property
def buttons(self):
"""
Return a set of buttons with current push values
"""
button_values = self._ss.digital_read_bulk(self._button_mask)
return Buttons(*[
not button_values & (1 << button)
for button in (BUTTON_UP, BUTTON_DOWN, BUTTON_LEFT, BUTTON_RIGHT,
BUTTON_A, BUTTON_B, BUTTON_SEL)
])
class MonsterM4sk:
"""Represents a single Monster M4sk
The terms "left" and "right" are always used from the
perspective of looking out of the mask.
The right screen is the one USB port directly above it.
"""
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
@property
def acceleration(self):
"""Accelerometer data, +/- 2G sensitivity.
This example initializes the mask and prints the accelerometer data.
.. code-block:: python
import adafruit_monsterm4sk
mask = adafruit_monsterm4sk.MonsterM4sk(i2c=board.I2C())
print(mask.acceleration)
"""
return (
self._accelerometer.acceleration
if self._accelerometer is not None
else None
)
@property
def light(self):
"""Light sensor data.
This example initializes the mask and prints the light sensor data.
.. code-block:: python
import adafruit_monsterm4sk
mask = adafruit_monsterm4sk.MonsterM4sk(i2c=board.I2C())
print(mask.light)
"""
return self._ss.analog_read(SS_LIGHTSENSOR_PIN)
@property
def buttons(self):
"""Buttons dictionary.
This example initializes the mask and prints when the S9 button
is pressed down.
.. code-block:: python
import adafruit_monsterm4sk
mask = adafruit_monsterm4sk.MonsterM4sk(i2c=board.I2C())
while True:
if mask.buttons["S9"]:
print("Button S9 pressed!")
"""
return {
"S9": self._ss.digital_read(SS_SWITCH1_PIN) is False,
"S10": self._ss.digital_read(SS_SWITCH2_PIN) is False,
"S11": self._ss.digital_read(SS_SWITCH3_PIN) is False,
}
@property
def boop(self):
"""Nose touch sense.
This example initializes the mask and prints when the nose touch pad
is being touched.
.. code-block:: python
import adafruit_monsterm4sk
mask = adafruit_monsterm4sk.MonsterM4sk(i2c=board.I2C())
while True:
if mask.boop:
print("Nose touched!")
"""
return self.nose.value
class MiniTFTFeatherWing_T:
"""
Row display for MiniTFT Featherwing
"""
def __init__(self):
self.reset_pin = 8
self.i2c = board.I2C()
self.ss = Seesaw(self.i2c, 0x5E)
self.ss.pin_mode(self.reset_pin, self.ss.OUTPUT)
self.spi = board.SPI()
self.tft_cs = board.D5
self.tft_dc = board.D6
self._auto_show = True
displayio.release_displays()
self.display_bus = displayio.FourWire(self.spi,
command=self.tft_dc,
chip_select=self.tft_cs)
self.ss.digital_write(self.reset_pin, True)
self.display = ST7735R(self.display_bus,
width=160,
height=80,
colstart=24,
rotation=270,
bgr=True)
self.nbr_rows = 5
self.row_height = int(self.display.height / self.nbr_rows)
self.row_vpos = [
int(i * self.row_height) for i in range(self.nbr_rows)
]
self.row_bkgnd_color = [
0x808080, 0xFF0000, 0x000040, 0x0000FF, 0xAA0088
]
self.row_text_color = [
0xFFFFFF, 0xFFFF00, 0xFF0000, 0xFFFF00, 0xFAFAFA
]
self.row_text = ['r1', 'r2', 'r3', 'r4', 'r5']
# -----------------------------------------------------------------------------------
# Button handler
# -----------------------------------------------------------------------------------
self.btn_mat = []
self.btn_mat.append([1 << BUTTON_RIGHT, 0, 0, False, 'right'])
self.btn_mat.append([1 << BUTTON_DOWN, 0, 0, False, 'down'])
self.btn_mat.append([1 << BUTTON_LEFT, 0, 0, False, 'left'])
self.btn_mat.append([1 << BUTTON_UP, 0, 0, False, 'up'])
self.btn_mat.append([1 << BUTTON_SEL, 0, 0, False, 'select'])
self.btn_mat.append([1 << BUTTON_A, 0, 0, False, 'A'])
self.btn_mat.append([1 << BUTTON_B, 0, 0, False, 'B'])
# print(btn_mat)
self.btn_mask = 0
for mask_indx in range(len(self.btn_mat)):
self.btn_mask = self.btn_mask | self.btn_mat[mask_indx][0]
# print(btn_mask)
self.ss.pin_mode_bulk(self.btn_mask, self.ss.INPUT_PULLUP)
self.state_dict = {
'idle': 0,
'pressed': 1,
'pressed_deb': 2,
'released': 3,
'released_deb': 4
}
self.btn_repeat_time = 1.0
self.btn_deb_time = 0.1
def print_at(self, row_indx, txt):
"""
Print one row a specific row number 0-4
"""
try:
self.row_text[row_indx] = txt
except IndexError:
self.row_text[self.nbr_rows -
1] = 'incorrect row index: ' + str(row_indx)
if self._auto_show:
self.show_rows()
def show_rows(self):
"""
Show printed rows on the display
- use print_at to fill the rows first
- background colors can be changed using the background_color function
- text colors can be changed using the text_color function
call show_rows when text and colors are OK
"""
row_disp = displayio.Group(max_size=10)
self.display.show(row_disp)
print('show')
for i in range(self.nbr_rows):
# Draw row rectangles
row_bitmap = displayio.Bitmap(self.display.width, self.row_height,
1)
row_palette = displayio.Palette(1)
row_palette[0] = self.row_bkgnd_color[i]
row_block = displayio.TileGrid(row_bitmap,
pixel_shader=row_palette,
x=0,
y=self.row_vpos[i])
row_disp.append(row_block)
text_group = displayio.Group(max_size=10,
scale=1,
x=8 + i,
y=6 + i * self.row_height)
text_area = label.Label(terminalio.FONT,
text=self.row_text[i],
color=self.row_text_color[i])
text_group.append(text_area) # Subgroup for text scaling
row_disp.append(text_group)
def background_color(self, row_indx, color_code):
"""
change background color for one row
row_indx = 0-4
color_code = 24 bit binary input 0xrrggbb
"""
try:
self.row_bkgnd_color[row_indx] = color_code
except IndexError:
self.row_text[self.nbr_rows -
1] = 'incorrect row index: ' + str(row_indx)
def text_color(self, row_indx, color_code):
"""
change text color for one row
row_indx = 0-4
color_code = 24 bit binary input 0xrrggbb
"""
try:
self.row_text_color[row_indx] = color_code
except IndexError:
self.row_text[self.nbr_rows -
1] = 'incorrect row index: ' + str(row_indx)
@property
def auto_show(self):
return self._auto_show
@auto_show.setter
def auto_show(self, t_f):
_auto_show = t_f
@property
def backlight(self):
"""
Return the current backlight duty cycle value
"""
return self._backlight.duty_cycle / 255
@backlight.setter
def backlight(self, brightness):
"""
Set the backlight duty cycle
"""
self._backlight.duty_cycle = int(255 * min(max(brightness, 0.0), 1.0))
# -----------------------------------------------------------------------------------
def scan(self):
"""
Class reading the buttons on Mini Color TFT with Joystick FeatherWing
key pressed-released states implemented
Keys are repeated if pressed over a time limit
call btn_scan() as often as possible. no upper limited but slow scanning will
decrease the performance
btn_read() returns one key at a time as text. when no key is pressed an
empty string will be reurned
* Author Tom Hoglund 2019
"""
time_now = time.monotonic()
buttons = self.ss.digital_read_bulk(self.btn_mask)
for mask_indx in range(len(self.btn_mat)):
if not buttons & self.btn_mat[mask_indx][0]:
if self.btn_mat[mask_indx][1] == self.state_dict['idle']:
self.btn_mat[mask_indx][1] = self.state_dict['pressed']
self.btn_mat[mask_indx][2] = time_now
elif self.btn_mat[mask_indx][1] == self.state_dict['pressed']:
if time_now > self.btn_mat[mask_indx][
2] + self.btn_deb_time:
self.btn_mat[mask_indx][1] = self.state_dict[
'pressed_deb']
self.btn_mat[mask_indx][2] = time_now
elif self.btn_mat[mask_indx][1] == self.state_dict[
'pressed_deb']:
if time_now > self.btn_mat[mask_indx][
2] + self.btn_repeat_time:
# btn_mat[mask_indx][1] = state_dict['pressed_deb']
self.btn_mat[mask_indx][2] = time_now
self.btn_mat[mask_indx][3] = True
else:
if self.btn_mat[mask_indx][1] == self.state_dict[
'pressed_deb']:
self.btn_mat[mask_indx][1] = self.state_dict['released']
self.btn_mat[mask_indx][2] = time_now
elif self.btn_mat[mask_indx][1] == self.state_dict['released']:
if time_now > self.btn_mat[mask_indx][
2] + self.btn_deb_time:
self.btn_mat[mask_indx][1] = self.state_dict[
'released_deb']
self.btn_mat[mask_indx][3] = True
if self.btn_mat[mask_indx][1] == self.state_dict['released_deb']:
if not self.btn_mat[mask_indx][3]:
self.btn_mat[mask_indx][1] = self.state_dict['idle']
self.btn_mat[mask_indx][2] = time_now
def read(self):
ret_val = ''
for mask_indx in range(len(self.btn_mat)):
if self.btn_mat[mask_indx][3]:
self.btn_mat[mask_indx][3] = False
self.btn_mat[mask_indx][1] = self.state_dict['idle']
ret_val = self.btn_mat[mask_indx][4]
break
return ret_val
from adafruit_seesaw.seesaw import Seesaw
import terminalio
from adafruit_display_text import label
font = terminalio.FONT
# setup for accelerometer
i2c = busio.I2C(board.SCL, board.SDA)
int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x18, int1=int1)
# backlight left display pin initialisation
ss = Seesaw(i2c)
ss.pin_mode(5, ss.OUTPUT)
ss.pin_mode(9, ss.INPUT_PULLUP)
ss.pin_mode(10, ss.INPUT_PULLUP)
ss.pin_mode(11, ss.INPUT_PULLUP)
# display setup for m4sk
displayio.release_displays()
spi1 = busio.SPI(board.RIGHT_TFT_SCK, MOSI=board.RIGHT_TFT_MOSI)
display1_bus = displayio.FourWire(spi1,
command=board.RIGHT_TFT_DC,
chip_select=board.RIGHT_TFT_CS,
reset=board.RIGHT_TFT_RST)
display1 = ST7789(display1_bus,
width=240,
import busio
from adafruit_seesaw.seesaw import Seesaw
i2c_bus = busio.I2C(SCL, SDA)
pwm = pulseio.PWMOut(board.D4, frequency=38000, duty_cycle=2**15)
pulseout = pulseio.PulseOut(pwm)
# Create an encoder that will take numbers and turn them into NEC IR pulses
encoder = adafruit_irremote.GenericTransmit(header=[9500, 4500],
one=[550, 550],
zero=[550, 1700],
trail=0)
ss = Seesaw(i2c_bus)
ss.pin_mode(9, ss.INPUT_PULLUP)
last_x = 0
last_y = 0
while True:
x = ss.analog_read(2)
y = ss.analog_read(3)
b = ss.digital_read(9)
if not b:
encoder.transmit(pulseout, [255, 2, 191, 64])
time.sleep(.01)
if (abs(x - last_x) > 3) or (abs(y - last_y) > 3):
# print(x, y)
last_x = x
