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
