def init():
global _i2c, _tick, _page, keys
if _i2c is not None:
return
_i2c = busio.I2C(sda=board.SDA0, scl=board.SCL0, frequency=600000)
_i2c.try_lock()
_tick = time.monotonic()
_matrix_write(0x03, 0x00, 0x03)
_matrix_write(0x00, 0x00)
_i2c.writeto(0x50, b'\x00\x7f\xfe\x7f\xfe\x7f\xfe\x7f\xfe\x7f\xfe'
b'\x7f\xfe\x7f\xfe\x7f\xfe\x7f\xfe\x7f\xfe\x7f\xfe')
#_accel_write(0x24, 0x80) # reboot
#time.sleep(0.005)
_accel_write(0x20, 0x37) # enable, data rate 400Hz
_accel_write(0x23, 0x88) # HiRes & BDU
_accel_write(0x1f, 0x80) # ADCs
keys = gamepad.GamePad(
digitalio.DigitalInOut(board.X),
digitalio.DigitalInOut(board.DOWN),
digitalio.DigitalInOut(board.LEFT),
digitalio.DigitalInOut(board.RIGHT),
digitalio.DigitalInOut(board.UP),
digitalio.DigitalInOut(board.O),
digitalio.DigitalInOut(board.S),
digitalio.DigitalInOut(board.Z),
).get_pressed
brightness(7)
def init_buttons(self):
for butt in [
board.BUTTON_SW1, board.BUTTON_SW2, board.BUTTON_SW3,
board.BUTTON_SW4
]:
self.buttons.append(digitalio.DigitalInOut(butt))
self.pad = gamepad.GamePad(*self.buttons)
def init():
global _i2c, _buffer, _temp, _tick, _page, _gamepad
_tick = time.monotonic()
_buffer = bytearray(17)
if _i2c is not None:
return
_i2c = busio.I2C(sda=board.SDA, scl=board.SCL, frequency=600000)
_i2c.try_lock()
_temp = bytearray(2)
_page = None
_keys = 0
_last_keys = 0
_register(0x03, 0x00, 0x03)
_register(0x00, 0x00)
_i2c.writeto(
0x50, b'\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
b'\xff\xff\xff\xff\xff\xff')
_gamepad = gamepad.GamePad(
digitalio.DigitalInOut(board.K_X),
digitalio.DigitalInOut(board.K_DOWN),
digitalio.DigitalInOut(board.K_LEFT),
digitalio.DigitalInOut(board.K_RIGHT),
digitalio.DigitalInOut(board.K_UP),
digitalio.DigitalInOut(board.K_O),
)
brightness(7)
def gamepad(self):
if not self._gamepad:
import gamepad
self._gamepad = gamepad.GamePad(
self._up, self._left, self._down, self._right, self._action
)
return self._gamepad
def __init__(self):
self._a = digitalio.DigitalInOut(board.BUTTON_A)
self._a.switch_to_input(pull=digitalio.Pull.DOWN)
self._b = digitalio.DigitalInOut(board.BUTTON_B)
self._b.switch_to_input(pull=digitalio.Pull.DOWN)
self.gamepad = gamepad.GamePad(self._a, self._b)
# Define switch:
self._switch = digitalio.DigitalInOut(board.SLIDE_SWITCH)
self._switch.switch_to_input(pull=digitalio.Pull.UP)
# Define LEDs:
self._led = digitalio.DigitalInOut(board.D13)
self._led.switch_to_output()
self._pixels = neopixel.NeoPixel(board.NEOPIXEL, 10)
# Define sensors:
self._temp = adafruit_thermistor.Thermistor(
board.TEMPERATURE, 10000, 10000, 25, 3950
)
self._light = Photocell(board.LIGHT)
# Define touch:
# Initially, self._touches stores the pin used for a particular touch. When that touch is
# used for the first time, the pin is replaced with the corresponding TouchIn object.
# This saves a little RAM over using a separate read-only pin tuple.
# For example, after `cp.touch_A2`, self._touches is equivalent to:
# [None, board.A1, touchio.TouchIn(board.A2), board.A3, ...]
# Slot 0 is not used (A0 is not allowed as a touch pin).
self._touches = [
None,
board.A1,
board.A2,
board.A3,
board.A4,
board.A5,
board.A6,
board.TX,
]
self._touch_threshold_adjustment = 0
# Define acceleration:
self._i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA)
self._int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)
self._lis3dh = adafruit_lis3dh.LIS3DH_I2C(
self._i2c, address=0x19, int1=self._int1
)
self._lis3dh.range = adafruit_lis3dh.RANGE_8_G
# Define audio:
self._speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)
self._speaker_enable.switch_to_output(value=False)
self._sample = None
self._sine_wave = None
self._sine_wave_sample = None
# Initialise tap:
self._detect_taps = 1
self.detect_taps = 1
def initialize(self):
self.pad = gamepad.GamePad()
self.pad.on_axischange += self.on_axischange
self.pad.on_connect += self.on_connect
self.pad.on_disconnect += self.on_disconnect
self.pad.on_buttondown += self.on_buttondown
self.pad.on_buttonup += self.on_buttonup
def __init__(self):
# Define I2C:
self._i2c = board.I2C()
# Define touch:
# Initially, self._touches stores the pin used for a particular touch. When that touch is
# used for the first time, the pin is replaced with the corresponding TouchIn object.
# This saves a little RAM over using a separate read-only pin tuple.
# For example, after `clue.touch_2`, self._touches is equivalent to:
# [board.D0, board.D1, touchio.TouchIn(board.D2)]
self._touches = [board.D0, board.D1, board.D2]
self._touch_threshold_adjustment = 0
# Define buttons:
self._a = digitalio.DigitalInOut(board.BUTTON_A)
self._a.switch_to_input(pull=digitalio.Pull.UP)
self._b = digitalio.DigitalInOut(board.BUTTON_B)
self._b.switch_to_input(pull=digitalio.Pull.UP)
self._gamepad = gamepad.GamePad(self._a, self._b)
# Define LEDs:
self._white_leds = digitalio.DigitalInOut(board.WHITE_LEDS)
self._white_leds.switch_to_output()
self._pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
self._red_led = digitalio.DigitalInOut(board.L)
self._red_led.switch_to_output()
# Define audio:
self._mic = audiobusio.PDMIn(
board.MICROPHONE_CLOCK,
board.MICROPHONE_DATA,
sample_rate=16000,
bit_depth=16,
)
self._sample = None
self._samples = None
self._sine_wave = None
self._sine_wave_sample = None
# Define sensors:
# Accelerometer/gyroscope:
self._accelerometer = adafruit_lsm6ds.LSM6DS33(self._i2c)
# Magnetometer:
self._magnetometer = adafruit_lis3mdl.LIS3MDL(self._i2c)
# DGesture/proximity/color/light sensor:
self._sensor = adafruit_apds9960.apds9960.APDS9960(self._i2c)
# Humidity sensor:
self._humidity = adafruit_sht31d.SHT31D(self._i2c)
# Barometric pressure sensor:
self._pressure = adafruit_bmp280.Adafruit_BMP280_I2C(self._i2c)
# Create displayio object for passing.
self.display = board.DISPLAY
def __init__(self):
self._i2c = board.I2C()
self._touches = [board.D0, board.D1, board.D2]
self._touch_threshold_adjustment = 0
self._a = digitalio.DigitalInOut(board.BUTTON_A)
self._a.switch_to_input(pull=digitalio.Pull.UP)
self._b = digitalio.DigitalInOut(board.BUTTON_B)
self._b.switch_to_input(pull=digitalio.Pull.UP)
self._gamepad = gamepad.GamePad(self._a, self._b)
def __init__(self):
self.buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.BUTTON_X),
digitalio.DigitalInOut(board.BUTTON_DOWN),
digitalio.DigitalInOut(board.BUTTON_LEFT),
digitalio.DigitalInOut(board.BUTTON_RIGHT),
digitalio.DigitalInOut(board.BUTTON_UP),
digitalio.DigitalInOut(board.BUTTON_O),
digitalio.DigitalInOut(board.BUTTON_Z),
)
self.last_z_press = None
def __init__(self):
import gamepad
self.buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.BTNA),
digitalio.DigitalInOut(board.BTNB),
digitalio.DigitalInOut(board.MENU),
digitalio.DigitalInOut(board.MENU),
digitalio.DigitalInOut(board.RIGHT),
digitalio.DigitalInOut(board.DOWN),
digitalio.DigitalInOut(board.UP),
digitalio.DigitalInOut(board.LEFT),
)
def __init__(self):
# Define I2C:
self._i2c = cutebot._i2c
# Define buttons:
self._a = digitalio.DigitalInOut(board.BUTTON_A)
self._a.switch_to_input(pull=digitalio.Pull.UP)
self._b = digitalio.DigitalInOut(board.BUTTON_B)
self._b.switch_to_input(pull=digitalio.Pull.UP)
self._gamepad = gamepad.GamePad(self._a, self._b)
# Define LEDs:
self._white_leds = digitalio.DigitalInOut(board.WHITE_LEDS)
self._white_leds.switch_to_output()
self._pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
self._red_led = digitalio.DigitalInOut(board.L)
self._red_led.switch_to_output()
# Define audio:
self._mic = audiobusio.PDMIn(
board.MICROPHONE_CLOCK,
board.MICROPHONE_DATA,
sample_rate=16000,
bit_depth=16,
)
self._sample = None
self._samples = None
self._sine_wave = None
self._sine_wave_sample = None
# Define sensors:
# Accelerometer/gyroscope:
self._accelerometer = adafruit_lsm6ds.lsm6ds33.LSM6DS33(self._i2c)
# Magnetometer:
self._magnetometer = adafruit_lis3mdl.LIS3MDL(self._i2c)
# DGesture/proximity/color/light sensor:
self._sensor = adafruit_apds9960.apds9960.APDS9960(self._i2c)
# Humidity sensor:
self._humidity = adafruit_sht31d.SHT31D(self._i2c)
# Barometric pressure sensor:
self._pressure = adafruit_bmp280.Adafruit_BMP280_I2C(self._i2c)
# Create displayio object for passing.
self.display = board.DISPLAY
def init():
global _tick, _display, _gamepad
if _tick is not None:
return
_tick = time.monotonic()
_gamepad = gamepad.GamePad(
digitalio.DigitalInOut(board.X),
digitalio.DigitalInOut(board.DOWN),
digitalio.DigitalInOut(board.LEFT),
digitalio.DigitalInOut(board.RIGHT),
digitalio.DigitalInOut(board.UP),
digitalio.DigitalInOut(board.O),
)
spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI)
dc = digitalio.DigitalInOut(board.DC)
_display = st7735.ST7735R(spi, dc)
_display.fill(0)
self.last_audio.stop()
def mute(self, value=True):
self.mute_pin.value = not value
dc = digitalio.DigitalInOut(board.D10)
cs = digitalio.DigitalInOut(board.D9)
cs.switch_to_output(value=True)
spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI, MISO=board.MISO)
display = ili9341.ILI9341(spi, dc, cs, 0)
backlight = pulseio.PWMOut(board.D11)
backlight.duty_cycle = 2**14
# buttons = gamepad.GamePad(
# digitalio.DigitalInOut(board.X),
# digitalio.DigitalInOut(board.DOWN),
# digitalio.DigitalInOut(board.LEFT),
# digitalio.DigitalInOut(board.RIGHT),
# digitalio.DigitalInOut(board.UP),
# digitalio.DigitalInOut(board.O),
# )
buttons = gamepad.GamePad(digitalio.DigitalInOut(board.D8), spi)
audio = Audio()
#battery = analogio.AnalogIn(board.BATTERY)
GPIO #27 (13) GP8 - Joystick down
"""
print("BUTTONS (Konami code)")
B_A = 1 << 0
B_B = 1 << 1
B_LEFT = 1 << 2
B_UP = 1 << 3
B_RIGHT = 1 << 4
B_DOWN = 1 << 5
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.GP7),
digitalio.DigitalInOut(board.GP17),
digitalio.DigitalInOut(board.GP9),
digitalio.DigitalInOut(board.GP27),
digitalio.DigitalInOut(board.GP26),
digitalio.DigitalInOut(board.GP8),
)
konami = [
B_UP, B_UP, B_DOWN, B_DOWN, B_LEFT, B_RIGHT, B_LEFT, B_RIGHT, B_B, B_A
]
position = 0
while True:
buttons = pad.get_pressed()
if buttons != 0:
if konami[position] == buttons:
dots[position % 3] = (0, 0, 0)
position += 1
import board
import digitalio
import gamepad
import time
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.PA11),
digitalio.DigitalInOut(board.PA12),
digitalio.DigitalInOut(board.PA24),
digitalio.DigitalInOut(board.PA25),
)
prev_buttons = 0
while True:
buttons = pad.get_pressed()
if buttons != prev_buttons:
for i in range(0, 4):
bit = (1 << i)
if (buttons & bit) != (prev_buttons & bit):
print('Button %d %s' %
(i + 1, 'pressed' if buttons & bit else 'released'))
prev_buttons = buttons
time.sleep(0.1)
def check_for_quit():
pad = gamepad.GamePad(digitalio.DigitalInOut(board.BUTTON_SW3))
buttons = pad.get_pressed()
if buttons & 1:
exit()
canvas = self.matrix.CreateFrameCanvas()
self.player.draw(canvas)
for i in range(len(self.rocks)):
self.rocks[i].draw(canvas)
offset_canvas = self.matrix.SwapOnVSync(canvas)
def run(self):
while True:
if (self.gamepad.buttons[gamepad.leftCode]):
self.player.orientation -= 0.125
elif (self.gamepad.buttons[gamepad.rightCode]):
self.player.orientation += 0.125
elif (self.gamepad.buttons[gamepad.upCode]):
self.player.xvel += 0.0125 * math.cos(self.player.orientation)
self.player.yvel += 0.0125 * math.sin(self.player.orientation)
for i in range(len(self.rocks)):
if self.player.collision(self.rocks[i]):
self.player = SpaceShip()
break
self.moveObjects()
self.drawFrame()
if __name__ == "__main__":
gamepad_thread = gamepad.GamePad("/dev/input/event0")
gamepad_thread.setDaemon(True)
gamepad_thread.start()
asteroids = Asteroids(gamepad_thread)
asteroids.run()
GAMEMENU[4] = ["Clean"]
GAMEMENU[5] = ["Doctor"]
GAMEMENU[6] = ["Discipline"]
GAMEMENU[7] = ["Display Stats"]
GAMEMENU[8] = ["Sound"]
GAMEMENU[9] = ["Lights"]
button_pins = (board.LEFT_BUTTON, board.MIDDLE_BUTTON, board.RIGHT_BUTTON)
B_LEFT = 1 << 0;
B_MID = 1 << 1;
B_RIGHT = 1 << 2;
buttons = [digitalio.DigitalInOut(pin) for pin in button_pins]
for button in buttons:
button.direction = digitalio.Direction.INPUT
button.pull = digitalio.Pull.DOWN
pad = gamepad.GamePad(buttons[0], buttons[1], buttons[2])
class VirtualPetGame:
def __init__(self):
# Main frame buffer
self.fb = VPB.VirtualPetFramebuf(SCRWIDTH, SCRHEIGHT)
self.splash()
self.fb.clearDisplay();
self.speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)
self.speaker_enable.switch_to_output(value=False)
# Initialize frequently used animation screens
# Avoids reading them from file every time
with open ("VirtualPet/assets/petWalkLeft1.txt", "r") as myfile:
try:
import neopixel_write
K_X = 0x01
K_DOWN = 0x02
K_LEFT = 0x04
K_RIGHT = 0x08
K_UP = 0x10
K_O = 0x20
dc = digitalio.DigitalInOut(board.MISO)
spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI)
spi.try_lock()
spi.configure(baudrate=100000, polarity=0, phase=0)
time.sleep(0.2)
display = st7735r.ST7735R(spi, dc, 0b110)
spi.configure(baudrate=23000000, polarity=0, phase=0)
buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.D5),
digitalio.DigitalInOut(board.D11),
digitalio.DigitalInOut(board.D12),
digitalio.DigitalInOut(board.D9),
digitalio.DigitalInOut(board.D10),
digitalio.DigitalInOut(board.D6),
)
try:
pin = digitalio.DigitalInOut(board.NEOPIXEL)
pin.switch_to_output()
neopixel_write.neopixel_write(pin, b'\x00\x00\x00')
except Exception:
pass
def stop(self):
if self.last_audio:
self.last_audio.stop()
def mute(self, value=True):
self.mute_pin.value = not value
dc = digitalio.DigitalInOut(board.DC)
cs = digitalio.DigitalInOut(board.CS)
cs.switch_to_output(value=1)
spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI)
spi.try_lock()
spi.configure(baudrate=24000000, polarity=0, phase=0)
cs.value = 0
display = st7735r.ST7735R(spi, dc, 0b101)
buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.X),
digitalio.DigitalInOut(board.DOWN),
digitalio.DigitalInOut(board.LEFT),
digitalio.DigitalInOut(board.RIGHT),
digitalio.DigitalInOut(board.UP),
digitalio.DigitalInOut(board.O),
)
audio = Audio()
battery = analogio.AnalogIn(board.BATTERY)
except Exception as er:
print(str(er))
time.sleep(5)
print("Bluetooth connection error")
pad_led.blink(on_time=0.2, off_time=0.2, n=2)
if __name__ == '__main__':
xbox_time = 0
menu_time = 0
pad = None
pad_button.when_pressed = connect_gamepad
while True:
try:
time.sleep(2)
pad = gamepad.GamePad()
pad.attach_axis(gamepad.AXIS_GAS, my_car.on_forward)
pad.attach_axis(gamepad.AXIS_BRAKE, my_car.on_reverse)
pad.attach_axis(gamepad.AXIS_X, my_car.on_steering_wheel)
pad.attach_axis(gamepad.AXIS_Z, my_car.on_camera_rotate)
pad.attach_axis(gamepad.AXIS_HAT0Y, my_car.on_light)
pad.attach_button(gamepad.BTN_B, my_car.on_brake)
pad.open()
print("Connected, starting GamePad loop")
pad_led.on()
my_car.on_connected()
connected = True
"""
B_Player2 = 1 << 0
B_Player1 = 1 << 1
B_ButtonB = 1 << 2
B_ButtonA = 1 << 3
B_ButtonY = 1 << 4
B_ButtonX = 1 << 5
B_Start = 1 << 6
B_Select = 1 << 7
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.GP9),
digitalio.DigitalInOut(board.GP27),
digitalio.DigitalInOut(board.GP11),
digitalio.DigitalInOut(board.GP18),
digitalio.DigitalInOut(board.GP12),
digitalio.DigitalInOut(board.GP17),
digitalio.DigitalInOut(board.GP14),
digitalio.DigitalInOut(board.GP16),
)
while True:
buttons = pad.get_pressed()
if buttons & B_Player1:
print("1")
elif buttons & B_Player2:
print("2")
elif buttons & B_ButtonB:
print("B")
elif buttons & B_ButtonA:
print("A")
def mute(self, mute):
pass
displayio.release_displays()
_tft_spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI)
_tft_spi.try_lock()
_tft_spi.configure(baudrate=24000000)
_tft_spi.unlock()
_fourwire = displayio.FourWire(_tft_spi,
command=board.A3,
chip_select=board.A2,
reset=board.A4)
display = displayio.Display(_fourwire,
_INIT_SEQUENCE,
width=160,
height=128,
rotation=0,
backlight_pin=board.A5)
display.auto_brightness = True
buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.SCL),
digitalio.DigitalInOut(board.D12),
digitalio.DigitalInOut(board.D11),
digitalio.DigitalInOut(board.D9),
digitalio.DigitalInOut(board.D10),
digitalio.DigitalInOut(board.D7),
digitalio.DigitalInOut(board.SDA),
)
audio = DummyAudio()
import board
import digitalio
import gamepad
import time
B_UP = 1 << 0
B_DOWN = 1 << 1
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.D10),
digitalio.DigitalInOut(board.D11),
)
y = 0
while True:
buttons = pad.get_pressed()
if buttons & B_UP:
y -= 1
print(y)
elif buttons & B_DOWN:
y += 1
print(y)
time.sleep(0.1)
while buttons:
# Wait for all buttons to be released.
buttons = pad.get_pressed()
time.sleep(0.1)
import board
import digitalio
import gamepad
import time
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.P0_11),
digitalio.DigitalInOut(board.P0_12),
digitalio.DigitalInOut(board.P0_24),
digitalio.DigitalInOut(board.P0_25),
)
prev_buttons = 0
while True:
buttons = pad.get_pressed()
if buttons != prev_buttons:
for i in range(0, 4):
bit = (1 << i)
if (buttons & bit) != (prev_buttons & bit):
print('Button %d %s' %
(i + 1, 'pressed' if buttons & bit else 'released'))
prev_buttons = buttons
time.sleep(0.1)
"""
B_Up = 1 << 0
B_Down = 1 << 1
B_Left = 1 << 2
B_Right = 1 << 3
B_Start = 1 << 4
B_Select = 1 << 5
B_A = 1 << 6
B_B = 1 << 7
pad = gamepad.GamePad(
digitalio.DigitalInOut(board.GP9),
digitalio.DigitalInOut(board.GP8),
digitalio.DigitalInOut(board.GP6),
digitalio.DigitalInOut(board.GP7),
digitalio.DigitalInOut(board.GP10),
digitalio.DigitalInOut(board.GP11),
digitalio.DigitalInOut(board.GP13),
digitalio.DigitalInOut(board.GP14),
)
while True:
buttons = pad.get_pressed()
if buttons & B_Up:
print("UP")
elif buttons & B_Down:
print("DOWN")
elif buttons & B_Left:
print("LEFT")
elif buttons & B_Right:
print("RIGHT")
text_grid.y = 48
text = terminalio.Terminal(text_grid, terminalio.FONT)
screen = displayio.Bitmap(10, 20, 6)
preview = displayio.Bitmap(4, 4, 6)
bricks = displayio.Group(scale=8)
bricks.append(displayio.TileGrid(screen, pixel_shader=palette, x=0, y=-4))
bricks.append(displayio.TileGrid(preview, pixel_shader=palette, x=12, y=0))
root = displayio.Group()
root.append(bricks)
root.append(text_grid)
board.DISPLAY.show(root)
buttons = gamepad.GamePad(
digitalio.DigitalInOut(board.BUTTON_O),
digitalio.DigitalInOut(board.BUTTON_X),
digitalio.DigitalInOut(board.BUTTON_Z),
digitalio.DigitalInOut(board.BUTTON_DOWN),
digitalio.DigitalInOut(board.BUTTON_LEFT),
digitalio.DigitalInOut(board.BUTTON_RIGHT),
digitalio.DigitalInOut(board.BUTTON_UP),
)
brick = None
score = 0
next_brick = Brick(random.randint(0, 4))
tick = time.monotonic()
while True:
if brick is None:
text.write("\r\n%08d" % score)
next_brick.draw(preview, 0)
brick = next_brick
brick.x = screen.width // 2
