def lcd_setup(lcd_columns = 16,lcd_rows = 2):
# Raspberry Pi Pin Config:
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D13)
lcd_d6 = digitalio.DigitalInOut(board.D6)
lcd_d5 = digitalio.DigitalInOut(board.D5)
lcd_d4 = digitalio.DigitalInOut(board.D22)
lcd_backlight = digitalio.DigitalInOut(board.D27)
# a NPN transistor's Base switches the LED backlight on/off
# Init lcd class obj
lcd = characterlcd.Character_LCD_Mono(
lcd_rs, lcd_en,
lcd_d4, lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows, lcd_backlight
)
lcd.text_direction = lcd.LEFT_TO_RIGHT
lcd.backlight = True
lcd.clear()
lcd.blink = True
lcd_msg(lcd,"<Setup>...")
lcd.cursor = True
msg_list = cpi.lcd_msg_list(lcd_columns, lcd_rows)
return lcd, msg_list
def main():
# Set the pins being used
lcd_rs = digitalio.DigitalInOut(board.D22)
lcd_en = digitalio.DigitalInOut(board.D17)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d6 = digitalio.DigitalInOut(board.D23)
lcd_d7 = digitalio.DigitalInOut(board.D18)
button = digitalio.DigitalInOut(board.D26)
# Setup the lcd
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, 16, 2)
# Show the IP address and blink cursor
lcd.clear()
lcd.message = "Waiting for\nnetwork..."
sleep(10)
lcd.clear()
lcd.message = ip()
sleep(1)
# Allow stopping for debugging purposes
flag = True
while flag:
# Get a message
payload = get_message().split("\n")
text = "\n".join(payload[:-1])
text = text.replace("\\n", "\n")
if len(text) > 16 and not text.count("\n"):
text = text[:16] + "\n" + text[16:]
try:
timeout = int(payload[-1])
except ValueError:
timeout = 5
print(timeout, text)
# Display the message
for i in range(16):
lcd.move_left()
sleep(0.2)
lcd.clear()
lcd.cursor_position(0, 0)
lcd.message = text
lcd.blink = True
if len(text.split("\n")[-1]) >= 16:
lcd.cursor_position(15, 1)
# Allow 10 seconds to cancel
total = 0
for i in range(20):
sleep(0.5)
if button.value:
total += 1
if total >= 4:
continue
lcd.blink = False
# Sleep for the designated amount of time
sleep(timeout * 60)
def main():
# LCD pin config
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D27)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_backlight = digitalio.DigitalInOut(board.D13)
# LCD size
lcd_columns = 16
lcd_rows = 2
# LCD class init
lcd = char_lcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6,
lcd_d7, lcd_columns, lcd_rows)
# connect to the psql database
try:
print('Connecting to PostgreSQL database...', end=' ')
params = config()
conn = pg.connect(**params)
except (Exception, pg.OperationalError) as error:
print(error)
print('Exiting...')
sys.exit()
print('Done.')
# initialize tables in database if not exist
init_tables(conn.cursor())
# main program loop
while True:
# get data from card reader
print('-' * 60)
lcd.clear()
lcd.message = 'Please swipe\nBuffOne...'
card_data = input('Please swipe card.\n')
if card_data == "":
# for debugging purposes, stop program if enter pressed
print('Exiting...')
conn.close()
lcd.clear()
sys.exit()
print('Processing...')
student_data = name_from_data(card_data)
# ensure data read from card properly
if student_data is not None:
# if success...
record_attendance(conn, lcd, student_data)
else:
# if error
lcd.clear()
lcd.message = 'Error, please\ntry again.'
print('Error, try again.')
time.sleep(1.5)
# clean up
conn.close()
def __init__(
self,
pin_lcd_rs,
pin_lcd_en,
pin_lcd_d7,
pin_lcd_d6,
pin_lcd_d5,
pin_lcd_d4,
pin_lcd_backlight,
lcd_columns=16,
lcd_rows=4,
):
self.lcd = character_lcd.Character_LCD_Mono(
DigitalInOut(pin_lcd_rs),
DigitalInOut(pin_lcd_en),
DigitalInOut(pin_lcd_d4),
DigitalInOut(pin_lcd_d5),
DigitalInOut(pin_lcd_d6),
DigitalInOut(pin_lcd_d7),
lcd_columns,
lcd_rows,
DigitalInOut(pin_lcd_backlight),
)
self.lcd.backlight = True
self.sequence = []
self.count = 0
self.item_index = 0
self.step_index = 0
self.seconds_elapsed = 0
def disp_aqi(pm25, aqi):
"""
Display PM 2.5 and AQI Nowcast on LCD display
"""
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D27)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_backlight = digitalio.DigitalInOut(board.D4)
lcd_columns = 16
lcd_rows = 2
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows, lcd_backlight)
# LCD on from 9 AM to 10 PM
now = datetime.now()
if 9 <= now.hour < 22:
lcd.backlight = False
else:
lcd.backlight = True
lcd.message = "PM2.5: " + str(pm25) + "\nAQI: " + str(aqi)
return
def __init__(self, waiting_message="WAITING", lcd_columns=16, lcd_rows=2):
# Raspberry Pi Pin Config:
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d7 = digitalio.DigitalInOut(board.D27)
lcd_backlight = digitalio.DigitalInOut(board.D4)
# Initialise the lcd class
print("Initialising LCD...")
self.lcd = characterlcd.Character_LCD_Mono(
lcd_rs,
lcd_en,
lcd_d4,
lcd_d5,
lcd_d6,
lcd_d7,
lcd_columns,
lcd_rows,
lcd_backlight,
)
self.lcd_columns = lcd_columns
self.lcd_rows = lcd_rows
self.waiting_message = waiting_message
self.turn_on()
self.display("BRESS ME\nPLEASE SIR")
def main():
# Initialize the buttons
GPIO.setmode(GPIO.BCM)
GPIO.setup(GREEN_BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(BLUE_BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(RED_BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
# Backlight Toggle
GPIO.setup(BACKLIGHT, GPIO.OUT)
GPIO.output(BACKLIGHT, BACKLIGHT_STATUS)
GPIO.add_event_detect(GREEN_BUTTON, GPIO.RISING, callback=toggle_backlight)
# Initialize the lcd object
global lcd
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, LCD_COLUMNS,
LCD_ROWS)
lcd.clear()
while True:
today = datetime.now()
delta = GRAD_DAY - today
delta = fmt_delta(delta)
lcd.message = delta + "\nUntil freedom :D"
time.sleep(1)
def _initialize_display(self):
lcd = characterlcd.Character_LCD_Mono(self.lcd_rs, self.lcd_en,
self.lcd_d4, self.lcd_d5,
self.lcd_d6, self.lcd_d7,
self.lcd_columns, self.lcd_rows)
lcd.message = 'Initialized\nwaiting for data'
return lcd
def __init__(self, lcd_columns=16, lcd_rows=2):
# Raspberry Pi Pin Config:
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D13)
lcd_d6 = digitalio.DigitalInOut(board.D6)
lcd_d5 = digitalio.DigitalInOut(board.D5)
lcd_d4 = digitalio.DigitalInOut(board.D22)
lcd_backlight = digitalio.DigitalInOut(board.D27)
# a NPN transistor's Base switches the LED backlight on/off
# Init lcd class obj
self.LCD = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4,
lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows,
lcd_backlight)
self.LCD.text_direction = self.LCD.LEFT_TO_RIGHT
self.LCD.backlight = True
self.LCD.clear()
self.LCD.blink = True
self.status = "<Setup>..."
self.display_single(self.status)
self.LCD.cursor = True
self.tt = tt.TimeTrack()
self.msg_list = cpi.lcd_msg_list(lcd_columns, lcd_rows)
# RPi Infos
self.printout_threads_setup([1, 12])
self.keyboard_listener_setup()
def initDisplay():
global lcd
# doc:https://circuitpython.readthedocs.io/projects/charlcd/en/latest/api.html
# Modify this if you have a different sized character LCD
lcd_columns = 16
lcd_rows = 2
# compatible with all versions of RPI as of Jan. 2019
# v1 - v3B+
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d4 = digitalio.DigitalInOut(board.D13)
lcd_d5 = digitalio.DigitalInOut(board.D21)
lcd_d6 = digitalio.DigitalInOut(board.D20)
lcd_d7 = digitalio.DigitalInOut(board.D16)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
# wipe LCD screen before we start
lcd.clear()
lcd.message = "1234567890123456\nDisplay initialized ..."
def __init__(self):
self.lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4,
lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows,
lcd_backlight)
self.lcd.backlight = False
def __init__(self, lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7 ):
lcd_rs = digitalio.DigitalInOut(lcd_rs)
lcd_en = digitalio.DigitalInOut(lcd_en)
lcd_d4 = digitalio.DigitalInOut(lcd_d4)
lcd_d5 = digitalio.DigitalInOut(lcd_d5)
lcd_d6 = digitalio.DigitalInOut(lcd_d6)
lcd_d7 = digitalio.DigitalInOut(lcd_d7)
self.lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows)
self.lcd.clear()
def init_lcd(self):
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D27)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, 16, 2)
lcd.message = "Initializing ..."
return lcd
def setup(userID):
"""This runs when the code runs for the first time. It loads the machine learning model
and reads and sets up the alarms from the database.
Args:
userID (string): the id of the user
"""
#load model
refresh(userID)
# LCD object
lcd_rs = digitalio.DigitalInOut(board.D5)
lcd_en = digitalio.DigitalInOut(board.D6)
lcd_d4 = digitalio.DigitalInOut(board.D12)
lcd_d5 = digitalio.DigitalInOut(board.D13)
lcd_d6 = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D16)
lcd_columns = 16
lcd_rows = 2
global lcd
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
global adc
adc = MCP3008()
global camera
camera = PiCamera()
camera.resolution = (250, 250)
#all LEDS
lSun = LED(24)
lMon = LED(23)
lTue = LED(22)
lWed = LED(27)
lThu = LED(18)
lFri = LED(17)
lSat = LED(4)
global DayLEDS
DayLEDS = [lSun, lMon, lTue, lWed, lThu, lFri, lSat]
global lError
lError = LED(26)
#button for sync and for picture
global button
button = Button(3)
GPIO.setmode(GPIO.BCM)
GPIO.setup(20, GPIO.OUT)
global pwm
pwm = GPIO.PWM(20, 0.5)
def __init__(self, char_weight=2):
self._lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4,
lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows)
self._lcd.clear()
self._line1 = ""
self._line2 = ""
if (char_weight == 2 or char_weight == 3):
self.char_weight = char_weight
else:
char_weight = 2
def __init__(self):
self.lcd_rs = digitalio.DigitalInOut(board.D26)
self.lcd_en = digitalio.DigitalInOut(board.D19)
self.lcd_d7 = digitalio.DigitalInOut(board.D27)
self.lcd_d6 = digitalio.DigitalInOut(board.D22)
self.lcd_d5 = digitalio.DigitalInOut(board.D24)
self.lcd_d4 = digitalio.DigitalInOut(board.D25)
self.lcd_columns = 16
self.lcd_rows = 2
self.lcd = characterlcd.Character_LCD_Mono(self.lcd_rs, self.lcd_en, self.lcd_d4, self.lcd_d5, self.lcd_d6, self.lcd_d7, self.lcd_columns, self.lcd_rows)
self.lcd.cursor = True
def lcdInit():
#Assign each lcd pin to GPIO
lcd_rs = digitalio.DigitalInOut(board.D17) #GPIO 17 pin 11
lcd_en = digitalio.DigitalInOut(board.D27) #GPIO 27 pin 13
lcd_d4 = digitalio.DigitalInOut(board.D22) #GPIO 22 pin 15
lcd_d5 = digitalio.DigitalInOut(board.D10) #GPIO 10 pin 19
lcd_d6 = digitalio.DigitalInOut(board.D9) #GPIO 9 pin 21
lcd_d7 = digitalio.DigitalInOut(board.D11) #GPIO 11 pin 23
lcd_columns = 16
lcd_rows = 2
global lcd
lcd = characterLCD.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
def setup(self):
global lcd
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D13)
lcd_d7 = digitalio.DigitalInOut(board.D6)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_columns = 16
lcd_rows = 2
import adafruit_character_lcd.character_lcd as characterlcd
self.lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows)
self.lcd.clear()
def __setup_screen():
"""
Method creates screen
:return: adafruit_character_lcd.character_lcd object
"""
return characterlcd.Character_LCD_Mono(
digitalio.DigitalInOut(board.D16),
digitalio.DigitalInOut(board.D12),
digitalio.DigitalInOut(board.D7),
digitalio.DigitalInOut(board.D8),
digitalio.DigitalInOut(board.D25),
digitalio.DigitalInOut(board.D24),
16,
2
)
def __init__(self):
lcd_rs = digitalio.DigitalInOut(board.D16)
lcd_en = digitalio.DigitalInOut(board.D12)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d6 = digitalio.DigitalInOut(board.D23)
lcd_d7 = digitalio.DigitalInOut(board.D18)
self.lcd_columns = 16
self.lcd_rows = 2
lcd = character_lcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7,
self.lcd_columns, self.lcd_rows)
lcd.clear()
time.sleep(2)
print("LCD init OK\n")
def setup_lcd():
global lcd
# Modify this if you have a different sized character LCD
lcd_columns = 24
lcd_rows = 2
lcd_rs = digitalio.DigitalInOut(board.D22)
lcd_en = digitalio.DigitalInOut(board.D17)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d6 = digitalio.DigitalInOut(board.D23)
lcd_d7 = digitalio.DigitalInOut(board.D18)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
def _lcd():
lcd_columns = 16
lcd_rows = 2
lcd_rs = digitalio.DigitalInOut(board.D25)
lcd_en = digitalio.DigitalInOut(board.D24)
lcd_d7 = digitalio.DigitalInOut(board.D22)
lcd_d6 = digitalio.DigitalInOut(board.D18)
lcd_d5 = digitalio.DigitalInOut(board.D27)
lcd_d4 = digitalio.DigitalInOut(board.D23)
lcd_backlight = digitalio.DigitalInOut(board.D4)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows, lcd_backlight)
lcd.backlight = True
return lcd
def initLCD():
# Modify this if you have a different sized character LCD
lcd_columns = 16
lcd_rows = 2
# compatible with all versions of RPI as of Jan. 2019
# v1 - v3B+
lcd_rs = digitalio.DigitalInOut(board.D22)
lcd_en = digitalio.DigitalInOut(board.D17)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d6 = digitalio.DigitalInOut(board.D23)
lcd_d7 = digitalio.DigitalInOut(board.D18)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
return (lcd)
def __init__(self, _lcd_columns, _lcd_rows, _time):
self.lcd_columns = _lcd_columns
self.lcd_rows = _lcd_rows
lcd_rs = digitalio.DigitalInOut(board.D5)
lcd_en = digitalio.DigitalInOut(board.D6)
lcd_d4 = digitalio.DigitalInOut(board.D13)
lcd_d5 = digitalio.DigitalInOut(board.D19)
lcd_d6 = digitalio.DigitalInOut(board.D26)
lcd_d7 = digitalio.DigitalInOut(board.D20)
lcd_backlight = digitalio.DigitalInOut(board.D4)
self.lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4,
lcd_d5, lcd_d6, lcd_d7,
self.lcd_columns,
self.lcd_rows)
self.duration = _time
def __init__(self):
self.lcd = characterlcd.Character_LCD_Mono(
lcd_rs,
lcd_en,
lcd_d4,
lcd_d5,
lcd_d6,
lcd_d7,
lcd_columns,
lcd_rows,
lcd_backlight
)
self.lcd.backlight = False
self.lcd.clear()
self.active_pomo = False
self.end_time = None
self.duration = 0
self.pause_time = None
self.secs_remaining = None
self.state = None
self.connected = False
def displayOnLCD(line1, line2):
GPIO.cleanup()
# Modify this if you have a different sized character LCD
lcd_columns = 16
lcd_rows = 2
# compatible with all versions of RPI as of Jan. 2019
# v1 - v3B+
lcd_rs = digitalio.DigitalInOut(board.D21)
lcd_en = digitalio.DigitalInOut(board.D20)
lcd_d4 = digitalio.DigitalInOut(board.D26)
lcd_d5 = digitalio.DigitalInOut(board.D19)
lcd_d6 = digitalio.DigitalInOut(board.D13)
lcd_d7 = digitalio.DigitalInOut(board.D16)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6,
lcd_d7, lcd_columns, lcd_rows)
# wipe LCD screen before we start
lcd.clear()
# combine both lines into one update to the display
lcd.message = line1 + line2
sleep(2)
GPIO.cleanup()
# Modify this if you have a different sized character LCD
lcd_columns = 16
lcd_rows = 2
# Raspberry Pi Pin Config:
lcd_rs = digitalio.DigitalInOut(board.D26)
lcd_en = digitalio.DigitalInOut(board.D19)
lcd_d7 = digitalio.DigitalInOut(board.D27)
lcd_d6 = digitalio.DigitalInOut(board.D22)
lcd_d5 = digitalio.DigitalInOut(board.D24)
lcd_d4 = digitalio.DigitalInOut(board.D25)
lcd_backlight = digitalio.DigitalInOut(board.D4)
# Initialise the lcd class
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6,
lcd_d7, lcd_columns, lcd_rows,
lcd_backlight)
# Turn backlight on
lcd.backlight = True
# Print a two line message
lcd.message = "Hello\nCircuitPython"
# Wait 5s
time.sleep(5)
lcd.clear()
# Print two line message right to left
lcd.text_direction = lcd.RIGHT_TO_LEFT
lcd.message = "Hello\nCircuitPython"
# Wait 5s
time.sleep(5)
# Return text direction to left to right
def __init__(self,
rows: int,
columns: int,
rs_pin: DigitalInOut,
en_pin: DigitalInOut,
d7_pin: DigitalInOut,
d6_pin: DigitalInOut,
d5_pin: DigitalInOut,
d4_pin: DigitalInOut,
colour_lcd: bool,
i2c_enabled: bool,
red_pin: PWMOut = None,
green_pin: PWMOut = None,
blue_pin: PWMOut = None,
backlight_pin: DigitalInOut = None,
button_controller: ButtonController = None):
"""
Create a Display object to simplify LCD operations.
The pins need to be specified as following:
digitalio.DigitalInOut( board.<PIN> )
For colours:
pulseio.PWMOut( board.<PIN> )
If it's a colour LCD, the pins for RED, GREEN and BLUE must be specified. backlight_pin can remain None.
If it's a mono LCD, the backlight pin has to be specified.
:param rows: Amount of rows on the LCD.
:param columns: Amount of columns on the LCD.
:param rs_pin: Location where the RS pin is connected on the board.
:param en_pin: Location where the EN pin is connected on the board.
:param d7_pin: Location where the D7 pin is connected on the board.
:param d6_pin: Location where the D6 pin is connected on the board.
:param d5_pin: Location where the D5 pin is connected on the board.
:param d4_pin: Location where the D4 pin is connected on the board.
:param colour_lcd: Whether it's a colour display or not.
:param i2c_enabled: Whether the screen has buttons or not.
:param red_pin: Location where the RED pin is connected on the board.
:param blue_pin: Location where the BLUE pin is connected on the board.
:param green_pin: Location where the GREEN pin is connected on the board.
:param backlight_pin: Location where the backlight pin is connected on the board.
:param button_controller: A Button Controller class.
"""
# Set a global variable for checking if it's a colour LCD or not.
# Then set the colour tuple for a blue screen.
self.is_colour_lcd = colour_lcd
self.is_i2c = i2c_enabled
self.colour = None
self.set_colour(0, 0, 100)
# Set a global variable with the dimensions
self.dimensions = (columns, rows)
if self.is_i2c:
if self.is_colour_lcd:
self.lcd = i2crgb.Character_LCD_RGB_I2C(
button_controller.i2c, columns, rows)
else:
self.lcd = i2cmono.Character_LCD_I2C(button_controller.i2c,
columns, rows)
else:
# Initialise the LCD screen (type depending on the type of screen).
if self.is_colour_lcd:
self.lcd = charlcd.Character_LCD_RGB(rs_pin, en_pin, d4_pin,
d5_pin, d6_pin, d7_pin,
columns, rows, red_pin,
blue_pin, green_pin)
else:
self.lcd = charlcd.Character_LCD_Mono(rs_pin, en_pin, d4_pin,
d5_pin, d6_pin, d7_pin,
columns, rows,
backlight_pin)
def main():
# Start SPI connection
spi = spidev.SpiDev()
spi.open(0, 0)
# Set up Raspberry Pi pins
GPIO.setwarnings(False)
GPIO.setup(26, GPIO.OUT)
GPIO.setup(20, GPIO.OUT)
GPIO.setup(14, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(13, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.output(26, GPIO.LOW)
GPIO.output(20, GPIO.LOW)
# Raspberry LCD pin setup
lcd_rs = digitalio.DigitalInOut(board.D25)
lcd_en = digitalio.DigitalInOut(board.D24)
lcd_d7 = digitalio.DigitalInOut(board.D22)
lcd_d6 = digitalio.DigitalInOut(board.D18)
lcd_d5 = digitalio.DigitalInOut(board.D17)
lcd_d4 = digitalio.DigitalInOut(board.D23)
# Define LCD column and row size for 16x2 LCD.
lcd_columns = 16
lcd_rows = 2
global lcd
lcd = character_lcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_columns,
lcd_rows)
LED = GPIO.output(26, GPIO.LOW)
GPIO.output(20, GPIO.LOW)
GPIO.add_event_detect(13, GPIO.RISING, callback=startStop, bouncetime=2000)
GPIO.add_event_detect(14,
GPIO.RISING,
callback=displayData,
bouncetime=2000)
global status
status = "OFF"
global current_page
current_page = 0
count = 0
minute_list = []
LCD_pages = []
print("Stand-by mode. Press button to start")
while True:
if status == "ON":
lcd.clear()
lcd.message = "Running \nscan"
with busio.I2C(SCL, SDA) as i2c:
try:
initialiseStation(i2c, spi, lcd, LED, count, minute_list)
except KeyboardInterrupt:
lcd.clear()
GPIO.cleanup()
break
elif status == "OFF":
try:
lcd.message = "Stand-by mode"
continue
except KeyboardInterrupt:
lcd.clear()
GPIO.cleanup()
break
shutdown_button = gpiozero.Button(3)
manual_stop_button = gpiozero.Button(4)
red_LED = gpiozero.PWMLED(17)
green_LED = gpiozero.PWMLED(27)
blue_LED = gpiozero.PWMLED(22)
# Setup LCD with digitalio
lcd_rs = digitalio.DigitalInOut(board.D13)
lcd_en = digitalio.DigitalInOut(board.D21)
lcd_d4 = digitalio.DigitalInOut(board.D19)
lcd_d5 = digitalio.DigitalInOut(board.D16)
lcd_d6 = digitalio.DigitalInOut(board.D26)
lcd_d7 = digitalio.DigitalInOut(board.D20)
lcd_coloumns = 16
lcd_rows = 2
lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_coloumns, lcd_rows)
# Define function to handle interrupt signal
def signal_handler(sig, frame):
lcd.clear()
lcd.message = "Cleaning up..."
print("Cleaning up ...")
leds_off()
subprocess.call("sudo docker stop rasa_actions rasa_server micvad > /dev/null 2>&1", shell=True)
subprocess.call("sudo docker rm rasa_actions rasa_server > /dev/null 2>&1", shell=True)
lcd.clear()
lcd.message = "Bye!"
print("Bye!")
time.sleep(2)
lcd.clear()
sys.exit(0)
