Runtime.c

// This file is part of the CircuitPython project: https://circuitpython.org
//
// SPDX-FileCopyrightText: Copyright (c) 2018 Michael Schroeder
//
// SPDX-License-Identifier: MIT

#include <stdbool.h>
#include "py/obj.h"
#include "py/enum.h"
#include "py/runtime.h"
#include "py/objproperty.h"

#include "shared-bindings/supervisor/RunReason.h"
#include "shared-bindings/supervisor/Runtime.h"
#include "shared-bindings/supervisor/SafeModeReason.h"

#include "supervisor/shared/reload.h"
#include "supervisor/shared/serial.h"
#include "supervisor/shared/stack.h"
#include "supervisor/shared/status_leds.h"
#include "supervisor/shared/bluetooth/bluetooth.h"

#if CIRCUITPY_DISPLAYIO
#include "shared-bindings/displayio/__init__.h"
#endif

#if CIRCUITPY_TINYUSB
#include "tusb.h"
#endif

static supervisor_run_reason_t _run_reason;

// TODO: add REPL to description once it is operational

//| class Runtime:
//|     """Current status of runtime objects.
//|
//|     Usage::
//|
//|        import supervisor
//|        if supervisor.runtime.serial_connected:
//|            print("Hello World!")"""
//|

//|     def __init__(self) -> None:
//|         """You cannot create an instance of `supervisor.Runtime`.
//|         Use `supervisor.runtime` to access the sole instance available."""
//|         ...
//|

//|     usb_connected: bool
//|     """Returns the USB enumeration status (read-only)."""
static mp_obj_t supervisor_runtime_get_usb_connected(mp_obj_t self) {
    #if CIRCUITPY_USB_DEVICE
    return mp_obj_new_bool(tud_ready());
    #else
    return mp_const_false;
    #endif
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_usb_connected_obj, supervisor_runtime_get_usb_connected);

MP_PROPERTY_GETTER(supervisor_runtime_usb_connected_obj,
    (mp_obj_t)&supervisor_runtime_get_usb_connected_obj);

//|     serial_connected: bool
//|     """Returns the USB serial communication status (read-only)."""
static mp_obj_t supervisor_runtime_get_serial_connected(mp_obj_t self) {
    return mp_obj_new_bool(serial_connected());
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_serial_connected_obj, supervisor_runtime_get_serial_connected);

MP_PROPERTY_GETTER(supervisor_runtime_serial_connected_obj,
    (mp_obj_t)&supervisor_runtime_get_serial_connected_obj);

//|     serial_bytes_available: int
//|     """Returns the number of bytes are available to read on the console serial input.
//|     Multiple console serial inputs may be in use at once, including
//|     USB, web workflow, BLE workflow, and/or UART.
//|
//|     Allows for polling to see whether to call the built-in input() or wait. (read-only)
//|
//|     **Limitations**: On STM, UART (not USB) console input can only determine that at least one character
//|     is available, and so if only the UART console is in use, only ``1`` or ``0`` will be returned.
//|
//|     Changed in version 9.1.0: Previously returned only ``True`` or ``False``.
//|     Since ``0`` acts as ``False``, ``if supervisor.runtime.serial_byes_available:``
//|     will still work.
//|     """
static mp_obj_t supervisor_runtime_get_serial_bytes_available(mp_obj_t self) {
    return MP_OBJ_NEW_SMALL_INT(serial_bytes_available());
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_serial_bytes_available_obj, supervisor_runtime_get_serial_bytes_available);

MP_PROPERTY_GETTER(supervisor_runtime_serial_bytes_available_obj,
    (mp_obj_t)&supervisor_runtime_get_serial_bytes_available_obj);

supervisor_run_reason_t supervisor_get_run_reason(void) {
    return _run_reason;
}

void supervisor_set_run_reason(supervisor_run_reason_t run_reason) {
    _run_reason = run_reason;
}

//|     run_reason: RunReason
//|     """Why CircuitPython started running this particular time (read-only)."""
static mp_obj_t supervisor_runtime_get_run_reason(mp_obj_t self) {
    return cp_enum_find(&supervisor_run_reason_type, _run_reason);
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_run_reason_obj, supervisor_runtime_get_run_reason);

MP_PROPERTY_GETTER(supervisor_runtime_run_reason_obj,
    (mp_obj_t)&supervisor_runtime_get_run_reason_obj);

//|     safe_mode_reason: SafeModeReason
//|     """Why CircuitPython went into safe mode this particular time (read-only).
//|
//|     **Limitations**: Raises ``NotImplementedError`` on builds that do not implement ``safemode.py``.
//|     """
static mp_obj_t supervisor_runtime_get_safe_mode_reason(mp_obj_t self) {
    #if CIRCUITPY_SAFEMODE_PY
    return cp_enum_find(&supervisor_safe_mode_reason_type, get_safe_mode());
    #else
    mp_raise_NotImplementedError(NULL);
    #endif
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_safe_mode_reason_obj, supervisor_runtime_get_safe_mode_reason);

MP_PROPERTY_GETTER(supervisor_runtime_safe_mode_reason_obj,
    (mp_obj_t)&supervisor_runtime_get_safe_mode_reason_obj);

//|     autoreload: bool
//|     """Whether CircuitPython may autoreload based on workflow writes to the filesystem."""
//|
static mp_obj_t supervisor_runtime_get_autoreload(mp_obj_t self) {
    return mp_obj_new_bool(autoreload_is_enabled());
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_autoreload_obj, supervisor_runtime_get_autoreload);

static mp_obj_t supervisor_runtime_set_autoreload(mp_obj_t self, mp_obj_t state_in) {
    if (mp_obj_is_true(state_in)) {
        autoreload_enable();
    } else {
        autoreload_disable();
    }
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(supervisor_runtime_set_autoreload_obj, supervisor_runtime_set_autoreload);

MP_PROPERTY_GETSET(supervisor_runtime_autoreload_obj,
    (mp_obj_t)&supervisor_runtime_get_autoreload_obj,
    (mp_obj_t)&supervisor_runtime_set_autoreload_obj);

//|     ble_workflow: bool
//|     """Enable/Disable ble workflow until a reset. This prevents BLE advertising outside of the VM and
//|     the services used for it."""
//|
static mp_obj_t supervisor_runtime_get_ble_workflow(mp_obj_t self) {
    #if CIRCUITPY_BLE_FILE_SERVICE && CIRCUITPY_SERIAL_BLE
    return mp_obj_new_bool(supervisor_bluetooth_workflow_is_enabled());
    #else
    return mp_const_false;
    #endif
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_ble_workflow_obj, supervisor_runtime_get_ble_workflow);

static mp_obj_t supervisor_runtime_set_ble_workflow(mp_obj_t self, mp_obj_t state_in) {
    #if CIRCUITPY_BLE_FILE_SERVICE && CIRCUITPY_SERIAL_BLE
    if (mp_obj_is_true(state_in)) {
        supervisor_bluetooth_enable_workflow();
    } else {
        supervisor_bluetooth_disable_workflow();
    }
    #else
    mp_raise_NotImplementedError(NULL);
    #endif
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(supervisor_runtime_set_ble_workflow_obj, supervisor_runtime_set_ble_workflow);

MP_PROPERTY_GETSET(supervisor_runtime_ble_workflow_obj,
    (mp_obj_t)&supervisor_runtime_get_ble_workflow_obj,
    (mp_obj_t)&supervisor_runtime_set_ble_workflow_obj);

//|     rgb_status_brightness: int
//|     """Set brightness of status RGB LED from 0-255. This will take effect
//|     after the current code finishes and the status LED is used to show
//|     the finish state."""
//|
static mp_obj_t supervisor_runtime_get_rgb_status_brightness(mp_obj_t self) {
    return MP_OBJ_NEW_SMALL_INT(get_status_brightness());
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_rgb_status_brightness_obj, supervisor_runtime_get_rgb_status_brightness);

static mp_obj_t supervisor_runtime_set_rgb_status_brightness(mp_obj_t self, mp_obj_t lvl) {
    #if CIRCUITPY_STATUS_LED
    // This must be int. If cast to uint8_t first, will never raise a ValueError.
    set_status_brightness((uint8_t)mp_arg_validate_int_range(mp_obj_get_int(lvl), 0, 255, MP_QSTR_brightness));
    #else
    mp_raise_NotImplementedError(NULL);
    #endif
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(supervisor_runtime_set_rgb_status_brightness_obj, supervisor_runtime_set_rgb_status_brightness);

MP_PROPERTY_GETSET(supervisor_runtime_rgb_status_brightness_obj,
    (mp_obj_t)&supervisor_runtime_get_rgb_status_brightness_obj,
    (mp_obj_t)&supervisor_runtime_set_rgb_status_brightness_obj);

#if CIRCUITPY_DISPLAYIO
//|     display: displayio.AnyDisplay | None
//|     """The primary configured displayio display, if any.
//|
//|     If the board has a display that is hard coded, or that was explicitly set
//|     in boot.py or code.py (including a previous run of code.py), it is
//|     available here until it is released with ``displayio.release_displays()``.
//|
//|     The display can be of any supported display type, such as `busdisplay.BusDisplay`.
//|
//|     If no display is configured, this property is `None`.
//|
//|     In a future release of CircuitPython, any display that is not the primary display
//|     will be automatically released at the end of running a code file.
//|
//|     On boards without displayio, this property is present but the value is always `None`."""
//|
//|
static mp_obj_t supervisor_runtime_get_display(mp_obj_t self) {
    return common_hal_displayio_get_primary_display();
}
MP_DEFINE_CONST_FUN_OBJ_1(supervisor_runtime_get_display_obj, supervisor_runtime_get_display);
static mp_obj_t supervisor_runtime_set_display(mp_obj_t self, mp_obj_t new_primary_display) {
    common_hal_displayio_set_primary_display(new_primary_display);
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(supervisor_runtime_set_display_obj, supervisor_runtime_set_display);

MP_PROPERTY_GETSET(supervisor_runtime_display_obj,
    (mp_obj_t)&supervisor_runtime_get_display_obj,
    (mp_obj_t)&supervisor_runtime_set_display_obj);
#endif

static const mp_rom_map_elem_t supervisor_runtime_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_usb_connected), MP_ROM_PTR(&supervisor_runtime_usb_connected_obj) },
    { MP_ROM_QSTR(MP_QSTR_serial_connected), MP_ROM_PTR(&supervisor_runtime_serial_connected_obj) },
    { MP_ROM_QSTR(MP_QSTR_serial_bytes_available), MP_ROM_PTR(&supervisor_runtime_serial_bytes_available_obj) },
    { MP_ROM_QSTR(MP_QSTR_run_reason), MP_ROM_PTR(&supervisor_runtime_run_reason_obj) },
    { MP_ROM_QSTR(MP_QSTR_safe_mode_reason), MP_ROM_PTR(&supervisor_runtime_safe_mode_reason_obj) },
    { MP_ROM_QSTR(MP_QSTR_autoreload), MP_ROM_PTR(&supervisor_runtime_autoreload_obj) },
    { MP_ROM_QSTR(MP_QSTR_ble_workflow),  MP_ROM_PTR(&supervisor_runtime_ble_workflow_obj) },
    { MP_ROM_QSTR(MP_QSTR_rgb_status_brightness),  MP_ROM_PTR(&supervisor_runtime_rgb_status_brightness_obj) },
    #if CIRCUITPY_DISPLAYIO
    { MP_ROM_QSTR(MP_QSTR_display),  MP_ROM_PTR(&supervisor_runtime_display_obj) },
    #else
    { MP_ROM_QSTR(MP_QSTR_display),  MP_ROM_NONE },
    #endif
};

static MP_DEFINE_CONST_DICT(supervisor_runtime_locals_dict, supervisor_runtime_locals_dict_table);

MP_DEFINE_CONST_OBJ_TYPE(
    supervisor_runtime_type,
    MP_QSTR_Runtime,
    MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS,
    locals_dict, &supervisor_runtime_locals_dict
    );