micropython-vibrating-alarm/vibrating_alarm_m5stickc.py

"""
tested on uiflow for stickc v1.8.1
"""

import json

# pylint: disable=import-error
import esp32
import m5ui
import machine
import micropython
import utils
import utime
from m5stack import axp, btnA, btnB, lcd, rtc

_LARGE_FONT = lcd.FONT_DejaVu40
_SMALL_FONT = lcd.FONT_DejaVu18
_DEFAULT_FONT_COLOR = lcd.WHITE
_LEFT_PADDING = 8
_ALARM_TIME_PATH = "alarm.json"
_SCREEN_WIDTH, _SCREEN_HEIGHT = lcd.winsize()
_AWAKE_SECONDS = 8


def _handle_pending_events():
    # > [...] a millisecond sleep larger than 10ms will check for pending (soft)
    # > interrupts during the sleep. [...] The reason for the 10ms value is
    # > because the FreeRTOS tick is 10ms, [...]
    # https://github.com/micropython/micropython/issues/3493#issuecomment-352617624
    # https://github.com/micropython/micropython/commit/4ed586528047d3eced28a9f4af11dbbe64fa99bb
    utime.sleep_ms(11)


def _get_current_daytime() -> int:
    # > [contradictory to] official micropython documentation, to set RTC,
    # > use particular tuple (year , month, day, week=0, hour, minute, second, timestamp=0)
    # https://community.m5stack.com/topic/3108/m5stack-core2-micropython-rtc-example
    hour, minute, seconds = rtc.now()[3:]
    return (hour * 60 + minute) * 60 + seconds


class App:
    # pylint: disable=too-few-public-methods,too-many-instance-attributes
    def __init__(self) -> None:
        self._clock_text_box = None
        self._menu_position = 0
        self._wait_for_sleep_start_time_update = False
        self._sleep_start_time_seconds = 0.0
        self._alarm_hour = None
        self._alarm_minute = None
        self._alarm_hour_text_box = None
        self._alarm_minute_text_box = None
        self._alarm_timer = None
        self._battery_status_text_box = None

    @property
    def _alarm_daytime(self) -> int:
        return (self._alarm_hour * 60 + self._alarm_minute) * 60  # type: ignore

    def _load_alarm_time(self) -> None:
        with open(_ALARM_TIME_PATH, "r") as alarm_time_file:
            alarm_time = json.load(alarm_time_file)
        self._alarm_hour = alarm_time["hour"]
        self._alarm_minute = alarm_time["minute"]

    def _save_alarm_time(self) -> None:
        with open(_ALARM_TIME_PATH, "w") as alarm_time_file:
            json.dump(
                {"hour": self._alarm_hour, "minute": self._alarm_minute},
                alarm_time_file,
            )

    def _reschedule_sleep(self, interrupt: bool) -> None:
        if interrupt:
            self._wait_for_sleep_start_time_update = True
            micropython.schedule(self._reschedule_sleep, False)
        else:
            self._sleep_start_time_seconds = utime.time() + _AWAKE_SECONDS
            self._wait_for_sleep_start_time_update = False

    def _update_menu(self, event_arg: None) -> None:
        # pylint: disable=unused-argument; callback
        self._alarm_hour_text_box.setColor(  # type: ignore
            lcd.GREEN
            if self._menu_position == 1
            else (lcd.RED if self._menu_position == 2 else _DEFAULT_FONT_COLOR)
        )
        self._alarm_minute_text_box.setColor(  # type: ignore
            lcd.GREEN
            if self._menu_position == 3
            else (lcd.RED if self._menu_position == 4 else _DEFAULT_FONT_COLOR)
        )

    def _button_a_pressed(self) -> None:
        self._reschedule_sleep(interrupt=True)
        self._menu_position = (self._menu_position + 1) % 5
        # https://docs.micropython.org/en/latest/library/micropython.html#micropython.schedule
        micropython.schedule(self._update_menu, None)

    @staticmethod
    def _alert() -> None:
        print("ALARM")

    def _alarm(self, timer: machine.Timer) -> None:
        # pylint: disable=unused-argument; callback
        micropython.schedule(lambda n: self._alert(), None)
        micropython.schedule(lambda n: self._configure_alarm_timer(), None)

    def _configure_alarm_timer(self) -> None:
        seconds_until_alarm = (self._alarm_daytime - _get_current_daytime() - 1) % (
            24 * 60 * 60
        ) + 1
        print("alarm in ", seconds_until_alarm / 60, " min")
        # TODO configure wake from sleep
        self._alarm_timer.init(  # type: ignore
            period=seconds_until_alarm * 1000,  # ms
            mode=machine.Timer.ONE_SHOT,
            callback=self._alarm,
        )

    def _update_alarm_time(self, event_arg: None) -> None:
        # pylint: disable=unused-argument; callback
        self._alarm_hour_text_box.setText(  # type: ignore
            "{:02d}".format(self._alarm_hour)  # type: ignore
        )
        self._alarm_minute_text_box.setText(  # type: ignore
            "{:02d}".format(self._alarm_minute)  # type: ignore
        )
        self._save_alarm_time()
        self._configure_alarm_timer()

    def _button_b_pressed(self) -> None:
        self._reschedule_sleep(interrupt=True)
        if self._menu_position == 1:
            self._alarm_hour += 1  # type: ignore
        elif self._menu_position == 2:
            self._alarm_hour -= 1  # type: ignore
        elif self._menu_position == 3:
            self._alarm_minute += 1  # type: ignore
        elif self._menu_position == 4:
            self._alarm_minute -= 1  # type: ignore
        self._alarm_hour %= 24  # type: ignore
        self._alarm_minute %= 60  # type: ignore
        micropython.schedule(self._update_alarm_time, None)

    @staticmethod
    def _format_time() -> str:
        return "{:02d}:{:02d}".format(*rtc.now()[3:5])

    def _setup_clock(self) -> None:
        # https://github.com/m5stack/UIFlow-Code/wiki/M5UI#textbox
        self._clock_text_box = m5ui.M5TextBox(
            _SCREEN_WIDTH - 1,
            _LEFT_PADDING,
            self._format_time(),
            _LARGE_FONT,
            _DEFAULT_FONT_COLOR,
            rotate=90,
        )
        machine.Timer(0).init(
            period=4000,  # ms
            mode=machine.Timer.PERIODIC,
            callback=lambda t: self._clock_text_box.setText(self._format_time()),  # type: ignore
        )

    def _setup_alarm(self) -> None:
        if not utils.exists(_ALARM_TIME_PATH):
            self._alarm_hour = self._alarm_minute = 0  # type: ignore
            self._save_alarm_time()
        else:
            self._load_alarm_time()
        self._alarm_hour_text_box = m5ui.M5TextBox(
            _SCREEN_WIDTH // 2,
            _LEFT_PADDING,
            "{:02d}".format(self._alarm_hour),  # type: ignore
            _LARGE_FONT,
            _DEFAULT_FONT_COLOR,
            rotate=90,
        )
        m5ui.M5TextBox(
            _SCREEN_WIDTH // 2,
            _LEFT_PADDING + 53,
            ":",
            _LARGE_FONT,
            _DEFAULT_FONT_COLOR,
            rotate=90,
        )
        self._alarm_minute_text_box = m5ui.M5TextBox(
            _SCREEN_WIDTH // 2,
            _LEFT_PADDING + 66,
            "{:02d}".format(self._alarm_minute),  # type: ignore
            _LARGE_FONT,
            _DEFAULT_FONT_COLOR,
            rotate=90,
        )
        # machine.Timer(1).init(...) breaks button handling
        self._alarm_timer = machine.Timer(2)
        self._configure_alarm_timer()

    def _update_battery_status_info(self) -> None:
        self._battery_status_text_box.setText(  # type: ignore
            "{:.02f}V".format(axp.getBatVoltage())
        )

    def _setup_battery_status_info(self) -> None:
        self._battery_status_text_box = m5ui.M5TextBox(
            12,
            _SCREEN_HEIGHT - 20,
            "",
            _SMALL_FONT,
            _DEFAULT_FONT_COLOR,
            rotate=0,
        )

    def run(self) -> None:
        m5ui.setScreenColor(0x000000)  # clear screen
        self._setup_clock()
        self._setup_alarm()
        self._setup_battery_status_info()
        btnA.wasPressed(self._button_a_pressed)
        btnB.wasPressed(self._button_b_pressed)
        # not sure whether ext0 would be better
        esp32.wake_on_ext1([btnA.pin], esp32.WAKEUP_ALL_LOW)
        self._reschedule_sleep(interrupt=False)
        while True:
            self._update_battery_status_info()
            while utime.time() < self._sleep_start_time_seconds:
                utime.sleep(1)  # seconds
            # TODO turn off display
            axp.setLcdBrightness(30)
            machine.lightsleep()
            # TODO turn on display
            axp.setLcdBrightness(100)
            print("wake reason:", machine.wake_reason())
            _handle_pending_events()
            while self._wait_for_sleep_start_time_update:
                _handle_pending_events()


App().run()