scrapeboard/gpio.py

130 lines
4.8 KiB
Python

# [SCRAPEBOARD] is an arcade game in development by [@diskmem] & [@snakesandrews]
#
# It requires custom hardware to play but can be tested in keyboard mode without
# the hardware. For more information on setting up and running the game, see
# README.md. For information on the game in general, see <https://scrape.nugget.fun/>.
#
# Full open source code is available at <https://git.nugget.fun/scrape/scrapeboard>.
#
# This module can be imported and used to check on the status of connections between four GPIO
# inputs on the Raspberry Pi for detecting the pads in Scrapeboard.
#
# It can also be run as a diagnostic script, in which case it prints connections detected between
# the input GPIO pins. Use the `-h` flag to print the options.
#
# $ python3 gpio.py -h
#
# Original algorithm by Dr. Clement Shimizu is taken from his Arduino code in serial/serial.ino
import time, itertools, argparse
import RPi.GPIO as GPIO
# These represent the game pads and the GPIO pins they're connected to
LNW, LNE, LSE, LSW = range(4)
pins = {
LNW: 26,
LNE: 19,
LSE: 13,
LSW: 6
}
def initialize_gpio():
"""
Set pin numbering mode to GPIO and initialize all pins to input pullup.
"""
# Use GPIO numbering
GPIO.setmode(GPIO.BCM)
# Set all pins to pullup
for pin_id, pin in pins.items():
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def connection2(pin_a, pin_b):
"""
Set `pin_a` to output a low signal, and set every other pin to pullup. If `pin_b` reads a low signal even though
it's set to pullup, that means `pin_a` is connected to it, so return `True`.
@param pin_a Pin which will be set to output LOW
@param pin_b Pin which will be read
@return `True` if a low signal is sent from `pin_a` to `pin_b`, `False` otherwise
"""
for pin_id, pin in pins.items():
if pin == pin_a:
# Set pin_a to output LOW
GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, GPIO.LOW)
else:
# Set all other pins to input pullup
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Force 25ns delay between comparisons
time.sleep(0.025)
# pin_b can now be tested to see if if reads the LOW signal from pin_a
return GPIO.input(pin_b) == GPIO.LOW
def connection(pin_a, pin_b):
"""
Tests low signals connect from both A to B and from B to A
@param pin_a Test if this pin is connected to `pin_b`
@param pin_b Test if this pin is connected to `pin_a`
@return `True` if `pin_a` and `pin_b` are connected, `False` otherwise
"""
return connection2(pin_a, pin_b) and connection2(pin_b, pin_a)
def connections():
"""
Look at all six possible connections between the four pins and return the state of each as a single dict.
@return A dict with one entry per combination of pins, the key is a tuple of pin IDs, and the value is the state of connection
"""
state = {}
for pin_id_a, pin_id_b in itertools.combinations(pins, 2):
if connection(pins[pin_id_a], pins[pin_id_b]):
state[(pin_id_a, pin_id_b)] = True
else:
state[(pin_id_a, pin_id_b)] = False
return state
def activity():
"""
Look at all six possible connections between the four pins, and if a pin appears in any active connection, consider it active.
Return the active state of all four pins as a dict.
@return A dict with one entry per pin. The key is the pin ID, and the value is the state of whether it's active (a.k.a. pressed)
"""
# Create a dict of pins all at False
state = pins.copy()
for pin in state.keys():
state[pin] = False
# Check all six combinations. If a pin appears in a connection, update its state to True.
for pin_id_a, pin_id_b in itertools.combinations(pins, 2):
if connection(pins[pin_id_a], pins[pin_id_b]):
state[pin_id_a] = True
state[pin_id_b] = True
return state
if __name__ == "__main__":
# Set up and parse CLI
parser = argparse.ArgumentParser()
parser.add_argument("--connections", action="store_true")
parser.add_argument("--activity", action="store_true")
arguments = parser.parse_args()
initialize_gpio()
while True:
if arguments.connections or not arguments.activity:
# Try all connections once each frame
for connection_ids, connection_state in connections().items():
# Only print connected combinations of pins
if connection_state:
pin_id_a, pin_id_b = connection_ids
print(f"{pin_id_a} ({pins[pin_id_a]}) <-> {pin_id_b} ({pins[pin_id_b]})")
else:
pin_activity = activity()
print(f"LNW {int(pin_activity[LNW])} LNE {int(pin_activity[LNE])} LSE {int(pin_activity[LSE])} LSW {int(pin_activity[LSW])}")