def main(): # now just write the code you would use in a real Raspberry Pi from gpiozero import LED, Button from time import sleep from Adafruit_CharLCD import Adafruit_CharLCD lcd = Adafruit_CharLCD(2, 3, 4, 5, 6, 7, 16, 2) global count count = 0 def show_next_characters(): global count print(f"Showing characters from code {count} to {count+31}") string = "" for i in range(0, 32): string += chr(count) if i == 15: string += "\n" count += 1 lcd.clear() lcd.message(string) button = Button(11) button.when_pressed = show_next_characters show_next_characters() while True: sleep(0.1)
def print_to_LCDScreen (message): try: lcd = Adafruit_CharLCD() lcd.begin(16,2) for x in range(0, 16): for y in range(0, 2): lcd.setCursor(x, y) lcd.message('>') time.sleep(.025) lcd.noDisplay() lcd.clear() lcd.message(str(message)) for x in range(0, 16): lcd.DisplayLeft() lcd.display() for x in range(0, 16): lcd.scrollDisplayRight() time.sleep(.05) # lcd.noDisplay() # lcd.display() # lcd.blink() # lcd.noCursor() # lcd.clear() # lcd.noBlink() # lcd.begin(16, 2) # lcd.setCursor(7, 0) # lcd.message('123') # lcd.message('x') # lcd.clear() return 'ok' except Exception,e: return e
def __init__(self, queues): ''' Initialize the LCD display ''' Process.__init__(self, name="LCD") self.inQueue = queues[0] # to read from self.outQueue = queues[1] # to write to # LCD PINS self.PIN_RS = 26 # RS pin of LCD self.PIN_E = 19 # enable pin of LCD self.PIN_DB = [13, 6, 5, 11] # data pins for LCD self.LCD_COL_SIZE = 2 # number of charactes available vertically on LCD self.LCD_ROW_SIZE = 16 # the number of characters available horizontally on LCD self.PIN_BLT = None self.DEF_MSG_LEN = 10 # the default space allocated for displaying a message on LCD self.PIN_LCD_BACKLIGHT = 20 # backlight pin for LCD # the Adafruit LCD object self.lcd = Adafruit_CharLCD(self.PIN_RS, self.PIN_E, self.PIN_DB[0], self.PIN_DB[1], self.PIN_DB[2], self.PIN_DB[3], self.LCD_COL_SIZE, self.LCD_ROW_SIZE) self.curr_screen = [] # fill current screen with empty for i in range(self.LCD_COL_SIZE * self.LCD_ROW_SIZE): self.curr_screen.append(" ") # turn on the display if (self.PIN_BLT != None): GPIO.setmode(GPIO.BCM) GPIO.setup(PIN_BLT, GPIO.OUT) GPIO.output(self.PIN_BLT, 1)
def print_to_lcd(): """ Print values to a 2x16 LCD display if it is provided with connections described """ lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=6, d6=5, d7=21, cols=16, lines=2) lcd.clear() lcd.set_cursor(0, 0) lcd.message("DHT22 Program") lcd.set_cursor(0, 1) lcd.message("Waiting...") sleep(2) try: while True: hum, temp = get_values() lcd.clear() lcd.set_cursor(0, 0) lcd.message("Temp: {0:.2f} C".format(temp)) lcd.set_cursor(0, 1) lcd.message("Humi: {0:.2f} %".format(hum)) sleep(5) except KeyboardInterrupt: print('Exiting...') lcd.clear() lcd.set_cursor(0, 0) lcd.message("OFFLINE")
def __init__(self): # Need a state set for this launcher. self.menu = ["Remote Control"] self.menu += ["Three Point Turn"] self.menu += ["Straight Line Speed"] self.menu += ["Line Following"] self.menu += ["Proximity"] self.menu += ["Quit Challenge"] self.menu += ["Power Off Pi"] self.menu_quit_challenge = 3 # default menu item is remote control self.menu_state = 0 self.menu_button_pressed = False self.drive = None self.wiimote = None # Current Challenge self.challenge = None self.challenge_name = "" GPIO.setwarnings(False) self.GPIO = GPIO # LCD Display self.lcd = Adafruit_CharLCD(pin_rs=25, pin_e=24, pins_db=[23, 17, 27, 22], GPIO=self.GPIO) self.lcd.begin(16, 1) self.lcd.clear() self.lcd.message('Initiating...') self.lcd_loop_skip = 5 # Shutting down status self.shutting_down = False
def configura_Rpi(): prints("configura_Rpi") global isRasp, lcd, GPIO global BOTAO_ESQUERDA, BOTAO_DIREITA, BOTAO_ENTER, BOTAO_ESC isRasp = True ''' Botoes conectados nos pinos: BCM 4 = BOARD pin 7 BCM 17 = BOARD pin 11 BCM 21 = BOARD pin 13 BCM 22 = BOARD pin 15 ''' BOTAO_ESQUERDA = 21 BOTAO_DIREITA = 17 BOTAO_ENTER = 4 BOTAO_ESC = 22 try: # raspberry pi import RPi.GPIO as GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) # LCD from Adafruit_CharLCD import Adafruit_CharLCD lcd = Adafruit_CharLCD() lcd.begin(16, 2) # I/O botoes GPIO.setup(BOTAO_ESQUERDA, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(BOTAO_DIREITA, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(BOTAO_ENTER, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(BOTAO_ESC, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) except RuntimeError: # caso o programa na esteja sendo executado em um RPi isRasp = False
def programa(): # importação de bibliotecas from gpiozero import LED from gpiozero import Button from time import sleep # definição de funções def apertaELiga(): led.toggle() return def piscaQuatro(): led2.blink(n=4) return def piscaContinuamente(): led3.blink(on_time=1, off_time=3.0) return def Noaperto(): global count count = count + 1 lcd.clear() lcd.message(str(count)) piscaQuatro() return def mantemAceso(): led5.on() return # criação de componentes led = LED(21) led2 = LED(22) led3 = LED(23) led5 = LED(25) button = Button(11) button2 = Button(12) button3 = Button(13) lcd = Adafruit_CharLCD(2, 3, 4, 5, 6, 7, 16, 2) global count count = 0 button.when_pressed = apertaELiga button2.when_pressed = Noaperto piscaContinuamente() # loop infinito while True: if (led3.is_lit and button3.is_pressed): mantemAceso() else: led5.off() sleep(0.2)
def __init__(self): logging.info('Create LcdManager instance') self.running = False self.line1 = '' self.line2 = '' self.screen = Adafruit_CharLCD() self.spinner_state = 0 return
def printLCD(string1, string2): '''Prints string1 and string2 onto a 16x2 character LCD.''' lcd = Adafruit_CharLCD() lcd.begin(16, 1) lcd.clear() sleep(0.5) lcd.message(string1 + "\n") lcd.message(string2)
def init(bus=1, address=0x20, gpio_count=8): # Create MCP230xx GPIO adapter. mcp = MCP230XX_GPIO(bus, address, gpio_count) # Create LCD, passing in MCP GPIO adapter. lcd = Adafruit_CharLCD(pin_rs=1, pin_e=2, pins_db=[3, 4, 5, 6], GPIO=mcp) lcd.clear() return lcd
def lcd_clear(self, topic, payload): """ This method writes to the LCD """ lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=6, d6=5, d7=11, cols=16, lines=2) lcd.clear() print("CLEARED")
def dumpLCD(): lcd = Adafruit_CharLCD() lcd.begin(20,4) lcd.clear() lcd.setCursor(0,0) lcd.message("Yay! Treats!") lcd.setCursor(0,1) lcd.message(" ") lcd.setCursor(0,3) lcd.message("Thank you!")
def homescreen(): lcd = Adafruit_CharLCD() lcd.begin(20,4) lcd.clear() lcd.setCursor(0,0) lcd.message("Judd Treat Machine!") lcd.setCursor(0,1) lcd.message("Awaiting Emails!") lcd.setCursor(0,3) lcd.message("Hurry up!")
def init(): #lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=8, d6=5, d7=11, cols=16, lines=2) lcd = Adafruit_CharLCD(rs=7, en=10, d4=22, d5=14, d6=8, d7=17, cols=16, lines=2) return lcd
def print_on_display(message): lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=6, d6=5, d7=11, cols=16, lines=2) lcd.clear() lcd.message(message)
def __init__(self, **kwargs): # Create MCP230xx GPIO adapter. mcp = MCP230XX_GPIO(CONF.lcd.bus, CONF.lcd.address, CONF.lcd.gpio_count) # Create LCD, passing in MCP GPIO adapter. self._lcd = Adafruit_CharLCD(pin_rs=1, pin_e=2, pins_db=[3, 4, 5, 6], GPIO=mcp) self._lcd.clear()
def __init__(self, init=True): # Create MCP230xx GPIO adapter. mcp = MCP230XX_GPIO(self.bus, self.address, self.gpio_count) # Create LCD, passing in MCP GPIO adapter. self.lcd = Adafruit_CharLCD(pin_rs=1, pin_e=2, pin_bl=7, pins_db=[3, 4, 5, 6], GPIO=mcp) if init: self.initialisation()
def main(USERNAME, PASSWORD, SENSOR_ID): lcd = Adafruit_CharLCD() lcd.clear() sessionToken, objectID = LoginUser(USERNAME, PASSWORD) pubnub = Pubnub(publish_key="pub-c-e6b9a1fd-eed2-441a-8622-a3ef7cc5853a", subscribe_key="sub-c-7e14a542-b148-11e4-9beb-02ee2ddab7fe") channel = SENSOR_ID def _callback(message, channel): print("Message received from channel: ", message) data = {'status': None, 'targetTemperature': None} if message['airconStatus']: if message['airconStatus'] == 'on': print "Lets turn on air con now" lcd.clear() lcd.message("Aircon On!") logging.warning("Lets turn on air con now") else: print "lets turn off aircon now" lcd.clear() lcd.message("Aircon Off!\n Have a good day!") logging.warning("Lets turn off air con now") data['status'] = message['airconStatus'] if message['targetTemperature']: print "Lets turn aircon to : ", message['targetTemperature'] lcd.clear() lcd.message("Setting temperature\n" + "Temp={0:0.1f}*C".format(message['targetTemperature'])) logging.warning("Lets turn aircon to : " + str(message['targetTemperature'])) data['targetTemperature'] = message['targetTemperature'] if message[ 'switchOffLCD']: #note that this might happen a few times because current logic is if last activity was more than 3 mins ago, we swtich off print "Lets switch off LCD" lcd.clear() logging.warning("switching off LCD") needToReLogin = SendDataToParse(data, objectID, sessionToken, SENSOR_ID) def _error(message): print("Error: ", message) logging.warning("Error: ", message) pubnub.subscribe(channel, callback=_callback, error=_error)
def main(): # now just write the code you would use in a real Raspberry Pi from Adafruit_CharLCD import Adafruit_CharLCD from gpiozero import Buzzer, LED, PWMLED, Button, DistanceSensor, LightSensor, MotionSensor from lirc import init, nextcode from py_irsend.irsend import send_once from time import sleep def show_sensor_values(): lcd.clear() lcd.message( "Distance: %.2fm\nLight: %d%%" % (distance_sensor.distance, light_sensor.value * 100) ) def send_infrared(): send_once("TV", ["KEY_4", "KEY_2", "KEY_OK"]) lcd = Adafruit_CharLCD(2, 3, 4, 5, 6, 7, 16, 2) buzzer = Buzzer(16) led1 = LED(21) led2 = LED(22) led3 = LED(23) led4 = LED(24) led5 = PWMLED(25) led5.pulse() button1 = Button(11) button2 = Button(12) button3 = Button(13) button4 = Button(14) button1.when_pressed = led1.toggle button2.when_pressed = buzzer.on button2.when_released = buzzer.off button3.when_pressed = show_sensor_values button4.when_pressed = send_infrared distance_sensor = DistanceSensor(trigger=17, echo=18) light_sensor = LightSensor(8) motion_sensor = MotionSensor(27) motion_sensor.when_motion = led2.on motion_sensor.when_no_motion = led2.off init("default") while True: code = nextcode() if code != []: key = code[0] lcd.clear() lcd.message(key + "\nwas pressed!") sleep(0.2)
def lcd_write(self, topic, payload): """ This method writes to the LCD """ print(payload['value']) print(type(payload['value'])) lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=6, d6=5, d7=11, cols=16, lines=2) lcd.clear() text = str(payload['value']) lcd.message(text)
def __init__(self): # Configuration self.pins_T0 = 3 # chip select pin for 1st thermocouple self.pins_T1 = 5 # chip select pin for 2nd thermocouple self.pins_out = 11 # output pin self.pins_clock = 7 # clock pin self.pins_relay = 24 # relay switch pin self.plot_avg = 5 # number of temp readings to be averaged self.control_time = 0 # initialize control time self.control_delay = 35 # control delay in second self.control_tolerance = 2 # tolerance self.alert_delay = 60 # alert delay in seconds self.alert_time = 0 # initialize alert time self.alert_email = '*****@*****.**' # Send message to email/smtp self.out_temp = 'temp.csv' # output file name for temperature data self.out_control = 'control.csv' # input file name for control parameters self.network_cmd0 = "ip addr show wlan0 | grep inet | awk '{print $2}' | cut -d/ -f1" self.network_cmd1 = "ip addr show eth0 | grep inet | awk '{print $2}' | cut -d/ -f1" self.network_smtp = ['*****@*****.**', '030206raspberrypi'] self.network_tweet = "/usr/local/bin/twitter [email protected] set " #Initialize components: self.LCD = Adafruit_CharLCD() self.LCD.begin(16, 1) self.RELAY = BBQpi_relay(self.pins_relay) self.T0 = BBQpi_thermocouple(self.pins_T0, self.pins_out, self.pins_clock) self.T1 = BBQpi_thermocouple(self.pins_T1, self.pins_out, self.pins_clock) # Initialize output files if os.path.isfile(self.out_temp): os.remove(self.out_temp) self.f = open(self.out_temp, 'wb') self.CSV = csv.writer(self.f, delimiter=',', quoting=csv.QUOTE_MINIMAL) # Find the devices IP Address self.ipaddr = '' try: self.ipaddr = run_cmd(self.network_cmd0) except: pass if (self.ipaddr == ''): self.ipaddr = run_cmd(self.network_cmd1)
def __init__(self): """ LCD Constructor """ # Setup LCD self.lcd = Adafruit_CharLCD( rs=12, en=5, d4=6, # Pins are being hardcoded d5=13, d6=19, d7=26, # cols=16, lines=2) # (16x2 LCD) # Clear the LCD self.lcd.clear()
def __init__(self, cols, rows, delay, debug=False): # number of columns on the character LCD (min: 16, max: 20) self.cols = cols # number of rows on the character LCD (min: 1, max: 4) self.rows = rows # duration in seconds to allow human to read LCD lines self.delay = delay # print messages to shell for debugging self.debug = debug if debug == True: print " cols = {0}".format(cols) print " rows = {0}".format(rows) print "delay = {0}".format(delay) self.lcd = Adafruit_CharLCD() self.lcd.begin(cols, rows)
def init(): global lcd global sub pins = rospy.get_param('/pibot/pins/LCD1602') lcd = Adafruit_CharLCD(pin_rs=pins['RS'], pin_e=pins['EN'], pins_db=pins['DATA'], GPIO=None) lcd.begin(16, 2) lcd.clear() lcd.write(' PiBot Loaded \n Hello World! ') lcd.setCursor(0, 0) rospy.init_node('lcd1602') sub = rospy.Subscriber('/pibot/lcd1602', String, handler)
def __init__(self, sortedlist, config): nokia_lcds = [] #get bus pins first hd44780bus = config['local']['buses']['hd44780'] nokiabus = config['local']['buses']['nokia'] hd44780data_pins = [] for i in range(8): thispin = 'LCD_D' + str(i) if thispin in hd44780bus: hd44780data_pins.append(hd44780bus[thispin]) nokia_rst = nokiabus['LCD_RST'] nokia_dc = nokiabus['LCD_DC'] for ctrlid in sortedlist: dispdef = config['local']['controls'][ctrlid]['display'] if dispdef['type'] == 'hd44780': newlcd = Adafruit_CharLCD(pin_rs=hd44780bus['LCD_RS'], pins_db=hd44780data_pins) newlcd.pin_e = dispdef['pin'] GPIO.setup(newlcd.pin_e, GPIO.OUT) GPIO.output(newlcd.pin_e, GPIO.LOW) newlcd.begin(dispdef['width'], dispdef['height']) self.lcd[ctrlid] = newlcd print "Control %s is hd44780 on pin %s" % (ctrlid, newlcd.pin_e) else: if "contrast" in dispdef: contrast = int(dispdef['contrast']) else: contrast = 0xbb newlcd = NokiaLCD(pin_DC=nokia_dc, pin_RST=nokia_rst, pin_SCE=dispdef['pin'], contrast=contrast) newlcd.width = dispdef['width'] newlcd.height = dispdef['height'] newlcd.display_init() self.lcd[ctrlid] = newlcd nokia_lcds.append(newlcd) print "Control %s is nokia on pin %s" % (ctrlid, dispdef['pin']) # Do this now as it does not work in the big loop for some reason. if len(nokia_lcds) > 0: nokia_lcds[0].reset_all_displays() for nokia_lcd in nokia_lcds: nokia_lcd.display_init()
def __init__(self, bus=None, addr=None, **kwargs): """ """ oid = kwargs.pop('oid', 'rpilcdchar.screen') name = kwargs.pop('name', "Screen") product_name = kwargs.pop('product_name', "Screen") product_type = kwargs.pop('product_type', "Screen") JNTComponent.__init__(self, oid=oid, bus=bus, addr=addr, name=name, product_name=product_name, product_type=product_type, **kwargs) logger.debug("[%s] - __init__ node uuid:%s", self.__class__.__name__, self.uuid) uuid = "message" self.values[uuid] = self.value_factory['action_string']( options=self.options, uuid=uuid, node_uuid=self.uuid, help='A message to print on the screen', label='Msg', default='Janitoo started', set_data_cb=self.set_message, is_writeonly=True, cmd_class=COMMAND_MOTOR, genre=0x01, ) poll_value = self.values[uuid].create_poll_value(default=300) self.values[poll_value.uuid] = poll_value self.pin_lcd_rs = 27 # Note this might need to be changed to 21 for older revision Pi's. self.pin_lcd_en = 22 self.pin_lcd_d4 = 25 self.pin_lcd_d5 = 24 self.pin_lcd_d6 = 23 self.pin_lcd_d7 = 18 self.pin_lcd_backlight = 4 self.lcd_columns = 20 self.lcd_rows = 4 self.lcd = Adafruit_CharLCD(self.pin_lcd_rs, self.pin_lcd_en, self.pin_lcd_d4, self.pin_lcd_d5, self.pin_lcd_d6, self.pin_lcd_d7, self.lcd_columns, self.lcd_rows, self.pin_lcd_backlight)
class Logger(): KOBUKI_BASE_MAX_CHARGE = 160 kobuki_previous_battery_level = 1000 lcd = Adafruit_CharLCD(rs=26, en=19, d4=13, d5=6, d6=5, d7=11, cols=16, lines=2) def __init__(self): self.lcd.clear() self.lcd.message("Starting...") rospy.init_node("toktak_logger", anonymous=False) rospy.on_shutdown(self.shutdown) rospy.Subscriber("/mobile_base/sensors/core", SensorState, self.SensorPowerEventCallback) rospy.spin() def SensorPowerEventCallback(self, msg): if (math.fabs(int(msg.battery) - self.kobuki_previous_battery_level) > 2): battery_level = round( float(msg.battery) / float(self.KOBUKI_BASE_MAX_CHARGE) * 100) rospy.loginfo("Kobuki's battery is now: " + str(battery_level) + "%") self.kobuki_previous_battery_level = int(msg.battery) self.display_lcd(battery_level) def display_lcd(self, msg): self.lcd.clear() self.lcd.message("Battery: " + str(msg) + "%") def shutdown(self): self.lcd.clear() self.lcd.message("Stop") rospy.loginfo("Stop")
def __init__(self): ''' Constructor ''' # the next assignment connenct the raspi to the adafruit RSE = 21 ENABLEIO = 20 GPIO1 = 16 GPIO2 = 12 GPIO3 = 7 GPIO4 = 8 self.lcd = Adafruit_CharLCD(rs=RSE, en=ENABLEIO, d4=GPIO1, d5=GPIO2, d6=GPIO3, d7=GPIO4, cols=16, lines=2)
def get_lcd_controller(self, columns, lines): from Adafruit_CharLCD import Adafruit_CharLCD lcd = Adafruit_CharLCD( cols=columns, lines=lines, rs=self._pin_rs, en=self._pin_en, d4=self._pin_d4, d5=self._pin_d5, d6=self._pin_d6, d7=self._pin_d7, backlight=self._pin_backlight, invert_polarity=False, enable_pwm=self._enable_pwm, pwm=self._get_pwm(), ) # Create custom chars, since not all ROMS have the PLAY and # PAUSE chars or other ones the user might need for i, pattern in enumerate(self._custom_char_patterns): lcd.create_char(i, pattern) return lcd
def programa(): # importação de bibliotecas from time import sleep from mplayer import Player from gpiozero import LED from gpiozero import Button from Adafruit_CharLCD import Adafruit_CharLCD # definição de funções #player.loadfile("musica.mp3") #player.loadlist("lista.txt") def TocarEPausar(): player.pause() if (player.paused): led.blink() else: led.on() def ProximaFaixa(): player.pt_step(1) return def FaixaAnterior(): if (player.time_pos > 2.00): player.time_pos = 0.00 return player.pt_step(-1) return # criação de componentes player = Player() player.loadlist("playlist.txt") led = LED(21) lcd = Adafruit_CharLCD(2,3,4,5,6,7,16,2) button1 = Button(11) button2 = Button(12) button3 = Button(13) button1.when_pressed = FaixaAnterior button2.when_pressed = TocarEPausar button3.when_pressed = ProximaFaixa led.on() # loop infinito while True: metadados = player.metadata if metadados != None: nome = player.metadata["Title"] lcd.clear() lcd.message(nome) sleep(0.2)