def __init__(self, bus_name): #ehm? super(dbusService, self).__init__(bus_name, "/com/arctura/2606a") 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 initialize_screen(): global lcd # lcd = CharLCD('PCF8574', 0x27) lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True)
def connect_lcd_gpio_8(app, cfg): """connect to LCD Through GPIO 8 bit mode""" from RPLCD.gpio import CharLCD try: app.pin_rs = int(cfg.get('LCD DISPLAY SETUP', 'lcd_pin_rs')) app.pin_e = int(cfg.get('LCD DISPLAY SETUP', 'lcd_pin_e')) app.data_pin0 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin0')) app.data_pin1 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin1')) app.data_pin2 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin2')) app.data_pin3 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin3')) app.data_pin4 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin4')) app.data_pin5 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin5')) app.data_pin6 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin6')) app.data_pin7 = int(cfg.get('LCD DISPLAY SETUP', 'lcd_data_pin7')) app.pin_backlight = cfg.get('LCD DISPLAY SETUP', 'lcd_pin_backlight').strip('"') app.charmap = cfg.get('LCD DISPLAY SETUP', 'lcd_charmap') app.cols = int(cfg.get('LCD DISPLAY SETUP', 'lcd_cols')) app.rows = int(cfg.get('LCD DISPLAY SETUP', 'lcd_rows')) d = app.pin_backlight.split() if "None" in d: app.lcd = CharLCD(numbering_mode=GPIO.BCM, charmap=(app.charmap), cols=int(app.cols), rows=int(app.rows), pin_rs=int(app.pin_rs), pin_e=int(app.pin_e), pins_data=[int(app.data_pin0), int(app.data_pin1), int(app.data_pin2), int(app.data_pin3), int(app.data_pin4), int(app.data_pin5), int(app.data_pin6), int(app.data_pin7)], pin_backlight=None, backlight_enabled=True, backlight_mode='active_high') else: app.lcd = CharLCD(numbering_mode=GPIO.BCM, charmap=(app.charmap), cols=int(app.cols), rows=int(app.rows), pin_rs=int(app.pin_rs), pin_e=int(app.pin_e), pins_data=[int(app.data_pin0), int(app.data_pin1), int(app.data_pin2), int(app.data_pin3), int(app.data_pin4), int(app.data_pin5), int(app.data_pin6), int(app.data_pin7)], pin_backlight=int(app.pin_backlight), backlight_enabled=True, backlight_mode='active_high') except OSError: pass # line conf part app.lines = [(cfg.get('LCD DISPLAY TEXT', 'lcd_line_1_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_1_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_2_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_2_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_3_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_3_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_4_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_4_type'))]
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
def __init__(self): self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=LCD_COLUMNS, rows=LCD_ROWS, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True)
def setup_display(): global lcd # Setup display in GPIO or I2C mode if config.lcd_mode == 'I2C': from RPLCD.i2c import CharLCD lcd = CharLCD("PCF8574", address=config.address, port=config.port, cols=config.cols, rows=config.rows, dotsize=config.dotsize, charmap=config.charmap, auto_linebreaks=config.auto_linebreaks, backlight_enabled=config.backlight_enabled) elif config.lcd_mode == 'GPIO': from RPLCD.gpio import CharLCD from RPi import GPIO lcd = CharLCD(pin_rs=config.pin_rs, pin_rw=config.pin_rw, pin_e=config.pin_e, pins_data=config.pins_data, numbering_mode=config.numbering_mode, cols=config.cols, rows=config.rows, dotsize=config.dotsize, charmap=config.charmap, auto_linebreaks=config.auto_linebreaks) else: # Error no lcd mode has been set! logging.debug('LCD Mode has not been set!')
class LCD(object): def __init__(self): self.lcd = CharLCD(i2c_expander='MCP23008', address=0x20, cols=16, rows=2, backlight_enabled=False) def write(self, msg, reset=True): if reset: self.clear() self.lcd.write_string(msg) self.on() def quick_write(self, msg, cursor_pos=(1,0)): self.lcd.cursor_pos = cursor_pos self.lcd.write_string(msg) def clear(self): self.lcd.clear() def on(self): self.lcd.backlight_enabled = True def off(self): self.clear() self.lcd.backlight_enabled = False
def lcd_print(value,show=5): board.digital[lcd_switch].write(1) lcd = CharLCD('PCF8574', 0x27) lcd.write_string("Moist:"+ str(value)+ "\r\n" +"Len DF: " + str(len(value_set))) time.sleep(show) lcd.clear() board.digital[lcd_switch].write(0)
class Display: def __init__(self, lcd=None): if lcd is None: self.lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=COLS, rows=2, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) else: self.lcd = lcd self.zeile_1 = None self.zeile_2 = None def display_schreiben(self, text): delay = 1.3 buffer = text_zerlegen(text) while buffer: self.lcd.clear() try: self.lcd.write_string("{zeile1}\n\r{zeile2}".format( zeile1=buffer[0], zeile2=buffer[1])) except IndexError: self.lcd.write_string("{zeile1}\n\r{zeile2}".format( zeile1=buffer[0], zeile2="")) time.sleep(delay) if len(buffer) <= 2: break buffer.pop(0)
def get_lcd(backlight_on, clear_screen=True): GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP) lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=20, rows=4, dotsize=8, charmap='A00', auto_linebreaks=True, #backlight_enabled=backlight_on) backlight_enabled=True) if clear_screen: lcd.clear() lcd.write_string("********************") lcd.cursor_pos = (1, 0) lcd.cursor_pos = (3, 0) lcd.write_string("********************") return lcd
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 WriteDisplay(self, string=None): if string is None: return print("LCDClass: WriteDisplay {}".format(string)) lcd = CharLCD(0x27) lcd.clear() lcd.write_string(str(string)) return
def __init__(self, verbose=True): super().__init__() self.verbose = verbose self.report = '' self.last_sensor_report = dict() self.last_sensor_report['t1'] = -1 self.last_sensor_report['humidity'] = -1 self.last_sensor_report['t2'] = -1 self.last_sensor_report['t3'] = -1 self.lock = threading.Lock() # create DHT22 sensor self.dht22sensor = DHT22Sensor(gpio=gpios.GPIO_PIN_AM2301) # instantiate LCD screen self.lcd = CharLCD(gpios.LCD_TYPE, int(gpios.LCD_I2C_ADDRESS, 16), charmap='A00') self.lcd.clear() # add hooks for buttons GPIO.setup(gpios.GPIO_PIN_BUTTON_FEEDING, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(gpios.GPIO_PIN_BUTTON_WATERING, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(gpios.GPIO_PIN_BUTTON_FEEDING, GPIO.BOTH, callback=self.__button_feeding_pressed, bouncetime=gpios.BUTTON_DEBOUNCE_DURATION) GPIO.add_event_detect(gpios.GPIO_PIN_BUTTON_WATERING, GPIO.BOTH, callback=self.__button_watering_pressed, bouncetime=gpios.BUTTON_DEBOUNCE_DURATION)
def __init__(self): CharLCD.__init__(self, i2c_expander='PCF8574', address=0x27, port=1, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=False, backlight_enabled=True) smile = (0b00000, 0b01010, 0b01010, 0b00000, 0b10001, 0b10001, 0b01110, 0b00000) degre = (0b01100, 0b10010, 0b10010, 0b01100, 0b00000, 0b00000, 0b00000, 0b00000) bksls = (0b00000, 0b10000, 0b01000, 0b00100, 0b00010, 0b00001, 0b00000, 0b00000) self.create_char(0, smile) #\x00 self.create_char(1, degre) #\x01 self.create_char(2, bksls) #\x02 self._wheeley = '-', '\x02', '|', '/', '\x00' self._wheel = cycle(self._wheeley) self.blank20 = ' '
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 __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()
class EcranLCD: """ Cette classe permet de simplifier l'utilisation des écrans LCD """ def __init__(self, adr): """ adr : adresse : 0x27 ou 0x26 """ self.lcd = CharLCD('PCF8574', adr) self.lcd.clear() def printString(self, char): if (isinstance(char, str)): self.lcd.clear() self.lcd.write_string(char) def clear(self): self.lcd.clear()
class LCDController: def __init__(self): self.lcd = CharLCD('PCF8574', address=0x27, port=1, backlight_enabled=True) GPIO.setmode(GPIO.BCM) sys.modules['smbus'] = smbus def writeLcd(self, firstStr, secondStr=""): self.lcd.clear() self.lcd.cursor_pos = (0, 0) self.lcd.write_string(firstStr) self.lcd.cursor_pos = (1, 0) self.lcd.write_string(secondStr)
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
class Screen: try: input = raw_input except NameError: pass try: unichr = unichr except NameError: unichr = chr # Defining LCD (i2c = port 1, i2c address is 3f), backlight turned on lcd = CharLCD(address=0x3f, port=1) lcd.backlight_enabled = True # Euro symbol defining and creating euro = (0b00110, 0b01001, 0b11110, 0b01000, 0b11110, 0b01001, 0b00110, 0b00000) lcd.create_char(1, euro) # function after button press def notify(self): notification = ' Een medewerker\r\n komt er aan!' self.led.write_string(notification) input('Retailer notified') # function to show product and price def show_info(self): shoe = 'Nike Air Max' price = '150' self.lcd.write_string(shoe) self.lcd.write_string('\r\n') self.lcd.write_string(unichr(1)) self.lcd.write_string(price) input('Price shown') # function to show sizes def show_sizes(self): self.lcd.write_string(' Voorraad maten ') input('')
class LCD: lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1, cols=20, rows=4, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) def __init__(self): self.lock = threading.Lock() self.lcd.cursor_pos = (3, 0) self.lock.acquire(True, 10) self.lcd.write_string("V3.0 St. NAP/RWS") self.lock.release() def writeToScreen(self, channel, location, status, current_level, desired_level): self.lock.acquire(True, 10) text = ( "{location} {status} {current_level:0.2f}/{desired_level:0.2f}" + (' ' * 20)).format(location=location, status=status, current_level=current_level, desired_level=desired_level)[:20] #print(text) self.lcd.cursor_pos = (channel, 0) self.lcd.write_string(text) self.lock.release() def writeInfoToScreen(self, message): self.lock.acquire(True, 10) self.lcd.cursor_pos = (3, 0) self.lcd.write_string( ("{message}" + (' ' * 20)).format(message=message[:20])[:20]) self.lock.release()
def run(): """Run the configured menu""" lcd = None try: # noinspection PyUnresolvedReferences from RPLCD.i2c import CharLCD lcd = CharLCD('PCF8574', 0x27, auto_linebreaks=True, charmap='A00', rows=2, cols=16, dotsize=8, backlight_enabled=True) except ImportError: print("ERROR: cannot load RPLCD library") exit(1) menu_state = MenuState(lcd) menu_state.bind_buttons(5, 6, 12, 13) add_menu_items(menu_state) menu_state.run()
def connect_i2c(app, cfg): """I2c connect to lcd""" from RPLCD.i2c import CharLCD try: app.chip = cfg.get('LCD DISPLAY SETUP', 'lcd_chip') app.address = cfg.get('LCD DISPLAY SETUP', 'lcd_port_address').strip('"') app.port = cfg.get('LCD DISPLAY SETUP', 'lcd_port') app.charmap = cfg.get('LCD DISPLAY SETUP', 'lcd_charmap') app.cols = int(cfg.get('LCD DISPLAY SETUP', 'lcd_cols')) app.rows = int(cfg.get('LCD DISPLAY SETUP', 'lcd_rows')) app.lcd = CharLCD(i2c_expander=app.chip, address=int(app.address, 16), port=int(app.port), charmap=(app.charmap), cols=int(app.cols), rows=int(app.rows), backlight_enabled=True) except OSError: pass # line conf part app.lines = [(cfg.get('LCD DISPLAY TEXT', 'lcd_line_1_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_1_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_2_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_2_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_3_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_3_type')), (cfg.get('LCD DISPLAY TEXT', 'lcd_line_4_text').strip('"'), cfg.get('LCD DISPLAY TEXT', 'lcd_line_4_type'))]
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 main(): lcd = CharLCD(i2c_expander='PCF8574', address=0x3F, port=1, cols=15, rows=2, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) while True: ip = get_ip() lcd.clear() print("IP Address: %s" % (ip)) lcd.write_string(ip) if ip != '127.0.0.1': break time.sleep(3)
class _PCF8574_LCD(_LCD): def __init__(self, address=None, cols=20, rows=2, backlight_enabled=True): from RPLCD.i2c import CharLCD self.device = CharLCD(i2c_expander='PCF8574', address=address, cols=cols, rows=rows, backlight_enabled=backlight_enabled) super(_PCF8574_LCD, self).__init__(cols=cols, rows=rows) def on(self): self.device.backlight_enabled = True def off(self): self.device.backlight_enabled = False def redraw(self, row=None): self.device.home() for r in range(self.rows): if row is None or row == r: value = self._get_value_at(r) self.device.write_string(value) self.device.crlf()
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)
# This is a command line utility to control the PFC8574 16x2 i2c backpack import argparse from RPLCD.i2c import CharLCD LCD = CharLCD('PCF8574', 0x27) def write_to_LCD(msg: str): LCD.cursor_pos = (0, 0) LCD.write_string(msg) def write_sensor_data_to_LCD(humidity: float, temperature: float): lcd_text = f"Temp: {temperature:.2f}F\r\nHumidity: {humidity:.2f}%" write_to_LCD(lcd_text) def main(): parser = argparse.ArgumentParser(description="Control the 16x2 LCD") parser.add_argument('command', help="write, data, backlight, clear") parser.add_argument('--message') parser.add_argument('--on') parser.add_argument('--off') parser.add_argument('--humidity') parser.add_argument('--temperature') args = parser.parse_args() if args.command == 'sensor': write_sensor_data_to_LCD(float(args.humidity), float(args.temperature)) elif args.command == 'write': write_to_LCD(args.message)
#!/bin/python3 # -*- coding: utf-8 -*- import sys from RPLCD.i2c import CharLCD lcd = CharLCD(i2c_expander='PCF8574', address=0x3f, port=1, cols=16, rows=2, dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) lcd.write_string(sys.argv[1]) lcd.cursor_pos = (1, 0) lcd.write_string(sys.argv[2] + "m" + sys.argv[3] + "s left") exit()
#dht를 이용하여 조건에 따른 led,lcd 변환. from RPLCD.i2c import CharLCD #LCD문자 import import Adafruit_DHT #온도센서(DHT) import import RPi.GPIO as GPIO #LED import import time #LCD 설정 lcd = CharLCD('PCF8574', 0x27) #DHT 설정 dht_type = 11 #DHT 타입 bcm_pin = 23 #핀 번호 normal_temperature = 27 try: while True: time.sleep(3) lcd.clear() humidity, temperature = Adafruit_DHT.read_retry(dht_type, bcm_pin) humid = round(humidity, 1) #여기선 연산비교를 해야되서 str()하면 안됨. temp = round(temperature, 1) print(temp, humid) #초기 : 콘솔에 현재 온/습도 출력 GPIO.setmode(GPIO.BCM) #LED 설정 GPIO.setup(16, GPIO.OUT) #LED1 red if normal_temperature < temp: #일정 온도(27도)보다 높을 때 lcd.write_string('201835652') #학번 띄우고 lcd.crlf() lcd.write_string('Need Cooling') # 출력 GPIO.output(16, True) # LED1 red on else: #일정 온도 이하로 내려가면 GPIO.cleanup() #LED off