class CommonHardwarePIHD44780GPIO(object): """ Class for interfacing with pi lcd HD44780 """ def __init__(self): self.lcd_inst = CharLCDGPIO(pin_rs=15, pin_rw=18, pin_e=16, pins_data=[21, 22, 23, 24], numbering_mode=GPIO.BOARD, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=True) def com_hard_pi_hd44780_write(self, lcd_string, x_pos=None, y_pos=None): if x_pos is not None: self.lcd_inst.cursor_pos = (x_pos, y_pos) self.lcd_inst.write_string(lcd_string) def com_hard_pi_hd44780_clear(self): self.lcd_inst.clear() def com_hard_pi_hd44780_close(self, clear_screen=True): self.lcd_inst.close(clear=clear_screen)
import RPLCD as RPLCD from RPLCD.gpio import CharLCD import RPi.GPIO as GPIO import time GPIO.setwarnings(False) lcd = CharLCD(numbering_mode=GPIO.BOARD, cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=[33, 31, 29, 26]) lcd.clear() kata = input('ketikkan karakter atau kata: ') lcd.write_string(kata) time.sleep(3) GPIO.cleanup()
class RaspberryPiIODiagnoser: def __init__(self): logger.debug(FUNCTION_CALL_MSG) GPIO.setwarnings(False) self.front_button_gpio = 4 self.back_button_gpio = 3 self.back_led_gpio = 14 # power LED self.bit_mode = 4 self.pin_modes = { 4: [33, 31, 29, 23], 8: [40, 38, 36, 32, 33, 31, 29, 23] } self.lcd = CharLCD(numbering_mode=GPIO.BOARD, cols=16, rows=2, pin_rs=37, pin_e=35, pins_data=self.pin_modes[self.bit_mode]) self.front_button = Button( pin=self.front_button_gpio, bounce_time=0.01, hold_time=self.mintime, # hold_repeat=True ) self.front_button.when_pressed = self.front_button__when_pressed self.front_button.when_held = self.front_button__when_held self.front_button.when_released = self.front_button__when_released self.back_button = Button( pin=self.back_button_gpio, bounce_time=0.01, hold_time=self.mintime, # hold_repeat=True ) self.back_button.when_pressed = self.back_button__when_pressed self.back_button.when_held = self.back_button__when_held self.back_button.when_released = self.back_button__when_released self.back_led = LED(self.back_led_gpio) self.lcd.clear() self.lcd.home() smiley = ( 0b00000, 0b01010, 0b01010, 0b00000, 0b10001, 0b10001, 0b01110, 0b00000, ) self.lcd.create_char(0, smiley) s = chr(0) line1 = f"{s}{s}{s}{s}{s}{s}{s}PI{s}{s}{s}{s}{s}{s}{s}" line2 = f"{s}{s}{s}{s}DIAGNOSH{s}{s}{s}{s}" self.lcd.cursor_pos = (0, 0) self.lcd.write_string(line1) self.lcd.cursor_pos = (1, 0) self.lcd.write_string(line2) def front_button__when_pressed(self): logger.debug(FUNCTION_CALL_MSG) def front_button__when_held(self): logger.debug(FUNCTION_CALL_MSG) def front_button__when_released(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_pressed(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_held(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_released(self): logger.debug(FUNCTION_CALL_MSG)
class Display(multiprocessing.Process): def __init__(self, write_queue): super().__init__() self.write_queue = write_queue self.strings_to_write = ['', ''] self.changed = multiprocessing.Value(c_bool, True) self.lcd = CharLCD(pin_rs=18, pin_rw=None, pin_e=23, pins_data=[12, 16, 20, 21], numbering_mode=GPIO.BCM, cols=16, rows=2, auto_linebreaks=False) self.lock = Lock() self.lcd.cursor_mode = 'hide' self.watch_queue = Thread(target=self.update_to_write, args=(self.changed, self.lock)) def run(self): self.watch_queue.start() top_scroll, bottom_scroll = False, False top_string = self.strings_to_write[0] bottom_string = self.strings_to_write[1] i, j = 0, 0 while True: try: if self.changed.value: with self.lock: # i, j = 0, 0 self.lcd.clear() if True: # if len(self.strings_to_write[0]) <= 16: top_scroll = False self.lcd.cursor_pos = (0, 0) self.lcd.write_string(self.strings_to_write[0][:16]) # else: # top_scroll = True # top_string = self.strings_to_write[0] + ' ' + self.strings_to_write[0] # max_i = len(self.strings_to_write[0]) + 2 # top_freeze_ticks = 4 # if len(self.strings_to_write[1]) <= 16: bottom_scroll = False self.lcd.cursor_pos = (1, 0) self.lcd.write_string(self.strings_to_write[1][:16]) # else: # bottom_scroll = True # bottom_string = self.strings_to_write[1] + ' ' + self.strings_to_write[1] # max_j = len(self.strings_to_write[1]) + 2 # bottom_freeze_ticks = 4 self.changed.value = False # if top_scroll: # self.lcd.cursor_pos = (0, 0) # self.lcd.write_string(top_string[i:i+16]) # if i == 0: # if top_freeze_ticks > 0: # top_freeze_ticks -= 1 # else: # top_freeze_ticks = 4 # i = 1 # else: # i = (i + 1) % max_i # # if bottom_scroll: # self.lcd.cursor_pos = (1, 0) # self.lcd.write_string(bottom_string[j:j+16]) # if j == 0: # if bottom_freeze_ticks > 0: # bottom_freeze_ticks -= 1 # else: # bottom_freeze_ticks = 4 # j = 1 # else: # j = (j + 1) % max_j sleep(0.2) except Exception as exception: print('display service exception: ', exception) def update_to_write(self, changed, lock): while True: try: msg = self.write_queue.get() if msg[0] != self.strings_to_write[0] or msg[1] != self.strings_to_write[1]: with lock: self.strings_to_write[0], self.strings_to_write[1] = msg[0], msg[1] changed.value = True sleep(2) except Exception as exception: print('invalid message received by display process: ', exception)
def main(): try: lcd = CharLCD(pin_rs=11, pin_rw=13, pin_e=15, pins_data=[12, 16, 20, 21], numbering_mode=GPIO.BCM, cols=16, rows=4) lcd.clear() hour = -1 min = -1 while True: #lcd.write_string('Raspberry Pi') now = time.localtime() soilMoisture = readadc(SM, CLK, DOUT, DIN, CS) water_time = setUpWaterTime() # dang datetime right_now = datetime.now() # dang datetime lcd.cursor_pos = (0, 1) lcd.write_string(water_time.strftime("%H:%M %d/%m")) lcd.cursor_pos = (1, 1) lcd.write_string(str(soilMoisture) + " %") lcd.cursor_pos = (1, 7) lcd.write_string("weather") #noWaterHours = (right_now.day*24 + right_now.hour) -(water_time.day*24 + water_time.hour) delta = (right_now - water_time).total_seconds() noWaterHours = delta // 3600 waterPy = AutoIrrigationSystem(soilMoisture, noWaterHours) #print("I'm here") if (now.tm_hour == 12 or now.tm_hour == 6) and (now.tm_hour != hour): print("Soil moisture: ", waterPy.soilMoisture, "|", "water time: ", water_time) print("Your garden has not been watered for", waterPy.noWaterHours, "hours") current = currentWeather() forecast = forecastWeather() if (waterPy.soilMoisture < threshold and waterPy.noWaterHours >= 24 and waterPy.noWaterHours < 72): if waterPy.isRain(current): print("It's", current["description"], ". No need to water right now") elif waterPy.expectedRain(forecast) != "": print("Expecting", waterPy.expectedRain(forecast), ". No need to water right now") else: waterPy.watering(current) print("It's", current["description"]) sendMail("WaterPy", "Your plant has been watered.") elif waterPy.noWaterHours >= 72: print(current["description"]) print("It's over 3 days without water. Watering...") waterPy.watering(current) sendMail("WaterPy", "Your plant has been watered.") elif (waterPy.soilMoisture < threshold and waterPy.noWaterHours < 24): print( "Soil moisture is %.1f, under threshold but your garden has been just watered %d hours ago" % (waterPy.soilMoisture, waterPy.noWaterHours)) elif waterPy.soilMoisture > threshold: print("Soil moisture is %.1f, above threshold" % waterPy.soilMoisture) hour = now.tm_hour elif (now.tm_min % 30 == 0 and now.tm_min != min): soilMoisture = readadc(soilMoisture, CLK, DOUT, DIN, CS) current = currentWeather() forecast = forecastWeather() waterPy.saveCurrentWeather(current) waterPy.saveSoilMoisture() print( "weather info and soil moisture values has been inserted into database" ) min = now.tm_min time.sleep(1) except KeyboardInterrupt: GPIO.cleanup() lcd.clear()
key_lookup = u'{}'.format( dictionary.scancodes.get( data.scancode)) or u'UNKNOWN:[{}]'.format( data.scancode) # Lookup or return UNKNOWN:XX if (data.scancode != 42) and (data.scancode != 28): x += key_lookup if (data.scancode == 28): return x # START OF FUNCTIONALITY ############################################################################# startMessage() internetConnected = False roundsDisplay.clear() roundsDisplay.write_string('Connecting to Network...') while (not internetConnected): try: response = urllib.request.urlopen("https://google.com", timeout=1) internetConnected = True except urllib.request.URLError: continue roundsDisplay.clear() roundsDisplay.write_string('Connected to Network!') time.sleep(2) timestamp = str(int(time.time())) preHash = cfg.path + timestamp + cfg.secret
class RaspberryPi(IODevice): def __init__(self, shutdown_system=False, output_rows=2, output_columns=16): logger.debug(f"{FUNCTION_CALL_MSG}, {__class__}") super().__init__(shutdown_system=shutdown_system, output_rows=output_rows, output_columns=output_columns) GPIO.setwarnings(False) self.front_button_gpio = 4 self.back_button_gpio = 3 self.back_led_gpio = 14 # power LED self.bit_mode = 4 self.pin_modes = { 4: [33, 31, 29, 23], 8: [40, 38, 36, 32, 33, 31, 29, 23] } self.lcd = CharLCD( numbering_mode=GPIO.BOARD, cols=self.output_columns, rows=self.output_rows, pin_rs=37, pin_e=35, pins_data=self.pin_modes[self.bit_mode], ) self.print_cleanup_method = self.print_cleanup_method_override self.print_method = self.print_method_override smiley = ( 0b00000, 0b01010, 0b01010, 0b00000, 0b10001, 0b10001, 0b01110, 0b00000, ) self.lcd.create_char(0, smiley) self.smiley = chr(0) self.front_button = ButtonWrapper(pin=self.front_button_gpio, bounce_time=0.01, hold_time=1, hold_repeat=True) self.front_button.when_pressed = self.front_button__when_pressed self.front_button.when_held = self.front_button__when_held self.front_button.when_released = self.front_button__when_released self.back_button = ButtonWrapper(pin=self.back_button_gpio, bounce_time=0.01, hold_time=1, hold_repeat=True) self.back_button.when_pressed = self.back_button__when_pressed self.back_button.when_held = self.back_button__when_held self.back_button.when_released = self.back_button__when_released self.back_led = LED(self.back_led_gpio) self.startup_method = self.set_startup_method def print_cleanup_method_override(self): logger.debug(FUNCTION_CALL_MSG) self.lock.acquire() self.lcd.home() self.lcd.clear() self.lock.release() def print_method_override(self, framebuffer): for row in framebuffer: try: self.lcd.write_string(row) self.lcd.crlf() except Exception as e: print("Something went wrong:") print(e) return def shutdown(self): logger.debug(FUNCTION_CALL_MSG) if self.shutdown_system: logger.debug("Shutting down system") self.back_led.on() os.system("sudo poweroff") else: raise NotImplementedError # logger.debug("Shutting down Pi process") # This throws some gpiozero related error on exit, but oh well # os.kill(self.pid, signal.SIGUSR1) # TODO: Keeping this around for the blinking logic that I need to reimplement # def shutdown_old(self, hold_time=6): # logger.debug(FUNCTION_CALL_MSG) # # find how long the button has been held # p = self.back_button.pressed_time # logger.debug(f"Held for {p} seconds") # # blink rate will increase the longer we hold # # the button down. E.g., at 2 seconds, use 1/4 second rate. # self.back_led.blink(on_time=0.5 / p, off_time=0.5 / p) # if p > hold_time: # # Depending on system, either shutdown # # whole system, or just the object process # if self.shutdown_system: # logger.debug("Shutting down system") # self.back_led.on() # os.system("sudo poweroff") # else: # raise NotImplementedError # # logger.debug("Shutting down Pi process") # # # This throws some gpiozero related error on exit, but oh well # # os.kill(self.pid, signal.SIGUSR1) def default_splash_screen(self): lines = [ f"{self.smiley*3}RASPBERRY{self.smiley*4}", f"{self.smiley*7}PI{self.smiley*7}" ] self.stream_lines(lines) def default_startup_text(self): startup_steps_lines = [['Loading', '.'], ['Loading', '..'], ['Loading', '...']] self.stream_multiples_of_lines(startup_steps_lines) # TODO: Rename this def set_startup_method(self): self.default_startup_text() self.default_splash_screen() def front_button__when_pressed(self): logger.debug(FUNCTION_CALL_MSG) def front_button__when_held(self): logger.debug(FUNCTION_CALL_MSG) def front_button__when_released(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_pressed(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_held(self): logger.debug(FUNCTION_CALL_MSG) def back_button__when_released(self): logger.debug(FUNCTION_CALL_MSG) self.back_led.off() def run(self): self.print_cleanup_method() self.startup_method() super().run()
class RpiInterface: def __init__(self, music_logic): self.music_logic = music_logic def draw_screen(self): self.clear_screen() self.write_to_screen(self.music_logic.get_current_bank().name, line=0) self.write_to_screen(f"RS: {self.music_logic.repeat_style.name}", line=1) def draw_screen_async(self): p = Process(target=self.draw_screen) p.start() def write_to_screen(self, text, line=None): written_characters = 0 total_available_characters = 0 if line in range(SCREEN_ROWS): total_available_characters = SCREEN_COLUMNS self._lcd.cursor_pos = (line, 0) elif line is None: total_available_characters = SCREEN_COLUMNS * SCREEN_ROWS self._lcd.home() else: raise AttributeError( f"line must be between 0 and {SCREEN_COLUMNS}") trimmed_text = text[:total_available_characters] self._lcd.write_string(trimmed_text) def clear_screen(self): self._lcd.clear() def start(self): os.putenv('SDL_VIDEODRIVER', 'fbcon') pygame.display.init() GPIO.setmode(GPIO.BCM) self._lcd = CharLCD(pin_rs=17, pin_e=27, pins_data=[22, 10, 9, 11], numbering_mode=GPIO.BCM, cols=SCREEN_COLUMNS, rows=SCREEN_ROWS) self._lcd.clear() self._lcd.write_string('Welcome to\r\nSoundFloored') time.sleep(1) self.draw_screen_async() control_button_1_pin = 2 control_button_2_pin = 26 GPIO.setup(control_button_1_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect( control_button_1_pin, GPIO.FALLING, callback=lambda channel: self.music_logic.decrement_bank(), bouncetime=200) GPIO.setup(control_button_2_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect( control_button_2_pin, GPIO.FALLING, callback=lambda channel: self.music_logic.increment_bank(), bouncetime=200) audio_clip_button_pins = [14, 15, 20, 21] # Used to discard the channel value that is automatically provided by # add_event_detect to the callback function callback_wrapper = lambda index, channel: self.music_logic.play_clip( index) for index, audio_clip_button_pin in enumerate(audio_clip_button_pins): GPIO.setup(audio_clip_button_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(audio_clip_button_pin, GPIO.FALLING, callback=partial(callback_wrapper, index), bouncetime=200) self.music_logic.after_state_change_functions.append( self.draw_screen_async) try: while True: for index, audio_clip_button_pin in enumerate( audio_clip_button_pins): if GPIO.input(audio_clip_button_pin ) == INPUT_VALUE_WHEN_BUTTON_PRESSED: # Sleep for just long enough to give the event detector a chance to # execute the callback, rather than stacking multiple calls # to play_clip at the same time time.sleep(0.01) self.music_logic.play_clip(index, is_distinct_trigger=False) except KeyboardInterrupt: pass finally: self._lcd.close(clear=True) GPIO.cleanup()
thread = threading.Thread(target=listener.output) thread.daemon = True listener.connect() thread.start() listener.run_forever() ''' Only start the client if its called as standalone and not loaded as a module. Parse arguments for host, port or use the defaults ''' if __name__ == '__main__': try: parser = argparse.ArgumentParser() parser.add_argument('-c', '--console', metavar='console', default=False, type=bool, help='If the data should be outputted to console instead') parser.add_argument('-n', '--host', metavar='HOST', default='127.0.0.1', help='the host to connect to') parser.add_argument('-p', '--port', help='the port to connect to', default=9000, type=int) args = parser.parse_args() lcd = None if using_rpi and not args.console: lcd = CharLCD(pin_rs=26, pin_rw=7, pin_e=19, pins_data=[13, 6, 5, 11], numbering_mode=GPIO.BCM, cols=CHARACTERS_PER_LINE, rows=2) else: lcd = ConsoleLCD() lcd.clear() client_init(lcd, args.host, args.port) finally: lcd.clear() if using_rpi: GPIO.cleanup()
class LCD_SYS_1: def __init__(self): if gv.SYSTEM_MODE == 1 and (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD or gv.USE_I2C_16X2DISPLAY): # Timing constants self.E_PULSE = 0.0005 self.E_DELAY = 0.0005 self.display_called = False self.temp_display = False if gv.IS_DEBIAN: self.thread_sleep = 0.05 else: self.thread_sleep = 0.1 self.timeout_init = 2 # default timeout reset time self.timeout_length = self.timeout_init # initial timeout length (timeout_custom will override) self.STRING_1 = '' self.STRING_2 = '' self.STRING_3 = '' self.STRING_4 = '' self.STRING_1_PRIORITY = '' self.STRING_2_PRIORITY = '' self.STRING_3_PRIORITY = '' self.STRING_4_PRIORITY = '' self.loop_alive = True if gv.IS_DEBIAN: import RPi.GPIO as GPIO import RPLCD if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD): from RPLCD.gpio import CharLCD self.lcd = CharLCD(pin_rs=gv.GPIO_LCD_RS, pin_rw=None, pin_e=gv.GPIO_LCD_E, pins_data=[gv.GPIO_LCD_D4, gv.GPIO_LCD_D5, gv.GPIO_LCD_D6, gv.GPIO_LCD_D7], numbering_mode=GPIO.BCM, cols=gv.LCD_COLS, rows=gv.LCD_ROWS, charmap='A00') elif (gv.USE_I2C_16X2DISPLAY): from RPLCD.i2c import CharLCD # print 'Addr: ' + str(gv.I2C_16x2DISPLAY_ADDR) # self.lcd = CharLCD('PCF8574', gv.I2C_16x2DISPLAY_ADDR) self.lcd = CharLCD(i2c_expander='PCF8574', address=gv.I2C_16x2DISPLAY_ADDR, port=1, cols=16, rows=2, dotsize=8, charmap='A00', auto_linebreaks=True, backlight_enabled=True) # self.lcd.write_string('Hello world') self.lcd.clear() # Hide the cursor # self.lcd._set_cursor_mode(CursorMode.hide) self.lcd.cursor_mode = 'hide' # Fill the display with blank spaces for i in xrange(1, gv.LCD_ROWS+1): self.lcd_string(' ', i) # Write custom codes to the LCD self.lcd.create_char(1, lcdcc.block) self.lcd.create_char(2, lcdcc.pause) self.lcd.create_char(3, lcdcc.voice_button_on) self.lcd.create_char(4, lcdcc.voice_button_off) self.lcd.create_char(5, lcdcc.block2) self.lcd.create_char(6, lcdcc.loading_1) self.lcd.create_char(7, lcdcc.loading_2) self.lcd.create_char(0, lcdcc.loading_3) self.LCDThread = threading.Thread(target=self.lcd_main) self.LCDThread.daemon = True self.LCDThread.start() def reset_after_timeout(self): self.display_called = False self.temp_display = False self.timeout_start = time.time() def lcd_main(self): if gv.USE_HD44780_20x4_LCD and gv.IS_DEBIAN: self.lcd.clear() # if gv.USE_HD44780_16x2_LCD: # self.lcd_string("WELCOME TO".center(gv.LCD_COLS, ' '), 1) # self.lcd_string("SAMPLERBOX".center(gv.LCD_COLS, ' '), 2) # elif gv.USE_HD44780_20x4_LCD: # self.lcd_string(unichr(1) * gv.LCD_COLS, 1) # self.lcd_string("WELCOME TO".center(gv.LCD_COLS, ' '), 2) # self.lcd_string("SAMPLERBOX".center(gv.LCD_COLS, ' '), 3) # self.lcd_string(unichr(1) * gv.LCD_COLS, 4) # time.sleep(0.6) self.timeout_start = time.time() print_message = '' while self.loop_alive: if self.display_called: now = time.time() if (now - self.timeout_start) > self.timeout_length: self.reset_after_timeout() if (self.temp_display or gv.displayer.menu_mode == gv.displayer.DISP_UTILS_MODE): self.lcd_string(self.STRING_1, 1) self.lcd_string(self.STRING_2, 2) print_message = "\r%s||%s" % (self.STRING_1[:gv.LCD_COLS], self.STRING_2[:gv.LCD_COLS]) if gv.USE_HD44780_20x4_LCD: self.lcd_string(self.STRING_3, 3) self.lcd_string(self.STRING_4, 4) print_message = "\r%s||%s||%s" % (print_message, self.STRING_3[:gv.LCD_COLS], self.STRING_4[:gv.LCD_COLS]) elif gv.displayer.menu_mode == gv.displayer.DISP_PRESET_MODE: self.lcd_string(self.STRING_1_PRIORITY, 1) self.lcd_string(self.STRING_2_PRIORITY, 2) print_message = "\r%s||%s" % (self.STRING_1_PRIORITY[:gv.LCD_COLS], self.STRING_2_PRIORITY[:gv.LCD_COLS]) if gv.USE_HD44780_20x4_LCD: self.lcd_string(self.STRING_3_PRIORITY, 3) self.lcd_string(self.STRING_4_PRIORITY, 4) print_message = "\r%s||%s||%s" % (print_message, self.STRING_3_PRIORITY[:gv.LCD_COLS], self.STRING_4_PRIORITY[:gv.LCD_COLS]) elif gv.displayer.menu_mode == gv.displayer.DISP_MENU_MODE: self.lcd_string(self.STRING_1_PRIORITY, 1) self.lcd_string(self.STRING_2_PRIORITY, 2) print_message = "\r%s||%s" % (self.STRING_1_PRIORITY[:gv.LCD_COLS], self.STRING_2_PRIORITY[:gv.LCD_COLS]) if gv.USE_HD44780_20x4_LCD: self.lcd_string(self.STRING_3_PRIORITY, 3) self.lcd_string(self.STRING_4_PRIORITY, 4) print_message = "\r%s||%s||%s" % (print_message, self.STRING_3_PRIORITY[:gv.LCD_COLS], self.STRING_4_PRIORITY[:gv.LCD_COLS]) if gv.PRINT_LCD_MESSAGES: sys.stdout.write(print_message) sys.stdout.flush() gui_message = print_message.replace('\r', '') gui_message = gui_message.replace('||', '\r') if gv.USE_GUI and not gv.IS_DEBIAN: gv.gui.output['text'] = gui_message time.sleep(self.thread_sleep) def lcd_string(self, message, line): message = message[:gv.LCD_COLS] message = message.ljust(gv.LCD_COLS, " ") if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD or gv.USE_I2C_16X2DISPLAY) and gv.IS_DEBIAN: self.lcd.write_string(message[:gv.LCD_COLS]) def display(self, message, line=1, is_priority=False, timeout_custom=None): message += ' ' * gv.LCD_COLS # Send string to display if line == 1: self.STRING_1 = message if is_priority: self.STRING_1_PRIORITY = message else: self.temp_display = True if line == 2: self.STRING_2 = message if is_priority: self.STRING_2_PRIORITY = message else: self.temp_display = True if line == 3: self.STRING_3 = message if is_priority: self.STRING_3_PRIORITY = message else: self.temp_display = True if line == 4: self.STRING_4 = message if is_priority: self.STRING_4_PRIORITY = message else: self.temp_display = True if timeout_custom != None: self.timeout_length = timeout_custom else: self.timeout_length = self.timeout_init self.timeout_start = time.time() self.display_called = True def stop(self): self.lcd.close() self.loop_alive = False