Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
1192d31a4This file is pinned to the selected release. Download the original to open it in your design tool.
# Copyright 2024 Allen Synthesis
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import europi
import gc
import machine
import sys
import time
from collections import OrderedDict
from europi import oled, OLED_HEIGHT, OLED_WIDTH, CHAR_HEIGHT, CHAR_WIDTH, reset_state
from europi_log import *
from europi_script import EuroPiScript
from ui import Menu
SCRIPT_DIR = "/lib/contrib/"
REG_FILE_CODE = 0x8000
DEBUG = False
class PrintMemoryUse:
def __init__(self, label=""):
self.label = label
def __enter__(self):
gc.collect() # Note that preemptive GC is required to get all of the scripts loaded
if DEBUG:
self.before = gc.mem_free()
def __exit__(self, *args):
if DEBUG:
gc.collect()
after = gc.mem_free()
log_info(
f"free: {after/1024: >6.2f}k, used: {(self.before - after)/1024: >6.2f}k {self.label}",
"bootloader",
)
class BootloaderMenu(EuroPiScript):
"""A Menu which allows the user to select and execute one of the scripts available to this EuroPi. The menu will
include the ``EuroPiScripts`` provided to it in the constructor. Button press handlers are added that allow the user
to exit the script and return to the menu by holding both buttons down for a short period of time. If the module is
restarted while a script is running it will boot right back into that same script.
In the menu:
* **Button 1:** choose the selected item
* **Button 2:** choose the selected item
* **Knob 1:** unused
* **Knob 2:** change the current selection
In a program that was launched from the menu:
* Hold both buttons for at least 0.5s and release to return to the menu.
"""
def __init__(self, scripts):
"""Create the bootloader menu
:param scripts: Dictionary where the keys are the display names of the classes to include in the menu and the
values are the fully-qualified names of the EuroPiScript classes that we launch
"""
self.scripts = scripts
self.run_request = None
@staticmethod
def show_progress(percentage):
oled.hline(0, OLED_HEIGHT - 1, int(OLED_WIDTH * percentage), 1)
oled.show()
@staticmethod
def get_class_for_name(script_class_name) -> type:
try:
module, clazz = script_class_name.rsplit(".", 1)
return getattr(__import__(module, None, None, [None]), clazz)
except Exception as e:
log_warning(
f"Warning: Ignoring bad qualified class name: {script_class_name}\n caused by: {e}",
"bootloader",
)
return None
@classmethod
def _is_europi_script(cls, c):
return issubclass(c, EuroPiScript)
@classmethod
def show_error(cls, title, message, duration=1):
"""Show a brief error message on-screen saying we can't launch the requested script
:param title: The title of the error
:param message: The body of the error message
:param duration: The number of seconds the message should show. If negative the message is shown forever
"""
oled.centre_text(f"--{title}--\n{message}")
if duration > 0:
time.sleep(duration)
def launch(self, selected_item):
"""Callback function for when the user chooses a menu item to launch
Sets run_request to the name of the class to launch. No validation is done here to keep this
callback small
"""
self.run_request = self.scripts[selected_item]
def exit_to_menu(self):
self.remove_state()
# Attempt to save the state of this script if it has been implemented.
self.save_state() # TODO: isn't this the wrong state?
machine.reset() # why doesn't machine.soft_reset() work anymore?
def run_menu(self) -> type:
"""Prompt the user to select a EuroPiScript class from the menu and return it
If the class is not a valid EuroPiScript an error message is shown and selection continues
:return: The type corresponding to self.run_request as set by the self.launch callback
"""
self.menu = Menu(
items=list(sorted(self.scripts.keys())),
select_func=self.launch,
select_knob=europi.k2,
choice_buttons=[europi.b1, europi.b2],
)
# let the user make a selection
# the menu selection returns the desired class name but doesn't validate it
# that validation is handled here
launch_class = None
old_selected = -1
while launch_class is None:
if self.run_request:
launch_class = self.get_class_for_name(self.run_request)
if not self._is_europi_script(launch_class):
self.show_error("Launch Err", "Invalid script class")
launch_class = None
self.run_request = None
else:
if old_selected != self.menu.selected:
old_selected = self.menu.selected
self.menu.draw_menu()
time.sleep(0.1)
return launch_class
def main(self):
saved_state = self.load_state_json()
script_class_name = saved_state.get("last_launched", None)
script_class = None
if script_class_name:
script_class = self.get_class_for_name(script_class_name)
if not script_class:
script_class = self.run_menu()
self.save_state_json(
{"last_launched": f"{script_class.__module__}.{script_class.__name__}"}
)
machine.reset()
else:
# setup the exit handlers, and execute the selection
europi.b1._handler_both(europi.b2, self.exit_to_menu)
europi.b2._handler_both(europi.b1, self.exit_to_menu)
try:
if (
europi.europi_config.MENU_AFTER_POWER_ON
or script_class_name == "calibrate.Calibrate"
):
# Remove the last-launched file to force the module back to the menu after it powers-on next time
self.save_state_json({})
script_class().main()
except Exception as err:
# set all outputs to zero for safety
europi.turn_off_all_cvs()
# in case we have the USB cable connected, print the stack trace for debugging
# otherwise, just halt and show the error message
log_error(f"Failed to run script: {err}", "bootloader")
sys.print_exception(err)
# show the type & first portion of the exception on the OLED
# we can only fit so many characters, so truncate as needed
MAX_CHARS = OLED_WIDTH // CHAR_WIDTH
self.show_error(
"Crash", f"{err.__class__.__name__[0:MAX_CHARS]}\n{str(err)[0:MAX_CHARS]}", -1
)
# Log the crash to a file for later analysis/recovery
try:
with open("last_crash.log", "w") as log_file:
log_file.write(f"{time.ticks_ms()}: {err}\n")
sys.print_exception(err, log_file)
log_error(f"Crash! See last_crash.txt for details: {err}", "bootloader")
except:
# If we fail to create the error log, just silently fail; we don't need
# an additional exception to handle
pass