Simple menu system

[cve2022]

I want to control a micropython based embedded system via the USB/Serial port using a simple text based menu system

The menu itself will have a tree structure where items are selected by typing an ASCII character (typically numeric) with esc or '0' to return to the previous upper level. Each (sub)menu would be described by a list with each item having some "menu item text to show", a callback, maybe some object to be passed to the callback. Most menu items will simply chose an operating mode, but some will require entering numeric values, so some consistency check library would also be needed.

I think these are quite simple requirements but I could not find anything after a quick search. Before I dig deeper in the search or worse, write some code myself, possibly reinventing the wheel, I would like to ask the good fellows in the forum if you know some library or libraries that meet the (IMO) simple requirements above.

Thanks in advance.

[mattytrentini]

PicoTui is an option, though with some caveats. It was originally written for MicroPython and, although the author has since gone off in a different direction, it should still work. It doesn't have a tree widget but perhaps you can work with what is provided - or add such a widget.

Ideally I'd like to have a port of Textual - but that's a large undertaking!

Another option is to create the app using Textual (or whichever library in CPython) and then use Belay to call across to your device when necessary.

[bulletmark]

I'd implement the device side as a simple microdot web service to receive commands + arguments over wifi sent from a remote client written in ordinary Python using cmd or cmd2. That is all very trivial to do and if happy with the result then you could later on re-implement the client side in a web framework like vue.

[cve2022]

Hello, fellows, thanks for your inputs.

Actually I was thinking in a much simpler (I think) solution, old school pure text solution, not even curses(ish). Instead, something of the sorts print (sub)menu list, print "choose and option", react to the option by calling the callback, print the same (sub)menu again, unless the choice was leaving the (sub)menu, in which case the parent (sub)menu would be printed.

PicoTui does look like the closest from what I need though, despite the curses style (but still overkill); I will certainly have a look at it.

BR.

[cve2022]

I have been looking at the suggestions and some more and they look like overkill for what I need. Even picotui.

It turns out the menu control part itself seems to be fairly simple to implement, the core is probably pretty small and the whole structure would be constituted by a set of lists.

The menus would be like these:

Main Menu (type CTRL+X to end program)
  [1] Submenu 1
  [2] Submenu 2
  ...
  [9] Submenu 9

  Please choose your option: _

If '1' is selected:

Submenu 1 - do some stuff
  [1] Some stuff #1
  [2] Some stuff #2
  ...
  [N] Some stuff #N
  [0] Return to previous menu

  Please choose your option: _

If '2' is selected:

Submenu 2 - do some other stuff
  [1] Some stuff #1
  [2] Some stuff #2
  [3] Set temperature
  ...
  [N] Some stuff #N
  [0] Return to previous menu

  Please choose your option: _

If '3' of the above is selected, then the callback would get the numeric value from stdin or the serial port (technically they would the same) and validate it.

Set temperature (range 0-50 C): _____

Now what I am struggling with now is more basic, how to get the options from the terminal in a non-blocking way, i.e., only when the option identifier (an alphanumeric character) is pressed, the menu object callback is called with the option and invokes the option callback with its arguments.

In the case a numeric entry is requested, then a more involved non-blocking input class with edition capabilities (e.g. backspace to correct a typo, ESC to cancel the option, CR(LF) to accept the entry) would be called.

As mentioned in my OP, I am trying to avoid reinventing the wheel if I can, I am sure there must be some builtins or modules that do what I described above but I am not being able to find them (my experience with python and MP is still limited, I may be using the wrong keywords to do my search).

So, any pointers to documents that allow me to read the options and, if possible, off-the-shelf classes that allow me to do the numeric entry would be appreciated.

[2dof]

I woud recomend implement console menu system on your board or some lcd like menu system ( see example https://github.com/sgall17a/encodermenu )
Other way, if your embedde system is typical control system ( on/of , set/read vslues etc ) then maybe a modbus system could be a solution ( slave on your device)

[bixb922]

For non blocking read/write with a UART you might want to take a look at https://github.com/peterhinch/micropython-async/tree/master/v3/as_demos

[cve2022]

@2dof , thank you for the hint on encodermenu, there are things that I can use and the README has many useful information, especially the part on coroutines. FWIW, your first suggestion, before editing (console-menu) was also good and it is in fact the closest to what I need.

@bixb922 , thank you for the hint. I did my homework, doing further research and playing a little with the code below (with rshell and putty - thonny simply does not work).

import sys
from machine import Pin

led=Pin(25, Pin.OUT)
led.on()

# Function to read a character from USB serial or return None.
def kbhit():
    kbch = sys.stdin.read(1)
    return kbch

while True:
    x = kbhit()
    if x:
        led.toggle()
        sys.stdout.write(hex(ord(x))+' ')

I will adapt the UART example to see how it works.

[emcek]

Did you try: https://awesome-micropython.com/#gui