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
