def __init__(self, hoplite, display): self.display = display self.h = hoplite self.debug = self.h.debug resource_package = __name__ resource_path = '' static_path = pkg_resources.resource_filename(resource_package, resource_path) self.font = ImageFont.truetype('%s/font/OpenSans-Regular.ttf' % static_path, 16) if self.display == None: utils.debug_msg(self, "Display not found, using default of st7735") self.display = 'st7735' try: parser = cmdline.create_parser(description='HOPLITE display args') conf = cmdline.load_config('%s/conf/%s.conf' % (static_path, display)) args = parser.parse_args(conf) except FileNotFoundError: conf = ['--display=%s' % display] args = parser.parse_args(conf) try: self.device = cmdline.create_device(args) except error.Error as e: parser.error(e) self.device = None
def get_device(actual_args=None): """ Create device from command-line arguments and return it. """ if actual_args is None: actual_args = sys.argv[1:] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) args # create device try: args.width = 128 args.height = 128 args.display = 'sh1106' args.rotate = 2 device = cmdline.create_device(args) print(display_settings(device, args)) return device except error.Error as e: parser.error(e) return None
def get_device(self, actual_args=None): """ Create device from command-line arguments and return it. """ if actual_args is None: actual_args = sys.argv[1:] # actual_args = ['--display', 'ssd1306', '--width', '128', # '--height', '64', '--i2c-port', '1', '--i2c-address', '0x3c'] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) print(self.display_settings(args)) # create device # display ssd1306 --width 128 --height 64 --i2c-port 1 --i2c-address 0x3c try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def createDevice(self, type='luma', chip='ssd1331', width='96', height='64', bus='spi', portNo='0', bgcolor="black", reset_pin='25', rotate_screen='2'): self.resolutionX = width self.resolutionY = height self.type = type self.chip = chip self.bus = bus self.portNumber = portNo if type == 'luma': try: args = ('-d' + chip, '--width=' + width, '--height=' + height, '-i' + bus, '--spi-device= ' + portNo, '--gpio-reset=' + reset_pin, '--rotate=' + self.rotate_conversion[rotate_screen]) parser = cmdline.create_parser( description='luma.examples arguments') args1 = parser.parse_args(args) self.device = cmdline.create_device(args1) self.image = ImageDraw.Draw self.background = Image.new("RGBA", self.device.size, "Black") return 0 except error.Error as e: return e
def get_device(self): parser = cmdline.create_parser(description='luma.examples arguments') #config = cmdline.load_config(args.config) config = [] config.append("--display=st7735") config.append("--interface=spi") config.append("--spi-bus-speed=16000000") config.append("--gpio-reset=24") config.append("--gpio-data-command=23") config.append("--gpio-backlight=18") config.append("--width=128") config.append("--height=128") config.append("--bgr") config.append("--h-offset=1") config.append("--v-offset=2") config.append("--backlight-active=high") config.append("--rotate=3") args = parser.parse_args(config) try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def get_device(actual_args=None): """ Create device from command-line arguments and return it. """ if actual_args is None: actual_args = sys.argv[1:] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) print("FOTOMETRIA POR EMISSAO POR CAPTURA DE IMAGENS FIRMWARE VER 1.0.7") print("Analises dos elementos por processamento de imagem") print("Elementos de analises") print("Sodio (Na), Calcio (C), Potassio (K) e Litio (Li)") print("Aguarde, iniciando ......") # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def __init__(self, display, font_size=16): self.display = display resource_package = __name__ resource_path = '' static_path = pkg_resources.resource_filename(resource_package, resource_path) self.font_size = font_size self.font_size_px = int(font_size * 1.33333333) self.font = ImageFont.truetype('%s/font/FreeSans.ttf' % static_path, self.font_size) self.fith_logo = self.load_image('%s/font/FITH_Logo.jpg' % static_path) self.lock = "\ua5c3" try: parser = cmdline.create_parser( description='FITHINATOR display args') conf = cmdline.load_config('%s/conf/%s.conf' % (static_path, display)) args = parser.parse_args(conf) except FileNotFoundError: conf = ['--display=%s' % display] args = parser.parse_args(conf) try: self.device = cmdline.create_device(args) except error.Error as e: parser.error(e) self.device = None self.max_char = int(self.device.width // self.textsize("A")[0])
def test_create_device_oled(): """ :py:func:`luma.core.cmdline.create_device` supports OLED displays. """ display_name = 'oled1234' display_types = {'oled': [display_name]} class args(test_spi_opts): display = display_name module_mock = Mock() module_mock.oled.device.oled1234.return_value = display_name with patch.dict( 'sys.modules', **{ # mock luma.oled package 'luma': module_mock, 'luma.oled': module_mock, 'luma.oled.device': module_mock }): try: device = cmdline.create_device(args, display_types=display_types) assert device == display_name except ImportError: pytest.skip(rpi_gpio_missing) except error.UnsupportedPlatform as e: # non-rpi platform pytest.skip('{0} ({1})'.format(type(e).__name__, str(e)))
def test_create_device_lcd(): """ :py:func:`luma.core.cmdline.create_device` supports LCD displays. """ display_name = 'lcd1234' display_types = {'lcd': [display_name], 'oled': []} class args(test_spi_opts): display = display_name gpio = 'fake_gpio' backlight_active = 'low' module_mock = Mock() module_mock.lcd.device.lcd1234.return_value = display_name with patch.dict( 'sys.modules', **{ # mock spidev and luma.lcd packages 'fake_gpio': module_mock, 'spidev': module_mock, 'luma': module_mock, 'luma.lcd': module_mock, 'luma.lcd.aux': module_mock, 'luma.lcd.device': module_mock }): device = cmdline.create_device(args, display_types=display_types) assert device == display_name
def parse_args(): actual_args = sys.argv[1:] parser = cmdline.create_parser(description="Display text on display.") parser.add_argument("--text", type=str, default="Text on the screen!", help="Text to display on screen.") args = parser.parse_args() if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) print(args) print(display_settings(args)) print('-' * 60) try: args.device = cmdline.create_device(args) except error.Error as e: parser.error(e) return args
def test_create_device_emulator(): """ :py:func:`luma.core.cmdline.create_device` supports emulators. """ display_name = 'emulator1234' display_types = { 'emulator': [display_name], 'led_matrix': [], 'lcd': [], 'oled': [] } class args(test_spi_opts): display = display_name module_mock = Mock() module_mock.emulator.device.emulator1234.return_value = display_name with patch.dict( 'sys.modules', **{ # mock spidev and luma.emulator packages 'spidev': module_mock, 'luma': module_mock, 'luma.emulator': module_mock, 'luma.emulator.device': module_mock }): device = cmdline.create_device(args, display_types=display_types) assert device == display_name
def test_create_device(): """ :py:func:`luma.core.cmdline.create_device` returns ``None`` for unknown displays. """ class args: display = 'foo' assert cmdline.create_device(args) is None
def load_device(self): self.close() parser = cmdline.create_parser(description='default') args = parser.parse_args([]) try: self.device = cmdline.create_device(args) except error.Error as e: print('ERROR: ', parser.error(e))
def test_create_device_oled(): """ :py:func:`luma.core.cmdline.create_device` supports OLED displays. """ display_name = 'oled1234' display_types = {'oled': [display_name]} class args(test_spi_opts): display = display_name module_mock = Mock() with patch.dict( 'sys.modules', **{ 'luma': module_mock, 'luma.oled': module_mock, 'luma.oled.device': module_mock }): with pytest.raises(error.UnsupportedPlatform): cmdline.create_device(args, display_types=display_types)
def get_device(): """ Create device from command-line arguments and return it. """ args = dispSettings() try: device = cmdline.create_device(args) except error.Error as e: print(e) return device
def __init__(self, config): self.mode = None self.uis = {} self.cur_ui = None parser = cmdline.create_parser('') device_args = parser.parse_args(config['lcd_config'].split(' ')) try: lcd = cmdline.create_device(device_args) except error.Error as e: parser.error(e) for ui_type, ui_cls in self.__ui_types.iteritems(): self.uis[ui_type] = ui_cls(lcd, device_args, config)
def get_device(): """ Create device from command-line arguments and return it. """ parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args("") args.display = Driver print(display_settings(args)) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def get_device(): parser = cmdline.create_parser(description='smartchime.luma') lumaConfig = [] for key, value in config['luma'].items(): lumaConfig.append(f"--{key}={value}") args = parser.parse_args(lumaConfig) # create device try: device = cmdline.create_device(args) return device except error.Error as e: parser.error(e) return None
def get_device(actual_args=None): """ Create device from command-line arguments and return it. """ logging.debug("Entering the get_device routine for checking for a display") global device_type device_type = "NEO" # we start assuming a NEO global port port = 0 #we start assuming a NEO globals.screen_enable[3] = 0 #assuming neo we only have one battery parser = cmdline.create_parser(description='luma.examples arguments') with open("/proc/cpuinfo", encoding='utf8') as f: filx = f.read() if ("Raspberry" in filx): if ("Compute Module" in filx): port = 10 device_type = "CM" globals.screen_enable[3] = 1 #we assume multi-battery else: #all other Raspberry Pi version other than compute modules port = 1 device_type = "PI" else: globals.screen_enable[ 3] = 0 #Just make sure that we have only one battery for NEO f.close() # for NEO we use i2c-port 0. For Pi's other than compute modules we use i2c-port 1 or 10 for CM logging.info("get device has determined were on i2c port# " + str(port)) args = parser.parse_args(['--i2c-port', str(port)]) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) # create device # logging.info("now we will try to connect to the display "+str(args)) try: device = cmdline.create_device(args) except error.Error as e: logging.info('no display device found') device = None return device
def get_device(deviceName): from luma.core import cmdline, error """ Create device from command-line arguments and return it. """ actual_args = ['-d', deviceName] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def get_device(actual_args=None): actual_args = ['-d', 'sh1106', '-i', 'spi', '--width', '128', '--height', '64'] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) #print(display_settings(args)) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def __init__(self, title, menuItems, selected): self.titleFont = ImageFont.truetype("FreeSans.ttf", 14) self.unselectedFont = ImageFont.truetype("Piboto-Regular.ttf", 10) self.selectedFont = ImageFont.truetype("FreeSansBold.ttf", 20) self.title = title self.menuItems = menuItems self.selected = selected # Config config = Config() displayDef = config.get("display.config", MenuDisplay.defaultDisplayConfig) config.save() # create device parser = cmdline.create_parser(description='luma arguments') displayArgs = parser.parse_args(displayDef) try: self.device = cmdline.create_device(displayArgs) except error.Error as e: parser.error(e)
def get_device(): # create parser parser = cmdline.create_parser(description='luma.examples arguments') # create arguments actual_args = [ '-d', 'pygame', '-i', 'spi', '--width', '128', '--height', '128' ] # parse arguments args = parser.parse_args(actual_args) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def get_device(): """ Create device from command-line arguments and return it. """ config = load_config(EYES_LCD_CONFIG_FILE) parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(config) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) print(display_settings(args)) return device
def test_create_device_core(): """ :py:func:`luma.core.cmdline.create_device` supports code devices. """ display_name = 'coredevice1234' display_types = {'core': [display_name]} class args(test_spi_opts): display = display_name module_mock = Mock() module_mock.core.device.coredevice1234.return_value = display_name with patch.dict('sys.modules', **{ # mock luma.core package 'luma': module_mock, 'luma.core': module_mock, 'luma.core.device': module_mock }): device = cmdline.create_device(args, display_types=display_types) assert device == display_name
def get_device(actual_args=None): """ Create device from command-line arguments and return it. """ actual_args = ['--interface', 'spi', '--d', 'ssd1306'] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def main() -> None: logging.basicConfig(level=logging.INFO, format="%(message)s") logging.getLogger("PIL").setLevel(logging.ERROR) parser = cmdline.create_parser( description="Display FQDN and IP on the OLED") parser.add_argument("--font", default="/usr/share/fonts/TTF/ProggySquare.ttf", help="Font path") parser.add_argument("--font-size", default=16, type=int, help="Font size") parser.add_argument("--interval", default=5, type=int, help="Screens interval") options = parser.parse_args(sys.argv[1:]) if options.config: config = cmdline.load_config(options.config) options = parser.parse_args(config + sys.argv[1:]) device = cmdline.create_device(options) font = ImageFont.truetype(options.font, options.font_size) display_types = cmdline.get_display_types() if options.display not in cmdline.get_display_types()["emulator"]: _logger.info("Iface: %s", options.interface) _logger.info("Display: %s", options.display) _logger.info("Size: %dx%d", device.width, device.height) try: summary = True while True: with canvas(device) as draw: if summary: text = f"{socket.getfqdn()}\nUp: {_get_uptime()}" else: text = f"Iface: %s\n%s" % (_get_ip()) draw.multiline_text((0, 0), text, font=font, fill="white") summary = (not summary) time.sleep(options.interval) except (SystemExit, KeyboardInterrupt): pass
def test_create_device_led_matrix(): """ :py:func:`luma.core.cmdline.create_device` supports LED matrix displays. """ display_name = 'matrix1234' display_types = {'led_matrix': [display_name], 'lcd': [], 'oled': []} class args(test_spi_opts): display = display_name module_mock = Mock() module_mock.led_matrix.device.matrix1234.return_value = display_name with patch.dict( 'sys.modules', **{ 'spidev': module_mock, 'luma': module_mock, 'luma.led_matrix': module_mock, 'luma.led_matrix.device': module_mock }): device = cmdline.create_device(args, display_types=display_types) assert device == display_name
def getDevice(self, actual_args=None): """ Create device from command-line arguments and return it. """ if actual_args is None: actual_args = sys.argv[1:] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device
def get_device(actual_args=None): if actual_args is None: actual_args = sys.argv[1:] parser = cmdline.create_parser(description='luma.examples arguments') args = parser.parse_args(actual_args) if args.config: # load config from file config = cmdline.load_config(args.config) args = parser.parse_args(config + actual_args) print(display_settings(args)) # create device try: device = cmdline.create_device(args) except error.Error as e: parser.error(e) return device