bump version

* add themes

* change tty defaults

.gitignore

@@ -5,3 +5,5 @@ client.db
 .DS_Store
 client.log
 settings.log
+config.json
+default_config.log

db_handler.py

@@ -1,8 +1,10 @@
 import sqlite3
-import globals
 import time
 from datetime import datetime
+import logging
 
+import globals
+import default_config as config
 from utilities.utils import get_name_from_number
 
 def get_table_name(channel):
@@ -14,7 +16,7 @@ def get_table_name(channel):
 def save_message_to_db(channel, user_id, message_text):
     """Save messages to the database, ensuring the table exists."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
 
             quoted_table_name = get_table_name(channel)
@@ -44,14 +46,14 @@ def save_message_to_db(channel, user_id, message_text):
             return timestamp
 
     except sqlite3.Error as e:
-        print(f"SQLite error in save_message_to_db: {e}")
+        logging.error(f"SQLite error in save_message_to_db: {e}")
 
     except Exception as e:
-        print(f"Unexpected error in save_message_to_db: {e}")
+        logging.error(f"Unexpected error in save_message_to_db: {e}")
 
 def update_ack_nak(channel, timestamp, message, ack):
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
             update_query = f"""
                 UPDATE {get_table_name(channel)}
@@ -65,10 +67,10 @@ def update_ack_nak(channel, timestamp, message, ack):
             db_connection.commit()
 
     except sqlite3.Error as e:
-        print(f"SQLite error in update_ack_nak: {e}")
+        logging.error(f"SQLite error in update_ack_nak: {e}")
 
     except Exception as e:
-        print(f"Unexpected error in update_ack_nak: {e}")
+        logging.error(f"Unexpected error in update_ack_nak: {e}")
 
 
 from datetime import datetime
@@ -76,7 +78,7 @@ from datetime import datetime
 def load_messages_from_db():
     """Load messages from the database for all channels and update globals.all_messages and globals.channel_list."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
 
             # Retrieve all table names that match the pattern
@@ -120,18 +122,18 @@ def load_messages_from_db():
                         if hour not in hourly_messages:
                             hourly_messages[hour] = []
                         
-                        ack_str = globals.ack_unknown_str
+                        ack_str = config.ack_unknown_str
                         if ack_type == "Implicit":
-                            ack_str = globals.ack_implicit_str
+                            ack_str = config.ack_implicit_str
                         elif ack_type == "Ack":
-                            ack_str = globals.ack_str
+                            ack_str = config.ack_str
                         elif ack_type == "Nak":
-                            ack_str = globals.nak_str
+                            ack_str = config.nak_str
 
                         if user_id == str(globals.myNodeNum):
-                            formatted_message = (f"{globals.sent_message_prefix}{ack_str}: ", message)
+                            formatted_message = (f"{config.sent_message_prefix}{ack_str}: ", message)
                         else:
-                            formatted_message = (f"{globals.message_prefix} {get_name_from_number(int(user_id), 'short')}: ", message)
+                            formatted_message = (f"{config.message_prefix} {get_name_from_number(int(user_id), 'short')}: ", message)
                         
                         hourly_messages[hour].append(formatted_message)
 
@@ -141,16 +143,16 @@ def load_messages_from_db():
                         globals.all_messages[channel].extend(messages)
 
                 except sqlite3.Error as e:
-                    print(f"SQLite error while loading messages from table '{table_name}': {e}")
+                    logging.error(f"SQLite error while loading messages from table '{table_name}': {e}")
 
     except sqlite3.Error as e:
-        print(f"SQLite error in load_messages_from_db: {e}")
+        logging.error(f"SQLite error in load_messages_from_db: {e}")
 
 
 def init_nodedb():
     """Initialize the node database and update it with nodes from the interface."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
 
             # Table name construction
@@ -196,14 +198,14 @@ def init_nodedb():
             db_connection.commit()
 
     except sqlite3.Error as e:
-        print(f"SQLite error in init_nodedb: {e}")
+        logging.error(f"SQLite error in init_nodedb: {e}")
     except Exception as e:
-        print(f"Unexpected error in init_nodedb: {e}")
+        logging.error(f"Unexpected error in init_nodedb: {e}")
 
 def maybe_store_nodeinfo_in_db(packet):
     """Save nodeinfo unless that record is already there."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
 
             table_name = f"{str(globals.myNodeNum)}_nodedb"
             nodeinfo_table = f'"{table_name}"'  # Quote the table name becuase we might begin with numerics
@@ -280,6 +282,6 @@ def maybe_store_nodeinfo_in_db(packet):
 
 
     except sqlite3.Error as e:
-        print(f"SQLite error in maybe_store_nodeinfo_in_db: {e}")
+        logging.error(f"SQLite error in maybe_store_nodeinfo_in_db: {e}")
     finally:
         db_connection.close()

default_config.py

@@ -0,0 +1,183 @@
+import os
+import json
+import logging
+
+def format_json_single_line_arrays(data, indent=4):
+    """
+    Formats JSON with arrays on a single line while keeping other elements properly indented.
+    """
+    def format_value(value, current_indent):
+        if isinstance(value, dict):
+            items = []
+            for key, val in value.items():
+                items.append(
+                    f'{" " * current_indent}"{key}": {format_value(val, current_indent + indent)}'
+                )
+            return "{\n" + ",\n".join(items) + f"\n{' ' * (current_indent - indent)}}}"
+        elif isinstance(value, list):
+            return f"[{', '.join(json.dumps(el, ensure_ascii=False) for el in value)}]"
+        else:
+            return json.dumps(value, ensure_ascii=False)
+
+    return format_value(data, indent)
+
+# Recursive function to check and update nested dictionaries
+def update_dict(default, actual):
+    updated = False
+    for key, value in default.items():
+        if key not in actual:
+            actual[key] = value
+            updated = True
+        elif isinstance(value, dict):
+            # Recursively check nested dictionaries
+            updated = update_dict(value, actual[key]) or updated
+    return updated
+
+def initialize_config():
+    app_directory = os.path.dirname(os.path.abspath(__file__))
+    json_file_path = os.path.join(app_directory, "config.json")
+
+    COLOR_CONFIG_DARK = {
+        "default": ["white", "black"],
+        "background": [" ", "black"],
+        "splash_logo": ["green", "black"],
+        "splash_text": ["white", "black"],
+        "input": ["white", "black"],
+        "node_list": ["white", "black"],
+        "channel_list": ["white", "black"],
+        "channel_selected": ["green", "black"],
+        "rx_messages": ["cyan", "black"],
+        "tx_messages": ["green", "black"],
+        "timestamps": ["white", "black"],
+        "commands": ["white", "black"],
+        "window_frame": ["white", "black"],
+        "window_frame_selected": ["green", "black"],
+        "log_header": ["blue", "black"],
+        "log": ["green", "black"],
+        "settings_default": ["white", "black"],
+        "settings_sensitive": ["red", "black"],
+        "settings_save": ["green", "black"],
+        "settings_breadcrumbs": ["white", "black"]
+    }
+
+    COLOR_CONFIG_LIGHT = {
+        "default": ["black", "white"],
+        "background": [" ", "white"],
+        "splash_logo": ["green", "white"],
+        "splash_text": ["black", "white"],
+        "input": ["black", "white"],
+        "node_list": ["black", "white"],
+        "channel_list": ["black", "white"],
+        "channel_selected": ["green", "white"],
+        "rx_messages": ["cyan", "white"],
+        "tx_messages": ["green", "white"],
+        "timestamps": ["black", "white"],
+        "commands": ["black", "white"],
+        "window_frame": ["black", "white"],
+        "window_frame_selected": ["green", "white"],
+        "log_header": ["black", "white"],
+        "log": ["blue", "white"],
+        "settings_default": ["black", "white"],
+        "settings_sensitive": ["red", "white"],
+        "settings_save": ["green", "white"],
+        "settings_breadcrumbs": ["black", "white"]
+    }
+    COLOR_CONFIG_GREEN = {
+        "default": ["green", "black"],
+        "background": [" ", "black"],
+        "splash_logo": ["green", "black"],
+        "splash_text": ["green", "black"],
+        "input": ["green", "black"],
+        "node_list": ["green", "black"],
+        "channel_list": ["green", "black"],
+        "channel_selected": ["cyan", "black"],
+        "rx_messages": ["green", "black"],
+        "tx_messages": ["green", "black"],
+        "timestamps": ["green", "black"],
+        "commands": ["green", "black"],
+        "window_frame": ["green", "black"],
+        "window_frame_selected": ["cyan", "black"],
+        "log_header": ["green", "black"],
+        "log": ["green", "black"],
+        "settings_default": ["green", "black"],
+        "settings_sensitive": ["green", "black"],
+        "settings_save": ["green", "black"],
+        "settings_breadcrumbs": ["green", "black"]
+    }
+
+    default_config_variables = {
+        "db_file_path": os.path.join(app_directory, "client.db"),
+        "log_file_path": os.path.join(app_directory, "client.log"),
+        "message_prefix": ">>",
+        "sent_message_prefix": ">> Sent",
+        "notification_symbol": "*",
+        "ack_implicit_str": "[◌]",
+        "ack_str": "[✓]",
+        "nak_str": "[x]",
+        "ack_unknown_str": "[…]",
+        "theme": "dark",
+        "COLOR_CONFIG_DARK": COLOR_CONFIG_DARK,
+        "COLOR_CONFIG_LIGHT": COLOR_CONFIG_LIGHT,
+        "COLOR_CONFIG_GREEN": COLOR_CONFIG_GREEN
+    }
+
+    if not os.path.exists(json_file_path):
+        with open(json_file_path, "w", encoding="utf-8") as json_file:
+            formatted_json = format_json_single_line_arrays(default_config_variables)
+            json_file.write(formatted_json)
+
+    # Ensure all default variables exist in the JSON file
+    with open(json_file_path, "r", encoding="utf-8") as json_file:
+        loaded_config = json.load(json_file)
+
+    # Check and add missing variables
+    updated = update_dict(default_config_variables, loaded_config)
+
+    # Update the JSON file if any variables were missing
+    if updated:
+            formatted_json = format_json_single_line_arrays(loaded_config)
+            with open(json_file_path, "w", encoding="utf-8") as json_file:
+                json_file.write(formatted_json)
+            logging.info(f"JSON file updated with missing default variables and COLOR_CONFIG items.")
+
+    return loaded_config
+
+# Call the function when the script is imported
+loaded_config = initialize_config()
+
+# Assign values to local variables
+db_file_path = loaded_config["db_file_path"]
+log_file_path = loaded_config["log_file_path"]
+message_prefix = loaded_config["message_prefix"]
+sent_message_prefix = loaded_config["sent_message_prefix"]
+notification_symbol = loaded_config["notification_symbol"]
+ack_implicit_str = loaded_config["ack_implicit_str"]
+ack_str = loaded_config["ack_str"]
+nak_str = loaded_config["nak_str"]
+ack_unknown_str = loaded_config["ack_unknown_str"]
+theme = loaded_config["theme"]
+if theme == "dark":
+    COLOR_CONFIG = loaded_config["COLOR_CONFIG_DARK"]
+elif theme == "light":
+    COLOR_CONFIG = loaded_config["COLOR_CONFIG_LIGHT"]
+elif theme == "green":
+    COLOR_CONFIG = loaded_config["COLOR_CONFIG_GREEN"]
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+    filename="default_config.log",
+    level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+    print("\nLoaded Configuration:")
+    print(f"Database File Path: {db_file_path}")
+    print(f"Log File Path: {log_file_path}")
+    print(f"Message Prefix: {message_prefix}")
+    print(f"Sent Message Prefix: {sent_message_prefix}")
+    print(f"Notification Symbol: {notification_symbol}")
+    print(f"ACK Implicit String: {ack_implicit_str}")
+    print(f"ACK String: {ack_str}")
+    print(f"NAK String: {nak_str}")
+    print(f"ACK Unknown String: {ack_unknown_str}")
+    print(f"Color Config: {COLOR_CONFIG}")

globals.py

@@ -1,7 +1,3 @@
-import os
-
-# App Variables
-app_directory = os.path.dirname(os.path.abspath(__file__))
 interface = None
 display_log = False
 all_messages = {}
@@ -13,15 +9,4 @@ myNodeNum = 0
 selected_channel = 0
 selected_message = 0
 selected_node = 0
-current_window = 0
-
-# User Configurable
-db_file_path = os.path.join(app_directory, "client.db")
-log_file_path = os.path.join(app_directory, "client.log")
-message_prefix = ">>"
-sent_message_prefix = message_prefix + " Sent"
-notification_symbol = "*"
-ack_implicit_str = "[◌]"
-ack_str = "[✓]"
-nak_str = "[x]"
-ack_unknown_str = "[…]"
+current_window = 0

input_handlers.py

@@ -1,5 +1,6 @@
 import curses
 import ipaddress
+from ui.colors import get_color
 
 def get_user_input(prompt):
     # Calculate the dynamic height and width for the input window
@@ -10,11 +11,13 @@ def get_user_input(prompt):
 
     # Create a new window for user input
     input_win = curses.newwin(height, width, start_y, start_x)
+    input_win.bkgd(get_color("background"))
+    input_win.attrset(get_color("window_frame"))
     input_win.border()
 
     # Display the prompt
-    input_win.addstr(1, 2, prompt, curses.A_BOLD)
-    input_win.addstr(3, 2, "Enter value: ")
+    input_win.addstr(1, 2, prompt, get_color("settings_default", bold=True))
+    input_win.addstr(3, 2, "Enter value: ", get_color("settings_default"))
     input_win.refresh()
 
     curses.curs_set(1)
@@ -29,11 +32,11 @@ def get_user_input(prompt):
             break
         elif key == curses.KEY_BACKSPACE or key == 127:  # Backspace
             user_input = user_input[:-1]
-            input_win.addstr(3, 15, " " * (len(user_input) + 1))  # Clear the line
-            input_win.addstr(3, 15, user_input)
+            input_win.addstr(3, 15, " " * (len(user_input) + 1), get_color("settings_default"))  # Clear the line
+            input_win.addstr(3, 15, user_input, get_color("settings_default"))
         else:
             user_input += chr(key)
-            input_win.addstr(3, 15, user_input)
+            input_win.addstr(3, 15, user_input, get_color("settings_default"))
 
     curses.curs_set(0)
 
@@ -54,18 +57,20 @@ def get_bool_selection(message, current_value):
     start_x = (curses.COLS - width) // 2
 
     bool_win = curses.newwin(height, width, start_y, start_x)
+    bool_win.bkgd(get_color("background"))
+    bool_win.attrset(get_color("window_frame"))
     bool_win.keypad(True)
 
     while True:
         bool_win.clear()
         bool_win.border()
-        bool_win.addstr(1, 2, message, curses.A_BOLD)
+        bool_win.addstr(1, 2, message, get_color("settings_default", bold=True))
 
         for idx, option in enumerate(options):
             if idx == selected_index:
-                bool_win.addstr(idx + 3, 4, option, curses.A_REVERSE)
+                bool_win.addstr(idx + 3, 4, option, get_color("settings_default", reverse=True))
             else:
-                bool_win.addstr(idx + 3, 4, option)
+                bool_win.addstr(idx + 3, 4, option, get_color("settings_default"))
 
         bool_win.refresh()
         key = bool_win.getch()
@@ -87,6 +92,8 @@ def get_repeated_input(current_value):
     start_x = (curses.COLS - width) // 2
 
     repeated_win = curses.newwin(height, width, start_y, start_x)
+    repeated_win.bkgd(get_color("background"))
+    repeated_win.attrset(get_color("window_frame"))
     repeated_win.keypad(True)  # Enable keypad for special keys
 
     curses.echo()
@@ -96,9 +103,9 @@ def get_repeated_input(current_value):
     while True:
         repeated_win.clear()
         repeated_win.border()
-        repeated_win.addstr(1, 2, "Enter comma-separated values:", curses.A_BOLD)
-        repeated_win.addstr(3, 2, f"Current: {', '.join(map(str, current_value))}")
-        repeated_win.addstr(5, 2, f"New value: {user_input}")
+        repeated_win.addstr(1, 2, "Enter comma-separated values:", get_color("settings_default", bold=True))
+        repeated_win.addstr(3, 2, f"Current: {', '.join(map(str, current_value))}", get_color("settings_default"))
+        repeated_win.addstr(5, 2, f"New value: {user_input}", get_color("settings_default"))
         repeated_win.refresh()
 
         key = repeated_win.getch()
@@ -128,18 +135,20 @@ def get_enum_input(options, current_value):
     start_x = (curses.COLS - width) // 2
 
     enum_win = curses.newwin(height, width, start_y, start_x)
+    enum_win.bkgd(get_color("background"))
+    enum_win.attrset(get_color("window_frame"))
     enum_win.keypad(True)
 
     while True:
         enum_win.clear()
         enum_win.border()
-        enum_win.addstr(1, 2, "Select an option:", curses.A_BOLD)
+        enum_win.addstr(1, 2, "Select an option:", get_color("settings_default", bold=True))
 
         for idx, option in enumerate(options):
             if idx == selected_index:
-                enum_win.addstr(idx + 2, 4, option, curses.A_REVERSE)
+                enum_win.addstr(idx + 2, 4, option, get_color("settings_default", reverse=True))
             else:
-                enum_win.addstr(idx + 2, 4, option)
+                enum_win.addstr(idx + 2, 4, option, get_color("settings_default"))
 
         enum_win.refresh()
         key = enum_win.getch()
@@ -163,6 +172,8 @@ def get_fixed32_input(current_value):
     start_x = (curses.COLS - width) // 2
 
     fixed32_win = curses.newwin(height, width, start_y, start_x)
+    fixed32_win.bkgd(get_color("background"))
+    fixed32_win.attrset(get_color("window_frame"))
     fixed32_win.keypad(True)
 
     curses.echo()

main.py

@@ -3,7 +3,7 @@
 '''
 Contact - A Console UI for Meshtastic by http://github.com/pdxlocations
 Powered by Meshtastic.org
-V 1.0.3
+V 1.1.2
 '''
 
 import curses
@@ -19,6 +19,7 @@ from ui.curses_ui import main_ui, draw_splash
 from utilities.utils import get_channels, get_node_list, get_nodeNum
 from db_handler import init_nodedb, load_messages_from_db
 import globals
+import default_config as config
 
 # Set environment variables for ncurses compatibility
 os.environ["NCURSES_NO_UTF8_ACS"] = "1"
@@ -28,7 +29,7 @@ os.environ["LANG"] = "C.UTF-8"
 # Configure logging
 # Run `tail -f client.log` in another terminal to view live
 logging.basicConfig(
-    filename=globals.log_file_path,
+    filename=config.log_file_path,
     level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
     format="%(asctime)s - %(levelname)s - %(message)s"
 )

message_handlers/rx_handler.py

@@ -1,8 +1,11 @@
+import logging
+import time
 from meshtastic import BROADCAST_NUM
 from utilities.utils import get_node_list, decimal_to_hex, get_name_from_number
 import globals
 from ui.curses_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
 from db_handler import save_message_to_db, maybe_store_nodeinfo_in_db
+import default_config as config
 
 
 from datetime import datetime
@@ -68,7 +71,7 @@ def on_receive(packet, interface):
                 globals.all_messages[globals.channel_list[channel_number]] = []
 
             # Timestamp handling
-            current_timestamp = int(packet['rxTime'])  # Use the packet's rxTime for timestamp
+            current_timestamp = time.time() 
             current_hour = datetime.fromtimestamp(current_timestamp).strftime('%Y-%m-%d %H:00')
 
             # Retrieve the last timestamp if available
@@ -88,7 +91,7 @@ def on_receive(packet, interface):
             if last_hour != current_hour:
                 globals.all_messages[globals.channel_list[channel_number]].append((f"-- {current_hour} --", ""))
 
-            globals.all_messages[globals.channel_list[channel_number]].append((f"{globals.message_prefix} {message_from_string} ", message_string))
+            globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string} ", message_string))
 
             if refresh_channels:
                 draw_channel_list()
@@ -98,4 +101,4 @@ def on_receive(packet, interface):
             save_message_to_db(globals.channel_list[channel_number], message_from_id, message_string)
 
     except KeyError as e:
-        print(f"Error processing packet: {e}")
+        logging.error(f"Error processing packet: {e}")

message_handlers/tx_handler.py

@@ -5,6 +5,7 @@ from meshtastic.protobuf import mesh_pb2, portnums_pb2
 from utilities.utils import get_name_from_number
 import globals
 import google.protobuf.json_format
+import default_config as config
 
 ack_naks = {}
 
@@ -23,16 +24,16 @@ def onAckNak(packet):
     ack_type = None
     if(packet['decoded']['routing']['errorReason'] == "NONE"):
         if(packet['from'] == globals.myNodeNum): # Ack "from" ourself means implicit ACK
-            confirm_string = globals.ack_implicit_str
+            confirm_string = config.ack_implicit_str
             ack_type = "Implicit"
         else:
-            confirm_string = globals.ack_str
+            confirm_string = config.ack_str
             ack_type = "Ack"
     else:
-        confirm_string = globals.nak_str
+        confirm_string = config.nak_str
         ack_type = "Nak"
 
-    globals.all_messages[acknak['channel']][acknak['messageIndex']] = (globals.sent_message_prefix + confirm_string + ": ", message)
+    globals.all_messages[acknak['channel']][acknak['messageIndex']] = (config.sent_message_prefix + confirm_string + ": ", message)
 
     update_ack_nak(acknak['channel'], acknak['timestamp'], message, ack_type)
 
@@ -105,7 +106,7 @@ def on_response_traceroute(packet):
 
     if globals.channel_list[channel_number] not in globals.all_messages:
         globals.all_messages[globals.channel_list[channel_number]] = []
-    globals.all_messages[globals.channel_list[channel_number]].append((f"{globals.message_prefix} {message_from_string}", msg_str))
+    globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string}", msg_str))
 
     if refresh_channels:
         draw_channel_list()
@@ -158,7 +159,7 @@ def send_message(message, destination=BROADCAST_NUM, channel=0):
     if last_hour != current_hour:
         globals.all_messages[channel_id].append((f"-- {current_hour} --", ""))
 
-    globals.all_messages[channel_id].append((globals.sent_message_prefix + globals.ack_unknown_str + ": ", message))
+    globals.all_messages[channel_id].append((config.sent_message_prefix + config.ack_unknown_str + ": ", message))
 
     timestamp = save_message_to_db(channel_id, myid, message)
 

save_to_radio.py

@@ -43,6 +43,7 @@ def save_changes(interface, menu_path, modified_settings):
             long_name = modified_settings.get("longName")
             short_name = modified_settings.get("shortName")
             is_licensed = modified_settings.get("isLicensed")
+            is_licensed = is_licensed == "True" or is_licensed is True
             node.setOwner(long_name, short_name, is_licensed)
             logging.info(f"Updated {config_category} with Long Name: {long_name} and Short Name {short_name} and Licensed Mode {is_licensed}")
             return
@@ -52,7 +53,7 @@ def save_changes(interface, menu_path, modified_settings):
 
             try:
                 channel = menu_path[-1]
-                channel_num = int(channel.split()[-1])
+                channel_num = int(channel.split()[-1]) - 1
             except (IndexError, ValueError) as e:
                 channel_num = None
 

settings.py

@@ -4,24 +4,29 @@ import logging
 from save_to_radio import settings_factory_reset, settings_reboot, settings_reset_nodedb, settings_shutdown, save_changes
 from ui.menus import generate_menu_from_protobuf
 from input_handlers import get_bool_selection, get_repeated_input, get_user_input, get_enum_input, get_fixed32_input
-from ui.colors import setup_colors
+from ui.colors import setup_colors, get_color
 from utilities.arg_parser import setup_parser
 from utilities.interfaces import initialize_interface
 import globals
 
+width = 60
+save_option = "Save Changes"
+sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
+
 def display_menu(current_menu, menu_path, selected_index, show_save_option):
     global menu_win
 
     # Calculate the dynamic height based on the number of menu items
     num_items = len(current_menu) + (1 if show_save_option else 0)  # Add 1 for the "Save Changes" option if applicable
     height = min(curses.LINES - 2, num_items + 5)  # Ensure the menu fits within the terminal height
-    width = 60
     start_y = (curses.LINES - height) // 2
     start_x = (curses.COLS - width) // 2
 
     # Create a new curses window with dynamic dimensions
     menu_win = curses.newwin(height, width, start_y, start_x)
     menu_win.clear()
+    menu_win.bkgd(get_color("background"))
+    menu_win.attrset(get_color("window_frame"))
     menu_win.border()
     menu_win.keypad(True)
 
@@ -29,7 +34,7 @@ def display_menu(current_menu, menu_path, selected_index, show_save_option):
     header = " > ".join(word.title() for word in menu_path)
     if len(header) > width - 4:
         header = header[:width - 7] + "..."
-    menu_win.addstr(1, 2, header, curses.A_BOLD)
+    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
 
     # Display the menu options
     for idx, option in enumerate(current_menu):
@@ -40,23 +45,34 @@ def display_menu(current_menu, menu_path, selected_index, show_save_option):
 
         try:
             # Use red color for "Reboot" or "Shutdown"
-            color = curses.color_pair(5) if option in ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"] else curses.color_pair(1)
-
-            if idx == selected_index:
-                menu_win.addstr(idx + 3, 4, f"{display_option:<{width // 2 - 2}} {display_value}", curses.A_REVERSE | color)
-            else:
-                menu_win.addstr(idx + 3, 4, f"{display_option:<{width // 2 - 2}} {display_value}", color)
+            color = get_color("settings_sensitive" if option in sensitive_settings else "settings_default", reverse = (idx == selected_index))
+            menu_win.addstr(idx + 3, 4, f"{display_option:<{width // 2 - 2}} {display_value}".ljust(width - 8), color)
         except curses.error:
             pass
 
     # Show save option if applicable
     if show_save_option:
-        save_option = "Save Changes"
         save_position = height - 2
-        if selected_index == len(current_menu):
-            menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, curses.color_pair(2) | curses.A_REVERSE)
-        else:
-            menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, curses.color_pair(2))
+        menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, get_color("settings_save", reverse = (selected_index == len(current_menu))))
+
+    menu_win.refresh()
+
+def move_highlight(old_idx, new_idx, options, show_save_option, menu_win):
+
+    if(old_idx == new_idx): # no-op
+        return
+
+    max_index = len(options) + (1 if show_save_option else 0) - 1
+
+    if show_save_option and old_idx == max_index: # special case un-highlight "Save" option
+        menu_win.chgat(max_index + 4, (width - len(save_option)) // 2, len(save_option), get_color("settings_save"))
+    else:
+        menu_win.chgat(old_idx + 3, 4, width - 8, get_color("settings_sensitive") if options[old_idx] in sensitive_settings else get_color("settings_default"))
+
+    if show_save_option and new_idx == max_index: # special case highlight "Save" option
+        menu_win.chgat(max_index + 4, (width - len(save_option)) // 2, len(save_option), get_color("settings_save", reverse = True))
+    else:
+       menu_win.chgat(new_idx + 3, 4, width - 8, get_color("settings_sensitive", reverse=True) if options[new_idx] in sensitive_settings else get_color("settings_default", reverse = True))
 
     menu_win.refresh()
 
@@ -68,31 +84,42 @@ def settings_menu(stdscr, interface):
     selected_index = 0
     modified_settings = {}
     
+    need_redraw = True
+    show_save_option = False
+
     while True:
-        options = list(current_menu.keys())
+        if(need_redraw):
+            options = list(current_menu.keys())
 
-        show_save_option = (
-            len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
-        ) or (
-            len(menu_path) == 2 and "User Settings" in menu_path 
-        ) or (
-            len(menu_path) == 3 and "Channels" in menu_path
-        )
+            show_save_option = (
+                len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
+            ) or (
+                len(menu_path) == 2 and "User Settings" in menu_path 
+            ) or (
+                len(menu_path) == 3 and "Channels" in menu_path
+            )
 
-        # Display the menu
-        display_menu(current_menu, menu_path, selected_index, show_save_option)
+            # Display the menu
+            display_menu(current_menu, menu_path, selected_index, show_save_option)
+
+            need_redraw = False
 
         # Capture user input
         key = menu_win.getch()
 
         if key == curses.KEY_UP:
+            old_selected_index = selected_index
             selected_index = max(0, selected_index - 1)
+            move_highlight(old_selected_index, selected_index, options, show_save_option, menu_win)
             
         elif key == curses.KEY_DOWN:
+            old_selected_index = selected_index
             max_index = len(options) + (1 if show_save_option else 0) - 1
             selected_index = min(max_index, selected_index + 1)
+            move_highlight(old_selected_index, selected_index, options, show_save_option, menu_win)
 
         elif key == curses.KEY_RIGHT or key == ord('\n'):
+            need_redraw = True
             menu_win.clear()
             menu_win.refresh()
             if show_save_option and selected_index == len(options):
@@ -119,24 +146,28 @@ def settings_menu(stdscr, interface):
                     settings_reboot(interface)
                     logging.info(f"Node Reboot Requested by menu")
                     break
+                continue
             elif selected_option == "Reset Node DB":
                 confirmation = get_bool_selection("Are you sure you want to Reset Node DB?", 0)
                 if confirmation == "True":
                     settings_reset_nodedb(interface)
                     logging.info(f"Node DB Reset Requested by menu")
                     break
+                continue
             elif selected_option == "Shutdown":
                 confirmation = get_bool_selection("Are you sure you want to Shutdown?", 0)
                 if confirmation == "True":
                     settings_shutdown(interface)
                     logging.info(f"Node Shutdown Requested by menu")
                     break
+                continue
             elif selected_option == "Factory Reset":
                 confirmation = get_bool_selection("Are you sure you want to Factory Reset?", 0)
                 if confirmation == "True":
                     settings_factory_reset(interface)
                     logging.info(f"Factory Reset Requested by menu")
                     break
+                continue
 
             field_info = current_menu.get(selected_option)
             if isinstance(field_info, tuple):
@@ -157,15 +188,16 @@ def settings_menu(stdscr, interface):
 
                 elif field.type == 8:  # Handle boolean type
                     new_value = get_bool_selection(selected_option, str(current_value))
-                    new_value = new_value == "True"
+                    new_value = new_value == "True" or new_value is True
 
                 elif field.label == field.LABEL_REPEATED:  # Handle repeated field
                     new_value = get_repeated_input(current_value)
                     new_value = current_value if new_value is None else [int(item) for item in new_value]
 
                 elif field.enum_type:  # Enum field
-                    enum_options = [v.name for v in field.enum_type.values]
-                    new_value = get_enum_input(enum_options, current_value)
+                    enum_options = {v.name: v.number for v in field.enum_type.values}
+                    new_value_name = get_enum_input(list(enum_options.keys()), current_value)
+                    new_value = enum_options.get(new_value_name, current_value)
 
                 elif field.type == 7: # Field type 7 corresponds to FIXED32
                     new_value = get_fixed32_input(current_value)
@@ -188,6 +220,11 @@ def settings_menu(stdscr, interface):
                 # Add the new value to the appropriate level
                 modified_settings[selected_option] = new_value
 
+                # Convert enum string to int
+                if field.enum_type:
+                    enum_value_descriptor = field.enum_type.values_by_number.get(new_value)
+                    new_value = enum_value_descriptor.name if enum_value_descriptor else new_value
+
                 current_menu[selected_option] = (field, new_value)
             else:
                 current_menu = current_menu[selected_option]
@@ -195,6 +232,7 @@ def settings_menu(stdscr, interface):
                 selected_index = 0
 
         elif key == curses.KEY_LEFT:
+            need_redraw = True
 
             menu_win.clear()
             menu_win.refresh()
@@ -232,4 +270,4 @@ def main(stdscr):
     settings_menu(stdscr, globals.interface)
 
 if __name__ == "__main__":
-    curses.wrapper(main)
+    curses.wrapper(main)

ui/colors.py

@@ -1,9 +1,38 @@
 import curses
+import default_config as config
+
+COLOR_MAP = {
+    "black": curses.COLOR_BLACK,
+    "red": curses.COLOR_RED,
+    "green": curses.COLOR_GREEN,
+    "yellow": curses.COLOR_YELLOW,
+    "blue": curses.COLOR_BLUE,
+    "magenta": curses.COLOR_MAGENTA,
+    "cyan": curses.COLOR_CYAN,
+    "white": curses.COLOR_WHITE
+}
 
 def setup_colors():
+    """
+    Initialize curses color pairs based on the COLOR_CONFIG.
+    """
     curses.start_color()
-    curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
-    curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK) 
-    curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)
-    curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
-    curses.init_pair(5, curses.COLOR_RED, curses.COLOR_BLACK)
+    for idx, (category, (fg_name, bg_name)) in enumerate(config.COLOR_CONFIG.items(), start=1):
+        fg = COLOR_MAP.get(fg_name.lower(), curses.COLOR_WHITE)
+        bg = COLOR_MAP.get(bg_name.lower(), curses.COLOR_BLACK)
+        curses.init_pair(idx, fg, bg)
+        config.COLOR_CONFIG[category] = idx
+
+
+def get_color(category, bold=False, reverse=False, underline=False):
+    """
+    Retrieve a curses color pair with optional attributes.
+    """
+    color = curses.color_pair(config.COLOR_CONFIG[category])
+    if bold:
+        color |= curses.A_BOLD
+    if reverse:
+        color |= curses.A_REVERSE
+    if underline:
+        color |= curses.A_UNDERLINE
+    return color

ui/curses_ui.py

@@ -5,7 +5,8 @@ from utilities.utils import get_name_from_number, get_channels
 from settings import settings_menu
 from message_handlers.tx_handler import send_message, send_traceroute
 import ui.dialog
-from ui.colors import setup_colors
+from ui.colors import setup_colors, get_color
+import default_config as config
 
 def get_msg_window_lines():
     packetlog_height = packetlog_win.getmaxyx()[0] if globals.display_log else 0
@@ -42,12 +43,15 @@ def refresh_pad(window):
 def highlight_line(highlight, window, line):
     pad = channel_pad
     select_len = 0
-    color = curses.color_pair(1)
+    ch_color = get_color("channel_list")
+    nd_color = get_color("node_list")
 
     if(window == 2):
         pad = nodes_pad
         select_len = len(get_name_from_number(globals.node_list[line], "long"))
 
+        pad.chgat(line, 1, select_len, nd_color | curses.A_REVERSE if highlight else nd_color)
+
     if(window == 0):
         channel = list(globals.all_messages.keys())[line]
         win_width = channel_box.getmaxyx()[1]
@@ -57,9 +61,9 @@ def highlight_line(highlight, window, line):
         select_len = min(len(channel), win_width - 4)
 
         if line == globals.selected_channel and highlight == False:
-            color = curses.color_pair(2)
+            ch_color = get_color("channel_selected")
 
-    pad.chgat(line, 1, select_len, color | curses.A_REVERSE if highlight else color)
+        pad.chgat(line, 1, select_len, ch_color | curses.A_REVERSE if highlight else ch_color)
 
 def add_notification(channel_number):
     globals.notifications.add(channel_number) 
@@ -67,15 +71,15 @@ def add_notification(channel_number):
 def remove_notification(channel_number):
     globals.notifications.discard(channel_number) 
 
-def draw_text_field(win, text):
+def draw_text_field(win, text, color):
     win.border()
-    win.addstr(1, 1, text)
+    win.addstr(1, 1, text, color)
 
-def draw_centered_text_field(win, text, y_offset = 0):
+def draw_centered_text_field(win, text, y_offset, color):
     height, width = win.getmaxyx()
     x = (width - len(text)) // 2
     y = (height // 2) + y_offset
-    win.addstr(y, x, text)
+    win.addstr(y, x, text, color)
     win.refresh()
 
 def draw_debug(value):
@@ -87,6 +91,8 @@ def draw_splash(stdscr):
     curses.curs_set(0)
 
     stdscr.clear()
+    stdscr.bkgd(get_color("background"))
+
     height, width = stdscr.getmaxyx()
     message_1 = "/ Λ"
     message_2 = "/ / \\"
@@ -96,10 +102,12 @@ def draw_splash(stdscr):
     start_x = width // 2 - len(message_1) // 2
     start_x2 = width // 2 - len(message_4) // 2
     start_y = height // 2 - 1
-    stdscr.addstr(start_y, start_x, message_1, curses.color_pair(2) | curses.A_BOLD)
-    stdscr.addstr(start_y+1, start_x-1, message_2, curses.color_pair(2) | curses.A_BOLD)
-    stdscr.addstr(start_y+2, start_x-2, message_3, curses.color_pair(2) | curses.A_BOLD)
-    stdscr.addstr(start_y+4, start_x2, message_4)
+    stdscr.addstr(start_y, start_x, message_1, get_color("splash_logo", bold=True))
+    stdscr.addstr(start_y+1, start_x-1, message_2, get_color("splash_logo", bold=True))
+    stdscr.addstr(start_y+2, start_x-2, message_3, get_color("splash_logo", bold=True))
+    stdscr.addstr(start_y+4, start_x2, message_4, get_color("splash_text"))
+
+    stdscr.attrset(get_color("window_frame"))
     stdscr.box()
     stdscr.refresh()
     curses.napms(500)
@@ -118,22 +126,22 @@ def draw_channel_list():
             channel = get_name_from_number(channel, type='long')
 
         # Determine whether to add the notification
-        notification = " " + globals.notification_symbol if i in globals.notifications else ""
+        notification = " " + config.notification_symbol if i in globals.notifications else ""
 
         # Truncate the channel name if it's too long to fit in the window
         truncated_channel = channel[:win_width - 5] + '-' if len(channel) > win_width - 5 else channel
         if i == globals.selected_channel:
             if globals.current_window == 0:
-                channel_pad.addstr(i, 1, truncated_channel + notification, curses.color_pair(1) | curses.A_REVERSE)
+                channel_pad.addstr(i, 1, truncated_channel + notification, get_color("channel_list", reverse=True))
                 remove_notification(globals.selected_channel)
             else:
-                channel_pad.addstr(i, 1, truncated_channel + notification, curses.color_pair(2))
+                channel_pad.addstr(i, 1, truncated_channel + notification, get_color("channel_selected"))
         else:
-            channel_pad.addstr(i, 1, truncated_channel + notification, curses.color_pair(1))
+            channel_pad.addstr(i, 1, truncated_channel + notification, get_color("channel_list"))
 
-    channel_box.attrset(curses.color_pair(2) if globals.current_window == 0 else curses.color_pair(0))
+    channel_box.attrset(get_color("window_frame_selected") if globals.current_window == 0 else get_color("window_frame"))
     channel_box.box()
-    channel_box.attrset(curses.color_pair(0))
+    channel_box.attrset((get_color("window_frame")))
     channel_box.refresh()
 
     refresh_pad(0)
@@ -157,13 +165,19 @@ def draw_messages_window(scroll_to_bottom = False):
             messages_pad.resize(msg_line_count, messages_box.getmaxyx()[1])
 
             for line in wrapped_lines:
-                color = curses.color_pair(1) if prefix.startswith("--") else (curses.color_pair(3) if prefix.startswith(globals.sent_message_prefix) else curses.color_pair(2))
+                if prefix.startswith("--"):
+                    color = get_color("timestamps")
+                elif prefix.startswith(config.sent_message_prefix):
+                    color = get_color("tx_messages") 
+                else:
+                    color = get_color("rx_messages") 
+                    
                 messages_pad.addstr(row, 1, line, color)
                 row += 1
 
-    messages_box.attrset(curses.color_pair(2) if globals.current_window == 1 else curses.color_pair(0))
+    messages_box.attrset(get_color("window_frame_selected") if globals.current_window == 1 else get_color("window_frame"))
     messages_box.box()
-    messages_box.attrset(curses.color_pair(0))
+    messages_box.attrset(get_color("window_frame"))
     messages_box.refresh()
 
     if(scroll_to_bottom):
@@ -184,13 +198,13 @@ def draw_node_list():
 
     for i, node in enumerate(globals.node_list):
         if globals.selected_node == i and globals.current_window == 2:
-            nodes_pad.addstr(i, 1, get_name_from_number(node, "long"), curses.color_pair(1) | curses.A_REVERSE)
+            nodes_pad.addstr(i, 1, get_name_from_number(node, "long"), get_color("node_list", reverse=True))
         else:
-            nodes_pad.addstr(i, 1, get_name_from_number(node, "long"), curses.color_pair(1))
+            nodes_pad.addstr(i, 1, get_name_from_number(node, "long"), get_color("node_list"))
 
-    nodes_box.attrset(curses.color_pair(2) if globals.current_window == 2 else curses.color_pair(0))
+    nodes_box.attrset(get_color("window_frame_selected") if globals.current_window == 2 else get_color("window_frame"))
     nodes_box.box()
-    nodes_box.attrset(curses.color_pair(0))
+    nodes_box.attrset(get_color("window_frame"))
     nodes_box.refresh()
 
     refresh_pad(2)
@@ -259,7 +273,7 @@ def draw_packetlog_win():
 
         # Add headers
         headers = f"{'From':<{columns[0]}} {'To':<{columns[1]}} {'Port':<{columns[2]}} {'Payload':<{width-span}}"
-        packetlog_win.addstr(1, 1, headers[:width - 2],curses.A_UNDERLINE)  # Truncate headers if they exceed window width
+        packetlog_win.addstr(1, 1, headers[:width - 2],get_color("log_header", underline=True))  # Truncate headers if they exceed window width
 
         for i, packet in enumerate(reversed(globals.packet_buffer)):
             if i >= height - 3:  # Skip if exceeds the window height
@@ -283,8 +297,9 @@ def draw_packetlog_win():
             logString = logString[:width - 3]
 
             # Add to the window
-            packetlog_win.addstr(i + 2, 1, logString)
-
+            packetlog_win.addstr(i + 2, 1, logString, get_color("log"))
+            
+        packetlog_win.attrset(get_color("window_frame"))
         packetlog_win.box()
         packetlog_win.refresh()
 
@@ -307,24 +322,46 @@ def main_ui(stdscr):
     messages_box = curses.newwin(height - 6, messages_width, 3, channel_width)
     nodes_box = curses.newwin(height - 6, nodes_width, 3, channel_width + messages_width)
 
+    entry_win.bkgd(get_color("background"))
+    channel_box.bkgd(get_color("background"))
+    messages_box.bkgd(get_color("background"))
+    nodes_box.bkgd(get_color("background"))
+
     # Will be resized to what we need when drawn
     messages_pad = curses.newpad(1, 1)
     nodes_pad = curses.newpad(1,1)
     channel_pad = curses.newpad(1,1)
 
+    messages_pad.bkgd(get_color("background"))
+    nodes_pad.bkgd(get_color("background"))
+    channel_pad.bkgd(get_color("background"))
+
     function_win = curses.newwin(3, width, height - 3, 0)
     packetlog_win = curses.newwin(int(height / 3), messages_width, height - int(height / 3) - 3, channel_width)
 
-    draw_centered_text_field(function_win, f"↑→↓← = Select    ENTER = Send    ` = Settings    ^P = Packet Log    ESC = Quit")
+    function_win.bkgd(get_color("background"))
+    packetlog_win.bkgd(get_color("background"))
+
+    draw_centered_text_field(function_win, f"↑→↓← = Select    ENTER = Send    ` = Settings    ^P = Packet Log    ESC = Quit",0 ,get_color("commands"))
 
     # Draw boxes around windows
-    channel_box.attrset(curses.color_pair(2))
+
+    # Set the normal frame color for the channel box
+    channel_box.attrset(get_color("window_frame"))
     channel_box.box()
-    channel_box.attrset(curses.color_pair(0))
+
+    # Draw boxes for other windows
+    entry_win.attrset(get_color("window_frame"))
     entry_win.box()
+
+    nodes_box.attrset(get_color("window_frame"))
     nodes_box.box()
+
+    messages_box.attrset(get_color("window_frame"))
     messages_box.box()
-    function_win.box() 
+
+    function_win.attrset(get_color("window_frame"))
+    function_win.box()
 
     # Refresh all windows
     entry_win.refresh()
@@ -343,7 +380,7 @@ def main_ui(stdscr):
     draw_messages_window(True)
 
     while True:
-        draw_text_field(entry_win, f"Input: {input_text[-(width - 10):]}")
+        draw_text_field(entry_win, f"Input: {input_text[-(width - 10):]}", get_color("input"))
 
         # Get user input from entry window
         char = entry_win.get_wch()
@@ -411,40 +448,40 @@ def main_ui(stdscr):
             globals.current_window = (globals.current_window + delta) % 3
 
             if old_window == 0:
-                channel_box.attrset(curses.color_pair(0))
+                channel_box.attrset(get_color("window_frame"))
                 channel_box.box()
                 channel_box.refresh()
                 highlight_line(False, 0, globals.selected_channel)
                 refresh_pad(0)
             if old_window == 1:
-                messages_box.attrset(curses.color_pair(0))
+                messages_box.attrset(get_color("window_frame"))
                 messages_box.box()
                 messages_box.refresh()
                 refresh_pad(1)
             elif old_window == 2:
-                nodes_box.attrset(curses.color_pair(0))
+                nodes_box.attrset(get_color("window_frame"))
                 nodes_box.box()
                 nodes_box.refresh()
                 highlight_line(False, 2, globals.selected_node)
                 refresh_pad(2)
 
             if globals.current_window == 0:
-                channel_box.attrset(curses.color_pair(2))
+                channel_box.attrset(get_color("window_frame_selected"))
                 channel_box.box()
-                channel_box.attrset(curses.color_pair(0))
+                channel_box.attrset(get_color("window_frame"))
                 channel_box.refresh()
                 highlight_line(True, 0, globals.selected_channel)
                 refresh_pad(0)
             elif globals.current_window == 1:
-                messages_box.attrset(curses.color_pair(2))
+                messages_box.attrset(get_color("window_frame_selected"))
                 messages_box.box()
-                messages_box.attrset(curses.color_pair(0))
+                messages_box.attrset(get_color("window_frame"))
                 messages_box.refresh()
                 refresh_pad(1)
             elif globals.current_window == 2:
-                nodes_box.attrset(curses.color_pair(2))
+                nodes_box.attrset(get_color("window_frame_selected"))
                 nodes_box.box()
-                nodes_box.attrset(curses.color_pair(0))
+                nodes_box.attrset(get_color("window_frame"))
                 nodes_box.refresh()
                 highlight_line(True, 2, globals.selected_node)
                 refresh_pad(2)
@@ -475,7 +512,7 @@ def main_ui(stdscr):
                 draw_channel_list()
                 draw_messages_window(True)
 
-            else:
+            elif len(input_text) > 0:
                 # Enter key pressed, send user input as message
                 send_message(input_text, channel=globals.selected_channel)
                 draw_messages_window(True)

utilities/interfaces.py

@@ -1,6 +1,5 @@
-import meshtastic.serial_interface
-import meshtastic.tcp_interface
-import meshtastic.ble_interface
+import logging
+import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
 import globals
 
 def initialize_interface(args):
@@ -12,6 +11,6 @@ def initialize_interface(args):
         try:
             return meshtastic.serial_interface.SerialInterface(args.port)
         except PermissionError as ex:
-            print("You probably need to add yourself to the `dialout` group to use a serial connection.")
+            logging.error("You probably need to add yourself to the `dialout` group to use a serial connection.")
         if globals.interface.devPath is None:
             return meshtastic.tcp_interface.TCPInterface("meshtastic.local")