def __init__(self): cols = 16 rows = 2 i2c = busio.I2C(board.SCL, board.SDA) self.lcd = char_lcd.Character_LCD_RGB_I2C(i2c, cols, rows) self.lcd.color = [100, 0, 0] self.lcd.message = 'Moin!'
def init_lcd_display(): cols = 16 rows = 2 i2c = busio.I2C(board.SCL, board.SDA) lcd = char_lcd.Character_LCD_RGB_I2C(i2c, cols, rows) lcd.clear() return lcd
def getIPAddress(): global lcd, i2c, lcd_columns, lcd_rows #This will set up a socket and using this, we can most reliably determine our IP address. s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('10.255.255.255', 1)) i2c = busio.I2C(board.SCL, board.SDA) lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) return s.getsockname()[0]
def __init__(self): lcd_columns = 16 lcd_rows = 2 i2c = busio.I2C(board.SCL, board.SDA) self._lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) # load custom chars num = 0 for data in custom_chars: self._lcd.create_char(num, list(data)) num += 1
def __init__(self, resolution=[1280, 720], framerate=27, isoMode="", address=0x04, lcdDimensions=[16, 2]): # Defining Communication Variables self.address = address self.lcmDimensions = lcdDimensions self.camera = PiCamera(resolution=resolution, framerate=framerate) self.resolution = resolution #TODO: Need to move these params to the init function so that they can be customized self.sensor_dimensions = [3.76, 2.74] self.distortion = np.load('camera_distortion.npy') self.intrinsic_params = np.load('camera_intrinsic.npy') self.focal_lengths = [ self.intrinsic_params[0][0] * self.sensor_dimensions[0] / resolution[0], self.intrinsic_params[1][1] * self.sensor_dimensions[1] / resolution[1] ] #Configure camera iso and exposure for consistent quality if isoMode == "dark": self.camera.iso = 1200 elif isoMode == "bright": self.camera.iso = 200 else: #print("Unrecognized iso mode. Setting iso to 700.") self.camera.iso = 700 self.camera.shutter_speed = self.camera.exposure_speed self.camera.exposure_mode = 'off' time.sleep(2) #Preconfigure the camera AWB setting to static values gains = self.camera.awb_gains self.camera.awb_mode = 'off' self.camera.awb_gains = gains time.sleep(0.1) #Configure i2c Settings self.bus = smbus.SMBus(1) #Set SDA and SCL to the connection on the I2c self.i2c = busio.I2C(board.SCL, board.SDA) # Initialise the LCD object self.lcd = character_lcd.Character_LCD_RGB_I2C(self.i2c, lcdDimensions[0], lcdDimensions[1]) self.turnOnLCD()
def __init__(self): lcd_columns = 16 lcd_rows = 2 i2c = busio.I2C(board.SCL, board.SDA) self.lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) self.lcd.clear() self.lcd.color = [100, 0, 0] self.departures: List[Tuple[str, List[Departure]]] = [] self.current_station = 0 self.request_update = False
def initializeLCD(): # Modify this if you have a different sized Character LCD lcd_columns = 16 lcd_rows = 2 # Initialise I2C bus. i2c = busio.I2C(board.SCL, board.SDA) # Initialise the LCD class lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) # Turn on LCD backlight lcd.color = [100, 0, 0] return i2c, lcd
def _init_lcd(self, lcd_columns, lcd_rows): try: if self._lcd_type is None: raise Exception("No LCD define") i2c = busio.I2C(board.SCL, board.SDA) if self._lcd_type == "sainsmart_charlcd_led": self._lcd = character_lcd_rgb_i2c.Character_LCD_RGB_I2C( i2c, lcd_columns, lcd_rows) self._lcd._mcp.iodira = set_bit(self._lcd._mcp.iodira, 5, 0) # Turn on backlight self._lcd._mcp.gpioa = set_bit(self._lcd._mcp.gpioa, 5, 0) elif self._lcd_type == "adafruit_charlcd_mono": self._lcd = character_lcd_i2c.Character_LCD_I2C( i2c, lcd_columns, lcd_rows) elif self._lcd_type == "adafruit_charlcd_rgb": self._lcd = character_lcd_rgb_i2c.Character_LCD_RGB_I2C( i2c, lcd_columns, lcd_rows) except: self._logger.debug(sys.exc_info())
def init_lcd(): ''' Params: lcd_columns - number of culumns the LCD Screen has (int) lcd_rows - number of rwos the LCD Screen has (int) i2c - calling i2c program lcd - setting lcd screen Returns: lcd ''' lcd_columns = 16 lcd_rows = 2 i2c = busio.I2C(board.SCL, board.SDA) lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) return lcd
def configure_communication(): """Configures i2c devices and bus for communication with LCD and Arduino""" lcd_columns = 16 lcd_rows = 2 # Initialise I2C bus. bus = smbus.SMBus(1) #Set SDA and SCL to the connection on the I2c i2c = busio.I2C(board.SCL, board.SDA) # Initialise the LCD class lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) lcd.clear() #Sets background colour of the LCD lcd.color = [100, 0, 0] time.sleep(1) return bus, i2c, lcd
def initialize_display(lcd_lock, wake_up): i2c = busio.I2C(board.SCL, board.SDA) # Initialize I2C bus lcd_columns = 16 # Set LCD dimensions lcd_rows = 2 global lcd lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) # Initialize lcd module object lcd.text_direction = lcd.LEFT_TO_RIGHT # Set text direction lcd.clear() # Clear LCD screen lcd.color = [100, 0, 0] # Set LCD color and turn backlight on # Initialize and start the listener thread and the timer for turning the display off. screen_timer = threading.Timer(20.0, lcd_power, args=[lcd_lock]) listener_thread = threading.Thread(target=has_button_been_pressed, args=[lcd_lock, screen_timer, wake_up]) listener_thread.daemon = True # Set daemon flag so that this thread terminates after the main one does. screen_timer.start() listener_thread.start()
def __init__(self, menuItems, aspectRatio): # initialize menu parameters self.aspectRatio = aspectRatio # display dimensions self.lcd_columns = aspectRatio[0] # columns self.lcd_rows = aspectRatio[1] # rows self.absPointer = 0 # absolute pointer to item in list self.relPointer = 0 # pointer relative to start of bracket self.bracketPos = 0 # start of bracket self.menuItems = menuItems # list of menu items passed on init self.menuSize = len(self.menuItems) # number of menu items # Initialise I2C bus. self.i2c = busio.I2C(board.SCL, board.SDA) # Initialise the LCD class self.lcd = character_lcd.Character_LCD_RGB_I2C(self.i2c, self.lcd_columns, self.lcd_rows) # start menu self.runMenu()
"""Simple test for I2C RGB character LCD shield kit""" import time import board import busio import adafruit_character_lcd.character_lcd_rgb_i2c as character_lcd import smbus # Modify this if you have a different sized Character LCD lcd_columns = 16 lcd_rows = 2 # Initialise I2C bus. i2c = busio.I2C(board.SCL, board.SDA) # Initialise the LCD class lcd = character_lcd.Character_LCD_RGB_I2C(i2c, lcd_columns, lcd_rows) # for RPI version 1, use “bus = smbus.SMBus(0)” bus = smbus.SMBus(1) # This is the address we setup in the Arduino Program address = 0x04 def writeNumber(value): bus.write_byte(address, value) # bus.write_byte_data(address, 0, value) return -1 def readNumber():
import os import time import board import busio import adafruit_character_lcd.character_lcd_rgb_i2c as character_lcd from threading import Barrier import radio import phatbeat import subprocess import socket import threading i2c = busio.I2C(board.SCL, board.SDA) lcd = character_lcd.Character_LCD_RGB_I2C(i2c, 16, 2) global radio radio = radio.Radio(lcd) radio.play() os.system("ping -c 1 google.com") time.sleep(5) def lcd_buttonthread(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) while True: if lcd.select_button: try: s.connect(('10.255.255.255', 1))
import socket import fcntl import struct import os import board import busio import time import adafruit_character_lcd.character_lcd_rgb_i2c as lcd cols = 16 rows = 2 i2c = busio.I2C(board.SCL, board.SDA) lcd = lcd.Character_LCD_RGB_I2C(i2c, cols, rows) lcd.message = "Loading ..." def get_ip(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) return socket.inet_ntoa( fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s', ifname[:15]))[20:24]) while True: try: print(get_ip(b'wlan0')) lcd.color = [50, 50, 100] lcd.message = get_ip(b'wlan0') except: lcd.color = [100, 0, 0]
def I2C_Handler(input_pipe, size, address, color=[255, 0, 0]): #Initialize I2C objects i2c_bus = busio.I2C(board.SCL, board.SDA) lcd = character_lcd.Character_LCD_RGB_I2C(i2c_bus, size[1], size[0]) lcd.clear() #Initialize SMbus object sm_bus = SMBus(1) #Initialize variables I2C_FPS = 100 #Frame rate control for thread to conserve resources I2C_Start = 0 data = [0, 0] data_in = ctypes.c_int8 #Initialize LCD screen lcd.clear() lcd.color = color lcd.message = "Init LCD Handler Done" while (True): #Record time I2C_Start = time.time() #Data shape: #[cmd, content] #Non-blocking read of pipe waiting for input if (input_pipe.poll()): data = input_pipe.recv() #Switch on command portion of data to figure out what to do if (data[0] == I2C_CMD.LCD_CLR_MSG ): #Clear LCD and send it a string to display try: #time.sleep(0.1) lcd.clear() lcd.message = str(data[1]) pass except: print("SM Bus Error!") elif (data[0] == I2C_CMD.WRITE_ARDU): #Write to the arduino try: print(data[1]) sm_bus.write_byte_data(address, 0, int(data[1])) except: print("SM Bus Error!") sm_bus = SMBus(1) elif (data[0] == I2C_CMD.FETCH_ANGLE ): #Fetch the angle from the arduino #print(sm_bus.read_byte_data(address, 0)) try: #Need to preserve the sign to make this sensible, use ctypes for that data_in = ctypes.c_int8(sm_bus.read_byte_data(address, 0)) #Convert data in from byte to degree angle data_in = data_in.value / 128 * 180 #Send angle down pipe input_pipe.send(data_in) except: print("SM Bus Error!") #Clear data data[0] = 0 #print("Sleep Time: " + str(max(1/I2C_FPS - (time.time() - I2C_Start),0))) #Frame lock the thread to preserve resources time.sleep(max(1 / I2C_FPS - (time.time() - I2C_Start), 0))
def __init__(self, rows: int, columns: int, rs_pin: DigitalInOut, en_pin: DigitalInOut, d7_pin: DigitalInOut, d6_pin: DigitalInOut, d5_pin: DigitalInOut, d4_pin: DigitalInOut, colour_lcd: bool, i2c_enabled: bool, red_pin: PWMOut = None, green_pin: PWMOut = None, blue_pin: PWMOut = None, backlight_pin: DigitalInOut = None, button_controller: ButtonController = None): """ Create a Display object to simplify LCD operations. The pins need to be specified as following: digitalio.DigitalInOut( board.<PIN> ) For colours: pulseio.PWMOut( board.<PIN> ) If it's a colour LCD, the pins for RED, GREEN and BLUE must be specified. backlight_pin can remain None. If it's a mono LCD, the backlight pin has to be specified. :param rows: Amount of rows on the LCD. :param columns: Amount of columns on the LCD. :param rs_pin: Location where the RS pin is connected on the board. :param en_pin: Location where the EN pin is connected on the board. :param d7_pin: Location where the D7 pin is connected on the board. :param d6_pin: Location where the D6 pin is connected on the board. :param d5_pin: Location where the D5 pin is connected on the board. :param d4_pin: Location where the D4 pin is connected on the board. :param colour_lcd: Whether it's a colour display or not. :param i2c_enabled: Whether the screen has buttons or not. :param red_pin: Location where the RED pin is connected on the board. :param blue_pin: Location where the BLUE pin is connected on the board. :param green_pin: Location where the GREEN pin is connected on the board. :param backlight_pin: Location where the backlight pin is connected on the board. :param button_controller: A Button Controller class. """ # Set a global variable for checking if it's a colour LCD or not. # Then set the colour tuple for a blue screen. self.is_colour_lcd = colour_lcd self.is_i2c = i2c_enabled self.colour = None self.set_colour(0, 0, 100) # Set a global variable with the dimensions self.dimensions = (columns, rows) if self.is_i2c: if self.is_colour_lcd: self.lcd = i2crgb.Character_LCD_RGB_I2C( button_controller.i2c, columns, rows) else: self.lcd = i2cmono.Character_LCD_I2C(button_controller.i2c, columns, rows) else: # Initialise the LCD screen (type depending on the type of screen). if self.is_colour_lcd: self.lcd = charlcd.Character_LCD_RGB(rs_pin, en_pin, d4_pin, d5_pin, d6_pin, d7_pin, columns, rows, red_pin, blue_pin, green_pin) else: self.lcd = charlcd.Character_LCD_Mono(rs_pin, en_pin, d4_pin, d5_pin, d6_pin, d7_pin, columns, rows, backlight_pin)