class HudServer(multiprocessing.Process):
def __init__(self, queue):
multiprocessing.Process.__init__(self)
self.queue = queue
self.assets_path = pathlib.Path(__file__).parent.absolute().as_posix()
def run(self):
self.button = Button("D0")
self.led = LED("D1")
self.miniscreen = Miniscreen()
self.button.when_pressed = self.stop_blink
while True:
message = self.queue.get()
if message is None:
print('HUD Exiting')
self.queue.task_done()
break
else:
print('HUD Got message ', message)
func = getattr(self, message)
func()
self.queue.task_done()
return
def welcome(self):
print("HUD welcome")
self.miniscreen.display_image_file(self.assets_path + "/welcome.gif")
def start_blink(self):
print("HUD blink")
self.led.blink()
self.miniscreen.display_multiline_text(
"Blinking... Press button to stop", font_size=12)
os.system("aplay " + self.assets_path + "/bell.wav")
def stop_blink(self):
print("HUD stop")
self.led.off()
os.system("espeak \"Excellent. I just turned off the led.\"")
self.welcome()
def goodbye(self):
print("HUD goodbye")
os.system("espeak \"Goodbye!\"")
def run(self):
self.button = Button("D0")
self.led = LED("D1")
self.miniscreen = Miniscreen()
self.button.when_pressed = self.stop_blink
while True:
message = self.queue.get()
if message is None:
print('HUD Exiting')
self.queue.task_done()
break
else:
print('HUD Got message ', message)
func = getattr(self, message)
func()
self.queue.task_done()
return
import io
import serial
from pitop.miniscreen import Miniscreen
from PIL import Image, ImageDraw, ImageFont
# Serial setup
serialConf = serial.Serial('/dev/ttyAMA0', 9600, timeout=0.3)
serialio = io.TextIOWrapper(io.BufferedRWPair(serialConf, serialConf))
# Enable only NMEA sentences required
serialConf.write(b'$PMTK314,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1*34\r\n')
# pi-top[4] Miniscreen setup
ms = Miniscreen()
image = Image.new(
ms.mode,
ms.size,
)
canvas = ImageDraw.Draw(image)
ms.set_max_fps(1)
# NMEA sentences required
nmea_list = ['$GPGGA', '$GPGSA', '$GPRMC', '$GPZDA']
def speedCalc(data, u):
#converts speed to user required units
if u == 1:
return f'{round((float(data) * 1.150779448),1)} MPH'
elif u == 2:
return f'{round((float(data) * 1.852),1)} KM/H'
if not is_root():
print("Admin access required - please run this script with 'sudo'.")
exit()
# Define Giphy parameters
SEARCH_LIMIT = 10
SEARCH_TERM = "Monochrome"
CONFIG_FILE_PATH = "/etc/pt-miniscreen/settings.ini"
STARTUP_GIF_PATH = "/home/pi/miniscreen-startup.gif"
API_KEY = "<MY GIPHY KEY>"
# Define global variables
gif = None
miniscreen = Miniscreen()
req = PreparedRequest()
req.prepare_url(
"http://api.giphy.com/v1/gifs/search",
urlencode({
"q": SEARCH_TERM,
"api_key": API_KEY,
"limit": f"{SEARCH_LIMIT}"
}),
)
def display_instructions_dialog():
miniscreen.select_button.when_pressed = play_random_gif
miniscreen.cancel_button.when_pressed = None
miniscreen.display_multiline_text("Press SELECT to load a random GIF!",
def __init__(self):
from pitop.miniscreen import Miniscreen
self._miniscreen = None
if device_type() == DeviceName.pi_top_4.value:
self._miniscreen = Miniscreen()
def run(self) -> int:
def path_to_stored_file(arg_path):
file_path = ""
if isfile(arg_path):
file_path = arg_path
elif isdir(arg_path):
file_path = join(arg_path, f"output_{strftime('%Y-%m-%d-%H-%M-%S')}")
else:
raise Exception(f"Invalid path: {arg_path}")
return file_path
try:
from pitop.miniscreen import Miniscreen
if self.args.oled_subcommand == "display":
oled = Miniscreen()
if self.args.force:
oled.set_control_to_pi()
try:
print("Press Ctrl + C to exit.")
skip_timeout = False
if isfile(self.args.text) or is_url(self.args.text):
oled.play_animated_image_file(self.args.text)
else:
oled.display_multiline_text(
self.args.text, font_size=self.args.font_size
)
if not skip_timeout:
sleep(self.args.timeout)
except KeyboardInterrupt:
pass
elif self.args.oled_subcommand == "spi":
oled = Miniscreen()
if self.args.spi_bus is not None:
oled.spi_bus = self.args.spi_bus
else:
print(oled.spi_bus)
elif self.args.oled_subcommand == "capture":
if self.args.capture_subcommand == "save":
file_path = path_to_stored_file(self.args.path)
extension = "PNG"
print(f"Saving capture to {file_path}.{extension}")
oled.image.save(f"{file_path}.{extension}")
elif self.args.capture_subcommand == "start":
file_path = path_to_stored_file(self.args.path)
extension = "MP4"
print(f"Saving video capture to {file_path}.{extension}")
# TODO: configure video capture from OLED
elif self.args.capture_subcommand == "stop":
print("Stopping video capture")
# TODO: configure video capture from OLED
return 0
except Exception as e:
print(f"Error on pitop-oled.run: {e}")
return 1
import queue, threading, io, serial, pynmea2
from time import sleep
import logging
from pitop.miniscreen import Miniscreen
from PIL import Image, ImageDraw, ImageFont
gpsSerial = serial.Serial('/dev/ttyS0', 9600, timeout=1.)
gpsIO = io.TextIOWrapper(io.BufferedRWPair(gpsSerial, gpsSerial))
gpsSerial.write(b'$PMTK314,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1*34\r\n')
ms = Miniscreen()
image = Image.new(
ms.mode,
ms.size,
)
canvas = ImageDraw.Draw(image)
ms.set_max_fps(60)
nmea_list = ['GGA', 'GSA', 'RMC', 'ZDA']
nmea_dict = {
'latitude': "",
'longitude': "",
'speed': "",
'date_time': "",
'satelites': 0,
'altitude': "",
'fix': True,
'fix_type': ""
}
q = queue.Queue()
def setUp(self):
from pitop.miniscreen import Miniscreen
self.miniscreen = Miniscreen()
class OLEDTestCase(TestCase):
@classmethod
def setUpClass(cls):
environ["SDL_VIDEODRIVER"] = "dummy"
@classmethod
def tearDownClass(cls):
del environ["SDL_VIDEODRIVER"]
def setUp(self):
from pitop.miniscreen import Miniscreen
self.miniscreen = Miniscreen()
def tearDown(self):
pass
def get_bitmap_pix(self, file_path):
bmp = Image.open(file_path).convert("1")
bmp = bmp.point(lambda x: 0 if x == 0 else 1, "1")
return self.miniscreen.core.canvas._pil_image_to_pix_arr(bmp)
def compare_arrays(self, func_name, canvas_pix, bmp_pix):
print("CANVAS:")
print(canvas_pix)
print("BITMAP:")
print(bmp_pix)
self.assertEqual(canvas_pix.all(), bmp_pix.all())
def test_image(self):
logo_path = root + "/assets/images/pi-top.png"
img = Image.open(logo_path)
canvas_pix = self.miniscreen.core.canvas.image(
self.miniscreen.core.canvas.top_left(), img)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/pi-top.bmp")
self.compare_arrays("image", canvas_pix, bmp_pix)
def test_rectangle(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.rectangle(
self.miniscreen.bounding_box)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/rectangle.bmp")
self.compare_arrays("rectangle", canvas_pix, bmp_pix)
def test_arc(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.arc(
self.miniscreen.bounding_box, 0, 180)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/arc.bmp")
self.compare_arrays("arc", canvas_pix, bmp_pix)
def test_chord(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.chord(
self.miniscreen.bounding_box, 0, 180)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/chord.bmp")
self.compare_arrays("chord", canvas_pix, bmp_pix)
def test_ellipse(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.ellipse(
self.miniscreen.bounding_box)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/ellipse.bmp")
self.compare_arrays("ellipse", canvas_pix, bmp_pix)
def test_line(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.line(
self.miniscreen.bounding_box)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/line.bmp")
self.compare_arrays("line", canvas_pix, bmp_pix)
def test_pieslice(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.pieslice(
self.miniscreen.bounding_box, 0, 180)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/pieslice.bmp")
self.compare_arrays("pieslice", canvas_pix, bmp_pix)
def test_point(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.point(
self.miniscreen.bounding_box)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/point.bmp")
self.compare_arrays("point", canvas_pix, bmp_pix)
def test_polygon(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.polygon(
self.miniscreen.bounding_box)
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/polygon.bmp")
self.compare_arrays("polygon", canvas_pix, bmp_pix)
def test_text(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.text(
self.miniscreen.core.canvas.top_left(), "test")
bmp_pix = self.get_bitmap_pix(root + "/assets/bitmaps/text.bmp")
self.compare_arrays("text", canvas_pix, bmp_pix)
def test_multiline_text(self):
self.miniscreen.reset()
canvas_pix = self.miniscreen.core.canvas.multiline_text(
self.miniscreen.core.canvas.top_left(), "Hello World!")
bmp_pix = self.get_bitmap_pix(root +
"/assets/bitmaps/multiline_text.bmp")
self.compare_arrays("multiline_text", canvas_pix, bmp_pix)
def test_max_fps(self):
max_fps = 50
self.miniscreen.reset()
self.miniscreen.fps_regulator.set_max_fps(max_fps)
max_sleep_time = self.miniscreen.fps_regulator.max_sleep_time
self.assertEqual(max_sleep_time, 1 / max_fps)
#!/usr/bin/env python3
from pitop.display import Display
from pitop.miniscreen import Miniscreen
from time import sleep
display = Display()
display.blank()
miniscreen = Miniscreen()
miniscreen.display_multiline_text("Hello, world!", font_size=20)
sleep(1)