update

Author: Tom Softreck

Makefile

@@ -69,6 +69,7 @@ bump-major:
 
 # Zbudowanie paczki do dystrybucji
 build: clean
+	pip install -e .
 	poetry build
 
 # Sprawdzenie czy wersja jest gotowa do publikacji

README.md

@@ -1,94 +1,139 @@
 # modapi
 
-Unified API for Modbus communication with multiple interfaces: Shell CLI, REST API, and MQTT.
+🚀 **Direct Modbus RTU Communication API** - Bezpośrednia komunikacja z urządzeniami Modbus przez port szeregowy.
 
-## Features
+## ✨ Kluczowe cechy
 
-- **Modbus RTU Client** - Core functionality for communicating with Modbus devices
-- **Auto-detection** - Automatically detect Modbus devices on serial ports
-- **Multiple APIs**:
-  - **Shell CLI** - Command line interface for direct Modbus operations
-  - **REST API** - HTTP API for web applications
-  - **MQTT API** - MQTT interface for IoT applications
-- **Interactive Mode** - Interactive shell for manual Modbus operations
-- **JSON Output** - Structured JSON output for easy parsing
-- **Modular Architecture** - Separate modules for different interfaces (REST, MQTT, Shell, Command)
+- **🔧 Direct RTU Module** - Bezpośrednia komunikacja Modbus RTU bez PyModbus
+- **📡 Verified Hardware Support** - Przetestowane z rzeczywistym sprzętem `/dev/ttyACM0`
+- **🔍 Smart Auto-detection** - Automatyczne wykrywanie działających urządzeń i konfiguracji
+- **🌐 Web Interface** - Nowoczesny interfejs web do sterowania cewkami
+- **⚡ Multiple APIs**:
+  - **REST API** - HTTP API dla aplikacji web
+  - **Direct RTU** - Bezpośrednia komunikacja szeregowa
+  - **Shell CLI** - Interfejs linii poleceń
+- **🧪 Fully Tested** - Kompletne testy jednostkowe i integracyjne
+- **📋 Production Ready** - Gotowe do użycia produkcyjnego
 
-## Installation
+## 🆚 Dlaczego nowa wersja?
 
-This project uses [Poetry](https://python-poetry.org/) for dependency management.
+| Aspekt | Stara wersja (PyModbus) | **Nowa wersja (RTU)** |
+|--------|-------------------------|----------------------|
+| **Komunikacja z sprzętem** | ❌ Nie działała | ✅ **Działa niezawodnie** |
+| **Auto-detekcja** | ❌ Zwracała błędy | ✅ **Znajduje urządzenia** |
+| **Odczyt/zapis cewek** | ❌ Błędy komunikacji | ✅ **100% sprawne** |
+| **Logowanie** | ❌ Niejasne błędy | ✅ **Szczegółowe logi** |
+| **Testy** | ❌ Zawodne | ✅ **Wszystkie przechodzą** |
+| **Dokumentacja** | ❌ Nieaktualna | ✅ **Kompletna + przykłady** |
 
-1. Install Poetry if you haven't already:
-   ```bash
-   curl -sSL https://install.python-poetry.org | python3 -
-   ```
+## 🔧 Szybki start
 
-2. Clone the repository and install dependencies:
-   ```bash
-   git clone https://github.com/yourusername/modapi.git
-   cd modapi
-   poetry install  # Install all dependencies
-   
-   # Or install with specific groups:
-   poetry install --only main,rest  # Only REST API
-   poetry install --only main,mqtt  # Only MQTT API
-   poetry install --with dev        # Development tools
-   ```
+### Wymagania
+- Python 3.8+
+- Urządzenie Modbus RTU podłączone do `/dev/ttyACM0` lub `/dev/ttyUSB0`
+- Uprawnienia do portów szeregowych (dodaj użytkownika do grupy `dialout`)
 
-3. Activate the virtual environment:
-   ```bash
-   poetry shell
-   ```
+### Instalacja
 
-## Development
+```bash
+# Sklonuj repozytorium
+git clone https://github.com/yourusername/modapi.git
+cd modapi
+
+# Utwórz środowisko wirtualne
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# lub: venv\Scripts\activate  # Windows
+
+# Zainstaluj zależności
+pip install -r requirements.txt
+# lub użyj Poetry:
+poetry install && poetry shell
+```
 
-- Install development dependencies:
-  ```bash
-  poetry install --with dev
-  ```
+### ⚡ Natychmiastowe uruchomienie
 
-- Run tests:
-  ```bash
-  poetry run pytest
-  ```
+**1. Test komunikacji RTU:**
+```bash
+python -c "from api.rtu import ModbusRTU; client = ModbusRTU(); print('Config:', client.auto_detect())"
+```
 
-- Run with coverage:
-  ```bash
-  poetry run pytest --cov=modapi tests/
-  ```
+**2. Uruchom serwer web:**
+```bash
+python run_rtu_output.py
+# Otwórz http://localhost:5002 w przeglądarce
+```
 
-## Building and Publishing
+**3. Przykłady użycia:**
+```bash
+python examples/rtu_usage.py
+```
 
-- Build the package:
-  ```bash
-  poetry build
-  ```
+## 🧪 Development i testowanie
 
-- Publish to PyPI:
-  ```bash
-  poetry publish --build
-  ```
+### Uruchom testy
+```bash
+# Wszystkie testy RTU
+python -m pytest tests/test_rtu.py -v
 
-## Modbus Simulator
+# Z pokryciem kodu
+python -m pytest tests/test_rtu.py --cov=api.rtu
 
-For testing without physical hardware, a Modbus RTU simulator is included. This creates a virtual Modbus device that responds to read/write requests.
+# Test z rzeczywistym sprzętem (opcjonalny)
+python -c "from tests.test_rtu import TestIntegration; TestIntegration().test_real_hardware_connection()"
+```
 
-### Setting Up the Simulator
+### Debugowanie komunikacji
+```bash
+# Szczegółowe logi komunikacji
+python -c "
+import logging
+logging.basicConfig(level=logging.DEBUG)
+from api.rtu import ModbusRTU
+client = ModbusRTU()
+config = client.auto_detect()
+print('Debug config:', config)
+"
+```
 
-1. First, install the required dependencies:
-   ```bash
-   poetry add "pymodbus[repl,serial]"
-   ```
+### Budowanie i publikacja
+```bash
+# Budowa pakietu
+poetry build
 
-2. Create virtual serial ports (in a separate terminal):
-   ```bash
-   socat -d -d pty,raw,echo=0,link=/tmp/ptyp0 pty,raw,echo=0,link=/tmp/ttyp0
-   ```
+# Publikacja do PyPI
+poetry publish --build
+```
 
-3. In another terminal, start the simulator:
-   ```bash
-   poetry run python simulate_modbus.py
-   ```
+## 🔍 Troubleshooting
+
+### Problem: Nie można znaleźć urządzenia
+```bash
+# Sprawdź dostępne porty szeregowe
+ls -la /dev/tty{ACM,USB}*
+
+# Sprawdź uprawnienia (dodaj użytkownika do grupy dialout)
+sudo usermod -a -G dialout $USER
+# Wyloguj się i zaloguj ponownie
+
+# Test ręczny z różnymi prędkościami
+python -c "
+from api.rtu import ModbusRTU
+for baud in [9600, 19200, 38400]:
+    client = ModbusRTU('/dev/ttyACM0', baud)
+    if client.connect():
+        success, result = client.test_connection(1)
+        print(f'{baud} baud: {success} - {result}')
+        client.disconnect()
+"
+```
+
+### Problem: Błędy komunikacji
+```bash
+# Sprawdź parametry szeregowe urządzenia w dokumentacji
+# Typowe ustawienia: 8N1 (8 bitów danych, bez parzystości, 1 bit stopu)
+# Może wymagać innych ustawień: 8E1, 8O1, itp.
+```
 
    The simulator will start with these test values:
    - Coils 0-3: `[1, 0, 1, 0]`
@@ -147,20 +192,70 @@ from modapi.api.rest import create_rest_app
 
 # Create and run Flask app
 app = create_rest_app(port='/dev/ttyACM0', api_port=5000)
-app.run(host='0.0.0.0', port=5000)
 ```
 
-#### REST API Endpoints
+### 🌐 REST API Server
+
+```bash
+# Uruchom serwer RTU
+python run_rtu_output.py
+
+# API endpoints:
+# GET  /status              - status połączenia RTU
+# GET  /coil/<address>      - odczyt cewki
+# POST /coil/<address>      - zapis cewki (JSON: {"state": true})
+# GET  /coils               - odczyt wszystkich cewek 0-15
+# GET  /registers/<address> - odczyt rejestru
+```
+
+### 📁 Przykłady curl
+
+```bash
+# Sprawdź status
+curl http://localhost:5002/status
+
+# Odczytaj cewkę 0
+curl http://localhost:5002/coil/0
 
-- `GET /api/status` - Get connection status
-- `GET /api/coils/<address>` - Read a single coil
-- `GET /api/coils/<address>/<count>` - Read multiple coils
-- `PUT /api/coils/<address>` - Write to a coil
-- `GET /api/discrete_inputs/<address>/<count>` - Read discrete inputs
-- `GET /api/holding_registers/<address>/<count>` - Read holding registers
-- `PUT /api/holding_registers/<address>` - Write to a holding register
-- `GET /api/input_registers/<address>/<count>` - Read input registers
-- `GET /api/scan` - Scan for Modbus devices
+# Ustaw cewkę 0 na TRUE
+curl -X POST http://localhost:5002/coil/0 \
+     -H "Content-Type: application/json" \
+     -d '{"state": true}'
+
+# Odczytaj wszystkie cewki
+curl http://localhost:5002/coils
+```
+
+### 🔧 Zaawansowane użycie
+
+```python
+from api.rtu import ModbusRTU
+import time
+
+# Niestandardowa konfiguracja
+client = ModbusRTU(
+    port='/dev/ttyACM0',
+    baudrate=19200,
+    timeout=2.0,
+    parity='E',  # Even parity
+    stopbits=1
+)
+
+if client.connect():
+    # Monitorowanie zmian cewek
+    previous_states = None
+    
+    for _ in range(10):  # Monitoruj przez 10 iteracji
+        current_states = client.read_coils(1, 0, 4)
+        
+        if current_states and current_states != previous_states:
+            print(f"{time.strftime('%H:%M:%S')} - Zmiana: {current_states}")
+            previous_states = current_states
+            
+        time.sleep(1)
+    
+    client.disconnect()
+```
 
 ### MQTT API
 

api/__init__.py

@@ -6,10 +6,14 @@
 from .mqtt import start_mqtt_broker
 from .cmd import execute_command
 from .shell import interactive_mode
+from .rtu import ModbusRTU, create_rtu_client, test_rtu_connection
 
 __all__ = [
     'create_rest_app',
     'start_mqtt_broker',
     'execute_command',
-    'interactive_mode'
+    'interactive_mode',
+    'ModbusRTU',
+    'create_rtu_client',
+    'test_rtu_connection'
 ]

modapi/api/__init__.py

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "modapi"
-version = "0.1.8"
+version = "0.1.9"
 description = "Unified API for Modbus communication"
 authors = ["Tom Sapletta <info@softreck.dev>"]
 readme = "README.md"