Added lcdMenu as a submodule

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/lcdMenu"]
+	path = lib/lcdMenu
+	url = https://git.privacynerd.de/BlueFox/lcdMenu.git

README.md

@@ -5,7 +5,7 @@ A collection of programs run on a Raspberry Pi Pico to control a uv exposure uni
 
 ## Hardware
 
-This program is strongly customized to my needs, and my DIY exposure unit has **two buttons** and **one switch** to interact with the software (and a power switch FWIW). Also, a **16*2 display** (maybe 20*4 or others do also work, but these are not tested) can show information to the user.
+This program is strongly customized to my needs, and my DIY exposure unit has **two buttons** and **one switch** to interact with the software (and a power switch FWIW). Also, a **16x2 display** (maybe 20x4 or others do also work, but these are not tested) can show information to the user.
 A **relais** is used for switching all the LEDs.
 
 | Device Pin         | Pi Pico Pin |
@@ -30,19 +30,45 @@ To install this, use [Thonny](https://thonny.org/), open all the files present i
 
 ## Configuration
 
-All the configuration can be done in the [config.py](config.py) file, just have a look around there. Some hints for editing this file:
+All the configuration can be done in the [config.json](config.json) file in JSON format just have a look around there. Some hints for editing this file:
 
-- When editing the startup section strings, make sure the "STARTUP_PROJECT_NAME" and the "STARTUP_MESSAGE_FINISHED" values have the same length as your display can show (likely 16 characters). Otherwise it could be that some things won't be displayed correctly.
+- For a description of all of the attributes, see below
+
+- When editing the startup section strings, make sure the "STARTUP\_PROJECT\_NAME" and the "STARTUP\_MESSAGE\_FINISHED" values have the same length as your display can show (likely 16 characters). Otherwise it could be that some things won't be displayed correctly.
 
 - When changing Pins in the Pinout section, make sure to follow the pinout assignment of your Pi Pico board (e.g. the i2c sda and scl pins)
 
 - If your display doesn't work properly - the first issue might be a wrong i2c address. To find the address of your display, just follow some of the tutorials on the internet on scanning for i2c devices (e.g. [here](https://randomnerdtutorials.com/raspberry-pi-pico-i2c-scanner-micropython/)).
 
 
+### Attribute table
+
+| Attribute name (on top level in config.json) | Type | Description | Default |
+| -------------------------------------------- | ---- | ----------- | ------- |
+| "LOG\_LEVEL"                                 | int  | defines up to which log level to show log messages in the serial console: warn (0), info (1), debug (2) | 2 |
+| "STARTUP\_WELCOME\_SHOW"                     | bool | show the startup screen? | true | 
+| "STARTUP\_PROJECT\_NAME"                     | str  | the name shown at the welcome/startup screen | "  UV-Belichter  " |
+| "STARTUP\_MESSAGE\_STARTING                  | str  | the message shown at startup when starting | "Starting..." |
+| "STARTUP\_PROJECT\_FINISHED"                 | str  | the message shown at startup when finished | "    Started!    " |
+| "STARTUP\_WELCOME\_CYCLES"                   | int  | how often the starting string shall go over the welcome screen | 1 |
+| "PIN\_IN\_BTN\_1"                            | dict | the dict must contain the "pin" and "pull" keys with respective values | {"pin": 15, "pull": "down"} |
+| "PIN\_IN\_BTN\_2"                            | dict | as above | {"pin": 14, "pull": "down"} |
+| "PIN\_IN\_SWITCH"                            | dict | as above | {"pin": 13, "pull": "down"} |
+| "PIN\_OUT\_RELAIS"                           | int  | pin number where the relais is connected | 21 |
+| "PIN\_SDA"                                   | int  | the pin number of the sda wire connected to the lcd | 8 |
+| "PIN\_SCL"                                   | int  | the pin number of the scl wire connected to the lcd | 9 |
+| "LCD\_I2C\_CH"                               | int  | the channel of the i2c bus used | 0 |
+| "LCD\_I2C\_ADDR"                             | int  | the i2c address of the lcd; make sure to convert hexadecimal to decimal numbers | 38 |
+| "LCD\_I2C\_NUM\_ROWS"                        | int  | how many rows for character display has the display? | 2 |
+| "LCD\_I2C\_NUM\_COLS"                        | int  | and how many characters can it display per row? | 16 |
+
+Note that this software has it's own small wrapper for the config file, e.g. to have instant access to an LCD object generated on the fly. These are all documented in the [utils.py](utils.py) file!
+
 ## Used libraries
 
-- PCF8574T - a driver for the i2c multiplexer used to address the 2x16 lcd display
+- [PCF8574T](https://git.privacynerd.de/BlueFox/micropython-libraries/src/branch/main/PCF8574T) - a driver for the i2c multiplexer used to address the 2x16 lcd display
-- [ProgramChooserAdapted](https://git.privacynerd.de/BlueFox/ProgramChooser) - an adapted version of ProgramChooser (but I'm planning to merge my changes to the upstream Programchooser)
+- [WelcomeScreen](https://git.privacynerd.de/BlueFox/WelcomeScreen) - used to display a small welcome message in the beginning
+- [lcdMenu](https://git.privacynerd.de/BlueFox/lcdMenu) - used for the menus
 
 
 ## License

config.json

@@ -0,0 +1,18 @@
+{
+"LOG_LEVEL": 2,
+"STARTUP_WELCOME_SHOW": true, 
+"STARTUP_PROJECT_NAME":"  UV-Belichter  ", 
+"STARTUP_MESSAGE_STARTING": "Starting...",
+"STARTUP_MESSAGE_FINISHED": "    Started!    ",
+"STARTUP_WELCOME_CYCLES": 1,
+"PIN_IN_BTN_1": {"pin": 15, "pull": "down"},
+"PIN_IN_BTN_2": {"pin": 14, "pull": "down"},
+"PIN_IN_SWITCH": {"pin": 13, "pull": "down"},
+"PIN_OUT_RELAIS": 21,
+"PIN_SDA": 8,
+"PIN_SCL": 9,
+"LCD_I2C_CH": 0,
+"LCD_I2C_ADDR": 39,
+"LCD_I2C_NUM_ROWS": 2,
+"LCD_I2C_NUM_COLS": 16,
+}

config.py

@@ -1,65 +0,0 @@
-"""
-uv-belichter-software - Configuration file
-Copyright (C) 2024  Benjamin Burkhardt
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
-"""
-
-
-"""
----------------------------
------ LOGGING SECTION -----
----------------------------
-"""
-LOG_LEVEL = 2  # there are three log levels: warn (0), info (1), debug (2)
-               # this value defines which log messages to show
-               # e.g. 2 means show [debug], [warn] and [info] messages
-
-"""
----------------------------
------ STARTUP SECTION -----
----------------------------
-"""
-STARTUP_PROJECT_NAME = "  UV-Belichter  "          # the name to show at startup
-STARTUP_MESSAGE_STARTING = "Starting..."       # the message to show at startup
-STARTUP_MESSAGE_FINISHED = "    Started!    "  # the message to show at startup
-STARTUP_WELCOME_SHOW = True                    # show the name and a startup message
-STARTUP_WELCOME_CYCLES = 1                     # how often shall "Starting..." run over the screen
-
-
-"""
---------------------------
------ PINOUT SECTION -----
---------------------------
-"""
-from machine import Pin
-
-BTN_1 = Pin(15, Pin.IN, Pin.PULL_DOWN)        # input of the first btn
-BTN_2 = Pin(14, Pin.IN, Pin.PULL_DOWN)        # input of the second btn
-SWITCH = Pin(13, Pin.IN, Pin.PULL_DOWN)       # input of switch
-LCD_SDA = Pin(8)                              # just some standard I2C serial data (SDA) outputs (on I2C channel 0 on Pi Pico)
-LCD_SCL = Pin(9)                              # just some standard I2C serial clock (SCL) outputs (on I2C channel 0 on Pi Pico)
-#LCD_SDA = Pin(16)                            # another pinout (soldered on the original project's circuit board)
-#LCD_SCL = Pin(17)                            # another pinout (soldered on the original project's circuit board)
-RELAIS = Pin(21, Pin.OUT)                     # where the relais is connected (for the UV lights)
-
-
-"""
------------------------
------ LCD SECTION -----
------------------------
-"""
-from machine import I2C, Pin
-from lib.PCF8574T import I2C_LCD
-
-LCD_I2C_ADDR     = 0x27  # the i2c adress of the display (yours might be different to this one)
-LCD_I2C_NUM_ROWS = 2     # how many rows for character display has the display?
-LCD_I2C_NUM_COLS = 16    # and how many characters can it display per row?
-LCD = I2C_LCD(I2C(0, sda=LCD_SDA, scl=LCD_SCL, freq=400000),
-              LCD_I2C_ADDR,
-              LCD_I2C_NUM_ROWS,
-              LCD_I2C_NUM_COLS)

input_tests.py

@@ -9,11 +9,25 @@ This program is distributed in the hope that it will be useful, but WITHOUT ANY
 You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-
+from utils import Config
-import config as cfg
 from time import sleep
 
+cfg = Config()
+
+def run(endless_loop: bool = True, serial_output: bool = True):
+    while endless_loop:
+        if cfg.PIN_IN_BTN_1.value() and cfg.PIN_IN_BTN_2.value() and cfg.PIN_IN_SWITCH.value():
+            cfg.LCD.move_to(0,0)
+            cfg.LCD.putstr("In: Y1 | G1 | S1    Exiting!    ")
+            if serial_output:
+                print("All configured inputs pressed! Exiting...")
+            sleep(0.2)
+            break
+        cfg.LCD.move_to(0,0)
+        cfg.LCD.putstr(f"In: Y{cfg.PIN_IN_BTN_1.value()} | G{cfg.PIN_IN_BTN_2.value()} | S{cfg.PIN_IN_SWITCH.value()}Push all to exit")
+        if serial_output:
+            print(f"Y_BTN: {cfg.PIN_IN_BTN_1.value()}; G_BTN: {cfg.PIN_IN_BTN_2.value()}; Lever: {cfg.PIN_IN_SWITCH.value()}")
+        sleep(0.05)
+
 if __name__ == "__main__":
-    while True:
+    run()  # run the program
-        print(f"Y_BTN: {cfg.BTN_1.value()}; G_BTN: {cfg.BTN_2.value()}; Lever: {cfg.SWITCH.value()}")
-        sleep(0.1)

lcd_big_hello.py

@@ -1,5 +1,5 @@
 """
-An example "program" which can be used with the ProgramChooser library, see also main.py
+An example "program" which can be used with the lcdMenu library, see also main.py
 Copyright (C) 2024  Benjamin Burkhardt <bluefox@privacynerd.de>
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

lib/ProgramChooserAdapted.py

@@ -1,93 +0,0 @@
-"""
-ProgramChooser - a program launcher for microPython (adapted to the UV Belichter needs)
-Copyright (C) 2024  Benjamin Burkhardt <bluefox@privacynerd.de>
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
-"""
-
-
-import utils, config
-from PCF8574T import I2C_LCD
-import time
-
-class ProgramChooser:
-    def __init__(self, programs, debug=False, run_directly=False):
-        self.lcd = config.LCD
-        self.ok_btn = config.BTN_1
-        self.next_btn = config.BTN_2
-        
-        self.lcd.move_to(0,0)
-        self.lcd.putstr("[   PROGRAMS   ]<              >")
-        
-        self.current_selection = None  # no selection
-        self.programs = programs  # a dictionary of programs and it's callbacks e.g. {"lora_test": some_callback}
-        
-        self.show_selection()
-        
-        if run_directly: self.run()
-        
-    def log(self, msg, is_debug=False):
-        if is_debug:
-            utils.log(2, f"[ProgramChooser] {msg}")
-        else:
-            utils.log(1, f"[ProgramChooser] {msg}")
-    
-    
-    def show_selection(self):
-        self.lcd.move_to(1,1)
-        
-        if len(self.programs) == 0:
-            self.lcd.putstr(" No programs!")
-            return True
-        if self.current_selection == None:  # set it initially
-            self.current_selection = 0
-        
-        # the actual displaying process
-        to_show = list(self.programs.keys())[self.current_selection]
-        if len(to_show) > 14:
-            to_show = to_show[:13] + chr(0)
-        else:
-            to_show = to_show[:14]
-        to_show = to_show.center(14)
-        self.lcd.putstr(to_show)
-        return True
-    
-    
-    def run(self):
-        while True:
-            if self.next_btn.value() == 1:
-                former_program_name = list(self.programs.keys())[self.current_selection]
-                self.current_selection = (self.current_selection+1)%len(list(self.programs.keys()))
-                self.show_selection()
-                now_program_name = list(self.programs.keys())[self.current_selection]
-                self.log(f"Selected next program (\"{former_program_name}\" -> \"{now_program_name}\")")
-                while self.next_btn.value() == 1: time.sleep(0.01)  # wait till release
-            if self.ok_btn.value() == 1:
-                program_name = list(self.programs.keys())[self.current_selection]
-                self.log(f"Running selected program! (\"{program_name}\")")
-                # shorten the name for displaying (if too long)
-                if len(program_name) > 14:
-                    program_name = program_name[:13] + chr(0)
-                else:
-                    program_name = program_name[:14]
-                program_name = program_name.center(14)
-                self.lcd.move_to(0,0)
-                self.lcd.putstr(f" {program_name}   Executing...  ")
-                self.execute_selection()
-                while self.ok_btn.value() == 1: time.sleep(0.01)  # wait till release (e.g. if the "program" is a simple send action)
-                self.lcd.putstr(f" {program_name}    Closing...   ")
-                time.sleep(1)
-                self.lcd.move_to(0,0)
-                self.lcd.putstr("[   PROGRAMS   ]<              >")
-                self.show_selection()
-                
-            time.sleep(0.01)
-    
-    
-    def execute_selection(self):  # execute the current selected program's callback
-        self.programs[list(self.programs.keys())[self.current_selection]]()
-

lib/WelcomeScreen/__init__.py

@@ -0,0 +1,126 @@
+"""
+WelcomeScreen: A simple library providing a customizable welcome screen fading over an LCD 
+Copyright (C) 2024  Benjamin Burkhardt
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from time import sleep
+
+
+class WelcomeScreen:
+    # __init__() - the constructor
+    # lcd: an object of I2C_LCD (from the PCF8574T library - https://git.privacynerd.de/BlueFox/micropython-libraries/src/branch/main/PCF8574T)
+    # ---
+    # interrupt_pins: a list containing machine.Pin objects exclusively (but if you give these you can still turn interrupting off
+    # via a parameter in the show method (see below!)
+    # ---
+    # subtitle: the text shown below the cycling text (e.g. the device's name, ...) (Lorem ipsum. by default)
+    # ---
+    # starting_msg: the text shown while cycling (default: Starting...)
+    # ---
+    # started_msg: the text shown while cycling (default: Started!)
+    def __init__(self, lcd, interrupt_pins=None, subtitle="Lorem ipsum.", starting_msg="Starting...", started_msg="Started!"):
+        self.lcd = lcd
+        self.columns = self.lcd.num_columns
+        self.lines = self.lcd.num_lines
+        
+        self.interrupt_pins = interrupt_pins
+        
+        self.subtitle = subtitle
+        self.starting_msg = starting_msg
+        self.started_msg = started_msg
+
+
+    # show() - Display the actual message
+    # ---
+    # cycles says how often the Starting text goes through
+    # ---
+    # wait_after_cycles is a number in seconds (can be float) defining how long to wait before returning OR
+    # if fading out is activated, the time to wait between end of the cycling animation and the fade out animation
+    # ---
+    # fade_down is a dict with following keys:
+    # - "enabled"      - REQUIRED - wether fading is enabled (default: true)
+    # - "wait_between" - OPTIONAL - the time in seconds to wait between each line fade
+    # - "wait_after"   - OPTIONAL - the time in seconds to wait after the fade out
+    # ---
+    # interruptable influences wether the program can be interrupted by pins in the self.interrupt_pins list
+    # if this list is empty, even when interruptable is set to true, nothing will be able to interrupt!
+    def show(self, cycles=1, wait_after_cycles=1, fade_down={"enabled": True}, interruptable=True):  
+        if cycles < 1: cycles = 1
+        padding = " " * self.columns  # as much spaces as padding as one display line is long
+        padding_hyphen = "-" * self.columns  # as much hyphens as padding as one display line is long
+                
+        # mechanism for centering on a 4*20 display
+        y_offset = 0
+        if self.lines == 4:
+            y_offset = 1
+            # also clear the top and bottom with ----
+            self.lcd.move_to(0,0)
+            self.lcd.putstr(padding_hyphen)
+            self.lcd.move_to(0,4)
+            self.lcd.putstr(padding_hyphen)
+        
+        # get the current pin values (only if there are pins specified) (when something changes, the interrupt happens and the cycle stops)
+        break_flag = False
+        if self.interrupt_pins:
+            pin_values = []
+            for p in self.interrupt_pins:
+                pin_values.append(p.value())
+        # cycle the text 'cycles' times and listen for changes on interrupt pins (if any given)
+        for i in range(cycles):
+            line1 = padding + self.starting_msg + padding
+            line2 = self.subtitle.center(self.columns)
+            for i in range(self.columns + len(self.starting_msg)):
+                self.lcd.move_to(0,y_offset)
+                self.lcd.putstr(line1[0:self.columns])
+                self.lcd.move_to(0,y_offset+1)
+                self.lcd.putstr(line2[0:self.columns])
+                line1 = line1[1:]
+                if self.interrupt_pins:
+                    for i, p in enumerate(self.interrupt_pins):
+                        if pin_values[i] != p.value():
+                            break_flag = True
+                if break_flag:
+                    break
+            if break_flag:
+                break
+        
+        self.lcd.move_to(0,y_offset)
+        self.lcd.putstr(self.started_msg.center(16))
+        
+        sleep(wait_after_cycles)
+        
+        # now fade down if enabled via the params
+        if fade_down["enabled"]:
+            # get all the waiting times
+            if "wait_between" in fade_down.keys():
+                wait_between = fade_down["wait_between"]
+            else:
+                wait_between = 0.1
+            if "wait_after" in fade_down.keys():
+                wait_after = fade_down["wait_after"]
+            else:
+                wait_after = 0.3
+            if self.lines == 4:
+                old_display = padding_hyphen + self.started_msg.center(16) + self.subtitle.center(self.columns) + padding_hyphen
+            else:
+                old_display = self.started_msg.center(16) + self.subtitle.center(self.columns)
+            self.lcd.move_to(0,0)  # move to the start of the lcd
+            while old_display != "":
+                old_display = old_display[:-self.columns]
+                lines_before = " " * (self.columns*self.lines-len(old_display))
+                self.lcd.putstr(lines_before + old_display)
+                sleep(wait_between)
+            sleep(wait_after)

main.py

@@ -10,61 +10,93 @@ You should have received a copy of the GNU General Public License along with thi
 """
 
 
-import config, utils
+import utils
-from lib.ProgramChooserAdapted import ProgramChooser
+from lcdMenu import lcdMenu
+from WelcomeScreen import WelcomeScreen
 from time import sleep
-import gc  # garbage collector for better memory performance
+from gc import collect  # garbage collector for better memory performance
 
+config = utils.Config()
+btn_mapping = {"ok_btn": config.PIN_IN_BTN_1, "next_btn": config.PIN_IN_BTN_2}  # the btn mapping for all lcdMenus
 
 # extra functions to access the garbage collector
 def manual():
     config.LCD.clear()
-    set_value = config.RELAIS.value()
+    set_value = config.PIN_OUT_RELAIS.value()
     config.LCD.putstr(f"---- MANUAL ----    State: {set_value}    ")
     while True:
-        if set_value != config.SWITCH.value():
+        if set_value != config.PIN_IN_SWITCH.value():
-            config.RELAIS.value(config.SWITCH.value())
+            config.PIN_OUT_RELAIS.value(config.PIN_IN_SWITCH.value())
-            set_value = config.RELAIS.value()
+            set_value = config.PIN_OUT_RELAIS.value()
             config.LCD.putstr(f"---- MANUAL ----    State: {set_value}    ")
-        if config.BTN_1.value() == 1 or config.BTN_2.value() == 1:
+        if config.PIN_IN_BTN_1.value() == 1 or config.PIN_IN_BTN_2.value() == 1:
-            return  # exit on press of these buttons
+            return True # exit on press of these buttons
 def timer():
     # display WIP
     config.LCD.clear()
     config.LCD.putstr("      Still     work-in-progress")
     sleep(3)
+    return True  # disable the "Quitting" message from lcdMenu
 def uv_on():
     config.RELAIS.value(1)
     config.LCD.clear()
-    config.LCD.putstr("       UV          turned on    ")
+    config.LCD.putstr("------ UV ------   turned on    ")
     sleep(1)
+    return True  # disable the "Quitting" message from lcdMenu
 def uv_off():
     config.RELAIS.value(0)
     config.LCD.clear()
     config.LCD.putstr("------ UV ------   turned off   ")
     sleep(1)
+    return True  # disable the "Quitting" message from lcdMenu
 def lcd_big_hello():
-    import lcd_big_hello
+    import lcd_big_hello as lbh
-    lcd_big_hello.run()
+    lbh.run()
-    gc.collect()
+    del lbh
+    collect()
+    return True
+def input_tests():
+    import input_tests as input_tests
+    input_tests.run(serial_output=False)
+    collect()
+    return True
 def settings():
     # display WIP
     config.LCD.clear()
     config.LCD.putstr("      Still     work-in-progress")
     sleep(3)
+    return True
+def run_demo_menu():
+    demo_menu = lcdMenu(config.LCD, btn_mapping, scroll_direction=True, cycle=True, hide_menu_name=False, name="DEMOS")
+    demo_programs = [("LCD Demo", lcd_big_hello),
+                     ("Input tests", input_tests),
+                     ("Exit", demo_menu.stop)]
+    demo_menu.setup(demo_programs)  # give it the callback list
+    ret = demo_menu.run()
+    del demo_menu, demo_programs
+    collect()
+    return ret
 
-# create a programs dict, where the items are callables (functions)
+if config.STARTUP_WELCOME_SHOW:
-programs = {
+    ws = WelcomeScreen(config.LCD,
-    "Settings": settings,
+                       interrupt_pins=[config.PIN_IN_BTN_1, config.PIN_IN_BTN_2, config.PIN_IN_SWITCH],
-    "LCD Demo": lcd_big_hello,
+                       subtitle=config.STARTUP_PROJECT_NAME,
-    "UV off": uv_off,
+                       starting_msg=config.STARTUP_MESSAGE_STARTING,
-    "UV on": uv_on,
+                       started_msg=config.STARTUP_MESSAGE_FINISHED)
-    "Timer": timer,
+    ws.show(cycles=config.STARTUP_WELCOME_CYCLES)
-    "Manual": manual,
+    del ws
-    }
+    collect()
 
     
-if config.STARTUP_WELCOME_SHOW: utils.show_welcome()
+# create the menus
+main_menu = lcdMenu(config.LCD, btn_mapping, scroll_direction=True, cycle=True, hide_menu_name=False, name="PROGRAMS")
+main_programs = [("Timer", timer),
+                 ("Manual", manual),
+                 ("UV off", uv_off),
+                 ("UV on", uv_on),
+                 ("Demos", run_demo_menu),
+                 ("Settings", settings)]
+main_menu.setup(main_programs)  # give it the callback list
 
-pc = ProgramChooser(programs)  # initialize the ProgramChooser
+# and run the main menu (will be an endless loop)
-pc.run()  # and run it (will be an endless loop)
+main_menu.run()

utils.py

@@ -9,9 +9,106 @@ This program is distributed in the hope that it will be useful, but WITHOUT ANY
 You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
+from gc import collect
 
-import config as cfg
+"""
-from time import sleep
+A small wrapper class as storing machine.Pin, LCD and machine.I2C objects in a file is not that cool :)
+Now only pin numbers and strings etc. are stored on the uC, and the complex objects are generated on the fly
+"""
+class Config:
+    """
+    The initializer method
+    - config_file: the path to the config file laying on the uC
+    """
+    def __init__(self, config_file: str = "config.json"):
+        self._attr_list = ["LOG_LEVEL",                 # there are three log levels: warn (0), info (1), debug (2)
+                                                        # this value defines which log messages to show
+                                                        # e.g. 2 means show [debug], [warn] and [info] messages
+                           "STARTUP_WELCOME_SHOW",      # show the name and a startup message
+                           "STARTUP_PROJECT_NAME",      # the name to show at startup
+                           "STARTUP_MESSAGE_STARTING",  # the message to show at startup
+                           "STARTUP_MESSAGE_FINISHED",  # the message to show at startup
+                           "STARTUP_WELCOME_CYCLES",    # how often shall "Starting..." run over the screen
+                           "PIN_IN_BTN_1",              # input of the first btn
+                           "PIN_IN_BTN_2",              # input of the second btn
+                           "PIN_IN_SWITCH",             # input of the switch
+                           "PIN_OUT_RELAIS",            # where the relais is connected (for the UV lights)
+                           "PIN_SDA",                   # just some standard I2C serial data (SDA) output
+                           "PIN_SCL",                   # just some standard I2C serial clock (SCL) output
+                           "LCD_I2C_CH",                # where the relais is connected (for the UV lights)
+                           "LCD_I2C_ADDR",              # the i2c adress of the display
+                           "LCD_I2C_NUM_ROWS",          # how many rows for character display has the display?
+                           "LCD_I2C_NUM_COLS",          # and how many characters can it display per row?
+                           "LCD"]                       # the actual lcd object (of the PCF8574T I2C_LCD class, see libraries)
+        self._config_file = config_file
+        self.load_config()
+    
+    def load_config(self):
+        # prepare the class
+        with open(self._config_file, "r") as f:
+            from json import load
+            self._config = load(f)
+            del load
+            collect()
+    
+    def save_config(self):
+        with open(self._config_file, "w") as f:
+            from json import dump
+            dump(self._config, f)
+            del dump
+            collect()
+    
+    
+    def __getattr__(self, name):
+        if name.startswith("_"):  # make private attributes unaccessible
+            raise AttributeError(f"'Access to the private attribute '{name}' of the object '{self.__class__.__name__}' is forbidden")
+        elif name in self._attr_list:  # valid attributes (only capital letters and -_ etc. are allowed)
+            try:
+                # now some if statements to check if the lcd or some pin object is asked
+                if name.startswith("PIN_"):
+                    from machine import Pin
+                    if name.startswith("PIN_IN"):
+                        if self._config[name]["pull"].lower() == "down":
+                            p = Pin(self._config[name]["pin"], Pin.IN, Pin.PULL_DOWN)
+                        elif self._config[name]["pull"].lower() == "up":
+                            p = Pin(self._config[name]["pin"], Pin.IN, Pin.PULL_UP)
+                        else:
+                            p = Pin(self._config[name]["pin"], Pin.IN)
+                    elif name.startswith("PIN_OUT"):
+                        p = Pin(self._config[name], Pin.OUT)
+                    else:
+                        p = Pin(self._config[name])
+                    del Pin
+                    collect()
+                    return p
+                elif name == "LCD":
+                    try:
+                        return self._lcd
+                    except:
+                        from machine import I2C, Pin
+                        from PCF8574T import I2C_LCD
+                        self._lcd = I2C_LCD(I2C(self.LCD_I2C_CH, sda=self.PIN_SDA, scl=self.PIN_SCL, freq=400000),
+                                            self.LCD_I2C_ADDR,
+                                            self.LCD_I2C_NUM_ROWS,
+                                            self.LCD_I2C_NUM_COLS)
+                        del I2C, Pin, I2C_LCD
+                        collect()
+                        return self._lcd
+                return self._config[name]
+            except KeyError:
+                raise AttributeError(f"Attribute '{name}' does not exist in the config file '{self._config_file}'")
+        else:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+    
+    
+    def __setattr__(self, name, value):
+        #print(f"Someone tried to edit my poor attributes! Affected: '{name}' should be set to '{value}'")
+        object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        raise AttributeError(f"You may not delete any attribute of the '{self.__class__.__name__}' object")
+
+cfg = Config()
 
 
 """
@@ -27,37 +124,3 @@ def log(log_level: int, message: str):
     elif cfg.LOG_LEVEL >= log_level:  # if log level is valid
         print(f"[{log_mapping[log_level]}] {message}")
 
-
-"""
-Simple function that displays a startup "welcome" screen
-Configurable in config.py
-"""
-def show_welcome():  # cycles says how often the startup text goes through
-    cycles = cfg.STARTUP_WELCOME_CYCLES
-    if cycles < 1:
-        cycles = 1
-        
-    padding = " "*cfg.LCD_I2C_NUM_COLS
-    started_str = cfg.STARTUP_MESSAGE_FINISHED
-    starting_str = cfg.STARTUP_MESSAGE_STARTING
-    
-    
-    # slide the first line over the display (animated from right to left)
-    for i in range(cycles):
-        line1 = padding + starting_str + padding
-        line2 = cfg.STARTUP_PROJECT_NAME
-        for i in range(cfg.LCD_I2C_NUM_COLS + len(starting_str)):
-            cfg.LCD.putstr(line1[0:16])
-            cfg.LCD.move_to(0,1)
-            cfg.LCD.putstr(line2[0:16])
-            line1 = line1[1:]
-    
-    cfg.LCD.move_to(0,0)
-    cfg.LCD.putstr(started_str)
-    
-    # now fade down
-    sleep(2)
-    cfg.LCD.move_to(0,0)
-    cfg.LCD.putstr(padding + started_str)
-    sleep(0.1)
-    cfg.LCD.clear()