def __init__(self):
if gv.IS_DEBIAN:
self.thread_sleep = 0.1
else:
self.thread_sleep = 0.2
self.timeout_init = 3 # 3 sec
self.timeout_init /= self.thread_sleep # Adjust according to while loop sleep time
self.timeout = self.timeout_init
self.display_called = False
if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD
or gv.USE_I2C_16X2DISPLAY) and gv.IS_DEBIAN:
import lcdcustomchars as lcdcc
import RPi.GPIO as GPIO
from RPLCD import CharLCD
if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD):
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):
self.lcd = CharLCD('PCF8574', gv.I2C_16x2DISPLAY_ADDR)
self.lcd.create_char(1, lcdcc.block)
self.lcd.create_char(2, lcdcc.arrow_right_01)
self.lcd.create_char(3, lcdcc.voice_button_on)
self.lcd.create_char(4, lcdcc.voice_button_off)
if (gv.USE_HD44780_16x2_LCD
or gv.USE_HD44780_20x4_LCD) and gv.SYSTEM_MODE == 2:
self.STRING_1 = ''
self.STRING_2 = ''
self.LCDThread = threading.Thread(target=self.lcd_main)
self.LCDThread.daemon = True
self.LCDThread.start()
def main():
lcd = CharLCD(numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23])
lcd.clear()
lcd.cursor_pos = (0, 0)
lcd.write_string(u'Scannez un tube')
code = ''
GPIO.setup(3, GPIO.IN)
GPIO.add_event_detect(3, GPIO.BOTH, callback=close)
while (True):
inkey = Getch()
k = inkey()
if ord(k) == 27:
GPIO.cleanup()
call(['shutdown', 'now'])
#quit()
elif k == '\r':
lcd.clear()
lcd.cursor_pos = (0, 0)
lcd.write_string(code)
sleep(5)
code = ''
lcd.cursor_pos = (0, 0)
lcd.write_string(u'Scannez un tube')
elif k != '':
code += k
def main(BUS_STOP_CODE):
lcd = CharLCD(cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23],
numbering_mode=GPIO.BOARD)
bus_api = DatamallApiClient()
while True:
buses = bus_api.bus_at_busstop_code(BUS_STOP_CODE)
for bus_num, bus_timings in buses.items():
display_string = ''
if len(bus_timings) == 0:
display_string = f"Bus {bus_num}: NOT\r\nAVAILABLE"
if len(bus_timings) == 1:
display_string = f"Bus {bus_num}: {bus_timings[0]}\r\nLAST BUS"
if len(bus_timings) == 2:
display_string = f"Bus {bus_num}: {bus_timings[0]}\r\n{bus_timings[1]}"
if len(bus_timings) == 3:
display_string = f"Bus {bus_num}: {bus_timings[0]}\r\n{bus_timings[1]}, {bus_timings[1]}"
#print(display_string)
lcd.clear()
time.sleep(1) # to make change in info visible in screen
lcd.write_string(display_string)
time.sleep(5)
time.sleep(
5
) # in case of no items, do not send request in loop so fast to DatamallApi.
def __init__(self):
if gv.SYSTEM_MODE == 1 and (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD):
# 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
from RPLCD import CursorMode
from RPLCD 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')
self.lcd.clear()
# Hide the cursor
self.lcd._set_cursor_mode(CursorMode.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_hour_glass)
self.LCDThread = threading.Thread(target=self.lcd_main)
self.LCDThread.daemon = True
self.LCDThread.start()
def __init__(self):
"""Initialize the nRF24 radio and the Raspberry Pi"""
self.state = IDLE # current state
self.lcd = None # LCD
self.radio = None # nRF24 radio
self.address = None # address of Cherry keyboard (CAUTION: Reversed byte order compared to sniffer tools!)
self.channel = 6 # used ShockBurst channel (was 6 for all tested Cherry keyboards)
self.payloads = [] # list of sniffed payloads
self.kbd = None # keyboard for keystroke injection attacks
try:
# disable GPIO warnings
GPIO.setwarnings(False)
# initialize LCD
self.lcd = CharLCD(cols=16, rows=2, pin_rs=15, pin_rw=18, pin_e=16, pins_data=[21, 22, 23, 24])
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(APP_NAME)
self.lcd.cursor_pos = (1, 0)
self.lcd.write_string(SYSS_BANNER)
# use Raspberry Pi board pin numbers
GPIO.setmode(GPIO.BOARD)
# set up the GPIO pins
GPIO.setup(RED_LED, GPIO.OUT, initial = GPIO.LOW)
GPIO.setup(GREEN_LED, GPIO.OUT, initial = GPIO.LOW)
GPIO.setup(BLUE_LED, GPIO.OUT, initial = GPIO.LOW)
GPIO.setup(RECORD_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(REPLAY_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(ATTACK_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(SCAN_BUTTON, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
# set callcack functions
GPIO.add_event_detect(RECORD_BUTTON, GPIO.RISING, callback = self.buttonCallback, bouncetime = 250)
GPIO.add_event_detect(REPLAY_BUTTON, GPIO.RISING, callback = self.buttonCallback, bouncetime = 250)
GPIO.add_event_detect(ATTACK_BUTTON, GPIO.RISING, callback = self.buttonCallback, bouncetime = 250)
GPIO.add_event_detect(SCAN_BUTTON, GPIO.RISING, callback = self.buttonCallback, bouncetime = 250)
# initialize radio
self.radio = nrf24.nrf24()
# enable LNA
self.radio.enable_lna()
# show startup info for some time with blinkenlights
self.blinkenlights()
# start scanning mode
self.setState(SCAN)
except:
# error when initializing Radio Hack Box
self.lcd.clear()
self.lcd.home()
self.lcd.write_string(u"Error: 0xDEAD")
self.lcd.cursor_pos = (1, 0)
self.lcd.write_string(u"Please RTFM!")
def __init__(self):
self.activated = False
self.lcd = CharLCD(cols=16,
rows=2,
pin_rs=6,
pin_e=5,
pins_data=[13, 19, 26, 1],
numbering_mode=GPIO.BCM)
def __init__(self,cols=16,rows=2): self.cols,self.rows= cols,rows self.blink=False self.data=None self.data_name=None self.time_last_packet=0 self.recieve_timeout=None GPIO.setmode(GPIO.BCM) self.screen = CharLCD(numbering_mode=GPIO.BCM,cols=self.cols, rows=self.rows, pin_rs=16, pin_e=18, pins_data=[23, 24, 2, 3])
def initLCD():
lcd = CharLCD(cols=24,
rows=2,
pin_rs=26,
pin_e=24,
pins_data=[16, 18, 22, 8],
numbering_mode=GPIO.BOARD)
biglcd.createLcdCustomChar(lcd)
return lcd
def __init__(self):
self.code = None
self.start_time = time.time()
self.send_to_db = False
self.delete_wait_time = 5
# for BCM Mode
# lcd_rs = 25
# lcd_en = 24
# lcd_d4 = 23
# lcd_d5 = 17
# lcd_d6 = 18
# lcd_d7 = 22
# lcd_backlight = 4
# for Board Mode
lcd_rs = 22
lcd_en = 18
lcd_d4 = 16
lcd_d5 = 11
lcd_d6 = 12
lcd_d7 = 15
lcd_backlight = 4
# Define LCD column and row size for 16x2 LCD.
lcd_columns = 16
lcd_rows = 2
self.lcd = CharLCD(cols=lcd_columns,
rows=lcd_rows,
pin_rs=lcd_rs,
pin_e=lcd_en,
pins_data=[lcd_d4, lcd_d5, lcd_d6, lcd_d7],
numbering_mode=GPIO.BOARD)
self.lcd.clear()
self.db = MongoDB()
GPIO.setmode(GPIO.BOARD)
self.red_light = 40
self.green_light = 37
self.buzzer = 38
self.button_remove = 32
GPIO.setup(10, GPIO.IN,
pull_up_down=GPIO.PUD_DOWN) # button for delete
GPIO.setup(self.green_light, GPIO.OUT) # Green Light
GPIO.setup(self.red_light, GPIO.OUT) # Red Light
GPIO.setup(self.buzzer, GPIO.OUT) # Buzzer
GPIO.setup(self.button_remove, GPIO.IN,
pull_up_down=GPIO.PUD_DOWN) # button for remove
GPIO.add_event_detect(10, GPIO.RISING, callback=self.button_callback)
GPIO.add_event_detect(self.button_remove,
GPIO.RISING,
callback=self.remove_item)
def setup(self):
GPIO.setmode(GPIO.BCM)
self.lcd = CharLCD(cols=16,
rows=2,
pin_rs=6,
pin_e=5,
pins_data=[13, 19, 26, 1],
numbering_mode=GPIO.BCM)
self.lcd.cursor_mode = 'hide'
print("Display setup finished")
def main():
# initialize lcd screen
lcd = CharLCD(cols=16,
rows=2,
pin_rs=37,
pin_e=35,
pins_data=[33, 31, 29, 23])
# DHT22 sensor is only accurate to +/- 2% humidity and +/- 0.5 celsius
# Poll 10 times and calculate median to get more accurate value
templist = []
humidlist = []
lcd.cursor_pos = (0, 0)
lcd.write_string("Polling...")
lcd.cursor_pos = (1, 0)
bar = "[----------]"
lcd.write_string(bar)
lcd.clear()
for i in range(1, 11):
data = poll()
lcd.cursor_pos = (0, 0)
lcd.write_string("Polling....")
lcd.cursor_pos = (1, 0)
bar = list(bar)
bar[i] = '#'
bar = ''.join(bar)
lcd.write_string(bar)
# Don't poll more often than every 2 seconds
sleep(3)
lcd.clear()
temp = int(round(data[0]))
humid = int(round(data[1]))
templist.append(temp)
humidlist.append(humid)
lcd.clear()
# Calculate median value
temp = (sorted(templist))[5]
humid = (sorted(humidlist))[5]
# Display results to LCD
display(lcd, temp, humid)
# Write data to CSV file for later analysis
write_data(temp, humid)
# Clears the screen / resets cursor position and closes connection
lcd.clear()
lcd.close(clear=True)
def write_to_lcd(ifname):
lcd = CharLCD()
lcd.clear()
lcd.home()
lcd.write_string(get_hostname())
lcd.cursor_pos = (1, 0)
lcd.write_string(get_device_type())
lcd.cursor_pos = (2, 0)
lcd.write_string(get_ip_address(ifname))
def getDefaultLCD():
# Setup 16x2 LCD
lcd = CharLCD(cols=16,
rows=2,
pin_rs=15,
pin_e=16,
pins_data=[36, 33, 31, 29],
numbering_mode=GPIO.BOARD,
auto_linebreaks=True,
charmap="A02")
return lcd
def lcd_init():
global lcd
pin_rs = 21 # Board: 40
pin_e = 20 # Board: 38
pins_data = [16, 26, 19, 13] # Board: 36, 37, 35, 33
lcd = CharLCD(numbering_mode=GPIO.BCM,
cols=16,
rows=2,
pin_rs=pin_rs,
pin_rw=None,
pin_e=pin_e,
pins_data=pins_data)
lcd.clear()
def LCD_screen():
while True:
lcd = CharLCD(cols=16,
rows=2,
pin_rs=19,
pin_e=26,
numbering_mode=GPIO.BCM,
pins_data=[17, 27, 22, 5, 12, 25, 24, 23])
string = (subprocess.check_output(["hostname",
"-I"]).split()[1]).decode('ascii')
lcd.write_string(f'{string}')
time.sleep(30)
lcd.clear()
def refresh():
lcd = CharLCD(pin_rs=37,
pin_rw=22,
pin_e=35,
pins_data=[33, 40, 38, 36],
numbering_mode=GPIO.BOARD,
cols=16,
rows=2,
dotsize=8,
auto_linebreaks=True,
pin_backlight=None,
backlight_enabled=True,
backlight_mode=BacklightMode.active_low)
def __init__(self,
cols=16,
rows=2,
rs=37,
e=35,
data_pins=[33, 31, 29, 23],
mode='BOARD'):
GPIO.setwarnings(False)
if mode == 'BCM':
self.lcd = CharLCD(cols=cols,
rows=rows,
pin_rs=rs,
pin_e=e,
pins_data=data_pins,
numbering_mode=GPIO.BCM)
else:
self.lcd = CharLCD(cols=cols,
rows=rows,
pin_rs=rs,
pin_e=e,
pins_data=data_pins,
numbering_mode=GPIO.BOARD)
def __post_init__(self) -> None:
self.logger = logging.getLogger(__name__)
self.logger.info("Initiating LCD")
# Use compatibility mode to avoid driver timing issues https://github.com/dbrgn/RPLCD/issues/70
self.lcd = CharLCD(compat_mode=True,
numbering_mode=GPIO.BCM,
cols=16,
rows=2,
pin_rs=22,
pin_e=17,
pins_data=[26, 19, 13, 6])
self.lcd.cursor_mode = 'hide'
self.lcd.clear()
self.write_lock = Lock()
def stop(self):
App.logger.info("Requesting stop")
self.lcd = CharLCD(cols=16,
rows=2,
pin_rs=11,
pin_e=5,
pins_data=[6, 13, 19, 26],
numbering_mode=GPIO.BCM)
self.isRunning = False
if self.ocv:
self.ocv.stop()
if self.cvp:
self.cvp.stop()
App.logger.info("Stop requested")
def __init__(self, system, console=False):
self.console = console
if not on_rpi:
self.console = True
if self.console:
lcd = None
else:
lcd = CharLCD(numbering_mode=GPIO.BCM,cols=16,rows=2,pin_rs=18,pin_e=23,pins_data=[24,25,12,16])
self.display = LCDProxy(lcd=lcd)
self.current_elem = build_menu(system.burner, system.temp, system.wifi_config)
self.prev_menus = []
self.update_display()
self.event_queue = queue.Queue()
class HD44780Lcd(Lcd):
_lines: list = ["", "", "", ""]
_lcd = CharLCD(pin_rs=18,
pin_rw=23,
pin_e=24,
pins_data=[25, 8, 7, 12],
numbering_mode=GPIO.BCM,
cols=20,
rows=4,
dotsize=8)
def write_line(self, num: int, value: str):
self._lines[num] = value
def flush(self):
self._lcd.clear()
for row, value in enumerate(self._lines):
self._lcd.cursor_pos = (row, 0)
self._lcd.write_string(value)
def main():
iterations = 300
interval = 0.1
print("starting {} second collection".format(iterations * interval))
sensor1 = SonicSensor(trig_pin=18, echo_pin=24, numbering_mode=GPIO.BCM)
sensor2 = SonicSensor(trig_pin=16, echo_pin=12, numbering_mode=GPIO.BCM)
lcd = CharLCD(numbering_mode=GPIO.BCM,
cols=16,
rows=2,
pin_rs=21,
pin_e=20,
pins_data=[5, 7, 8, 25, 26, 19, 13, 6])
results1 = []
results2 = []
try:
for i in range(iterations):
dist1 = sensor1.get_distance()
dist2 = sensor2.get_distance()
results1.append(dist1)
results2.append(dist2)
lcd.write_string(u'%.1f cm' % dist2)
print(u'%.1f cm' % dist2)
lcd.write_string(u'\n%.1f cm' % dist1)
print(u'%.1f cm' % dist1)
time.sleep(interval)
lcd.clear()
except KeyboardInterrupt:
pass
GPIO.cleanup()
with open('results.pickle', 'wb') as file:
pickle.dump((results1, results2), file)
def __init__(self):
# hardcoded PINOUT
self.sensor_left = SonicSensor(trig_pin=16, echo_pin=12, numbering_mode=GPIO.BCM)
self.sensor_right = SonicSensor(trig_pin=18, echo_pin=24, numbering_mode=GPIO.BCM)
self.lcd = CharLCD(numbering_mode=GPIO.BCM, cols=16, rows=2, pin_rs=21, pin_e=20, pins_data=[5,7,8,25,26,19,13,6])
self.rotary = RotaryEncoder(dt_pin=3, clk_pin=4, lower_limit=0, upper_limit=40)
self.button = Button(pin=2)
# parameters for filtering and smoothing
# self.interval = ?? #
self.window = 30 # for filters and running smoother
self.threshold = 3 # for filters
self.weight = .3 # for exponential smoother
self.iterations = 3 # for exponential smoother
self.lag = 10 # for peak detection. Probably not needed as using a simple peak detector
# memory for both sensors
self.raw_data_left = deque([-1]*self.window, maxlen=self.window)
self.raw_data_right = deque([-1]*self.window, maxlen=self.window)
self.data_left = deque([-1]*self.window, maxlen=self.window)
self.data_right = deque([-1]*self.window, maxlen=self.window)
# parameters and variables for tide
self.initial_water_level = -1 # mean measured from past hour
self.initial_median_dist = 0 # man measured distance from past readings
self.current_median_dist = 0 #
self.tide_window = 1001
self.points_for_median_dist = deque(maxlen=self.tide_window) # used for adding points to running average
# parameters and variables for speed
self.sensor_spacing = 10 # cm
self.delay = .3 # time to do one iteration
self.left_peak = False
self.counter = -1 # used as unit of time
# misc
self.calibration_delay = 0 # s time used after setting water level to move sensor into place
self.line2 = u'Wave: None'
def __init__(self,
rsPin,
enPin,
d4Pin,
d5Pin,
d6Pin,
d7Pin,
boardNum=GPIO.BCM,
rwPin=None,
cols=16,
rows=2,
warnings=False):
if warnings is False:
GPIO.setwarnings(False)
self.cols = cols
self.rows = rows
self.firstRun = True
self.lcd = CharLCD(cols=cols,
rows=rows,
pin_rw=rwPin,
pin_rs=rsPin,
pin_e=enPin,
pins_data=[d4Pin, d5Pin, d6Pin, d7Pin],
numbering_mode=boardNum)
self.lcdmem = self._generate_lcd_memory()
self.curpos = [0, 0] # [row, column]
self._warm_up_display()
sleep(1)
self.lcd.clear()
sleep(1)
def main():
try:
rotary = RotaryEncoder(dt_pin=3, clk_pin=4)
rotary.start()
button = Button(pin=2)
lcd = CharLCD(numbering_mode=GPIO.BCM,
cols=16,
rows=2,
pin_rs=21,
pin_e=20,
pins_data=[5, 7, 8, 25, 26, 19, 13, 6])
while True:
if button.pressed():
break
lcd.clear()
lcd.write_string(u'{}'.format(rotary.get_count()))
time.sleep(0.1)
except KeyboardInterrupt: # Ctrl-C to terminate the program
pass
print("stopped at {}".format(rotary.get_count()))
rotary.stop()
GPIO.cleanup()
def reboot_algorithm(self):
CVProcessor.logger.info("Rebooting...")
self.working_lock.acquire()
self.car_names = {}
self.tracker = Tracker()
self.count = 0
self.colors = {}
self.times = {}
self.car_detected_count = {}
self.car_detected_names = {}
self.last_reboot = time.time()
self.working_lock.release()
self.lcd = CharLCD(cols=16,
rows=2,
pin_rs=11,
pin_e=5,
pins_data=[6, 13, 19, 26],
numbering_mode=GPIO.BCM)
self.lcd.clear()
self.lcd.write_string(u'Running..')
GPIO.output(CVProcessor.output_pin, GPIO.LOW)
GPIO.output(CVProcessor.output_pin_puerta, GPIO.LOW)
from threading import Thread, Lock
from sets import Set
from picamera import PiCamera
import qrtools
import requests
from apscheduler.schedulers.background import BackgroundScheduler
import logging
import sys
from RPLCD import CharLCD
import RPi.GPIO as GPIO
lcd = CharLCD(pin_rs=4,
pin_rw=18,
pin_e=17,
pins_data=[18, 22, 23, 24],
numbering_mode=GPIO.BCM,
cols=16,
rows=2,
dotsize=8,
auto_linebreaks=True)
logging.basicConfig()
syncInterval = 5.0
syncFile = 'workspace/sync.txt'
queuedMessages = Set([])
submittedMessages = Set([])
qr = qrtools.QR()
offlineMode = False
syncMutex = Lock()
import os
import glob
import time
from RPLCD import CharLCD
lcd = CharLCD(cols=16, rows=2, pin_rs=22, pin_e=18, pins_data=[16, 11, 40, 15])
os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')
base_dir = '/sys/bus/w1/devices/'
device_folder = glob.glob(base_dir + '28*')[0]
device_file = device_folder + '/w1_slave'
def read_temp_raw():
f = open(device_file, 'r')
lines = f.readlines()
f.close()
return lines
#CELSIUS CALCULATION
def read_temp_c():
lines = read_temp_raw()
while lines[0].strip()[-3:] != 'YES':
time.sleep(0.2)
lines = read_temp_raw()
equals_pos = lines[1].find('t=')
if equals_pos != -1:
temp_string = lines[1][equals_pos + 2:]
elif 'server.py' in files:
device_type = 'server'
else:
device_type = 'unknown'
device_type = 'type: ' + device_type
return device_type
framebuffer = [
get_hostname(),
get_device_type(),
get_ip_address('eth0'),
'',
]
lcd = CharLCD()
process = Process()
thread_stop_event = Event()
def write_to_lcd(lcd, framebuffer, num_cols):
lcd.home()
#lcd.clear()
for row in framebuffer:
lcd.write_string(row.ljust(num_cols)[:num_cols])
lcd.write_string('\r')
def loop_string(string, lcd, framebuffer, row, num_cols, delay=0.5):
padding = ' ' * num_cols
from RPLCD import CharLCD
import RPi.GPIO as GPIO
import time
from pad4pi import rpi_gpio
pins_data=[9, 10, 22, 21]
pins_data2=[21,22,10,9]
pin_e=11
pin_rs=7
GPIO.setmode(GPIO.BCM)
GPIO.setup(pin_rs, GPIO.OUT)
GPIO.setup(pin_e, GPIO.OUT)
for pin in pins_data:
GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, True)
lcd = CharLCD(cols=16, rows=2, pin_rs=7, pin_e=11, pins_data=[9, 10, 21, 22], numbering_mode=GPIO.BCM)
lcd.cursor_pos = (0,0)
lcd.write_string(u'Pinjam/Kembali?')
lcd.cursor_pos = (1,0)
lcd.write_string(u'1:P 2:K 3:Back')
time.sleep(5)
lcd.clear()
GPIO.cleanup()