REPL over SEGGER's RTT

[mateusz-]

Don't know the feasibility of this (not very familiar with RTT), but it would be very useful to support REPL over SEGGER's RTT, for boards that do not have a UART, USB or other means of communication.

[jonnor]

Moving to a discussion. If anyone is interested in implementing this, or knows how it could be done, just comment :)

[andrewleech]

I think this is actually something that could be done fairly easily as a user-c-module. The RTT library it pretty much standalone with a read / write pair of functions. These could be wrapped / exposed as a python class that implements the stream protocol so you can use RTT as a normal python stream. This class could be then instantiated in boot/main.py and registered with dupterm to add it to the repl.

[andrewleech]

On a whim I asked Gemini:

Write a micropython usercmodule that includes and wraps the Segger RTT library and exposes it as a micropython stream protocol

What it gave actually looks really quite good, it might almost work:

#include "py/runtime.h"
#include "py/stream.h"
#include "SEGGER_RTT.h"

#define RTT_CHANNEL 0

STATIC mp_obj_t rtt_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
    (void)self_in; // unused
    size_t written = SEGGER_RTT_Write(RTT_CHANNEL, buf_in, size);
    if (written != size) {
        *errcode = MP_EIO; // Or another appropriate error
        return MP_OBJ_NULL;
    }
    return mp_obj_new_int(written);
}

STATIC mp_obj_t rtt_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
    (void)self_in; // unused
    size_t read = SEGGER_RTT_Read(RTT_CHANNEL, buf_in, size);
    if (read == 0) {
        *errcode = MP_EAGAIN; // Or handle as needed
        return MP_OBJ_NULL;
    }
    return mp_obj_new_int(read);
}

STATIC mp_obj_t rtt_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
    (void)self_in; // unused
    switch (request) {
        case MP_STREAM_POLL: {
            mp_uint_t ret = 0;
            if (SEGGER_RTT_HasData(RTT_CHANNEL)) {
                ret |= MP_STREAM_POLL_RD;
            }
            // Add write poll if needed.
            return mp_obj_new_int(ret);
        }
        default:
            *errcode = MP_EINVAL;
            return MP_OBJ_NULL;
    }
}

STATIC const mp_stream_p_t rtt_stream_p = {
    .flags = MP_STREAM_RW | MP_STREAM_POLL,
    .read = rtt_read,
    .write = rtt_write,
    .ioctl = rtt_ioctl,
};

typedef struct _rtt_obj_t {
    mp_obj_base_t base;
} rtt_obj_t;

STATIC const mp_obj_type_t rtt_type = {
    { &mp_type_type },
    .name = MP_QSTR_RTT,
    .protocol = &rtt_stream_p,
};

STATIC mp_obj_t rtt_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
    mp_arg_check_num(n_args, n_kw, 0, 0, false);
    rtt_obj_t *self = m_new_obj(rtt_obj_t);
    self->base.type = &rtt_type;
    return MP_OBJ_FROM_PTR(self);
}

STATIC const mp_rom_map_elem_t rtt_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_rtt) },
    { MP_ROM_QSTR(MP_QSTR_RTT), MP_ROM_PTR(&rtt_type) },
};

STATIC MP_DEFINE_CONST_DICT(rtt_module_globals, rtt_module_globals_table);

const mp_obj_module_t rtt_module = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t *)&rtt_module_globals,
};

MP_REGISTER_MODULE(MP_QSTR_rtt, rtt_module);

For more info: https://g.co/gemini/share/22c87cdbc161