diff --git a/software/tools/modbus_tool/README.de.md b/software/tools/modbus_tool/README.de.md new file mode 100644 index 0000000..ad9a59b --- /dev/null +++ b/software/tools/modbus_tool/README.de.md @@ -0,0 +1,95 @@ +# Modbus Tool für Bewässerungssystem-Knoten + +Dieses Python-Skript bietet eine interaktive Kommandozeilen-Benutzeroberfläche (TUI) zur Steuerung und Überwachung eines Ventil-Knotens des Bewässerungssystems über Modbus RTU. + +## Features + +- **Interaktive Benutzeroberfläche:** Eine benutzerfreundliche, auf `curses` basierende Oberfläche, die eine einfache Bedienung ermöglicht. +- **Live-Statusanzeige:** Zeigt tabellarisch und in Echtzeit den Zustand des Ventils, die Bewegung, den Motorstrom, die konfigurierten Öffnungs-/Schließzeiten sowie Firmware-Version und Uptime des Geräts an. +- **Volle Kontrolle:** Ermöglicht das Senden von Befehlen zum Öffnen, Schließen und Stoppen des Ventils. +- **Konfiguration zur Laufzeit:** Die maximalen Öffnungs- und Schließzeiten können direkt in der Oberfläche geändert werden. +- **Anpassbares Design:** Die Benutzeroberfläche ist für eine klare Lesbarkeit mit einem durchgehenden blauen Hintergrund und abgesetzten Schaltflächen gestaltet. + +## Installation + +### Voraussetzungen + +- Python 3.x +- `pip` (Python Paket-Installer) + +### Installation der Abhängigkeiten + +Die benötigten Python-Pakete sind in der Datei `requirements.txt` aufgeführt. Sie können auf zwei Arten installiert werden: global oder in einer virtuellen Umgebung (empfohlen). + +#### Option 1: Installation mit virtueller Umgebung (empfohlen) + +Eine virtuelle Umgebung isoliert die Projekt-Abhängigkeiten von Ihrem globalen Python-System, was Konflikte vermeidet. + +1. **Virtuelle Umgebung erstellen:** + Führen Sie im Verzeichnis `software/tools/modbus_tool` den folgenden Befehl aus, um eine Umgebung im Ordner `.venv` zu erstellen: + ```bash + python3 -m venv .venv + ``` + +2. **Umgebung aktivieren:** + - **Linux / macOS:** + ```bash + source .venv/bin/activate + ``` + Ihre Shell-Anzeige sollte sich ändern und `(.venv)` am Anfang zeigen. + - **Windows (cmd.exe):** + ```bash + .venv\Scripts\activate.bat + ``` + - **Windows (PowerShell):** + ```powershell + .venv\Scripts\Activate.ps1 + ``` + +3. **Abhängigkeiten installieren:** + Wenn die Umgebung aktiv ist, installieren Sie die Pakete: + ```bash + pip install -r requirements.txt + ``` + +4. **Umgebung deaktivieren:** + Wenn Sie fertig sind, können Sie die Umgebung mit folgendem Befehl wieder verlassen: + ```bash + deactivate + ``` + +#### Option 2: Globale Installation (nicht empfohlen) + +Wenn Sie keine virtuelle Umgebung verwenden möchten, können Sie die Pakete direkt in Ihrem globalen Python-System installieren. + +```bash +pip install -r requirements.txt +``` + +## Verwendung + +Stellen Sie sicher, dass das Skript ausführbar ist: +```bash +chmod +x modbus_tool.py +``` + +Starten Sie das Tool, indem Sie den seriellen Port als Argument übergeben: + +```bash +./modbus_tool.py /dev/ttyACM0 +``` +Ersetzen Sie `/dev/ttyACM0` durch den korrekten Port Ihres Geräts. + +### Kommandozeilen-Argumente + +- `port`: (Erforderlich) Der serielle Port (z.B. `/dev/ttyACM0` oder `COM3`). +- `--baud`: Die Baudrate (Standard: `19200`). +- `--slave-id`: Die Modbus Slave ID des Geräts (Standard: `1`). +- `--interval`: Das Abfrageintervall für den Status in Sekunden (Standard: `1.0`). + +### Bedienung der Oberfläche + +- **Navigation:** Verwenden Sie die **Pfeiltasten (↑/↓)**, um zwischen den Menüpunkten zu navigieren. +- **Auswählen:** Drücken Sie **Enter**, um den ausgewählten Befehl auszuführen. +- **Werte eingeben:** Bei Aktionen wie "Set Max Opening Time" werden Sie zur Eingabe eines Wertes aufgefordert. Geben Sie den Wert ein und bestätigen Sie mit **Enter**. +- **Beenden:** Wählen Sie den Menüpunkt **"Exit"** und drücken Sie **Enter**. diff --git a/software/tools/modbus_tool/modbus_tool.py b/software/tools/modbus_tool/modbus_tool.py new file mode 100755 index 0000000..64c9473 --- /dev/null +++ b/software/tools/modbus_tool/modbus_tool.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 +import argparse +import threading +import time +import sys +import curses +from pymodbus.client import ModbusSerialClient +from pymodbus.exceptions import ModbusException + +# Register Definitions +REG_INPUT_VALVE_STATE_MOVEMENT = 0x0000 +REG_INPUT_MOTOR_CURRENT_MA = 0x0001 +REG_INPUT_FIRMWARE_VERSION_MAJOR_MINOR = 0x00F0 +REG_INPUT_FIRMWARE_VERSION_PATCH = 0x00F1 +REG_INPUT_UPTIME_SECONDS_LOW = 0x00F3 +REG_INPUT_UPTIME_SECONDS_HIGH = 0x00F4 +REG_HOLDING_VALVE_COMMAND = 0x0000 +REG_HOLDING_MAX_OPENING_TIME_S = 0x0001 +REG_HOLDING_MAX_CLOSING_TIME_S = 0x0002 + +# Global state +stop_event = threading.Event() +client = None +status_data = {} +status_lock = threading.Lock() + +def poll_status(slave_id, interval): + """Periodically polls the status of the node and updates the global status_data dict.""" + global status_data + while not stop_event.is_set(): + new_data = {"error": None} + try: + # Read all registers in a few calls + rr = client.read_input_registers(REG_INPUT_VALVE_STATE_MOVEMENT, count=2, slave=slave_id) + hr = client.read_holding_registers(REG_HOLDING_MAX_OPENING_TIME_S, count=2, slave=slave_id) + rr_sys = client.read_input_registers(REG_INPUT_FIRMWARE_VERSION_MAJOR_MINOR, count=5, slave=slave_id) + + if rr.isError(): raise ModbusException(f"reading valve status: {rr}") + if hr.isError(): raise ModbusException(f"reading holding registers: {hr}") + if rr_sys.isError(): raise ModbusException(f"reading system status: {rr_sys}") + + valve_state_raw = rr.registers[0] + movement_map = {0: "Idle", 1: "Opening", 2: "Closing", 3: "Error"} + state_map = {0: "Closed", 1: "Open"} + new_data["movement"] = movement_map.get(valve_state_raw >> 8, 'Unknown') + new_data["state"] = state_map.get(valve_state_raw & 0xFF, 'Unknown') + new_data["motor_current"] = f"{rr.registers[1]} mA" + new_data["open_time"] = f"{hr.registers[0]}s" + new_data["close_time"] = f"{hr.registers[1]}s" + + fw_major = rr_sys.registers[0] >> 8 + fw_minor = rr_sys.registers[0] & 0xFF + fw_patch = rr_sys.registers[1] + uptime_low = rr_sys.registers[3] + uptime_high = rr_sys.registers[4] + uptime = (uptime_high << 16) | uptime_low + new_data["firmware"] = f"v{fw_major}.{fw_minor}.{fw_patch}" + new_data["uptime"] = f"{uptime}s" + + except ModbusException as e: + new_data["error"] = f"Modbus Error: {e}" + except Exception as e: + new_data["error"] = f"Unexpected Error: {e}" + + with status_lock: + status_data = new_data + time.sleep(interval) + +def draw_button(stdscr, y, x, text, selected=False): + """Draws a button with a border, handling selection highlight.""" + button_width = len(text) + 4 + if selected: + color = curses.color_pair(2) # Highlighted (blue on white) + else: + color = curses.color_pair(1) # Normal (white on blue) + + # Draw the button background and text + stdscr.addstr(y, x, " " * button_width, color) + stdscr.addstr(y, x + 2, text, color) + # Draw the border with the same color attribute + stdscr.addstr(y - 1, x, "┌" + "─" * (button_width - 2) + "┐", color) + stdscr.addstr(y, x, "│", color) + stdscr.addstr(y, x + button_width - 1, "│", color) + stdscr.addstr(y + 1, x, "└" + "─" * (button_width - 2) + "┘", color) + +def get_user_input(stdscr, h, w, prompt): + """Safely get user input in a curses window.""" + curses.echo() + curses.curs_set(1) + stdscr.nodelay(0) + input_line_y = h - 2 + stdscr.addstr(input_line_y, 0, " " * (w - 1), curses.color_pair(1)) + stdscr.addstr(input_line_y, 0, prompt, curses.color_pair(1) | curses.A_BOLD) + stdscr.refresh() + # Input should be on a white background for readability + input_win = curses.newwin(1, w - len(prompt) - 1, input_line_y, len(prompt)) + input_win.bkgd(' ', curses.color_pair(4)) # Black on white + input_str = input_win.getstr().decode('utf-8') + + stdscr.nodelay(1) + curses.noecho() + curses.curs_set(0) + return input_str + +def show_message(stdscr, h, w, message, is_error=False, duration=1.5): + """Display a message for a short duration.""" + msg_y = h - 2 + color = curses.color_pair(3) if is_error else curses.color_pair(1) + stdscr.addstr(msg_y, 0, " " * (w - 1), color) + stdscr.addstr(msg_y, 0, message, color | curses.A_BOLD) + stdscr.refresh() + time.sleep(duration) + +def main_menu(stdscr, slave_id): + """The main curses UI with a full blue background.""" + global status_data + curses.curs_set(0) + stdscr.nodelay(1) + stdscr.timeout(100) + + # Initialize colors + curses.start_color() + curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE) # Main: white on blue + curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_WHITE) # Selected: blue on white + curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLUE) # Error: red on blue + curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_WHITE) # Input: black on white + + # Set the background for the whole screen + stdscr.bkgd(' ', curses.color_pair(1)) + + menu = ["Open Valve", "Close Valve", "Stop Valve", "Set Max Opening Time", "Set Max Closing Time", "Exit"] + current_row_idx = 0 + + while not stop_event.is_set(): + stdscr.clear() # Clear screen with the background color + h, w = stdscr.getmaxyx() + + # --- Draw Status Area --- + with status_lock: + current_data = status_data.copy() + + if current_data.get("error"): + stdscr.addstr(0, 0, current_data["error"], curses.color_pair(3) | curses.A_BOLD) + else: + # Use a single color pair, bold for labels + bold = curses.color_pair(1) | curses.A_BOLD + normal = curses.color_pair(1) + col1_x, col2_x, col3_x = 2, 35, 70 + stdscr.addstr(1, col1_x, "Valve State:", bold) + stdscr.addstr(1, col1_x + 14, str(current_data.get('state', 'N/A')), normal) + stdscr.addstr(2, col1_x, "Movement:", bold) + stdscr.addstr(2, col1_x + 14, str(current_data.get('movement', 'N/A')), normal) + stdscr.addstr(3, col1_x, "Motor Current:", bold) + stdscr.addstr(3, col1_x + 14, str(current_data.get('motor_current', 'N/A')), normal) + + stdscr.addstr(1, col2_x, "Max Open Time:", bold) + stdscr.addstr(1, col2_x + 16, str(current_data.get('open_time', 'N/A')), normal) + stdscr.addstr(2, col2_x, "Max Close Time:", bold) + stdscr.addstr(2, col2_x + 16, str(current_data.get('close_time', 'N/A')), normal) + + stdscr.addstr(1, col3_x, "Firmware:", bold) + stdscr.addstr(1, col3_x + 11, str(current_data.get('firmware', 'N/A')), normal) + stdscr.addstr(2, col3_x, "Uptime:", bold) + stdscr.addstr(2, col3_x + 11, str(current_data.get('uptime', 'N/A')), normal) + stdscr.addstr(5, 0, "─" * (w - 1), normal) + + # --- Draw Menu Buttons --- + for idx, row in enumerate(menu): + x = w // 2 - (len(row) + 4) // 2 + y = h // 2 - (len(menu)) + (idx * 3) + draw_button(stdscr, y, x, row, idx == current_row_idx) + + stdscr.refresh() + key = stdscr.getch() + + if key == curses.KEY_UP and current_row_idx > 0: + current_row_idx -= 1 + elif key == curses.KEY_DOWN and current_row_idx < len(menu) - 1: + current_row_idx += 1 + elif key == curses.KEY_ENTER or key in [10, 13]: + selected_option = menu[current_row_idx] + + if selected_option == "Exit": + stop_event.set() + break + elif selected_option == "Open Valve": + client.write_register(REG_HOLDING_VALVE_COMMAND, 1, slave=slave_id) + show_message(stdscr, h, w, "-> Sent OPEN command") + elif selected_option == "Close Valve": + client.write_register(REG_HOLDING_VALVE_COMMAND, 2, slave=slave_id) + show_message(stdscr, h, w, "-> Sent CLOSE command") + elif selected_option == "Stop Valve": + client.write_register(REG_HOLDING_VALVE_COMMAND, 0, slave=slave_id) + show_message(stdscr, h, w, "-> Sent STOP command") + elif "Set Max" in selected_option: + prompt = f"Enter new value for '{selected_option}' (seconds): " + input_str = get_user_input(stdscr, h, w, prompt) + try: + seconds = int(input_str) + reg = REG_HOLDING_MAX_OPENING_TIME_S if "Opening" in selected_option else REG_HOLDING_MAX_CLOSING_TIME_S + client.write_register(reg, seconds, slave=slave_id) + show_message(stdscr, h, w, f"-> Set '{selected_option}' to {seconds}s") + except ValueError: + show_message(stdscr, h, w, "-> Invalid input. Please enter a number.", is_error=True) + except Exception as e: + show_message(stdscr, h, w, f"-> Error: {e}", is_error=True) + +def main(): + global client + parser = argparse.ArgumentParser(description="Modbus tool for irrigation system nodes.") + parser.add_argument("port", help="Serial port (e.g., /dev/ttyACM0)") + parser.add_argument("--baud", type=int, default=19200, help="Baud rate") + parser.add_argument("--slave-id", type=int, default=1, help="Modbus slave ID") + parser.add_argument("--interval", type=float, default=1.0, help="Polling interval (sec)") + args = parser.parse_args() + + client = ModbusSerialClient(port=args.port, baudrate=args.baud, stopbits=1, bytesize=8, parity="N", timeout=1) + if not client.connect(): + print(f"Error: Failed to connect to serial port {args.port}") + sys.exit(1) + + print(f"Successfully connected to {args.port}. Starting UI...") + time.sleep(0.5) + + poll_thread = threading.Thread(target=poll_status, args=(args.slave_id, args.interval)) + poll_thread.daemon = True + poll_thread.start() + + try: + curses.wrapper(main_menu, args.slave_id) + finally: + stop_event.set() + print("\nExiting...") + if client.is_socket_open(): + client.close() + poll_thread.join(timeout=2) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/software/tools/modbus_tool/requirements.txt b/software/tools/modbus_tool/requirements.txt new file mode 100644 index 0000000..97b5493 --- /dev/null +++ b/software/tools/modbus_tool/requirements.txt @@ -0,0 +1,2 @@ +pymodbus>=3.6.0 +pyserial>=3.5