def main(): sensor = Sensor(sensor_type, sensor_channel) lcd = CharLCD("PCF8574", 0x27) # add custom chars lcd.create_char(0, degrees) menu = { 1: sensor_data(sensor, lcd), 2: clock(), 3: ip() } for i in menu.keys(): show(lcd, menu[i]) time.sleep(3) lcd.clear()
def _init_lcd(self): lcd = CharLCD(i2c_expander='PCF8574', address=self._rsc.lcd_address, port=1, cols=20, rows=4, dotsize=8, charmap='A00', auto_linebreaks=True, backlight_enabled=False) #self._lcd.backlight_enabled = False lcd.cursor_mode = "hide" wifi_char = (0b00000, 0b11111, 0b00000, 0b01110, 0b00000, 0b00100, 0b00100, 0b00000) backspace_char = (0b00000, 0b00000, 0b00111, 0b01001, 0b10001, 0b01001, 0b00111, 0b00000) enter_char = (0b00000, 0b00001, 0b00101, 0b01001, 0b11111, 0b01000, 0b00100, 0b00000) lcd.create_char(0, wifi_char) lcd.create_char(1, backspace_char) lcd.create_char(2, enter_char) return lcd
from RPi import GPIO lcd = CharLCD(cols=cols, rows=rows, charmap=charmap, numbering_mode=GPIO.BOARD, pin_rs=pin_rs, pin_rw=pin_rw, pin_e=pin_e, pins_data=pins_data, auto_linebreaks=False) off = 0b00000 on = 0b11111 b = [(off, off, off, off, off, off, off, on), (off, off, off, off, off, off, on, on), (off, off, off, off, off, on, on, on), (off, off, off, off, on, on, on, on), (off, off, off, on, on, on, on, on), (off, off, on, on, on, on, on, on), (off, on, on, on, on, on, on, on), (on, on, on, on, on, on, on, on)] for i in range(8): lcd.create_char(i, b[i - 1]) ib = ['', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07'] # cava.conf: framerate = 4, ascii_max_range = 8 for line in iter(sys.stdin.readline, b''): val = line[:-2].split(';') str = '' for i in val: str = str + ib[int(i)] lcd.clear() lcd.write_string(str)
class ScreenManager: """Manages Screens Creates the arborescence needed for a LedPanel and manages it Please call cleanup() once you have finished. """ def __init__(self, panel): self.panel = panel self.lcd_lock = threading.RLock() self.gpio_lock = threading.Lock() home = StartScreen('HOME', 'LedPanel 289', self, 'Made by N.V.Zuijlen') main_menu = MenuScreen('MAIN_MENU', 'Menu', self) manual_menu = MenuScreen('MANUAL_MENU', 'Manuel', self) universe_selector = ValueScreen('UNIVERSE_SELECTOR', 'Choix Univers', self, self.panel.start_universe, 0, math.inf) channel_selector = ValueScreen('CHANNEL_SELECTOR', 'Choix Adresse', self, self.panel.start_channel+1, 1, DMX_UNIVERSE_SIZE) blackout = ToggleScreen('BLACKOUT', 'Blackout', self) test_pattern = MacroScreen('TEST_PATTERN', 'Test leds', self, macros.TestPixels(panel.columns, panel.rows)) ip_info = InformationScreen('IP_INFO', 'Adresse IP', self, get_ip_address()) universe_selector.setCallback(lambda uni: self.panel.setAddress(universe=uni)) channel_selector.setCallback(lambda chan: self.panel.setAddress(channel=chan)) blackout.setCallback(lambda off: self.panel.setOnOff(not off)) home.addChild(main_menu) main_menu.addChild(universe_selector) main_menu.addChild(channel_selector) main_menu.addChild(manual_menu) main_menu.addChild(ip_info) manual_menu.addChild(blackout) manual_menu.addChild(test_pattern) self.current = home with self.lcd_lock: self.lcd = CharLCD(i2c_expander='PCF8574', address=0x3F, cols=20, rows=4, auto_linebreaks=False, backlight_enabled=False) self.lcd.cursor_mode = 'hide' # UP/DOWN arrow. Use as char \x00 self.lcd.create_char(0, ( 0b00100, 0b01110, 0b11111, 0b00000, 0b00000, 0b11111, 0b01110, 0b00100 )) self.updateScreen() #self.backlightOn() def listenToGPIO(self): for pin in [UP_BUTTON, DOWN_BUTTON, OK_BUTTON, BACK_BUTTON]: GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect( pin, GPIO.RISING, callback=self.getGPIOCallback(), bouncetime=200 ) def getGPIOCallback(self): def GPIOCallback(channel): with self.gpio_lock: GPIO.output(STATUS_LED, GPIO.HIGH) #self.backlightOn() if channel == UP_BUTTON: print("UP", channel) self.current.onUp() elif channel == DOWN_BUTTON: print("DOWN", channel) self.current.onDown() elif channel == OK_BUTTON: print("OK", channel) self.current.onOK() elif channel == BACK_BUTTON: print("BACK", channel) self.current.onBack() self.updateScreen() GPIO.output(STATUS_LED, GPIO.LOW) return GPIOCallback def backlightOn(self): self.on_time = datetime.now() with self.lcd_lock: self.lcd.backlight_enabled = True self.panel.threadSafeSchedule( 11*1000, self.turn_off_backlight_if_inactivity ) def turn_off_backlight_if_inactivity(self): if datetime.now() - self.on_time >= timedelta(seconds=10): with self.lcd_lock: self.lcd.backlight_enabled = False def updateScreen(self): self.current.computeDisplay() with self.lcd_lock: self.lcd.clear() self.lcd.write_string(self.current.first_line) self.lcd.crlf() self.lcd.write_string(self.current.second_line) def cleanup(self): GPIO.cleanup() with self.lcd_lock: self.lcd.close(clear=True)
0b01110, 0b10110, 0b11010, 0b11100, ) dot = ( 0b00000, 0b00000, 0b00000, 0b00110, 0b00110, 0b00000, 0b00000, 0b00000, ) lcd.create_char(0, pause) lcd.create_char(1, play) lcd.create_char(2, stop) lcd.create_char(3, logol) lcd.create_char(4, logor) lcd.create_char(5, dot) ipause = '\x00 ' iplay = '\x01 ' istop = '\x02 ' irr = '\x03\x04' idots = ' \x05 \x05 \x05' rn = '\r\n' if len(sys.argv) == 2: # rr - splash or single argument string (^ = linebreak) if argv1 == 'rr':
class LCDScreen(object): def __init__(self, welcome_text, i2c_bus=1, i2c_addr=0x27, lcd_width=16, lcd_rows=2): self.lcd = CharLCD(i2c_expander='PCF8574', address=i2c_addr, port=i2c_bus, cols=lcd_width, rows=lcd_rows, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) self._lcd_width = lcd_width self.prevStr = '' # Create some custom characters self.lcd.create_char(0, (0, 0, 0, 0, 0, 0, 0, 0)) self.lcd.create_char(1, (16, 24, 24, 24, 24, 24, 24, 16)) self.lcd.create_char(2, (1, 3, 3, 3, 3, 3, 3, 1)) self.lcd.create_char(3, (17, 27, 27, 27, 27, 27, 27, 17)) self.lcd.create_char(4, (31, 31, 0, 0, 0, 0, 0, 0)) self.lcd.create_char(5, (0, 0, 0, 0, 0, 0, 31, 31)) self.lcd.create_char(6, (31, 31, 0, 0, 0, 0, 0, 31)) self.lcd.create_char(7, (31, 0, 0, 0, 0, 0, 31, 31)) self.lcd.backlight_enabled = True self.lcd.clear() self.print_line(welcome_text, 0, align='CENTER') self.print_line(__version__, 1, align='CENTER') self.lcd.home() def print_line(self, text, line=0, align='LEFT'): """Checks the string, if different than last call, update screen. :param text: :param line: :param align: :return: """ if isinstance(text, float): text = str(text) text = text.encode('utf-8') if self.prevStr != text: # Oh what a shitty way around actually learning the ins and outs of encoding chars... # Display string has changed, update LCD #self.lcd.clear() text_length = len(text) if text_length < self._lcd_width: blank_space = self._lcd_width - text_length if align == 'LEFT': text = text + b' ' * blank_space elif align == 'RIGHT': text = b' ' * blank_space + text else: text = b' ' * (blank_space // 2) + text + b' ' * ( blank_space - blank_space // 2) else: text = text[:self._lcd_width] self.lcd.cursor_pos = (line, 0) self.lcd.write_string(text.decode('utf-8')) # Save so we can test if screen changed between calls, don't update if not needed to reduce LCD flicker self.prevStr = text
def cleanup(self): self.logger.debug("PlayingState cleaned up") self._random_msg_display.stop() self._name_display.stop() self._title_display.stop() if __name__ == "__main__": # Resourcecs initialization rsc = Resources("/home/pi/python/webradio/conf.txt") # lcd initialization lcd = CharLCD(i2c_expander='PCF8574', address=0x3f, port=1, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) lcd.backlight_enabled = True wifi = (0b00000, 0b11111, 0b00000, 0b01110, 0b00000, 0b00100, 0b00100, 0b00000) lcd.create_char(0, wifi) state = PlayingState(lcd, rsc) state.enter_state() input("Entree pour quitter...") lcd.backlight_enabled = False
class LCD: # Guard critical sections with shared class-lock LOCK = Lock() AXIS = 'XYZABC' POST_DECIMAL_PLACE = 1 PRE_DECIMAL_PLACE = 3 # Sign + Decimal Point + Digits before + Digits after WIDTH = 1 + 1 * (PRE_DECIMAL_PLACE > 0) + PRE_DECIMAL_PLACE + POST_DECIMAL_PLACE STATUS_LEN = 18 SW_I2C_PORT = 11 SW_I2C_SDA = 23 SW_I2C_SCL = 24 CONNECTED_CHAR = 0 DISCONNECTED_CHAR = 1 CONNECTED_SYMBOL = ( 0b01110, 0b10001, 0b10001, 0b10001, 0b11111, 0b11011, 0b11011, 0b11111, ) DISCONNECTED_SYMBOL = ( 0b01110, 0b10000, 0b10000, 0b10000, 0b11111, 0b11011, 0b11011, 0b11111, ) def __init__(self): # Adress and port expander type are fixed # Hide the specific implementation used try: self._lcd = CharLCD('PCF8574', 0x26, port=self.SW_I2C_PORT) except Exception: self.connected = False else: self.connected = True self._lcd.create_char(self.CONNECTED_CHAR, self.CONNECTED_SYMBOL) self._lcd.create_char(self.DISCONNECTED_CHAR, self.DISCONNECTED_SYMBOL) def print_pose(self, pose: List[float]): """ Prints a pose on the lower three rows of the display """ if self.connected: rows = 3 * [''] for i, (ax, val) in enumerate(zip(self.AXIS, pose)): if i >= 3: space = ' ' unit = chr(223) val = math.degrees(val) else: space = '' unit = ' mm' rows[ i % 3] += f'{ax}{val:+0{self.WIDTH}.{self.POST_DECIMAL_PLACE}f}{unit}{space}' display_str = '\r\n'.join(rows) # Critical section with self.LOCK: # Set cursor to start of second row and write positions self._lcd.cursor_pos = (1, 0) self._lcd.write_string(display_str) def print_connection(self, is_connected: bool): if self.connected: # Critical section with self.LOCK: # Move cursor to upper right corner self._lcd.cursor_pos = (0, self.STATUS_LEN + 1) if is_connected: self._lcd.write_string(chr(self.CONNECTED_CHAR)) else: self._lcd.write_string(chr(self.DISCONNECTED_CHAR)) def print_status(self, status: str): if self.connected: # Critical section with self.LOCK: self._lcd.home() if len(status) > self.STATUS_LEN: status = status[:self.STATUS_LEN + 1] else: status += ' ' * (self.STATUS_LEN - len(status)) # Critical section with self.LOCK: self._lcd.write_string(status) def __del__(self): if self.connected: # Critical section with self.LOCK: self._lcd.close()
def main(): try: thread_one_wire = One_Wire() thread_one_wire.start() thread_stop_watch = Stop_Watch() thread_stop_watch.start() lcd = CharLCD('PCF8574', 0x27) degree = (0b00010, 0b00101, 0b00101, 0b00010, 0b00000, 0b00000, 0b00000, 0b00000) lcd.create_char(0, degree) sandclock = (0b00000, 0b11111, 0b01010, 0b00100, 0b00100, 0b01010, 0b11111, 0b00000) lcd.create_char(1, sandclock) lcd.cursor_pos = (0, 0) lcd.write_string('Temp 1: 00.0\x00C') lcd.cursor_pos = (1, 0) lcd.write_string('Temp 2: 00.0\x00C') lcd.cursor_pos = (2, 0) lcd.write_string('Temp 3: 00.0\x00C') lcd.cursor_pos = (3, 0) lcd.write_string('Timer : 00:00:00') Display_ref = ['0','02','03'] print("End program with CRLT+C !!") while(True): for i in range(3): lcd.cursor_pos = (i, 8) lcd.write_string(thread_one_wire.Device_Temp[i]) if Display_ref[0] != thread_stop_watch.Display_value[0]: lcd.cursor_pos = (3, 9) Display_ref[0] = thread_stop_watch.Display_value[0] lcd.write_string(thread_stop_watch.Display_value[0]) #print("treffer hour") if Display_ref[1] != thread_stop_watch.Display_value[1]: lcd.cursor_pos = (3, 11) Display_ref[1] = thread_stop_watch.Display_value[1] #print("treffer min") if len(thread_stop_watch.Display_value[1]) > 1: lcd.write_string(thread_stop_watch.Display_value[1]) else: lcd.write_string("0" + thread_stop_watch.Display_value[1]) if Display_ref[2] != thread_stop_watch.Display_value[2]: lcd.cursor_pos = (3, 14) Display_ref[2] = thread_stop_watch.Display_value[2] #print("treffer sec") if len(thread_stop_watch.Display_value[2]) > 1: lcd.write_string(thread_stop_watch.Display_value[2]) else: lcd.write_string("0" + thread_stop_watch.Display_value[2]) if thread_stop_watch.Timer_running == True: lcd.cursor_pos = (3, 18) lcd.write_string('\x01') else: lcd.cursor_pos = (3, 18) lcd.write_string(' ') time.sleep(.5) except Exception as err: print(err)
0b01000, 0b10001, ) sunR = ( 0b01001, 0b00010, 0b10000, 0b11000, 0b11011, 0b10000, 0b00010, 0b01001, ) plug = ( 0b01010, 0b01010, 0b01010, 0b11111, 0b11111, 0b01110, 0b01110, 0b00100, ) device2.create_char(0, degree) device2.create_char(1, sunL) device2.create_char(2, sunR) device2.create_char(3, plug) main() except KeyboardInterrupt: pass
from RPLCD.i2c import CharLCD lcd = CharLCD('PCF8574', 0x3f) lcd.clear(); i = ( 0b00000, 0b00000, 0b00010, 0b11011, 0b11010, 0b00010, 0b00000, 0b00000 ) lcd.create_char(0, i) e = ( 0b00000, 0b00000, 0b00010, 0b11010, 0b11010, 0b00010, 0b00000, 0b00000 ) lcd.create_char(1, e) t = ( 0b00001,
0b11111, 0b10001, 0b01110, 0b00000, ) waiting = ( 0b00000, 0b01010, 0b00000, 0b00000, 0b00000, 0b11111, 0b00000, 0b00000, ) lcd.create_char(0, smiley) lcd.create_char(1, smiley_open) lcd.create_char(2, waiting) # Make sure that the LCD will be cleared on exit def close_lcd(): lcd.close(clear=True) atexit.register(close_lcd) def write_to_lcd(string): lcd.clear()
class StompBox(): def __init__(self): # initialize LCD if I2C: self.LCD = CharLCD(i2c_expander=I2CEXPANDER, address=I2CADDR, port=1, cols=COLS, rows=ROWS, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) else: self.LCD = RPLCD.CharLCD( pin_rs=LCD_RS, pin_e=LCD_EN, pin_rw=None, pins_data=[LCD_D4, LCD_D5, LCD_D6, LCD_D7], numbering_mode=GPIO.BCM, cols=COLS, rows=ROWS, compat_mode=True) self.LCD.create_char(CHR_BSP, [0, 3, 5, 9, 5, 3, 0, 0]) self.LCD.create_char(CHR_ENT, [0, 1, 5, 9, 31, 8, 4, 0]) self.lcd_clear() # set up buttons GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) for button in BUTTONS: if ACTIVE_HIGH: GPIO.setup(BUTTONS[button], GPIO.IN, pull_up_down=GPIO.PUD_DOWN) else: GPIO.setup(BUTTONS[button], GPIO.IN, pull_up_down=GPIO.PUD_UP) self.state = {button: UP for button in BUTTONS} self.timer = {button: 0 for button in BUTTONS} def button(self, button): return self.state[button] def buttons(self): return self.state.values() def update(self): time.sleep(POLL_TIME) t = time.time() for button in BUTTONS: if GPIO.input(BUTTONS[button]) != ACTIVE: self.timer[button] = t if self.state[button] == DOWN: self.state[button] = TAP else: self.state[button] = UP else: if self.state[button] == UP: self.state[button] = DOWN self.timer[button] = t elif self.state[button] == DOWN: if (t - self.timer[button]) >= HOLD_TIME: self.state[button] = HOLD elif self.state[button] == HOLD: self.state[button] = HELD elif self.state[button] == HELD: if (t - self.timer[button]) >= LONG_TIME: self.state[button] = LONG elif self.state[button] == LONG: self.state[button] = LONGER if self.scrollmsg: if (t - self.lastscroll) >= SCROLL_TIME: self.lastscroll = t self.scrollpos += 1 self.lcd_write(self.scrollmsg, self.scrollrow) def waitforrelease(self, tmin=0): # wait for all buttons to be released and at least :tmin seconds tmin = time.time() + tmin while True: self.update() if time.time() >= tmin: if all(s == UP for s in self.state.values()): break def waitfortap(self, t): # wait :t seconds or until a button is tapped # return True if tapped, False if not tstop = time.time() + t while time.time() < tstop: self.update() if TAP in self.state.values(): return True return False def lcd_clear(self): self.LCD.clear() self.scrollmsg = '' def lcd_write(self, text, row=0, col=0): if len(text) > COLS: if self.scrollmsg: self.LCD.cursor_pos = (row, 0) if self.scrollpos < 0: self.LCD.write_string(LINESTR % self.scrollmsg[:COLS]) elif self.scrollpos < (len(self.scrollmsg) - COLS): self.LCD.write_string( LINESTR % self.scrollmsg[self.scrollpos:self.scrollpos + COLS]) elif self.scrollpos < (len(self.scrollmsg) - (COLS - 2)): self.LCD.write_string(LINESTR % self.scrollmsg[-COLS:]) else: self.scrollpos = -4 else: self.scrollmsg = text self.scrollrow = row self.scrollpos = -4 self.lastscroll = time.time() self.LCD.cursor_pos = (row, 0) self.LCD.write_string(LINESTR % text[:COLS]) else: if self.scrollmsg and row == self.scrollrow: self.scrollmsg = '' self.LCD.cursor_pos = (row, col) self.LCD.write_string(text + ' ' * (COLS - len(text))) def lcd_blink(self, text, row=0, n=3): while n != 0: self.lcd_write(' ' * COLS, row) time.sleep(BLINK_TIME) self.lcd_write(LINESTR % text, row) time.sleep(BLINK_TIME) n -= 1 def choose_opt(self, opts, row=0, timeout=MENU_TIMEOUT, passlong=False): """ has the user choose from a list of choices in :opts returns the index of the choice or -1 if the user backed out or time expired passlong: pass LONG through to calling loop """ i = 0 while True: self.lcd_write(' ' * COLS, row) self.lcd_write(opts[i], row) if ROWS == 4: if COLS == 20: self.lcd_write('Prev Next', 2) self.lcd_write('Back---Long---Select', 3) else: self.lcd_write('Prev Next', 2) self.lcd_write('Back-Long-Select', 3) tstop = time.time() + timeout while True: if timeout and time.time() > tstop: self.lcd_write(' ' * COLS, row) return -1 self.update() if sum(self.state.values()) == UP: continue elif self.state['right'] == TAP: i = (i + 1) % len(opts) break elif self.state['left'] == TAP: i = (i - 1) % len(opts) break elif self.state['right'] == HOLD: self.lcd_blink(opts[i], row) return i elif self.state['left'] == HOLD: self.lcd_write(' ' * COLS, row) return -1 elif LONG in self.state.values() and passlong: for b in self.state: if self.state[b] == LONG: self.state[b] = HELD return -1 def choose_val(self, val, inc, minval, maxval, format=LINESTR): """ lets the user change a numeric parameter returns the user's choice on timeout """ while True: self.lcd_write(LINESTR % (format % val), 1) tstop = time.time() + MENU_TIMEOUT while time.time() < tstop: self.update() if sum(self.state.values()) == UP: continue if self.state['right'] > DOWN: val = min(val + inc, maxval) elif self.state['left'] > DOWN: val = max(val - inc, minval) break else: return val def char_input(self, text='', row=1, timeout=MENU_TIMEOUT, charset=INPCHARS): """ a way of letting the user enter a text string with two buttons text: the initial value of the text user taps buttons to choose character, holds buttons to move cursor right or left when cursor is at end of input, user can tap to delete or newline character newline returns text timeout returns empty string """ i = len(text) char = len(charset) - 1 self.LCD.cursor_mode = 'blink' while True: if i < len(text): char = charset.find(text[i]) lpos = max(i - (COLS - 1), 0) self.lcd_write(LINESTR % text[lpos:lpos + COLS], row) if char > -1: self.lcd_write(charset[char], row, min(i, COLS - 1)) self.LCD.cursor_pos = (row, min(i, COLS - 1)) tstop = time.time() + timeout while time.time() < tstop: self.update() if sum(self.state.values()) == UP: continue elif TAP in self.state.values(): if i == len(text): if self.state['right'] == TAP: char = (char + 1) % len(charset) else: char = (char - 1) % len(charset) else: if self.state['right'] == TAP: char = (char + 1) % (len(charset) - 2) else: char = (char - 1) % (len(charset) - 2) if char < (len(charset) - 2): text = text[0:i] + charset[char] + text[i + 1:] break elif self.state['right'] >= HOLD: if self.state['right'] == HELD: continue if char == (len(charset) - 1): if self.state['right'] != HOLD: continue self.LCD.cursor_mode = 'hide' self.lcd_blink(text.strip()[0:COLS], row) return text.strip() if self.state['right'] > HELD: time.sleep(BLINK_TIME) i = min(i + 1, len(text)) if i == len(text): char = len(charset) - 1 break elif self.state['left'] >= HOLD: if self.state['left'] == HELD: continue if char == (len(charset) - 2): text = text[0:max(0, i - 1)] + text[i:] if self.state['left'] > HELD: time.sleep(BLINK_TIME) i = max(i - 1, 0) break else: self.LCD.cursor_mode = 'hide' return ''
class LCD1602Plugin(octoprint.plugin.StartupPlugin, octoprint.plugin.EventHandlerPlugin, octoprint.plugin.ProgressPlugin): def __init__(self): if (os.getenv('LCD1602_DOCKER')): print('We are running in test environnement, no i2c device attached.') try: print('Loading fake_rpi instead of smbus2') sys.modules['smbus2'] = fake_rpi.smbus self.mylcd = fake_rpi.smbus.SMBus(1) except: print('Cannot load fake_rpi !') else: self.mylcd = CharLCD(i2c_expander='PCF8574', address=0x27, cols=16, rows=2, backlight_enabled=True, charmap='A00') # create block for progress bar self.block = bytearray(b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF') self.block.append(255) self.mylcd.create_char(1,self.block) # init vars self.start_date = 0 # create block for progress bar #self.mylcd.create_char(1,self.block) def JobIsDone(self,lcd): # create final anim self.birdy = [ '^_-' , '^_^', '-_^' , '^_^', '0_0', '-_-', '^_-', '^_^','@_@','*_*','$_$','<_<','>_>'] for pos in range(0,13): lcd.cursor_pos = (1,pos) lcd.write_string(self.birdy[pos]) time.sleep(0.5) lcd.clear() lcd.write_string('Job is Done \,,/(^_^)\,,/') def on_after_startup(self): mylcd = self.mylcd self._logger.info("plugin initialized !") def on_print_progress(self,storage,path,progress): mylcd = self.mylcd percent = int(progress/6.25)+1 completed = '\x01'*percent mylcd.clear() mylcd.write_string('Completed: '+str(progress)+'%') mylcd.cursor_pos = (1,0) mylcd.write_string(completed) if progress==1 : self.start_date=time.time() if progress>10 and progress<100: now=time.time() elapsed=now-self.start_date average=elapsed/(progress-1) remaining=int((100-progress)*average) remaining=str(datetime.timedelta(seconds=remaining)) mylcd.cursor_pos = (1,3) mylcd.write_string(remaining) if progress==100 : self.JobIsDone(mylcd) def on_event(self,event,payload): mylcd = self.mylcd if event in "Connected": mylcd.clear() mylcd.write_string('Connected to:') mylcd.cursor_pos = (1,0) mylcd.write_string(payload["port"]) if event in "Shutdown": mylcd.clear() mylcd.write_string('Bye bye ^_^') time.sleep(1) mylcd._set_backlight_enabled(False) mylcd.close() if event in "PrinterStateChanged": if payload["state_string"] in "Offline": mylcd.clear() mylcd.write_string('Octoprint is not connected') time.sleep(2) mylcd.clear() mylcd.write_string('saving a polar bear, eco mode ON') time.sleep(5) mylcd._set_backlight_enabled(False) if payload["state_string"] in "Operational": mylcd._set_backlight_enabled(True) mylcd.clear() mylcd.write_string('Printer is Operational') if payload["state_string"] in "Cancelling": mylcd.clear() mylcd.write_string('Printer is Cancelling job') time.sleep(0.2) if payload["state_string"] in "PrintCancelled": mylcd.clear() time.sleep(0.5) mylcd.write_string(' Job has been Cancelled (0_0) ' ) time.sleep(2) if payload["state_string"] in "Paused": mylcd.clear() time.sleep(0.5) mylcd.write_string('Printer is Paused') if payload["state_string"] in "Resuming": mylcd.clear() mylcd.write_string('Printer is Resuming its job') time.sleep(0.2) def get_update_information(self): return dict( LCD1602Plugin=dict( displayName="LCD1602 display", displayVersion=self._plugin_version, type="github_release", current=self._plugin_version, user="******", repo="OctoPrint-Lcd1602", pip="https://github.com/n3bojs4/octoprint-LCD1602/archive/{target}.zip" ) )
lcd.clear() lcd.write_string('This is a long string that will wrap across multiple lines!') input('Text should nicely wrap around lines. ') lcd.clear() lcd.cursor_mode = CursorMode.hide lcd.write_string('Paris: 21{deg}C\n\rZ{uuml}rich: 18{deg}C'.format(deg=unichr(176), uuml=unichr(129))) print('Text should now show "Paris: 21°C, Zürich: 18°C" without any encoding issues.', end='') input() # Test custom chars lcd.clear() happy = (0b00000, 0b01010, 0b01010, 0b00000, 0b10001, 0b10001, 0b01110, 0b00000) sad = (0b00000, 0b01010, 0b01010, 0b00000, 0b01110, 0b10001, 0b10001, 0b00000) lcd.create_char(0, sad) lcd.write_string(unichr(0)) lcd.create_char(1, happy) lcd.write_string(unichr(1)) input('You should now see a sad and a happy face next to each other. ') lcd.create_char(0, happy) lcd.home() lcd.write_string(unichr(0)) input('Now both faces should be happy. ') lcd.clear() lcd.write_string('12345678901234567890\r\n2nd line') input('The first line should be filled with numbers, the second line should show "2nd line"') lcd.clear() lcd.write_string('999456..............\n\r\n\n\n123')
class TwolineDisplay: __lcd = None __animIdx = -1 __animChars = [] __screenMode = "" __port = 1 __logger = None def __init__(self, logger): self.__logger = logger return None def open(self): addr = self.__find_device(self.__port) if (addr < 1): raise exception self.__lcd = CharLCD(i2c_expander='PCF8574', address=addr, port=self.__port, cols=16, rows=2, dotsize=8, #charmap='A02', auto_linebreaks=True, backlight_enabled=True) self.__lcd.clear() self.__create_custom_chars() return True def close(self): self.__lcd.clear() self.__lcd.close() self.__lcd = None return True def __find_device(self,port): bus = smbus.SMBus(port) # 1 indicates /dev/i2c-1 for device in range(128): try: bus.read_byte(device) #print(hex(device)) return device except: # exception if read_byte fails pass return -1 def clear(self): self.__lcd.clear() self.__screenMode = "" def show_centered(self,line,text): self.__setScreenModeToText() self.__logger.debug("Display: " + text) self.__lcd.cursor_pos = (line, 0) self.__lcd.write_string(text.center(16)) def show_centered(self,line0,line1): self.__setScreenModeToText() self.__logger.debug("Display: " + (line0 if line0 is not None else "") + " || " + (line1 if line1 is not None else "")) if (line0 is not None): self.__lcd.cursor_pos = (0, 0) self.__lcd.write_string(line0.center(16)) if (line1 is not None): self.__lcd.cursor_pos = (1, 0) self.__lcd.write_string(line1.center(16)) def update_value_time_trend(self,value,mins,trend): self.__setScreenModeToEgv() valStr = "--" trendChars = " " if (value > 0): valStr = str(value) trendChars = self.__get_trend_chars(trend) print(valStr + " " + str(mins)) valStr = valStr.replace("0","O") valStr = valStr.rjust(6) self.__lcd.cursor_pos = (0, 0) self.__lcd.write_string(valStr) self.__lcd.cursor_pos = (1, 4) self.__lcd.write_string(trendChars) ageStr = self.update_age(mins) def update_age(self, mins): self.__setScreenModeToEgv() ageStr = "now" if (mins > 50): ageStr = "50+" elif (mins > 0): ageStr = str(mins) + "m" ageStr = ageStr.replace("0","O") ageStr = ageStr.rjust(3) self.__lcd.cursor_pos = (1, 13) self.__lcd.write_string(ageStr) def updateAnimation(self): self.__setScreenModeToEgv() self.__animIdx += 1 if (self.__animIdx >= len(self.__animChars)): self.__animIdx = 0 char = self.__animChars[self.__animIdx] self.__lcd.cursor_pos = (0, 15) self.__lcd.write_string(char) def __setScreenModeToEgv(self): if (not self.__screenMode == "egv"): self.__logger.debug("Display mode EGV") self.__screenMode = "egv" self.__lcd.clear() def __setScreenModeToText(self): if (not self.__screenMode == "text"): self.__logger.debug("Display mode Text") self.__screenMode = "text" self.__lcd.clear() def __get_trend_chars(self,trend): if(trend == Trend.NONE): return "**" if(trend == Trend.DoubleUp): return "\x01\x01" if(trend == Trend.SingleUp): return "\x01 " if(trend == Trend.FortyFiveUp): return "\x02 " if(trend == Trend.Flat): return "-\x7e" if(trend == Trend.FortyFiveDown): return "\x03 " if(trend == Trend.SingleDown): return "\x04 " if(trend == Trend.DoubleDown): return "\x04\x04" if(trend == Trend.NotComputable): return "NC" if(trend == Trend.RateOutOfRange): return "HI" return "??" #self.__lcd.write_string('\x02\x02 \x02 \x03 -\x7e \x05 \x06 \x06\x06') def __create_custom_chars(self): upArrow = ( 0b00000, 0b00100, 0b01110, 0b10101, 0b00100, 0b00100, 0b00100, 0b00100 ) self.__lcd.create_char(1, upArrow) upSlight = ( 0b00000, 0b00000, 0b00111, 0b00011, 0b00101, 0b01000, 0b10000, 0b00000 ) self.__lcd.create_char(2, upSlight) dnSlight = ( 0b00000, 0b00000, 0b10000, 0b01000, 0b00101, 0b00011, 0b00111, 0b00000 ) self.__lcd.create_char(3, dnSlight) dnArrow = ( 0b00000, 0b00100, 0b00100, 0b00100, 0b00100, 0b10101, 0b01110, 0b00100 ) self.__lcd.create_char(4, dnArrow) self.__animChars = [ '\x05', '\x06', '\x07' ] anim1 = ( 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00010, 0b00000 ) self.__lcd.create_char(5, anim1) anim2 = ( 0b00000, 0b00000, 0b00000, 0b00100, 0b01010, 0b00100, 0b00000, 0b00000 ) self.__lcd.create_char(6, anim2) anim3 = ( 0b01100, 0b10010, 0b10010, 0b01100, 0b00000, 0b00000, 0b00000, 0b00000 ) self.__lcd.create_char(7, anim3)
class OctoPrintLcd1604(octoprint.plugin.StartupPlugin, octoprint.plugin.EventHandlerPlugin, octoprint.plugin.ProgressPlugin): def __init__(self): # init vars self.start_date = 0 self.block = bytearray(b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF') self.block.append(255) self.cols = 20 self.rows = 4 # init lcd self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=self.cols, rows=self.rows, dotsize=8, charmap='A00', auto_linebreaks=True, backlight_enabled=True) # create block for progress bar self.lcd.create_char(1, self.block) def on_after_startup(self): lcd = self.lcd lcd.clear() self._logger.info("plugin initialized!") def on_print_progress(self, storage, path, progress): lcd = self.lcd lcd.clear() cols = self.cols rows = self.rows if progress == 0: self.start_date = time.time() self.start_time = time.strftime("%H:%M:%S") # progress str_progress = str(str(progress) + '%') lcd.cursor_pos = (0, 0) lcd.write_string('Progress:') lcd.cursor_pos = (0, int(cols - len(str_progress))) lcd.write_string(str_progress) # duration duration = int(time.time() - self.start_date) duration = str(datetime.timedelta(seconds=duration)) lcd.cursor_pos = (1, 0) lcd.write_string('Duration:') lcd.cursor_pos = (1, int(cols - len(duration))) lcd.write_string(duration) # estimate lcd.cursor_pos = (2, 0) lcd.write_string('Estimate:') if progress > 5 and progress < 100: elapsed = time.time() - self.start_date average = elapsed / (progress - 1) remaining = int((100 - progress) * average) remaining = str(datetime.timedelta(seconds=remaining)) else: remaining = str(datetime.timedelta(seconds=0)) lcd.cursor_pos = (2, int(cols - len(remaining))) lcd.write_string(remaining) # progress bar percent = int(progress / (101 / cols)) completed = '\x01' * percent lcd.cursor_pos = (3, 0) lcd.write_string(completed) def get_update_information(self): return dict(OctoPrintLcd1604=dict( displayName="OctoPrint LCD1604", displayVersion=self._plugin_version, type="github_release", current=self._plugin_version, user="******", repo="octoprint-lcd1604", pip= "https://github.com/tivrobo/octoprint-lcd1604/archive/{target}.zip" ))
class lcd_mgr(): lcd = None framebuffer = ['', ''] num_cols = 16 #threads = [] t = None def __init__(self): self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=16, rows=2, dotsize=8, charmap='A00', auto_linebreaks=True, backlight_enabled=True) self.framebuffer[0] = ' ' self.framebuffer[1] = ' ' self.lcd.clear() self.charset() def write_to_lcd(self): """Write the framebuffer out to the specified LCD.""" self.lcd.home() for row in self.framebuffer: self.lcd.write_string(row.ljust(self.num_cols)[:self.num_cols]) self.lcd.write_string('\r\n') def set_fb_str(self, row, col, txt): self.framebuffer[row] = self.framebuffer[ row][:col] + txt + self.framebuffer[row][col + len(txt):] def lcd_text(self, txt): self.set_fb_str(0, 0, txt) self.write_to_lcd() def lcd_play(self, artist, track, filename, tracknumber, tracktotal): #self.lcd_text( '{1}{2}/{3}'.format('\x00',tracknumber,tracktotal) ) self.set_fb_str(1, 0, '{0}{1}/{2}'.format('\x00', tracknumber, tracktotal)) # Various display modes: # 1) Artist - Trackname if not artist == None and not track == None: testtxt = '{0} - {1}'.format(artist, track) else: testtxt = filename self.lcd_text(testtxt) #not the right place to stop... stop at every display change... hmm, write_to_lcd?? #threads[0].stop() #self.t.stop() THREADS CAN'T BE STOPPED IN PYTHON!!! ---- multiprocessing ? asyncio ? if len(testtxt) > 16: #todo run under separate thread! (or atleast async..) self.loop_string(testtxt, 0, delay=0) time.sleep(2) self.lcd_text(testtxt) #self.t = threading.Thread(target=self.worker, args=(testtxt,)) #threads.append(t) #self.t.start() #self.worker( testtxt, 0, delay=0 ) def lcd_ding(self, bla): if bla == 'src_usb': self.set_fb_str(1, 1, 'USB') self.write_to_lcd() elif bla == 'update_on': self.set_fb_str(1, 5, 'UPD') self.write_to_lcd() elif bla == 'random_on': self.set_fb_str(1, 9, 'RND') self.write_to_lcd() elif bla == 'att_on': self.set_fb_str(1, 13, 'ATT') self.write_to_lcd() def worker(self, string): while True: self.loop_string(string, 0, delay=0) time.sleep(2) self.lcd_text(string) time.sleep(2) def loop_string(self, string, row, postfix='', delay=0.3): padding = ' ' * self.num_cols s = string for i in range(len(s) - self.num_cols + 1 + len(postfix)): self.framebuffer[row] = s[i:i + self.num_cols - len(postfix)] + postfix self.write_to_lcd() time.sleep(delay) def charset(self): """ chr_play = ( 0b10000, 0b11000, 0b11100, 0b11110, 0b11100, 0b11000, 0b10000, 0b00000 ) """ chr_play = (0b00000, 0b10000, 0b11000, 0b11100, 0b11000, 0b10000, 0b00000, 0b00000) chr_pause = (0b11011, 0b11011, 0b11011, 0b11011, 0b11011, 0b11011, 0b11011, 0b00000) chr_up = (0b00000, 0b00100, 0b01110, 0b11111, 0b00100, 0b00100, 0b00100, 0b00000) chr_down = (0b00000, 0b00100, 0b00100, 0b00100, 0b11111, 0b01110, 0b00100, 0b00000) chr_left = (0b00000, 0b00000, 0b00100, 0b01100, 0b11111, 0b01100, 0b00100, 0b00000) chr_right = (0b00000, 0b00000, 0b00100, 0b00110, 0b11111, 0b00110, 0b00100, 0b00000) self.lcd.create_char(0, chr_play) self.lcd.create_char(1, chr_pause) self.lcd.create_char(4, chr_up) self.lcd.create_char(5, chr_down) self.lcd.create_char(6, chr_left) self.lcd.create_char(7, chr_right)
class Display(): def __init__(self): self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=20, rows=4, dotsize=8, charmap='A00', auto_linebreaks=True) def rus_test(self): line = 'БГДЖЗИЙЛПУФЦЧШЩЬЫЮЯ ' line1 = line[0:8] line2 = line[8:16] line3 = line[16:19] str_out = '\x00\x01\x02\x03\x04\x05\x06\x07' for l in [line1, line2, line3]: for char in enumerate(l): self.lcd.create_char(char[0], chars_dict[char[1]]) self.lcd.write_string(str_out[:len(l)]) sleep(2) self.lcd.clear() self.lcd.backlight_enabled = False self.lcd.close(clear=True) def clear(self): self.lcd.clear() def welcome_message(self): # Здравствуйте # Нажмите # одну из кнопок # ЗДУЙ # ЖИЮП for char in enumerate('ЗДУЙЖИДП'): self.lcd.create_char(char[0], chars_dict[char[1]]) self.lcd.cursor_pos = (0, 4) self.lcd.write_string('\x00\x01PABCTB\x02\x03TE!') self.lcd.cursor_pos = (2, 6) self.lcd.write_string('HA\x04M\x05TE') self.lcd.cursor_pos = (3, 3) self.lcd.write_string('O\x06H\x02 \x05\x00 KHO\x07OK') def turn_off(self): self.lcd.clear() self.lcd.backlight_enabled = False self.lcd.close(clear=True) def print_rus_string(self, strings): """ Печатает набор строк на экране LCD2004 Подставляет русские символы, не более 8-ми :param strings: список вида [((row, col), string), ...] (row, col) - позиция начала строки string - содержание строки :return: True - строка выведена, False - строка не выведена """ strings = list(strings) long_string = '' # начальное преобразование и проверка словаря строк для вывода for item in strings: row = item[0][0] col = item[0][1] string = item[1].upper()[:min(20, len(item[1]))] if row > 3 | col > 19: raise ValueError('Illegal position') # формирование одной длинной строки для проверки long_string += item[1] strings[strings.index(item)] = ((row, col), string) rus_letters = list(chars_dict.keys( )) # строка русских символов (словарь индивидуальных символов) # выделение и проверка количества символов, требующих подстановки individual_chars = list( set([item for item in long_string.upper() if item in rus_letters])) if len(individual_chars) > 8: raise ValueError('Too many RUS symbols: {:d}'.format( len(individual_chars))) else: print('Total RUS characters: {:d}'.format(len(individual_chars))) # создание словаря escape - последовательностей for char in enumerate(individual_chars): self.lcd.create_char(char[0], chars_dict[char[1]]) # создание словаря строк для печати (английские буквы + escape последовательности) strings_to_print = [] for item in strings: row = item[0][0] col = item[0][1] string = item[1] string_to_print = '' for letter in list(string): if letter in individual_chars: string_to_print += escapes[individual_chars.index(letter)] else: string_to_print += eng_rus[letter] strings_to_print.append(((row, col), string_to_print)) for item in strings_to_print: self.lcd.cursor_pos = item[0] self.lcd.write_string(item[1])