Modbus RTU Communication

import json
import threading
import time
from datetime import datetime
from typing import Dict, List, Callable
import sqlite3

class ModbusDataLogger:
    def __init__(self, modbus_master: ModbusMaster, db_path: str = 'modbus_data.db'):
        self.modbus = modbus_master
        self.db_path = db_path
        self.devices = {}
        self.logging = False
        self.callbacks = {}
        
        # Initialize database
        self._init_database()
        
    def _init_database(self):
        """Initialize SQLite database for data logging"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Create tables
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS device_config (
                device_id INTEGER PRIMARY KEY,
                slave_id INTEGER NOT NULL,
                name TEXT NOT NULL,
                description TEXT,
                poll_interval REAL DEFAULT 1.0,
                enabled BOOLEAN DEFAULT 1,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS register_config (
                register_id INTEGER PRIMARY KEY,
                device_id INTEGER REFERENCES device_config(device_id),
                register_type TEXT NOT NULL,
                address INTEGER NOT NULL,
                count INTEGER DEFAULT 1,
                name TEXT NOT NULL,
                unit TEXT,
                scale_factor REAL DEFAULT 1.0,
                offset REAL DEFAULT 0.0,
                enabled BOOLEAN DEFAULT 1
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS data_log (
                log_id INTEGER PRIMARY KEY,
                register_id INTEGER REFERENCES register_config(register_id),
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                raw_value INTEGER,
                scaled_value REAL,
                quality_code INTEGER DEFAULT 0
            )
        ''')
        
        conn.commit()
        conn.close()
        
    def add_device(self, slave_id: int, name: str, description: str = "", poll_interval: float = 1.0):
        """Add device to monitoring"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO device_config (slave_id, name, description, poll_interval)
            VALUES (?, ?, ?, ?)
        ''', (slave_id, name, description, poll_interval))
        
        device_id = cursor.lastrowid
        conn.commit()
        conn.close()
        
        self.devices[device_id] = {
            'slave_id': slave_id,
            'name': name,
            'description': description,
            'poll_interval': poll_interval,
            'registers': {},
            'last_poll': 0
        }
        
        print(f"📱 Added device: {name} (Slave ID: {slave_id})")
        return device_id
        
    def add_register(self, device_id: int, register_type: str, address: int, name: str,
                    count: int = 1, unit: str = "", scale_factor: float = 1.0, offset: float = 0.0):
        """Add register to monitor"""
        if device_id not in self.devices:
            print(f"❌ Device {device_id} not found")
            return None
            
        valid_types = ['holding', 'input', 'coil', 'discrete']
        if register_type not in valid_types:
            print(f"❌ Invalid register type. Must be one of: {valid_types}")
            return None
            
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO register_config (device_id, register_type, address, count, name, unit, scale_factor, offset)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        ''', (device_id, register_type, address, count, name, unit, scale_factor, offset))
        
        register_id = cursor.lastrowid
        conn.commit()
        conn.close()
        
        self.devices[device_id]['registers'][register_id] = {
            'type': register_type,
            'address': address,
            'count': count,
            'name': name,
            'unit': unit,
            'scale_factor': scale_factor,
            'offset': offset
        }
        
        print(f"📊 Added register: {name} ({register_type} @ {address})")
        return register_id
        
    def start_logging(self):
        """Start data logging"""
        if self.logging:
            print("⚠️ Logging already started")
            return
            
        self.logging = True
        self.log_thread = threading.Thread(target=self._logging_worker)
        self.log_thread.daemon = True
        self.log_thread.start()
        
        print("🔄 Data logging started")
        
    def _logging_worker(self):
        """Background logging worker"""
        while self.logging:
            current_time = time.time()
            
            for device_id, device in self.devices.items():
                # Check if it's time to poll this device
                if current_time - device['last_poll'] >= device['poll_interval']:
                    self._poll_device(device_id, device)
                    device['last_poll'] = current_time
                    
            time.sleep(0.1)
            
    def _poll_device(self, device_id: int, device: Dict):
        """Poll a single device"""
        slave_id = device['slave_id']
        
        for register_id, register in device['registers'].items():
            try:
                # Read register based on type
                register_type = register['type']
                address = register['address']
                count = register['count']
                
                if register_type == 'holding':
                    values = self.modbus.read_holding_registers(slave_id, address, count)
                elif register_type == 'input':
                    values = self.modbus.read_input_registers(slave_id, address, count)
                elif register_type == 'coil':
                    values = self.modbus.read_coils(slave_id, address, count)
                elif register_type == 'discrete':
                    values = self.modbus.read_discrete_inputs(slave_id, address, count)
                else:
                    continue
                    
                if values is not None:
                    # Log each value
                    for i, raw_value in enumerate(values):
                        # Apply scaling
                        if isinstance(raw_value, bool):
                            scaled_value = float(raw_value)
                        else:
                            scaled_value = raw_value * register['scale_factor'] + register['offset']
                            
                        # Store in database
                        self._log_value(register_id, raw_value, scaled_value)
                        
                        # Trigger callbacks
                        if register_id in self.callbacks:
                            for callback in self.callbacks[register_id]:
                                try:
                                    callback(register_id, register['name'], scaled_value, register['unit'])
                                except Exception as e:
                                    print(f"Callback error: {e}")
                    
                    quality_code = 0  # Good quality
                else:
                    quality_code = 1  # Bad quality
                    
            except Exception as e:
                print(f"Error polling {device['name']} register {register['name']}: {e}")
                quality_code = 2  # Communication error
                
    def _log_value(self, register_id: int, raw_value: Union[int, bool], scaled_value: float):
        """Log value to database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO data_log (register_id, raw_value, scaled_value)
            VALUES (?, ?, ?)
        ''', (register_id, int(raw_value), scaled_value))
        
        conn.commit()
        conn.close()
        
    def add_callback(self, register_id: int, callback: Callable):
        """Add callback for register value changes"""
        if register_id not in self.callbacks:
            self.callbacks[register_id] = []
        self.callbacks[register_id].append(callback)
        
    def get_current_values(self) -> Dict:
        """Get current values for all registers"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT r.name, r.unit, d.scaled_value, d.timestamp
            FROM register_config r
            JOIN data_log d ON r.register_id = d.register_id
            WHERE d.timestamp = (
                SELECT MAX(timestamp) FROM data_log d2 WHERE d2.register_id = r.register_id
            )
        ''')
        
        results = cursor.fetchall()
        conn.close()
        
        values = {}
        for name, unit, value, timestamp in results:
            values[name] = {
                'value': value,
                'unit': unit,
                'timestamp': timestamp
            }
            
        return values
        
    def get_historical_data(self, register_name: str, hours: int = 24) -> List[Dict]:
        """Get historical data for a register"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT d.timestamp, d.scaled_value, r.unit
            FROM data_log d
            JOIN register_config r ON d.register_id = r.register_id
            WHERE r.name = ? AND d.timestamp >= datetime('now', '-{} hours')
            ORDER BY d.timestamp
        '''.format(hours), (register_name,))
        
        results = cursor.fetchall()
        conn.close()
        
        return [{'timestamp': ts, 'value': val, 'unit': unit} for ts, val, unit in results]
        
    def export_data(self, filename: str, hours: int = 24):
        """Export data to JSON file"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT d.name as device_name, r.name as register_name, r.unit,
                   l.timestamp, l.scaled_value
            FROM data_log l
            JOIN register_config r ON l.register_id = r.register_id
            JOIN device_config d ON r.device_id = d.device_id
            WHERE l.timestamp >= datetime('now', '-{} hours')
            ORDER BY l.timestamp
        '''.format(hours))
        
        results = cursor.fetchall()
        conn.close()
        
        export_data = {
            'export_time': datetime.now().isoformat(),
            'period_hours': hours,
            'data': []
        }
        
        for device_name, register_name, unit, timestamp, value in results:
            export_data['data'].append({
                'device': device_name,
                'register': register_name,
                'unit': unit,
                'timestamp': timestamp,
                'value': value
            })
            
        with open(filename, 'w') as f:
            json.dump(export_data, f, indent=2)
            
        print(f"📄 Exported {len(results)} data points to {filename}")
        
    def stop_logging(self):
        """Stop data logging"""
        self.logging = False
        if hasattr(self, 'log_thread'):
            self.log_thread.join()
        print("⏹️ Data logging stopped")

# Usage example
def temperature_alert(register_id, name, value, unit):
    """Alert callback for temperature values"""
    if name.lower().find('temperature') != -1 and value > 80:
        print(f"🚨 HIGH TEMPERATURE ALERT: {name} = {value:.1f}°{unit}")

# Create data logger
logger = ModbusDataLogger(modbus)

# Add devices and registers
device1_id = logger.add_device(1, "Temperature Controller", "Main process temperature", 2.0)
logger.add_register(device1_id, 'input', 0, 'Temperature', unit='°C', scale_factor=0.1)
logger.add_register(device1_id, 'input', 1, 'Humidity', unit='%', scale_factor=0.1)
logger.add_register(device1_id, 'coil', 0, 'Heater Status')

device2_id = logger.add_device(2, "Flow Meter", "Process flow measurement", 1.0)
logger.add_register(device2_id, 'input', 0, 'Flow Rate', unit='L/min', scale_factor=0.01)
logger.add_register(device2_id, 'holding', 0, 'Flow Setpoint', unit='L/min')

# Add temperature alert callback
temp_register_id = 1  # Assuming this is the temperature register ID
logger.add_callback(temp_register_id, temperature_alert)

# Start logging
logger.start_logging()

try:
    # Run for a while
    time.sleep(60)
    
    # Show current values
    current = logger.get_current_values()
    print("📊 Current Values:")
    for name, data in current.items():
        print(f"  {name}: {data['value']:.2f} {data['unit']}")
    
    # Export data
    logger.export_data('modbus_data.json', 1)
    
except KeyboardInterrupt:
    print("Stopping data logger...")
    
finally:
    logger.stop_logging()

import tkinter as tk
from tkinter import ttk, messagebox
import threading
import time
from typing import Dict

class ModbusHMI:
    def __init__(self, modbus_master: ModbusMaster):
        self.modbus = modbus_master
        self.root = tk.Tk()
        self.root.title("Modbus HMI Interface")
        self.root.geometry("800x600")
        
        self.devices = {}
        self.widgets = {}
        self.monitoring = False
        
        self._create_interface()
        
    def _create_interface(self):
        """Create HMI interface"""
        # Main notebook for tabs
        notebook = ttk.Notebook(self.root)
        notebook.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Device tab
        self.device_frame = ttk.Frame(notebook)
        notebook.add(self.device_frame, text='Devices')
        self._create_device_tab()
        
        # Control tab
        self.control_frame = ttk.Frame(notebook)
        notebook.add(self.control_frame, text='Control')
        self._create_control_tab()
        
        # Diagnostics tab
        self.diag_frame = ttk.Frame(notebook)
        notebook.add(self.diag_frame, text='Diagnostics')
        self._create_diagnostics_tab()
        
    def _create_device_tab(self):
        """Create device monitoring tab"""
        # Device list
        device_list_frame = ttk.LabelFrame(self.device_frame, text="Devices")
        device_list_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Treeview for device data
        columns = ('Device', 'Address', 'Value', 'Unit', 'Status', 'Last Update')
        self.device_tree = ttk.Treeview(device_list_frame, columns=columns, show='headings')
        
        for col in columns:
            self.device_tree.heading(col, text=col)
            self.device_tree.column(col, width=120)
            
        self.device_tree.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Control buttons
        button_frame = ttk.Frame(device_list_frame)
        button_frame.pack(fill='x', padx=5, pady=5)
        
        ttk.Button(button_frame, text="Start Monitoring", command=self._start_monitoring).pack(side='left', padx=5)
        ttk.Button(button_frame, text="Stop Monitoring", command=self._stop_monitoring).pack(side='left', padx=5)
        ttk.Button(button_frame, text="Scan Slaves", command=self._scan_slaves).pack(side='left', padx=5)
        ttk.Button(button_frame, text="Add Device", command=self._show_add_device_dialog).pack(side='left', padx=5)
        
    def _create_control_tab(self):
        """Create manual control tab"""
        # Manual control section
        control_frame = ttk.LabelFrame(self.control_frame, text="Manual Control")
        control_frame.pack(fill='x', padx=5, pady=5)
        
        # Read registers section
        read_frame = ttk.LabelFrame(control_frame, text="Read Registers")
        read_frame.pack(fill='x', padx=5, pady=5)
        
        ttk.Label(read_frame, text="Slave ID:").grid(row=0, column=0, padx=5, pady=2, sticky='w')
        self.read_slave_var = tk.IntVar(value=1)
        ttk.Entry(read_frame, textvariable=self.read_slave_var, width=10).grid(row=0, column=1, padx=5, pady=2)
        
        ttk.Label(read_frame, text="Address:").grid(row=0, column=2, padx=5, pady=2, sticky='w')
        self.read_addr_var = tk.IntVar(value=0)
        ttk.Entry(read_frame, textvariable=self.read_addr_var, width=10).grid(row=0, column=3, padx=5, pady=2)
        
        ttk.Label(read_frame, text="Count:").grid(row=0, column=4, padx=5, pady=2, sticky='w')
        self.read_count_var = tk.IntVar(value=1)
        ttk.Entry(read_frame, textvariable=self.read_count_var, width=10).grid(row=0, column=5, padx=5, pady=2)
        
        ttk.Button(read_frame, text="Read Holding", command=lambda: self._manual_read('holding')).grid(row=1, column=0, padx=5, pady=5)
        ttk.Button(read_frame, text="Read Input", command=lambda: self._manual_read('input')).grid(row=1, column=1, padx=5, pady=5)
        ttk.Button(read_frame, text="Read Coils", command=lambda: self._manual_read('coil')).grid(row=1, column=2, padx=5, pady=5)
        
        # Result display
        self.read_result_var = tk.StringVar(value="No data read yet")\n        ttk.Label(read_frame, textvariable=self.read_result_var, background='white', relief='sunken').grid(row=2, column=0, columnspan=6, padx=5, pady=5, sticky='ew')
        
        # Write registers section
        write_frame = ttk.LabelFrame(control_frame, text="Write Registers")
        write_frame.pack(fill='x', padx=5, pady=5)
        
        ttk.Label(write_frame, text="Slave ID:").grid(row=0, column=0, padx=5, pady=2, sticky='w')
        self.write_slave_var = tk.IntVar(value=1)
        ttk.Entry(write_frame, textvariable=self.write_slave_var, width=10).grid(row=0, column=1, padx=5, pady=2)
        
        ttk.Label(write_frame, text="Address:").grid(row=0, column=2, padx=5, pady=2, sticky='w')
        self.write_addr_var = tk.IntVar(value=0)
        ttk.Entry(write_frame, textvariable=self.write_addr_var, width=10).grid(row=0, column=3, padx=5, pady=2)
        
        ttk.Label(write_frame, text="Value:").grid(row=0, column=4, padx=5, pady=2, sticky='w')
        self.write_value_var = tk.StringVar(value="0")
        ttk.Entry(write_frame, textvariable=self.write_value_var, width=15).grid(row=0, column=5, padx=5, pady=2)
        
        ttk.Button(write_frame, text="Write Register", command=self._manual_write_register).grid(row=1, column=0, padx=5, pady=5)
        ttk.Button(write_frame, text="Write Coil", command=self._manual_write_coil).grid(row=1, column=1, padx=5, pady=5)
        
    def _create_diagnostics_tab(self):
        """Create diagnostics tab"""
        diag_frame = ttk.LabelFrame(self.diag_frame, text="Communication Statistics")
        diag_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Statistics display
        self.stats_text = tk.Text(diag_frame, height=20, width=60)
        self.stats_text.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Control buttons
        button_frame = ttk.Frame(diag_frame)
        button_frame.pack(fill='x', padx=5, pady=5)
        
        ttk.Button(button_frame, text="Update Stats", command=self._update_statistics).pack(side='left', padx=5)
        ttk.Button(button_frame, text="Reset Stats", command=self._reset_statistics).pack(side='left', padx=5)
        ttk.Button(button_frame, text="Test Connection", command=self._test_connection).pack(side='left', padx=5)
        
    def add_device(self, slave_id: int, name: str, registers: List[Dict]):
        """Add device to monitor"""
        device_id = f"device_{slave_id}"
        self.devices[device_id] = {
            'slave_id': slave_id,
            'name': name,
            'registers': registers,
            'last_values': {},
            'status': 'Unknown'
        }
        
        # Add to treeview
        for reg in registers:
            item_id = f"{device_id}_{reg['address']}"
            self.device_tree.insert('', 'end', iid=item_id, values=(
                name, f"{reg['type']}.{reg['address']}", 
                '--', reg.get('unit', ''), 'Unknown', 'Never'
            ))
            
    def _start_monitoring(self):
        """Start device monitoring"""
        if self.monitoring:
            return
            
        self.monitoring = True
        self.monitor_thread = threading.Thread(target=self._monitor_devices)
        self.monitor_thread.daemon = True
        self.monitor_thread.start()
        
    def _stop_monitoring(self):
        """Stop device monitoring"""
        self.monitoring = False
        
    def _monitor_devices(self):
        """Monitor devices in background thread"""
        while self.monitoring:
            for device_id, device in self.devices.items():
                slave_id = device['slave_id']
                
                for reg in device['registers']:
                    try:
                        # Read register
                        if reg['type'] == 'holding':
                            values = self.modbus.read_holding_registers(slave_id, reg['address'], 1)
                        elif reg['type'] == 'input':
                            values = self.modbus.read_input_registers(slave_id, reg['address'], 1)
                        elif reg['type'] == 'coil':
                            values = self.modbus.read_coils(slave_id, reg['address'], 1)
                        else:
                            continue
                            
                        if values:
                            value = values[0]
                            device['status'] = 'Online'
                            
                            # Update treeview (thread-safe)
                            item_id = f"{device_id}_{reg['address']}"
                            self.root.after(0, self._update_treeview_item, item_id, value, reg.get('unit', ''))
                            
                    except Exception as e:
                        device['status'] = 'Error'
                        
            time.sleep(1)  # Poll every second
            
    def _update_treeview_item(self, item_id: str, value, unit: str):
        """Update treeview item (GUI thread)"""
        try:
            current_values = list(self.device_tree.item(item_id)['values'])
            current_values[2] = str(value)  # Value column
            current_values[3] = unit  # Unit column
            current_values[4] = 'Online'  # Status column
            current_values[5] = time.strftime('%H:%M:%S')  # Last update column
            
            self.device_tree.item(item_id, values=current_values)
        except:
            pass  # Item might not exist
            
    def _manual_read(self, register_type: str):
        """Manual register read"""
        try:
            slave_id = self.read_slave_var.get()
            address = self.read_addr_var.get()
            count = self.read_count_var.get()
            
            if register_type == 'holding':
                values = self.modbus.read_holding_registers(slave_id, address, count)
            elif register_type == 'input':
                values = self.modbus.read_input_registers(slave_id, address, count)
            elif register_type == 'coil':
                values = self.modbus.read_coils(slave_id, address, count)
            else:
                values = None
                
            if values:
                result = f"Success: {values}"
            else:
                result = "Failed to read"
                
            self.read_result_var.set(result)
            
        except Exception as e:
            self.read_result_var.set(f"Error: {e}")
            
    def _manual_write_register(self):
        """Manual register write"""
        try:
            slave_id = self.write_slave_var.get()
            address = self.write_addr_var.get()
            value = int(self.write_value_var.get())
            
            success = self.modbus.write_single_register(slave_id, address, value)
            
            if success:
                messagebox.showinfo("Success", f"Register {address} written successfully")
            else:
                messagebox.showerror("Error", "Failed to write register")
                
        except Exception as e:
            messagebox.showerror("Error", f"Write error: {e}")
            
    def _manual_write_coil(self):
        """Manual coil write"""
        try:
            slave_id = self.write_slave_var.get()
            address = self.write_addr_var.get()
            value = self.write_value_var.get().lower() in ('1', 'true', 'on')
            
            success = self.modbus.write_single_coil(slave_id, address, value)
            
            if success:
                messagebox.showinfo("Success", f"Coil {address} written successfully")
            else:
                messagebox.showerror("Error", "Failed to write coil")
                
        except Exception as e:
            messagebox.showerror("Error", f"Write error: {e}")
            
    def _scan_slaves(self):
        """Scan for Modbus slaves"""
        def scan_thread():
            try:
                slaves = self.modbus.scan_slaves(10)  # Scan first 10 slave IDs
                self.root.after(0, lambda: messagebox.showinfo("Scan Results", f"Found slaves: {slaves}"))
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Scan Error", f"Scan failed: {e}"))
                
        threading.Thread(target=scan_thread, daemon=True).start()
        
    def _update_statistics(self):
        """Update statistics display"""
        stats = self.modbus.get_statistics()
        
        stats_text = "Modbus Communication Statistics\n"
        stats_text += "=" * 40 + "\n\n"
        
        for key, value in stats.items():
            if key == 'success_rate':
                stats_text += f"{key.replace('_', ' ').title()}: {value:.1f}%\n"
            else:
                stats_text += f"{key.replace('_', ' ').title()}: {value}\n"
                
        self.stats_text.delete(1.0, tk.END)
        self.stats_text.insert(tk.END, stats_text)
        
    def _reset_statistics(self):
        """Reset communication statistics"""
        self.modbus.reset_statistics()
        self._update_statistics()
        
    def _test_connection(self):
        """Test Modbus connection"""
        def test_thread():
            try:
                # Try to read from slave 1
                result = self.modbus.read_holding_registers(1, 0, 1)
                if result is not None:
                    self.root.after(0, lambda: messagebox.showinfo("Connection Test", "Connection OK"))
                else:
                    self.root.after(0, lambda: messagebox.showwarning("Connection Test", "No response from slave"))
            except Exception as e:
                self.root.after(0, lambda: messagebox.showerror("Connection Test", f"Connection failed: {e}"))
                
        threading.Thread(target=test_thread, daemon=True).start()
        
    def _show_add_device_dialog(self):
        """Show add device dialog"""
        dialog = tk.Toplevel(self.root)
        dialog.title("Add Device")
        dialog.geometry("400x300")
        
        ttk.Label(dialog, text="Slave ID:").grid(row=0, column=0, padx=5, pady=5, sticky='w')
        slave_id_var = tk.IntVar(value=1)
        ttk.Entry(dialog, textvariable=slave_id_var).grid(row=0, column=1, padx=5, pady=5)
        
        ttk.Label(dialog, text="Name:").grid(row=1, column=0, padx=5, pady=5, sticky='w')
        name_var = tk.StringVar(value="Device")
        ttk.Entry(dialog, textvariable=name_var).grid(row=1, column=1, padx=5, pady=5)
        
        def add_device_action():
            registers = [
                {'type': 'holding', 'address': 0, 'unit': ''},
                {'type': 'input', 'address': 0, 'unit': ''},
            ]
            self.add_device(slave_id_var.get(), name_var.get(), registers)
            dialog.destroy()
            
        ttk.Button(dialog, text="Add", command=add_device_action).grid(row=2, column=0, columnspan=2, pady=10)
        
    def run(self):
        """Run the HMI interface"""
        # Add sample devices
        self.add_device(1, "Temperature Controller", [
            {'type': 'input', 'address': 0, 'unit': '°C'},
            {'type': 'input', 'address': 1, 'unit': '%'},
            {'type': 'coil', 'address': 0, 'unit': ''}
        ])
        
        self.add_device(2, "Flow Meter", [
            {'type': 'input', 'address': 0, 'unit': 'L/min'},
            {'type': 'holding', 'address': 0, 'unit': 'L/min'}
        ])
        
        self.root.mainloop()

# Usage
if modbus.connect():
    hmi = ModbusHMI(modbus)
    hmi.run()