class KeypadDisplay(object): def __init__(self, lcd_address, button_pins=[17, 18, 27, 22, 23, 24, 25], led_pins=[16, 20, 21]): """Initializes the KeypadDisplay object button_pins: A list of 7 GPIO pins used for button inputs, order is A, B, L, U, D, R, C pin Usage ---|----------- 17 | Button A 18 | Button B 27 | Button Left 22 | Button Up 23 | Button Down 24 | Button right 25 | Button C led_pins: A list of 3 GPIO pins to use for led outputs, order is R, G, B pin Usage ---|---------- 16 | Red LED 20 | Yellow LED 21 | Green LED """ self.button_a = Button(button_pins[0]) self.button_b = Button(button_pins[1]) self.button_left = Button(button_pins[2]) self.button_up = Button(button_pins[3]) self.button_down = Button(button_pins[4]) self.button_right = Button(button_pins[5]) self.button_c = Button(button_pins[6]) self.led_red = LED(led_pins[0]) self.led_yellow = LED(led_pins[1]) self.led_green = LED(led_pins[2]) self.lcd = LCD(I2CPCF8574Interface(lcd_address), num_rows=4, num_cols=20) def set_led(self, value) -> Leds: """Sets the LED's according to the passed value""" self.led_red.off() self.led_yellow.off() self.led_green.off() if value in [Leds.RED, Leds.ALL]: self.led_red.on() if value in [Leds.YELLOW, Leds.ALL]: self.led_yellow.on() if value in [Leds.GREEN, Leds.ALL]: self.led_green.on() def print(self, message): """Clears the LCD and display the message""" self.lcd.clear() self.lcd.print(message)
#Just here becauses it is paired with the RPS printing Below if photoPin.value: lread = True elif fread == lread: interrupts += 1 lread = not lread #LCD 1 Second Updates if now - initial >= 1: lcd.clear() lcd.set_cursor_pos(0, 0) #clears and resets LCD if (MotorPotOut <= 5000): lcd.print(str("Speed: 0")) elif (MotorPotOut >= 60000): lcd.print("Speed: 100") else: lcd.print(("Speed: ") + (str(displayMotorPotOut))) #RPS Printing lcd.set_cursor_pos(1, 0) lcd.print(("RPS: ") + str(interrupts)) interrupts = 0 #End of the 1 Second Check initial = time.monotonic() time.sleep(.05)
from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from digitalio import DigitalInOut, Direction, Pull from lcd.lcd import CursorMode import board # Talk to the LCD at I2C address 0x27. # The number of rows and columns defaults to 4x20, so those # arguments could be omitted in this case. lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) # 0x27 or 0x3F button = DigitalInOut(board.D2) button.direction = Direction.INPUT button.pull = Pull.UP button_state = None last_state = None value = 0 lcd.print(" CircuitPython LCD ") time.sleep(2) lcd.clear() lcd.set_cursor_pos(0, 0) lcd.print("ButtonPresses:") # Make the cursor visible as a line. lcd.set_cursor_mode(CursorMode.LINE) while True: if button.value: print("not pressed") else: value = value + 1 print(value) button_state = None lcd.set_cursor_pos(1, 0)
StateFlipper = False counterTouched = False while True: # These two if statements make touching the 'switch' wire change the increment from going up to going down and vice versa if filippe.value and not StateFlipper: state = state * -1 StateFlipper = True if not filippe.value: StateFlipper = False # These two if statements make touching the 'counter' wire change the lcd screen value, based on if the state is positive or negative if button.value and not counterTouched: value = value + state counterTouched = True if not button.value: counterTouched = False # This block of code prints out the value and the increment on the lcd screen on different lines lcd.clear() lcd.set_cursor_pos(0, 0) lcd.print('Value: ' + str(value)) lcd.set_cursor_pos(1, 0) lcd.print('Change: ' + str(state)) time.sleep(.05)
button_a.direction = digitalio.Direction.INPUT button_a.pull = digitalio.Pull.UP switch = digitalio.DigitalInOut(board.D8) switch.direction = digitalio.Direction.INPUT switch.pull = digitalio.Pull.UP from lcd.lcd import CursorMode lcd = LCD(I2CPCF8574Interface(0x27), num_rows=4, num_cols=20) lcd.clear() lcd.set_cursor_pos(0,0) lcd.print("Button presses") lcd.set_cursor_mode(CursorMode.LINE) presses = 0 lastbutton = True while True: print(button_a.value) time.sleep(.05) if not button_a.value and switch.value and lastbutton: lcd.set_cursor_pos(1,0) presses = presses + 1 lcd.print(str(presses )) if not button_a.value and not switch.value and lastbutton: lcd.set_cursor_pos(1,0) presses = presses - 1
# made a switch switch = DigitalInOut(board.D6) switch.direction = digitalio.Direction.INPUT switch.pull = digitalio.Pull.UP lcd = LCD(I2CPCF8574Interface(0x27), num_rows=4, num_cols=20) lcd.clear() lcd.set_cursor_mode(CursorMode.LINE) count = 0 buttonValue = True lcd.set_cursor_pos(0, 0) lcd.print("buttonValue:") while True: # count up if not button.value and switch.value and buttonValue: lcd.set_cursor_pos(1,0) count = count + 1 lcd.print(str(count)) lcd.print(" ") # count down if not button.value and not switch.value and buttonValue: lcd.set_cursor_pos(1,0) count = count - 1 lcd.print(str(count)) lcd.print(" ") buttonValue = button.value
# can be 1 or -1 # Add in all of the capacitive touch stuff touch_pad_green = board.A0 # Will not work for Circuit Playground Express! touch_pad_yellow = board.A1 touchGreen = touchio.TouchIn(touch_pad_green) touchYellow = touchio.TouchIn(touch_pad_yellow) # green will be the counter # yellow will be the switch # and the variables for the past values pastGreen = None pastYellow = None lcd.set_cursor_pos(0, 0) lcd.print("Increment ") lcd.set_cursor_pos(1, 0) lcd.print("Value ") while True: if touchYellow.value and not (pastYellow): print("Touched Yellow!") increment = increment * -1 lcd.set_cursor_pos(0, 10) lcd.print(str(increment) + " ") print(increment) if touchGreen.value and not (pastGreen): print("Touched Green!") count = count + increment
# https://github.com/jkammau97/CircuitPython import time import digitalio import board photoPin = digitalio.DigitalInOut(board.D5) photoPin.direction = digitalio.Direction.INPUT photoPin.pull = digitalio.Pull.UP from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) lcd.set_cursor_pos(0, 0) lcd.print("The number of interrupts is ") init = time.monotonic() count = 0 pastInterrupt = False #returns amount of time elapsed since the program started in SECONDS while True: interrupted = photoPin.value now = time.monotonic() if interrupted and not (pastInterrupt): count = count + 1 print("interrupt") pastInterrupt = interrupted if now - init > 4: # If 4 seconds elapses
import board import digitalio from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode button_a = digitalio.DigitalInOut(board.D3) button_a.direction = digitalio.Direction.INPUT button_a.pull = digitalio.Pull.UP value = 1 lcd = LCD(I2CPCF8574Interface(0x3F), num_rows=2, num_cols=16) lcd.clear() lcd.set_cursor_pos(0, 0) lcd.print("Switch State:") while True: if button_a.value: lcd.set_cursor_pos(1, 0) lcd.print("Presses:") else: lcd.set_cursor_pos(1, 0) lcd.print("Presses:") value = value + 1 lcd.print(str(value)) lcd.set_cursor_mode(CursorMode.LINE)
switch = DigitalInOut(board.D3) switch.direction = Direction.INPUT switch.pull = Pull.UP button = DigitalInOut(board.D4) button.direction = Direction.INPUT button.pull = Pull.UP pressed = True lastState = True count = 0 switched = False lastswitch = False dirn = 1 while True: lcd.set_cursor_pos(0, 0) lcd.print("Counting ",("down","up")[dirn==1]) pressed = switch.value switched = button.value if not pressed and lastState: count += dirn if not switched and lastswtich: dirn = -dirn lcd.set_cursor_pos(1, 0) lcd.print("Presses: ") lcd.set_cursor_pos(1,8) lcd.print(str(count)) lastState = pressed lastswitch = switched
from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) import touchio import board import time import touchio touch_A0 = touchio.TouchIn(board.A0) # Which pin the first wire is in touch_A1 = touchio.TouchIn(board.A1) # Which pin the second wire is in x = 0 y = 1 while True: if touch_A0.value: lcd.clear() x = x + 1 lcd.print(str(x)) while touch_A0.value: print("HelloA0" ) # Prints HelloA0 while the first wire is being touched if touch_A1.value: lcd.clear() x = x - 1 lcd.print(str(x)) while touch_A1.value: print("HelloA1" ) # Prints HelloA1 while the first wire is being touched
time.sleep(2) counter = 0 # counter starts at zero print("running") while True: if blue.value: # blue wire toggles counter direction message = "GOING UP " # prints direction state = False else: message = "GOING DOWN " # prints direction state = True lcd.set_cursor_pos(0, 0) # first row of lcd screen lcd.print(message) # print direction "up or down" if state is True: # if direction is down direction = -1 # subtract 1 from counter else: # if direction is up direction = 1 # add 1 to counter if yellow.value: counter = counter + direction # controls which way it counts lcd.set_cursor_pos(1, 0) # second line of lcd screen message = "PRESS NO. " message += str(counter) # print counter number to lcd print(counter) # prints counter to serial moniter lcd.print(message) # prints press no + counter while yellow.value: # so it doesn't count continuously time.sleep(.25)
from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode # Talk to the LCD at I2C address 0x27. # The number of rows and columns defaults to 4x20, so those # arguments could be omitted in this case. lcd = LCD(I2CPCF8574Interface(0x27), num_rows=4, num_cols=20) lcd.print("abc ") lcd.print("This is quite long and will wrap onto the next line automatically.") lcd.clear() # Start at the second line, fifth column (numbering from zero). lcd.set_cursor_pos(1, 4) lcd.print("Here I am") # Make the cursor visible as a line. lcd.set_cursor_mode(CursorMode.LINE)
lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) touch_pad1 = board.A0 touch1 = touchio.TouchIn(touch_pad1) touch_pad2 = board.A1 touch2 = touchio.TouchIn(touch_pad2) count_direction = "up" count = 0 needs_refresh = True while True: if needs_refresh: lcd.clear() lcd.print("Direction: " + count_direction) # toggles the direction lcd.print(" Count: " + str(count)) # counts the numbers needs_refresh = False if touch1.value: # if touchpad1 is touched, execute the following code needs_refresh = True # refreshes the lcd if count_direction == "up": count_direction = "down" else: count_direction = "up" while touch1.value: #when tachpad1 is being touched, the following code will be executed time.sleep( 0.25) # wait for .25 seconds from when touchpad1 is touched if not touch1.value: #if touchpad1 is not being touched anymore break # stop continue #if it's still being touched than continue
from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) interrupter = DigitalInOut(board.D3) interrupter.direction = Direction.INPUT interrupter.pull = Pull.UP #makes the photointerrupter an input lcd.set_cursor_pos(0, 0) time.sleep(2) counter = 0 max = 4 #delay time start = time.time() while True: lcd.set_cursor_pos(0, 0) if interrupter.value: #if an object passes through, the counter increases by one counter += 1 time.sleep(.20) # this allows it to count individual passes else: counter = counter remaining = max - time.time() if remaining <= 0: lcdmessage = "Interruptions: " lcdmessage += str(counter) lcd.print(lcdmessage) print(lcdmessage) max = time.time() + 4 counter = counter
import board from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode from digitalio import DigitalInOut import time # Talk to the LCD at I2C address 0x27 or 0x3F. lcd = LCD(I2CPCF8574Interface(0x3F), num_rows=2, num_cols=16) button = DigitalInOut(board.D2) lcd.print("Ready?") time.sleep(0.05) lcd.clear() # Start at the second line, fifth column (numbering from zero). lcd.set_cursor_pos(1, 2) lcd.print("Button Presses :") lcd.print(0) while True: if button.value: # button is pushed lcd.print(++) time.sleep(0.05) # Make the cursor visible as a line. lcd.set_cursor_mode(CursorMode.LINE)
switch = DigitalInOut(board.D13) #setting the pin for switch switch.direction = Direction.INPUT switch.pull = Pull.UP counter = 0 #counter starts at zero now = True later = True switchValue = True while True: now = button.value switchValue = switch.value print(str(switchValue)) #print if the switch is up or down if now == False and later == True: if switchValue: #if switch is up count up counter += 1 #go up by 1 if not switchValue: #if switch is down count down counter -= 1 #go down by one lcd.set_cursor_pos(0, 0) #where the lcd is printing lcd.print("button presses: ") lcd.set_cursor_pos(1, 0) lcd.print(str( counter)) #print the number of times the button has been pressed lcd.print(" ") #to clear the previous number time.sleep(0.05) now = True later = button.value time.sleep(.05)
from lcd.lcd import CursorMode switch = DigitalInOut(board.D2) switch.direction = Direction.INPUT switch.pull = Pull.UP switch2 = DigitalInOut(board.D7) switch2.direction = Direction.INPUT switch2.pull = Pull.UP # Talk to the LCD at I2C address 0x27. # The number of rows and columns defaults to 4x20, so those # arguments could be omitted in this case. lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) presses = 0 fread = True while True: lcd.set_cursor_pos(0, 0) lcd.print("SwitchState:") if switch.value: fread = True else: if fread == True: if switch2.value: lcd.print("Up") lcd.print(" ") presses += 1 fread = not fread else: lcd.print("Down") lcd.print(" ") presses -= 1 fread = not fread lcd.set_cursor_pos(1, 0)
from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface import digitalio import board import time from lcd.lcd import CursorMode # Talk to the LCD at I2C address 0x27. # The number of rows and columns defaults to 2x16, so those # arguments could be omitted in this case. lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) lcd.clear() lcd.print("Switch State:") lcd.set_cursor_pos(0, 0) button_a = digitalio.DigitalInOut(board.D2) button_a.direction = digitalio.Direction.INPUT button_a.pull = digitalio.Pull.DOWN counter = 0 while True: if button_a.value: counter += 1 lcd.set_cursor_pos(1, 4) lcd.print(str(counter)) time.sleep(0.1) else: counter = counter
lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) button_a = digitalio.DigitalInOut(board.D7) button_a.direction = digitalio.Direction.INPUT button_a.pull = digitalio.Pull.UP button_b = digitalio.DigitalInOut(board.D2) button_b.direction = digitalio.Direction.INPUT button_b.pull = digitalio.Pull.UP count = 0 while True: if not button_a.value: if button_b.value: count += 1 lcd.clear() lcd.set_cursor_pos(0, 0) lcd.print("ButtonState:UP") else: count -= 1 lcd.clear() lcd.set_cursor_pos(0, 0) lcd.print("ButtonState:DOWN") lcd.set_cursor_pos(1, 0) lcd.print("Presses:") lcd.set_cursor_pos(1, 8) lcd.print(str(count)) time.sleep(0.0)
# Bob Kammauff # circuitPythonLCD # https://github.com/jkammau97/CircuitPython # code from https://cvilleschools.instructure.com/courses/31071/assignments/303469 from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface # some LCDs are 0x3f... some are 0x27. lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) lcd.print("Hello, Engineer!")
import time import board from digitalio import DigitalInOut, Direction, Pull from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode led = DigitalInOut(board.D13) lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) switch = DigitalInOut(board.D2) switch.direction = Direction.INPUT switch.pull = Pull.UP value = 0 lcd.set_cursor_pos(0, 1) lcd.print("ButtonPress:") while True: if switch.value: lcd.set_cursor_pos(0, 14) else: lcd.set_cursor_pos(0, 14) value = value + 1 lcd.print(str(value)) time.sleep(0.3)
import board from digitalio import DigitalInOut, Direction, Pull button = DigitalInOut(board.D8) button.direction = Direction.INPUT button.pull = Pull.UP # Talk to the LCD at I2C address 0x27. # The number of rows and columns defaults to 4x20, so those # arguments could be omitted in this case.S lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) lcd.set_cursor_pos(1,4) lcd.print("button presses") lcd.clear() counter = 0 now = True later = True while True: now = button.value if now == False and later == True: lcd.set_cursor_pos(0,0) lcd.print("pushed") lcd.sec_cursor_pos (1,1) lcd.print(str(counter)) time.sleep(0.05) counter += 1
from lcd.lcd import CursorMode switch = DigitalInOut(board.D7) button = DigitalInOut(board.D2) switch.direction = Direction.INPUT button.direction = Direction.INPUT switch.pull = Pull.DOWN button.pull = Pull.DOWN presses = 0 direction = 1 lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) toggle1 = 0 while True: lcd.set_cursor_pos(0, 0) lcd.print("Switch: ") lcd.set_cursor_pos(1, 0) lcd.print("Presses:") if switch.value and not button.value: direction = 1 lcd.clear() lcd.set_cursor_pos(0, 8) lcd.print("UP") print("UP") if button.value and toggle1 == 0 and not switch.value: toggle1 = 1 presses += direction lcd.set_cursor_pos(1, 9) lcd.print(str(presses)) lcd.print(" ") print(str(presses))
switch.pull = Pull.UP lcd.set_cursor_mode(CursorMode.LINE) press = False x = 0 while True: print(button.value) lcd.backlight = True if not button.value: if (press == False): press = True if not switch.value: x = x - 1 if switch.value: x = x + 1 print((0, )) if button.value: press = False lcd.set_cursor_pos(0, 0) lcd.print("Presses: ") lcd.set_cursor_pos(0, 10) lcd.print(str(x)) lcd.print(" ") lcd.set_cursor_pos(1, 0) lcd.print("Switch: ") if not switch.value: lcd.print("DOWN") if switch.value: lcd.print("UP ") time.sleep(0.05)
# so that this if statement will only run once per interrupt if pi.value and toggle: interrupts += 1 g = 255 r = 0 toggle = False # changing neopixel color and setting toggle to True so that the if statement ^^^ # can run again if not pi.value: r = 255 g = 0 toggle = True # FUN TIME TIME # if the time_toggle variable is True, run this statement if time_toggle: current_time = time.time( ) # setting current_time variable as time.time(), a variable that returns the seconds since some event # important part - the variable increases by one every second time_toggle = False # so that this statement only runs once per every four seconds lcd.print("Number of") lcd.set_cursor_pos(1, 0) lcd.print("Interrupts: " + str(interrupts)) # will run if the current time is four less than the current time if current_time == time.time() - 4: time_toggle = True # so that the if statement ^^^ can run again lcd.clear()
from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from lcd.lcd import CursorMode import time from digitalio import DigitalInOut, Direction, Pull import board button = DigitalInOut(board.D2) button.direction = Direction.INPUT # sets the button pin for receiving input button.pull = Pull.UP # provides power for button presses = 0 # creates a counter for how many times the button has been pressed lcd = LCD(I2CPCF8574Interface(0x3F), num_rows=2, num_cols=16) lcd.set_cursor_mode(CursorMode.LINE) # Make the cursor visible as a line. lcd.set_cursor_pos(0, 2) # Sets position of cursor. lcd.print("Booting up!") time.sleep(.5) while True: lcd.set_cursor_pos(0, 0) # Sets position of cursor. lcd.print("Button Presses:") if not button.value: presses += 1 # shorter way of saying presses = presses + 1 lcd.set_cursor_pos(1, 0) # Sets position of cursor. lcd.print(str(presses)) print(button.value) # tells me if the button is getting pressed time.sleep(.01) # stops it from looping a zillion times a second
analog_out = AnalogOut(board.A0) lcd = LCD(I2CPCF8574Interface(0x27), num_rows=2, num_cols=16) button_a = digitalio.DigitalInOut(board.D1) button_a.direction = digitalio.Direction.INPUT button_a.pull = digitalio.Pull.DOWN button_b = digitalio.DigitalInOut(board.D2) button_b.direction = digitalio.Direction.INPUT button_b.pull = digitalio.Pull.DOWN up = 1 number = 0 while True: lcd.set_cursor_pos(0, 0) lcd.print("Switch State: ") #prints out "switch state on lcd screen lcd.print( str(up)) #prints out the number that corresponds to the variable "up" lcd.set_cursor_pos(1, 0) lcd.print("presses:") #prints out "presses:" below "switch state" if button_a.value: number += up #if button a is pressed then it adds 1 to "up" if button_b.value: up *= -1 #if button a is pressed then it changes what is next to switchstate, either 1 or -1 lcd.print(str(number)) lcd.print(" ")
button.direction = digitalio.Direction.INPUT #setup button button.pull = digitalio.Pull.DOWN switch = digitalio.DigitalInOut(board.D5) switch.direction = digitalio.Direction.INPUT #setup switch switch.pull = digitalio.Pull.DOWN upDown = 1 buttonState = 0 #create variables number = 0 while True: #loop if not buttonState and button.value: number += upDown #count when button is pressed buttonState = button.value if switch.value: upDown = 1 #should the number go up or down? else: upDown = -1 lcd.set_cursor_pos(0, 0) lcd.print("up or down: ") if upDown == 1: lcd.print("up ") #print things to LCD else: lcd.print("down") lcd.print("number is: ") lcd.print(str(number)) lcd.print(" ")
import time # import math import board from lcd.lcd import LCD from lcd.i2c_pcf8574_interface import I2CPCF8574Interface from digitalio import DigitalInOut, Direction, Pull from lcd.lcd import CursorMode photo = DigitalInOut(board.D8) photo.direction = Direction.INPUT photo.pull = Pull.UP lcd = LCD(I2CPCF8574Interface(0x3f), num_rows=2, num_cols=16) photoState = True oldPhoto = True value = 0 while True: photoState = photo.value if photoState and not oldPhoto: value = value + 1 lcd.set_cursor_pos(1, 0) lcd.print(str(value)) else: lcd.set_cursor_pos(1, 0) lcd.print(str(value)) oldPhoto = photoState