import digitalio
import sys
# from adafruit_mcp230xx.mcp23008 import MCP23008
from adafruit_mcp230xx.mcp23017 import MCP23017
# Initialize the I2C bus:
i2c = busio.I2C(board.SCL, board.SDA)
# Create an instance of either the MCP23008 or MCP23017 class depending on
# which chip you're using:
# mcp = MCP23008(i2c) # MCP23008
mcp = MCP23017(i2c, address=0x27) # MCP23017
# Optionally change the address of the device if you set any of the A0, A1, A2
# pins. Specify the new address with a keyword parameter:
# mcp = MCP23017(i2c, address=0x21) # MCP23017 w/ A0 set
def cleanAndExit():
print("Resetting to default...")
# Exit
pinA0.value = False
pinA1.value = False
pinA2.value = False
pinA3.value = False
import board
import busio
from digitalio import DigitalInOut, Direction, Pull
from adafruit_mcp230xx.mcp23017 import MCP23017
from kmk.hid import HIDModes
from kmk.keys import KC
from kmk.kmk_keyboard import KMKKeyboard
from kmk.matrix import DiodeOrientation
from kmk.modules.layers import Layers
# DEBUG_ENABLE = True
i2c = busio.I2C(scl=board.SCL, sda=board.SDA, frequency=100000)
mcp = MCP23017(i2c, address=0x20)
keyboard = KMKKeyboard()
layer_ext = Layers
keyboard.modules = [layer_ext]
_______ = KC.TRNS
XXXXXXX = KC.NO
FN = KC.MO(1)
keyboard.debug_enabled = True
keyboard.col_pins = (mcp.get_pin(8), mcp.get_pin(9), mcp.get_pin(10),
mcp.get_pin(11), mcp.get_pin(12), mcp.get_pin(13),
mcp.get_pin(14), mcp.get_pin(15), mcp.get_pin(4),
mcp.get_pin(5), mcp.get_pin(6), mcp.get_pin(7),
import time
import board
import busio
import digitalio
from adafruit_mcp230xx.mcp23017 import MCP23017
i2c = busio.I2C(board.SCL, board.SDA)
devs = [
MCP23017(i2c, 0x20),
MCP23017(i2c, 0x21),
MCP23017(i2c, 0x22),
MCP23017(i2c, 0x23)
]
state = 'INIT'
dev = 0
pin_glob = 0
def run_tester(device, pin):
global dev, devs, pin_glob
devs[dev].get_pin(pin_glob).value = False
devs[device].get_pin(pin).value = True
print("Pin " + str(pin) + " of device " + str(device) + " is now high!")
pin_glob = pin
dev = device
# delay = delay/2.0
# start = time.time()
# print("Cycle rate is {} Hz".format(1.0/(2.0*delay)))
# while True:
#
# time.sleep(1000)
# GPIO.output(VOLT_OUT_PIN, GPIO.LOW)
# sys.exit()
i2c = busio.I2C(board.SCL, board.SDA)
mcp = MCP23017(i2c) # , address=0x20) # MCP23017
alarm1 = mcp.get_pin(0)
alarm2 = mcp.get_pin(1)
alarm3 = mcp.get_pin(2)
alarm1.switch_to_output(value=False)
alarm2.switch_to_output(value=False)
alarm3.switch_to_output(value=False)
while True:
# Seven Alarm modes plus off.
alarm1.value = False
alarm2.value = False
import time
import board
import busio
import digitalio
import sys
from adafruit_mcp230xx.mcp23017 import MCP23017
i2c = busio.I2C(board.SCL, board.SDA)
devs = [MCP23017(i2c, 0x22), MCP23017(i2c, 0x23)]
# For testing:
# pins = [devs[0].get_pin(6), devs[0].get_pin(7)]
# For real:
matrix = {"a": [], "b": [], }
unknown = None
readout = []
pins = []
for dev in devs:
for i in range(16):
pins.append(dev.get_pin(i))
for pin in pins:
pin.pull = digitalio.Pull.UP
while 1:
readout = []
VERSION = "V1.0.0 (2020-07-31)"
import sys
sys.path.append('/var/www/gardenpi_control/gardenpi/utilities')
import threading
from neptune import switch_from_fish_source, get_water_source, toggle_fish_available
from adafruit_mcp230xx.mcp23017 import MCP23017
import board
import busio
from digitalio import Direction, Pull
nutrient_tank = 0
#Setup our GPIO Expanders here - need to modify this to use wiringpi (maybe?)
i2c = busio.I2C(board.SCL, board.SDA)
mcp3 = MCP23017(i2c, address=0x24)
mcp3.get_pin(nutrient_tank)
mcp3.get_pin(nutrient_tank).direction = Direction.INPUT
mcp3.get_pin(nutrient_tank).pull = Pull.UP
checked = False
def change_water_source():
"""Function to actually change our water source if we run out of water."""
global checked
if not checked:
checked = True
if (get_water_source()['job_water_source']) == 'fish_water':
print('switching source')
switch_from_fish_source()
def __init__(self, comm, **definitions):
self.mcp = MCP23017(comm, definitions['address'])
self.pin_defs = definitions['pins']
self.initialize_pins()
adc_add.append(config[confsec].getint('a_address'))
if not config[confsec].getboolean('Pi_pins'):
gpio_add.append(config[confsec].getint('m_address'))
adc_add = list(set(adc_add))
gpio_add = list(set(gpio_add))
i2c = busio.I2C(board.SCL, board.SDA)
if adc_add:
for add in adc_add:
adc.append(ADS.ADS1015(i2c, address=add))
if gpio_add:
for add in gpio_add:
gpioe.append(MCP23017(i2c, address=add))
def runner(sysnum, gpioe, gpio_add, adc, adc_add, chkt, loops):
confsec = 'CU' + str(sysnum)
print(confsec)
pipins = config[confsec].getboolean('Pi_pins')
pins = [config[confsec].getint('P_LED_pins')]
if config[confsec]['P_ind_pins'].isdigit():
pins.append(config[confsec].getint('P_ind_pins'))
photod = AnalogIn(
adc[adc_add.index(config[confsec].getint('a_address'))],
getattr(ADS, 'P' + str(config[confsec].getint('Analogin'))))
if pipins:
GPIO.setmode(GPIO.BCM)
def main():
# -------------------------
# main
# -------------------------
global resetButton
global LEDNrList, LEDList
global statusLEDgreenNr, statusLEDredNr, statusLEDblueNr, statusLEDgreen, statusLEDred, statusLEDblue
global i2c, mymcp1
global status, justBuzzer, justReset
global buzzerPressedTime
# -----------------------------------------------
# Initialize the I2C bus and the GPIO port expander
# -----------------------------------------------
i2c = busio.I2C(board.SCL, board.SDA)
mymcp1 = MCP23017(i2c, address=0x20)
# -----------------------------------------------
# Initialize the GPIO ports
# -----------------------------------------------
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# -------------------------
# GPIO initialisieren
# -------------------------
for tasti in tasterList:
# print("GPIO setup taster", tasti)
GPIO.setup(tasti, GPIO.IN)
LEDList = []
for ledi in range(8):
LEDList.append(mymcp1.get_pin(LEDNrList[ledi]))
LEDList[ledi].direction = digitalio.Direction.OUTPUT
GPIO.setup(resetButton, GPIO.IN, pull_up_down=GPIO.PUD_UP)
statusLEDred = mymcp1.get_pin(statusLEDredNr)
statusLEDred.direction = digitalio.Direction.OUTPUT
statusLEDgreen = mymcp1.get_pin(statusLEDgreenNr)
statusLEDgreen.direction = digitalio.Direction.OUTPUT
statusLEDblue = mymcp1.get_pin(statusLEDblueNr)
statusLEDblue.direction = digitalio.Direction.OUTPUT
# -----------------------------
# LEDs initialisieren
# -----------------------------
LEDeinaus(0)
LEDeinaus(99)
time.sleep(1)
LEDeinaus(0)
statusLED("off")
# -------------------------
# Interrupts der anderen Taster setzen
# -------------------------
interruptResetVerarb(resetButton)
# -------------------------
# Main loop
# -------------------------
print("Auf gehts")
try:
while True:
# status ist entweder "BuzzerPressed" oder "BuzzerWait"
# zur Vereinfachung: Buzzerpressed = True, BuzzerWait = False
if justBuzzer:
# Buzzer wurde gedrückt
interruptBuzzerVerarb(interruptPin)
if justReset:
interruptResetVerarb(resetButton)
if buzzerPressedTime is not None:
elapsed = (datetime.now() - buzzerPressedTime).total_seconds()
if elapsed >= waitMinSeconds:
print("Wartezeit verstrichen - Reset")
buzzerPressedTime = None
justReset = True
status = False
interruptReset(resetButton)
time.sleep(.2)
except KeyboardInterrupt:
GPIO.cleanup()
except:
print("unprocessed Error:", sys.exc_info()[0])
GPIO.cleanup()
# -------------------------
# Cleaning at the end
# -------------------------
GPIO.cleanup()
parameters = pika.ConnectionParameters(
remote_config["opena3xx.amqp.host"],
remote_config["opena3xx.amqp.port"],
remote_config["opena3xx.amqp.vhost"],
credentials,
heartbeat=60)
connect_amqp()
#---------------------------------------------
# Initialize the I2C bus:
i2c = busio.I2C(board.SCL, board.SDA)
#---------------------------------------------
# Initialize the MCP23017 chips
bus_1 = MCP23017(i2c, address=0x20)
bus_2 = MCP23017(i2c, address=0x21)
#---------------------------------------------
for pin in range(0, 16):
bus_1_pins.append(bus_1.get_pin(pin))
for pin in range(0, 16):
bus_2_pins.append(bus_2.get_pin(pin))
#---------------------------------------------
# Set all the pins to input
for pin in bus_1_pins:
pin.direction = Direction.INPUT
def pin_setup(self):
try:
self.pico_33_ref = DigitalInOut(board.GP2)
self.pico_33_ref.direction = Direction.OUTPUT
self.pico_33_ref.value = True
except:
pass
self.key_count = 108
if self.key_matrix_enabled == True:
self.i2c = busio.I2C(scl=board.GP1,
sda=board.GP0,
frequency=self.i2c_baud)
self._mcp = [
MCP23017(self.i2c, address=0x20),
MCP23017(self.i2c, address=0x21)
]
self.int_pins = [
DigitalInOut(board.GP5),
DigitalInOut(board.GP4),
DigitalInOut(board.GP7),
DigitalInOut(board.GP6)
]
self.row_pins = [
self._mcp_pin(0, 8), #Rows 0 to 6
self._mcp_pin(0, 9),
self._mcp_pin(0, 10),
self._mcp_pin(0, 11),
self._mcp_pin(0, 12),
self._mcp_pin(0, 13),
self._mcp_pin(0, 14)
]
self.col_pins = [
self._mcp_pin(0, 0), #Cols 0 to 20
self._mcp_pin(0, 1),
self._mcp_pin(0, 2),
self._mcp_pin(0, 3),
self._mcp_pin(0, 4),
self._mcp_pin(0, 5),
self._mcp_pin(0, 6),
self._mcp_pin(1, 0),
self._mcp_pin(1, 1),
self._mcp_pin(1, 2),
self._mcp_pin(1, 3),
self._mcp_pin(1, 4),
self._mcp_pin(1, 5),
self._mcp_pin(1, 6),
self._mcp_pin(1, 8),
self._mcp_pin(1, 9),
self._mcp_pin(1, 10),
self._mcp_pin(1, 11),
self._mcp_pin(1, 12),
self._mcp_pin(1, 13),
self._mcp_pin(1, 14)
]
self.mcp_irq_pins = [
self.col_pins[
0:
7], #This maps interrupt pins in self.int_pins to mcp pins in self.rows and self.cols
self.row_pins,
self.col_pins[7:14],
self.col_pins[15:]
]
self.mcp_irq_pins_count = [
0, #This maps interrupt pins in self.int_pins to pin offset counts to get the correct column index for the keymap
None,
len(self.mcp_irq_pins[0]),
len(self.mcp_irq_pins[0] + self.mcp_irq_pins[2])
]
self.int_clears = [
self.mcp(0).clear_inta,
self.mcp(0).clear_intb,
self.mcp(1).clear_inta,
self.mcp(1).clear_intb
]
self.gpios = [
self._mcp_gpioa, self._mcp_gpiob, self._mcp_gpioa,
self._mcp_gpiob
]
self.int_flags = [
self._mcp_int_flaga, self._mcp_int_flagb, self._mcp_int_flaga,
self._mcp_int_flagb
]
self.int_pins_to_mcp = [
0, #This maps int pins to MCP device number
0,
1,
1
]
if self.leds_enabled == True:
self.led_spi = [
self._led_spi(board.GP10, board.GP11, 1),
self._led_spi(board.GP14, board.GP15, 13)
# self._led_spi(board.GP10,board.GP11,4),
# self._led_spi(board.GP14,board.GP15,110)
]
if self.screen_enabled == True:
self.screen_spi = self._screen_spi(board.GP18, board.GP19,
board.GP16, board.GP17,
board.GP20)
def main():
# -------------------------
# main
# -------------------------
global mymcp1, mymcp2
global tank
# -----------------------------------------------
# Initialize the I2C bus and the GPIO port expander
# -----------------------------------------------
i2c = busio.I2C(board.SCL, board.SDA)
mymcp1 = MCP23017(i2c, address=0x20)
mymcp2 = MCP23017(i2c, address=0x21)
# -----------------------------------------------
# Initialize the GPIO ports
# -----------------------------------------------
GPIO.setmode(GPIO.BCM)
# -------------------------
# process call parameters
# -------------------------
opts = []
args = []
writeFile = 0
displayScreen = 0
try:
opts, args = getopt.getopt(sys.argv[1:], shortOptions, longOptions)
except getopt.GetoptError:
print(datetime.datetime.now().strftime("%Y%m%d%H%M%S "),
"ERROR: options not correct")
usage()
sys.exit()
for o, a in opts:
if o == "--help" or o == "-h":
print("HELP")
usage()
sys.exit()
elif o == "--tank" or o == "-t":
tank = int(a)
print("Tanknummer ", '{:.0f}'.format(tank))
elif o == "--file" or o == "-f":
print("output also to file ", filePosition)
writeFile = 1
elif o == "--screen" or o == "-s":
print("output also to this screen")
displayScreen = 1
for a in args:
print("further argument: ", a)
# -------------------------
# read defaults
# -------------------------
(literLevel1, literLevel2, literLevel3,
literLevel4) = CaravanPiFiles.readFillLevels(tank)
# -------------------------
# initialize IO Pins on MCP23017
# pin number from 0 to 15 for the GPIOA0...GPIOA7, GPIOB0...GPIOB7 pins (i.e. pin 12 is GPIOB4)
# Füllstände: 1 an Pin GPIOB3 (11), ..., 4 an Pin GPIOB6 (14)
# -------------------------
fillingLevel1 = mymcp2.get_pin(11)
fillingLevel1.direction = digitalio.Direction.INPUT
fillingLevel2 = mymcp2.get_pin(12)
fillingLevel2.direction = digitalio.Direction.INPUT
fillingLevel3 = mymcp2.get_pin(13)
fillingLevel3.direction = digitalio.Direction.INPUT
fillingLevel4 = mymcp2.get_pin(14)
fillingLevel4.direction = digitalio.Direction.INPUT
# -------------------------
# Main
# -------------------------
try:
while True:
if displayScreen == 1:
print("Level prüfen ...")
level1contact = fillingLevel1.value
level2contact = fillingLevel2.value
level3contact = fillingLevel3.value
level4contact = fillingLevel4.value
if displayScreen == 1:
print("Level 1 erreicht? {0}".format(level1contact),
literLevel1, " Liter")
print("Level 2 erreicht? {0}".format(level2contact),
literLevel2, " Liter")
print("Level 3 erreicht? {0}".format(level3contact),
literLevel3, " Liter")
print("Level 4 erreicht? {0}".format(level4contact),
literLevel4, " Liter")
if level4contact:
actLiter = literLevel4
elif level3contact:
actLiter = literLevel3
elif level2contact:
actLiter = literLevel2
elif level1contact:
actLiter = literLevel1
else:
actLiter = 0
if displayScreen == 1:
if actLiter < literLevel1:
print("Füllmenge gering")
else:
print("mind. " + str(actLiter) + " Liter im Tank")
if writeFile == 1:
write2file(actLiter)
time.sleep(waitAfterReadingSeconds)
except KeyboardInterrupt:
GPIO.cleanup()
except:
print("unprocessed Error:", sys.exc_info()[0])
GPIO.cleanup()
# -------------------------
# Cleaning at the end
# -------------------------
GPIO.cleanup()
import adafruit_ble_midi
# These import auto-register the message type with the MIDI machinery.
# pylint: disable=unused-import
import adafruit_midi
from adafruit_midi.control_change import ControlChange
from adafruit_midi.midi_message import MIDIUnknownEvent
from adafruit_midi.note_off import NoteOff
from adafruit_midi.note_on import NoteOn
from adafruit_midi.pitch_bend import PitchBend
# i2c setup
i2c = busio.I2C(board.SCL, board.SDA)
# i2c addresses for muxes
mcp1 = MCP23017(i2c, address=0x20)
mcp2 = MCP23017(i2c, address=0x21)
# 1st solenoid array, corresponds with 1st mux
noids0 = []
for pin in range(16):
noids0.append(mcp1.get_pin(pin))
for n in noids0:
n.direction = Direction.OUTPUT
# 2nd solenoid array, corresponds with 2nd mux
noids1 = []
for pin in range(16):
noids1.append(mcp2.get_pin(pin))
import board import busio from adafruit_tca9548a impprt TCA9548A from adafruit_mcp230xx.mcp23017 import MCP23017 from digitalio import Direction, Pull from time import sleep # Create I2C bus i2c = busio.I2C(board.SCL, board.SDA) # Create the main I2C multiplexer object tca = TCA9548A(i2c, address=0x71) # Declare the column objects mcp_ab = MCP23017(tca[0], address=0x20) mcp_cd = MCP23017(tca[0], address=0x21) # mcp_ef = MCP23017(tca[0], address=0x22) # mcp_gh = MCP23017(tca[0], address=0x23) # Check the pin states while True: for i in range(0, 16): pv_ab = mcp_ab.get_pin(i) pv_ab.direction = Direction.INPUT pv_ab.pull = Pull.UP pv_cd = mcp_cd.get_pin(i) pv_cd.direction = Direction.INPUT pv_cd.pull = Pull.UP
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
COLORS = [GREEN, BLUE, YELLOW, RED]
led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led[0] = RED
i2c = busio.I2C(board.SCL, board.SDA)
mcp = MCP23017(i2c, address=I2C_ADDR)
KEYS = {'2': 0, '0': 1, 'P': 2, 'C': 3}
def keypress(k, duration = 0.25):
p = mcp.get_pin(KEYS[str(k)])
p.value = True
time.sleep(duration)
p.value = False
for n in range(16):
pin = mcp.get_pin(n)
pin.direction = Direction.OUTPUT
pin.value = False
try:
evenum = int(sys.argv[1])
fant = float(sys.argv[3])
except ValueError:
sys.exit("Please type a number.")
config = configparser.ConfigParser()
config.read('../test/multiplex/eve-conf.ini')
totsys = (''.join(config.sections())).count('CU')
sysstr = 'CU' + str(evenum)
i2c = busio.I2C(board.SCL, board.SDA)
# mcp = adafruit_mcp230xx.MCP23017(i2c, address=32)
mcp = MCP23017(i2c, address=config[sysstr].getint('m_address'))
fant=abs(fant)
# setup the GPIO pins to control the devices
P_sfan_pins = config[sysstr].getint('P_sfan_pins')
P_fan_pins = config[sysstr].getint('P_fan_pins')
pin_list = [P_fan_pins, P_sfan_pins]
pins = [None]*(max(pin_list)+1)
for i in pin_list:
pins[i] = mcp.get_pin(i)
pins[i].direction = digitalio.Direction.OUTPUT
pins[i].value = False
def main():
# -------------------------
# main
# -------------------------
global mymcp1, mymcp2
global tank
global waitAfterPumpSeconds
global pumpOnTime
global pinPumpeAn
# -----------------------------------------------
# Initialize the I2C bus and the GPIO port expander
# -----------------------------------------------
i2c = busio.I2C(board.SCL, board.SDA)
mymcp1 = MCP23017(i2c, address=0x20)
mymcp2 = MCP23017(i2c, address=0x21)
# -----------------------------------------------
# Initialize the GPIO ports
# -----------------------------------------------
GPIO.setmode(GPIO.BCM)
# -------------------------
# process call parameters
# -------------------------
opts = []
args = []
writeFile = 0
displayScreen = 0
try:
opts, args = getopt.getopt(sys.argv[1:], shortOptions, longOptions)
except getopt.GetoptError:
print(datetime.datetime.now().strftime("%Y%m%d%H%M%S "),
"ERROR: options not correct")
usage()
sys.exit()
for o, a in opts:
if o == "--help" or o == "-h":
print("HELP")
usage()
sys.exit()
elif o == "--tank" or o == "-t":
tank = int(a)
print("Tanknummer ", '{:.0f}'.format(tank))
elif o == "--file" or o == "-f":
print("output also to file ", filePosition)
writeFile = 1
elif o == "--screen" or o == "-s":
print("output also to this screen")
displayScreen = 1
for a in args:
print("further argument: ", a)
# -------------------------
# read defaults
# -------------------------
(literLevel1, literLevel2, literLevel3,
literLevel4) = CaravanPiFiles.readFillLevels(tank)
# -------------------------
# initialize IO Pins on MCP23017
# pin number from 0 to 15 for the GPIOA0...GPIOA7, GPIOB0...GPIOB7 pins (i.e. pin 12 is GPIOB4)
# Füllstände: 1 an Pin GPIOB0 (8), ..., 4 an Pin GPIOB3 (11)
# Relais an Pin GPIOB4 (12)
# -------------------------
fillingLevel1 = mymcp1.get_pin(8)
fillingLevel1.direction = digitalio.Direction.INPUT
fillingLevel2 = mymcp1.get_pin(9)
fillingLevel2.direction = digitalio.Direction.INPUT
fillingLevel3 = mymcp1.get_pin(10)
fillingLevel3.direction = digitalio.Direction.INPUT
fillingLevel4 = mymcp1.get_pin(11)
fillingLevel4.direction = digitalio.Direction.INPUT
levelPower = mymcp1.get_pin(12)
levelPower.direction = digitalio.Direction.OUTPUT
# -------------------------
# initialisieren
# -------------------------
levelPower.value = False
# -------------------------
# Interrupt for switching on the pump
# -------------------------
GPIO.setup(pinPumpeAn, GPIO.IN)
# Wenn Pumpe wieder ausschaltet, dann Interruptbehandlung
GPIO.add_event_detect(pinPumpeAn,
GPIO.RISING,
callback=interruptPumpOn,
bouncetime=400)
# -------------------------
# set things for meassuring at startup
# -------------------------
actLiter = 0
pumpOnTime = datetime.datetime.now() - datetime.timedelta(
seconds=waitAfterPumpSeconds + 1)
# -------------------------
# Main loop
# -------------------------
try:
while True:
if pumpOnTime is not None:
elapsed = (datetime.datetime.now() -
pumpOnTime).total_seconds()
# print("Sekunden seit Interrupt: ", elapsed)
if elapsed >= waitAfterPumpSeconds:
# print(datetime.datetime.now().strftime("%Y%m%d%H%M%S "), "Spannung anlegen")
levelPower.value = True
time.sleep(.5)
level1contact = not fillingLevel1.value
level2contact = not fillingLevel2.value
level3contact = not fillingLevel3.value
level4contact = not fillingLevel4.value
# print("Spannung aus")
levelPower.value = False
pumpOnTime = None
if displayScreen == 1:
print("Level 1 erreicht? {0}".format(level1contact),
literLevel1, " Liter")
print("Level 2 erreicht? {0}".format(level2contact),
literLevel2, " Liter")
print("Level 3 erreicht? {0}".format(level3contact),
literLevel3, " Liter")
print("Level 4 erreicht? {0}".format(level4contact),
literLevel4, " Liter")
if level4contact:
actLiter = literLevel4
elif level3contact:
actLiter = literLevel3
elif level2contact:
actLiter = literLevel2
elif level1contact:
actLiter = literLevel1
else:
actLiter = 0
if displayScreen == 1:
if actLiter < literLevel1:
print("Füllmenge gering")
else:
print("mind. " + str(actLiter) + " Liter im Tank")
if writeFile == 1:
write2file(actLiter)
time.sleep(waitAfterPumpSeconds)
except KeyboardInterrupt:
GPIO.cleanup()
except:
print("unprocessed Error:", sys.exc_info()[0])
GPIO.cleanup()
# -------------------------
# Cleaning at the end
# -------------------------
GPIO.cleanup()
import time
import board
import busio
from adafruit_mcp230xx.mcp23017 import MCP23017
from digitalio import Direction, DigitalInOut
i2c = busio.I2C(board.SCL, board.SDA)
mcp = MCP23017(i2c)
# for L293D IC (motor driver)
enable_pin = mcp.get_pin(0)
enable_pin.direction = Direction.OUTPUT
coil_A_1_pin = DigitalInOut(board.D4) #mcp.get_pin(0)
coil_A_1_pin = Direction.OUTPUT
coil_A_2_pin = mcp.get_pin(1)
coil_A_2_pin = Direction.OUTPUT
coil_B_1_pin = mcp.get_pin(2)
coil_B_1_pin = Direction.OUTPUT
coil_B_2_pin = mcp.get_pin(3)
coil_B_2_pin = Direction.OUTPUT
enable_pin.value = True
def forward(delay, steps):
i = 0
cs_pin_num = [8, 9, 10, 11, 12, 13]
#constructor to assign the SPI and what chip select is going to be activated
#for the particular MCP23S17
def __init__(self, cs_pin=None, address=0x20):
self.cs_enable = cs_pin
self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
self.mcp_spi = MCP23S17(self.spi, self.cs_enable, address)
self.pin = []
self.mcp = []
#creating a MCP23017 to use it as chip select for the MCP23S17
i2c = busio.I2C(board.SCL, board.SDA)
chip_ic = MCP23017(i2c, 0x27)
pin = []
#Becuase I am not using pull ups resistors for the chip select, first, initialize
# the cs as high logic voltage.
print("INIT PULL UPS SPI ")
for pin_num in range(16):
pin.append(chip_ic.get_pin(pin_num))
pin[pin_num].direction = Direction.OUTPUT
pin[pin_num].pull = Pull.UP
pin[pin_num].value = True
print("pin {} configured... ".format(pin_num))
time.sleep(0.2)
#create the MCP23S17 devices.
print("*" * 50)