Merge branch 'main' of https://github.com/davidson-engineering/remote-app-monitor into davidson-engineering-main

Author: generalmattza

README.md

@@ -1,9 +1,120 @@
-# project_name
-### project_summary
+# Remote App Monitor
 
-project description
+`remote-app-monitor` is a Python-based tool designed to facilitate remote monitoring of applications by creating and managing monitor elements like progress bars, tables, and range bars. It allows for efficient, customizable data visualization and monitoring from both serial and ZeroMQ data sources.
 
+## Features
 
+- **Modular Monitors**: Configure multiple monitor elements such as RangeBars, Log Monitors, and Tables.
+- **Group Functionality**: Group elements under specific IDs for easy reference and enhanced organization (e.g., `X.velocity`, `X.torque`).
+- **Asynchronous Updating**: Updates monitored data asynchronously at a set rate, independent of data input frequency.
+- **Serial and ZeroMQ Communication**: Supports both serial and ZeroMQ data sources, enabling flexible data streaming.
+- **ANSI-Formatted Terminal Output**: Customize terminal output with ANSI colors and formatting for clear visual differentiation.
+
+## Installation
+
+1. **Clone the Repository**:
+   ```bash
+   git clone https://github.com/davidson-engineering/remote-app-monitor.git
+   cd remote-app-monitor
+   ```
+
+2. **Install Dependencies**:
+   Make sure you have Python 3.7+ installed, then install dependencies:
+   ```bash
+   pip install .
+   ```
+
+## Usage
+
+### Basic Setup
+
+1. **Initialize the Monitor**:
+   ```python
+   from remote_app_monitor import Monitor
+
+   monitor = Monitor()
+   ```
+
+2. **Add Monitor Elements**:
+   Add various monitor elements like `RangeBar`, `LogMonitor`, or `Table` with unique IDs:
+   ```python
+   monitor.add_range_bar("X.velocity", min_val=0, max_val=100)
+   monitor.add_log("X.torque", timestamp=True)
+   monitor.add_table("system_status")
+   ```
+
+3. **Start Monitoring**:
+   Start the monitor asynchronously. Data can then be sent to update each element.
+   ```python
+   monitor.start()
+   ```
+
+### Serial Server
+
+The `remote-app-monitor` includes a **Serial Server** to handle communication with serial devices, enabling real-time monitoring from an Arduino or similar microcontroller. The Serial Server is optimized for speed, using a custom protocol to minimize overhead.
+
+1. **Initialize the Serial Server**:
+   ```python
+   from remote_app_monitor import SerialServer
+
+   serial_server = SerialServer(port='COM3', baudrate=9600)
+   monitor.add_server(serial_server)
+   ```
+
+2. **Start Serial Communication**:
+   Once the Serial Server is added, the monitor will handle incoming data:
+   ```python
+   serial_server.start()
+   ```
+
+3. **Updating Elements via Serial**:
+   Data packets received over serial should match the monitor element IDs (e.g., `X.velocity`, `X.torque`). The Serial Server will parse and update the respective elements.
+
+### ZeroMQ Server
+
+`remote-app-monitor` also includes a **ZeroMQ Server** to support scalable data communication through a PUB-SUB pattern, ideal for real-time, remote monitoring from multiple data sources.
+
+1. **Initialize the ZeroMQ Server**:
+   ```python
+   from remote_app_monitor import ZeroMQServer
+
+   zmq_server = ZeroMQServer("tcp://localhost:5555")
+   monitor.add_server(zmq_server)
+   ```
+
+2. **Start ZeroMQ Communication**:
+   Similar to the Serial Server, the ZeroMQ server will handle incoming data from remote publishers:
+   ```python
+   zmq_server.start()
+   ```
+
+3. **Publishing Data to ZeroMQ**:
+   From a remote data source, publish updates that match monitor element IDs (e.g., `X.velocity`, `X.torque`). ZeroMQ will parse and distribute the data to the correct elements.
+
+### Example: Grouping Elements
+
+Elements can be grouped under an ID to allow for structured, hierarchical monitoring. For example, `X` could represent an axis, with `X.velocity` and `X.torque` representing specific monitored metrics:
+
+```python
+monitor.add_range_bar("X.velocity", min_val=0, max_val=100)
+monitor.add_range_bar("X.torque", min_val=0, max_val=500)
+monitor.add_log("X.status", timestamp=True)
 ```
-some demonstrative code
-```
+
+### Example: Socket Based Remote Monitor
+
+The SocketManager class can be used to push data to a socket that can be fed to a service such as an HTML page.
+See the file [html_monitor_example.py](https://github.com/davidson-engineering/remote-app-monitor/blob/f40e98c6b4bc729f2f2e2dbddc4e4c305bfd0a42/html_monitor_example.py)
+<img width="863" alt="image" src="https://github.com/user-attachments/assets/25d4d863-92a9-4207-bdc9-0849cbb3f10c">
+
+## Customization
+
+Each monitor element can be customized with parameters during initialization:
+
+- **RangeBar**: Configure min/max values, colors, and update frequency.
+- **LogMonitor**: Set timestamps, log format, and custom colors.
+- **Table**: Define columns, row structure, and update formats.
+
+## License
+
+This project is licensed under the MIT License.

html_monitor_example.py

@@ -0,0 +1,71 @@
+from flask import Flask, render_template
+from flask_socketio import SocketIO
+import asyncio
+import threading
+
+from app_monitor import SocketManager
+from app_monitor.server import OrderedDecoder, SerialUpdateServer
+from app_monitor.elements_base import TextElement
+from app_monitor.text_formatter import TextFormat
+
+app = Flask(__name__)
+app.config["SECRET_KEY"] = "secret!"
+socketio = SocketIO(app)
+
+# Initialize SocketManager with Flask-SocketIO instance
+manager = SocketManager(socketio=socketio, frequency=20)  # 20Hz update rate
+
+text_format = TextFormat(width=9, precision=3, force_sign=True)
+
+data_formats = {
+    "position_x": text_format,
+    "position_y": text_format,
+    "position_z": text_format,
+    "motor1_speed": None,
+    "motor1_torque": None,
+    "motor1_status": None,
+    "motor2_speed": None,
+    "motor2_torque": None,
+    "motor2_status": None,
+    "motor3_speed": None,
+    "motor3_torque": None,
+    "motor3_status": None,
+    "motor4_speed": None,
+    "motor4_torque": None,
+    "motor4_status": None,
+}
+# Define and add elements to the manager
+for name, format in data_formats.items():
+    text_element = TextElement(element_id=name, text_format=format)
+    manager.add_element(text_element)
+
+# Set up the Serial Update Server
+server = SerialUpdateServer(
+    manager,
+    detect_devices=True,
+    baudrate=115200,
+    decoder=OrderedDecoder(keys=data_formats.keys()),
+)
+
+
+@app.route("/")
+def index():
+    return render_template("example.html")
+
+
+def run_flask():
+    """Run Flask in a separate thread."""
+    socketio.run(app, port=5000)
+
+
+async def main():
+    # Start the Flask app in a separate thread
+    flask_thread = threading.Thread(target=run_flask)
+    flask_thread.start()
+
+    # Start the asyncio tasks
+    await asyncio.gather(manager.push_data(), server.start(frequency=20))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

main.py

@@ -17,7 +17,7 @@
 from config_loader import load_configs
 
 from app_monitor import (
-    MonitorManager,
+    TerminalManager,
     ProgressBar,
     Table,
     RangeBar,
@@ -43,7 +43,7 @@ async def main():
     logging.info(configs["application"])
 
     # Create a MonitorManager instances
-    manager = MonitorManager()
+    manager = TerminalManager()
 
     # Add a progress bar and table elements with formatting
     BAR_WIDTH = 30

src/app_monitor/__init__.py

@@ -1,7 +1,7 @@
 __version__ = "0.1.1"
 
 
-from .app_monitor import MonitorManager
+from .app_monitor import TerminalManager, SocketManager
 from .elements_base import (
     ProgressBar,
     Table,

src/app_monitor/app_monitor.py

@@ -47,7 +47,29 @@ def update(self, element_id, *args):
                 element.update(*args)
                 break
 
-    def update_all_elements(self):
+    def generate_element_id_map(self):
+        """Generate a list of all element IDs in the monitor manager."""
+        element_count = 0
+
+        def _element_id_generator(elements):
+            """Recursively generate element IDs."""
+            nonlocal element_count
+            for element in elements:
+                if isinstance(element, MonitorGroup):
+                    yield from _element_id_generator(element.elements.values())
+                else:
+                    yield element_count, element.element_id
+                    element_count += 1
+
+        return {
+            str(number): element_id
+            for number, element_id in _element_id_generator(self.elements)
+        }
+
+
+class TerminalManager(MonitorManager):
+
+    def update_screen_buffer(self):
         """Construct the full screen content in a buffer"""
         self.buffer = []  # Clear the buffer for the new frame
 
@@ -73,42 +95,67 @@ async def update_screen_fixed_rate(self, frequency=1):
             self.update_screen()  # Display the current metrics
             await asyncio.sleep(1 / frequency)  # Wait for the next update cycle
 
-    async def update_all_elements_fixed_rate(self, frequency=1):
+    async def update_screen_buffer_fixed_rate(self, frequency=1):
         """Asynchronously update all elements at a fixed rate."""
         assert frequency > 0, "Frequency must be greater than 0."
         while True:
-            self.update_all_elements()
+            self.update_screen_buffer()
             await asyncio.sleep(1 / frequency)
 
     async def update_fixed_rate(self, frequency=30):
         await asyncio.gather(
             self.update_screen_fixed_rate(frequency=frequency),
-            self.update_all_elements_fixed_rate(frequency=frequency),
+            self.update_screen_buffer_fixed_rate(frequency=frequency),
         )
 
-    def generate_element_id_map(self):
-        """Generate a list of all element IDs in the monitor manager."""
-        element_count = 0
 
-        def _element_id_generator(elements):
-            """Recursively generate element IDs."""
-            nonlocal element_count
-            for element in elements:
-                if isinstance(element, MonitorGroup):
-                    yield from _element_id_generator(element.elements.values())
-                else:
-                    yield element_count, element.element_id
-                    element_count += 1
+import asyncio
+import json
+from flask_socketio import SocketIO
 
-        return {
-            str(number): element_id
-            for number, element_id in _element_id_generator(self.elements)
-        }
+
+class SocketManager(MonitorManager):
+    """Subclass of MonitorManager that adds functionality to push data to a WebSocket."""
+
+    def __init__(self, socketio: SocketIO, frequency=1):
+        """
+        Initialize with a SocketIO instance and a push frequency.
+
+        :param socketio: SocketIO instance to handle WebSocket communication.
+        :param frequency: Frequency in Hz for pushing updates to clients.
+        """
+        super().__init__()  # Initialize the parent MonitorManager
+        self.socketio = socketio
+        self.frequency = frequency
+
+    def to_json(self):
+        """Convert all monitor elements to JSON format."""
+        data = {}
+        for element in self.elements:
+            if isinstance(element, MonitorGroup):
+                data[element.group_id] = {
+                    e_id: el.display() for e_id, el in element.elements.items()
+                }
+            else:
+                data[element.element_id] = element.display()
+        return json.dumps(data)
+
+    async def push_data(self):
+        """Asynchronously push data to all connected WebSocket clients at the specified frequency."""
+        while True:
+            data = self.to_json()  # Get data in JSON format
+            self.socketio.emit("update", data)  # Push data to WebSocket clients
+            await asyncio.sleep(1 / self.frequency)  # Control push frequency
+
+    def set_frequency(self, frequency):
+        """Set the frequency at which data is pushed to clients."""
+        assert frequency > 0, "Frequency must be greater than 0."
+        self.frequency = frequency
 
 
 async def main():
     # Create a MonitorManager instance
-    manager = MonitorManager()
+    manager = TerminalManager()
 
     # Add a text element and a progress bar
     text = TextElement("Buffers")