# This Program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation; either
# version 3 of the License, or (at your option) any later version.
import os
import ugfx
import glut
white = ugfx.color(255, 255, 255)
black = ugfx.color(0, 0, 0)
use_glut = 'DISPLAY' in os.environ
if use_glut:
screen = glut.screen()
else:
screen = ugfx.screen("/dev/fb0")
c, d = black, white
x, w = 0, 400
while w >= 100:
screen.box(x, x, x+w, x+w, c)
x += 2
w -= 4
c, d = d, c
screen.invert(100, 100, 200, 200)
import font
font.draw(screen, (0, 0), "Hello!", 80, False)
def main():
print 'init...'
screen = None
for arg in sys.argv:
if 'nokia5110' in arg:
sys.argv.remove(arg)
print 'using nokia5110'
screen = ugfx.nokia5110screen()
if not screen:
if use_glut:
screen = glut.screen((120, 210))
#screen = glut.screen((64, 128))
#screen = glut.screen((48, 84))
else:
screen = ugfx.screen("/dev/fb0")
if screen.width == 416 and screen.height == 656:
# no actual device or display
print 'no actual screen, running headless'
screen = None
if screen.width > 480:
screen.width = 480
screen.height= min(screen.height, 640)
lcdclient = LCDClient(screen)
if screen:
# magnify to fill screen
mag = min(screen.width / lcdclient.surface.width, screen.height / lcdclient.surface.height)
if mag != 1:
print "magnifying lcd surface to fit screen"
magsurface = ugfx.surface(screen)
invsurface = ugfx.surface(lcdclient.surface)
def idle():
if screen:
lcdclient.display()
surface = lcdclient.surface
if lcdclient.config['invert']:
invsurface.blit(surface, 0, 0)
surface = invsurface
surface.invert(0, 0, surface.width, surface.height)
if mag != 1:
magsurface.magnify(surface, mag)
surface = magsurface
# mag = 2
#surface.magnify(mag)
screen.blit(surface, 0, 0, lcdclient.config['flip'])
screen.refresh()
if 'contrast' in lcdclient.config:
screen.contrast = int(lcdclient.config['contrast'])
lcdclient.idle()
if use_glut:
from OpenGL.GLUT import glutMainLoop
from OpenGL.GLUT import glutIdleFunc
from OpenGL.GLUT import glutKeyboardFunc
from OpenGL.GLUT import glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc
from OpenGL.GLUT import glutSpecialUpFunc
glutKeyboardFunc(lcdclient.glutkeydown)
glutKeyboardUpFunc(lcdclient.glutkeyup)
glutSpecialFunc(lcdclient.glutspecialdown)
glutSpecialUpFunc(lcdclient.glutspecialup)
glutIdleFunc(idle)
# glutIgnoreKeyRepeat(True)
glutMainLoop()
else:
while True:
idle()
def __init__(self, config):
if config:
self.config = config['lcd']
else:
self.config = {}
self.pipe = False
self.poller = False
self.voltage = False
default = {
'contrast': 60,
'invert': False,
'backlight': 20,
'hue': 214,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1,
'buzzer': 2
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
global driver
# set the driver to the one read from hat eeprom, or specified in hat.conf
if config and 'hat' in config:
if driver == 'default':
driver = config['hat']['lcd']['driver']
self.host = config['host']
else:
self.host = False
self.battery_voltage = 0
use_tft = True if micropython else False
self.keypress = False
use_glut = not use_tft and 'DISPLAY' in os.environ
self.surface = None
self.use_glut = False
print('lcd driver', driver, use_tft, use_glut)
if driver == 'none':
page = None
screen = None
self.bw = None
elif driver == 'tft' or (driver == 'default' and use_tft):
import gc
if gc.mem_free() > 1e6: # larger ttgo display
screen = ugfx.surface(240, 320, 1)
else:
screen = ugfx.surface(136, 240, 1)
self.surface = screen
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
# emulate which screen resolution?
#screen = glut.screen((240, 320))
screen = glut.screen((136, 240))
#screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
self.glutkeytime = False
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
print('warning huge width')
#screen.width = 480
#screen.height= min(screen.height, 640)
if screen:
self.bw = 1 if screen.width < 120 else False
self.mag = 1
if not self.surface:
w, h = screen.width, screen.height
self.surface = ugfx.surface(w, h, screen.bypp, None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
else:
self.surface = None
self.screen = screen
set_language(self.config['language'])
self.client = False
self.connect()
self.menu = False
self.page = connecting(self)
self.need_refresh = True
self.keypad = []
for i in range(NUM_KEYS):
self.keypad.append(Key())
self.blink = black, white # two cursor states
self.data_update = False
def __init__(self, hat):
self.hat = hat
if hat:
self.config = hat.config['lcd']
elif micropython:
from config_esp32 import read_config
self.config = read_config()
else:
self.config = {}
default = {
'contrast': 60,
'invert': False,
'backlight': 20,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
# set the driver to the one from hat eeprom
driver = 'default'
if self.hat and 'hat' in self.hat.config:
driver = self.hat.config['hat']['lcd']['driver']
self.host = self.hat.client.config['host']
else:
self.host = False
for pdriver in [
'nokia5110', 'jlx12864', 'glut', 'framebuffer', 'tft', 'none'
]:
if pdriver in sys.argv:
print('overriding driver', driver, ' to command line', pdriver)
sys.argv.remove(pdriver)
driver = pdriver
break
self.battery_voltage = 0
use_tft = True if micropython else False
if not use_tft:
use_glut = 'DISPLAY' in os.environ
self.use_glut = False
self.surface = None
if driver == 'none':
page = None
elif driver == 'tft' or (driver == 'default' and use_tft):
screen = ugfx.surface(136, 240, 1)
self.surface = screen
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
# emulate which screen resolution?
#screen = glut.screen((240, 320))
screen = glut.screen((136, 240))
#screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
self.glutkeytime = False
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
print('warning huge width')
#screen.width = 480
#screen.height= min(screen.height, 640)
if screen:
self.bw = 1 if screen.width < 120 else False
self.mag = 1
if not self.surface:
w, h = screen.width, screen.height
self.surface = ugfx.surface(w, h, screen.bypp, None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
else:
self.surface = None
self.lastframetime = 0
self.screen = screen
set_language(self.config['language'])
self.client = False
self.connect()
self.menu = False
self.page = connecting(self)
self.need_refresh = True
self.keypad = []
for i in range(NUM_KEYS):
self.keypad.append(Key())
self.blink = black, white # two cursor states
self.data_update = False
def __init__(self, hat):
self.hat = hat
self.config = hat.config['lcd']
default = {
'contrast': 60,
'invert': False,
'backlight': 200,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1,
'remote': False
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
# set the driver to the one from hat eeprom
driver = 'default'
if self.hat.hatconfig:
driver = self.hat.hatconfig['lcd']['driver']
for pdriver in [
'nokia5110', 'jlx12864', 'glut', 'framebuffer', 'none'
]:
if pdriver in sys.argv:
sys.argv.remove(pdriver)
driver = pdriver
break
print('Using driver', driver)
use_glut = 'DISPLAY' in os.environ
self.use_glut = False
if driver == 'none':
screen = None
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
#screen = glut.screen((120, 210))
#screen = glut.screen((64, 128))
screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
screen.width = 480
screen.height = min(screen.height, 640)
if screen:
w, h = screen.width, screen.height
mul = int(math.ceil(w / 48.0))
self.bw = 1 if w < 256 else False
width = min(w, 48 * mul)
self.surface = ugfx.surface(width, int(width * h / w), screen.bypp,
None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
self.frameperiod = .25 # 4 frames a second possible
self.lastframetime = 0
else:
self.surface = None
self.frameperiod = 1
self.screen = screen
self.set_language(self.config['language'])
self.range_edit = False
self.modes = {
'compass': self.have_compass,
'gps': self.have_gps,
'wind': self.have_wind,
'true wind': self.have_true_wind
}
self.modes_list = ['compass', 'gps', 'wind', 'true wind'] # in order
self.watchlist = [
'ap.enabled', 'ap.mode', 'ap.pilot', 'ap.heading_command',
'gps.source', 'wind.source', 'servo.controller', 'servo.flags',
'imu.compass.calibration', 'imu.compass.calibration.sigmapoints',
'imu.compass.calibration.locked', 'imu.alignmentQ',
'rudder.calibration_state'
]
self.initial_gets = [
'servo.speed.min', 'servo.speed.max', 'servo.max_current',
'servo.period', 'imu.alignmentCounter'
]
self.create_mainmenu()
self.display_page = self.display_control
self.connecting_dots = 0
self.keypad = [False, False, False, False, False, False, False, False]
self.keypadup = list(self.keypad)
self.blink = black, white
self.control = False # used to keep track of what is drawn on screen to avoid redrawing it
self.wifi = False
