Improve database page layout and highlight most recent data

Layout improvements:
- Reorganized cards to fit 3 across on large screens (col-lg-4)
- View database, download data, and danger zone now on same row
- Added h-100 class to cards for equal height
- Made delete button larger and full-width for better visibility

Button spacing:
- Added mb-2 (margin-bottom) to all measurement trigger buttons
- Improved vertical spacing for better readability

Data visualization:
- Added light green background (#d4edda) to first table row
- First row now highlights the most recent data entry
- Makes it easy to see the latest sensor reading at a glance

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.claude/README.md

@@ -0,0 +1,21 @@
+# Claude Code Settings
+
+This directory contains configuration for Claude Code.
+
+## Files
+
+- **settings.json**: Project-wide default settings (tracked in git)
+- **settings.local.json**: Local user-specific overrides (not tracked in git)
+
+## Usage
+
+The `settings.json` file contains the default configuration that applies to all developers/devices. If you need to customize settings for your local environment, create a `settings.local.json` file which will override the defaults.
+
+### Example: Create local overrides
+
+```bash
+cp .claude/settings.json .claude/settings.local.json
+# Edit settings.local.json with your preferences
+```
+
+Your local changes will not be committed to git.

.claude/settings.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3:*)"
+    ],
+    "deny": []
+  },
+  "enableAllProjectMcpServers": false
+}

.gitignore

@@ -14,4 +14,9 @@ NPM/data/*.txt
 NPM/data/*.json
 *.lock
 sqlite/*.db
-tests/
+sqlite/*.sql
+
+tests/
+
+# Claude Code local settings
+.claude/settings.local.json

CLAUDE.md

@@ -0,0 +1,270 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+NebuleAir Pro 4G is an environmental monitoring system running on Raspberry Pi 4/CM4. It collects air quality and environmental data from multiple sensors and transmits it via 4G cellular modem. The system includes a self-hosted web interface for configuration and monitoring.
+
+## Architecture
+
+### Data Flow
+1. **Data Collection**: Sensors are polled by individual Python scripts triggered by systemd timers
+2. **Local Storage**: All sensor data is stored in SQLite database (`sqlite/sensors.db`)
+3. **Data Transmission**: Main loop script reads aggregated data from SQLite and transmits via SARA R4/R5 4G modem
+4. **Web Interface**: Apache serves PHP pages that interact with SQLite and execute Python scripts
+
+### Key Components
+
+**Sensors & Hardware:**
+- NextPM (NPM): Particulate matter sensor via Modbus (ttyAMA0)
+- Envea CAIRSENS: Gas sensors (NO2, H2S, NH3, CO, O3) via serial (ttyAMA2-5)
+- BME280: Temperature, humidity, pressure via I2C (0x76)
+- NSRT MK4: Noise sensor via I2C (0x48)
+- SARA R4/R5: 4G cellular modem (ttyAMA2)
+- Wind meter: via ADS1115 ADC
+- MPPT: Solar charger monitoring
+
+**Software Stack:**
+- OS: Raspberry Pi OS (Linux)
+- Web server: Apache2
+- Database: SQLite3
+- Languages: Python 3, PHP, Bash
+- Network: NetworkManager (nmcli)
+
+### Directory Structure
+- `NPM/`: NextPM sensor scripts
+- `envea/`: Envea sensor scripts
+- `BME280/`: BME280 sensor scripts
+- `sound_meter/`: Noise sensor code (C program)
+- `SARA/`: 4G modem communication (AT commands)
+- `windMeter/`: Wind sensor scripts
+- `MPPT/`: Solar charger scripts
+- `RTC/`: DS3231 real-time clock module scripts
+- `sqlite/`: Database scripts (create, read, write, config)
+- `loop/`: Main data transmission script
+- `html/`: Web interface files
+- `services/`: Systemd service/timer configuration
+- `logs/`: Application logs
+
+## Common Development Commands
+
+### Database Operations
+```bash
+# Initialize database
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/create_db.py
+
+# Set configuration
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/set_config.py
+
+# Read data from specific table
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/read.py <table_name> <limit>
+```
+
+### Systemd Services
+The system uses systemd timers for scheduling sensor data collection:
+
+```bash
+# View all NebuleAir timers
+systemctl list-timers | grep nebuleair
+
+# Check specific service status
+systemctl status nebuleair-npm-data.service
+systemctl status nebuleair-sara-data.service
+
+# View service logs
+journalctl -u nebuleair-npm-data.service
+journalctl -u nebuleair-sara-data.service -f  # follow
+
+# Restart services
+systemctl restart nebuleair-npm-data.timer
+systemctl restart nebuleair-sara-data.timer
+
+# Setup all services
+sudo /var/www/nebuleair_pro_4g/services/setup_services.sh
+```
+
+**Service Schedule:**
+- `nebuleair-npm-data.timer`: Every 10 seconds (NextPM sensor)
+- `nebuleair-envea-data.timer`: Every 10 seconds (Envea sensors)
+- `nebuleair-sara-data.timer`: Every 60 seconds (4G data transmission)
+- `nebuleair-bme280-data.timer`: Every 120 seconds (BME280 sensor)
+- `nebuleair-mppt-data.timer`: Every 120 seconds (MPPT charger)
+- `nebuleair-noise-data.timer`: Every 60 seconds (Noise sensor)
+- `nebuleair-db-cleanup-data.timer`: Daily (database cleanup)
+
+### Sensor Testing
+```bash
+# Test NextPM sensor
+/usr/bin/python3 /var/www/nebuleair_pro_4g/NPM/get_data_modbus_v3.py
+
+# Test Envea sensors (read reference/ID)
+/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_ref_v2.py
+
+# Test Envea sensor values
+/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_value_v2.py
+
+# Test BME280
+/usr/bin/python3 /var/www/nebuleair_pro_4g/BME280/get_data_v2.py
+
+# Test noise sensor
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sound_meter/NSRT_mk4_get_data.py
+
+# Test RTC module
+/usr/bin/python3 /var/www/nebuleair_pro_4g/RTC/read.py
+
+# Test MPPT charger
+/usr/bin/python3 /var/www/nebuleair_pro_4g/MPPT/read.py
+```
+
+### 4G Modem (SARA R4/R5)
+```bash
+# Send AT command
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 "AT+CSQ" 5
+
+# Check network connection
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_connectNetwork.py ttyAMA2 <networkID> 120
+
+# Set server URL (HTTP profile 0 for AirCarto)
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_setURL.py ttyAMA2 data.nebuleair.fr 0
+
+# Check modem status
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/check_running.py
+```
+
+### Network Configuration
+```bash
+# Scan WiFi networks (saved to wifi_list.csv)
+nmcli device wifi list ifname wlan0
+
+# Connect to WiFi
+sudo nmcli device wifi connect "SSID" password "PASSWORD"
+
+# Create hotspot (done automatically at boot if no connection)
+sudo nmcli device wifi hotspot ifname wlan0 ssid nebuleair_pro password nebuleaircfg
+
+# Check connection status
+nmcli device show wlan0
+nmcli device show eth0
+```
+
+### Permissions & Serial Ports
+```bash
+# Grant serial port access (run at boot via cron)
+chmod 777 /dev/ttyAMA* /dev/i2c-1
+
+# Check I2C devices
+sudo i2cdetect -y 1
+```
+
+### Logs
+```bash
+# View main application log
+tail -f /var/www/nebuleair_pro_4g/logs/app.log
+
+# View SARA transmission log
+tail -f /var/www/nebuleair_pro_4g/logs/sara_service.log
+
+# View service-specific logs
+tail -f /var/www/nebuleair_pro_4g/logs/npm_service.log
+tail -f /var/www/nebuleair_pro_4g/logs/envea_service.log
+
+# Clear logs (done daily via cron)
+find /var/www/nebuleair_pro_4g/logs -name "*.log" -type f -exec truncate -s 0 {} \;
+```
+
+## Configuration System
+
+Configuration is stored in SQLite database (`sqlite/sensors.db`) in the `config_table`:
+
+**Key Configuration Parameters:**
+- `deviceID`: Unique device identifier (string)
+- `modem_config_mode`: When true, disables data transmission loop (bool)
+- `modem_version`: SARA R4 or R5 (string)
+- `SaraR4_baudrate`: Modem baudrate, usually 115200 or 9600 (int)
+- `SARA_R4_neworkID`: Cellular network ID for connection (int)
+- `send_miotiq`: Enable UDP transmission to Miotiq server (bool)
+- `send_aircarto`: Enable HTTP transmission to AirCarto server (bool)
+- `send_uSpot`: Enable HTTPS transmission to uSpot server (bool)
+- `npm_5channel`: Enable 5-channel particle size distribution (bool)
+- `envea`: Enable Envea gas sensors (bool)
+- `windMeter`: Enable wind meter (bool)
+- `BME280`: Enable BME280 sensor (bool)
+- `MPPT`: Enable MPPT charger monitoring (bool)
+- `NOISE`: Enable noise sensor (bool)
+- `latitude_raw`, `longitude_raw`: GPS coordinates (float)
+
+Configuration can be updated via web interface (launcher.php) or Python scripts in `sqlite/`.
+
+## Data Transmission Protocols
+
+### 1. UDP to Miotiq (Binary Protocol)
+- 100-byte fixed binary payload via UDP socket
+- Server: 192.168.0.20:4242
+- Format: Device ID (8 bytes) + signal quality + sensor data (all packed as binary)
+
+### 2. HTTP POST to AirCarto
+- CSV payload sent as file attachment
+- URL: `data.nebuleair.fr/pro_4G/data.php?sensor_id={id}&datetime={timestamp}`
+- Uses SARA HTTP client (AT+UHTTPC profile 0)
+
+### 3. HTTPS POST to uSpot
+- JSON payload with SSL/TLS
+- URL: `api-prod.uspot.probesys.net/nebuleair?token=2AFF6dQk68daFZ` (port 443)
+- Uses SARA HTTPS client with certificate validation (AT+UHTTPC profile 1)
+
+## Important Implementation Notes
+
+### SARA R4/R5 Modem Communication
+- The main transmission script (`loop/SARA_send_data_v2.py`) handles complex error recovery
+- Error codes from AT+UHTTPER command trigger specific recovery actions:
+  - Error 4: Invalid hostname → Reset HTTP profile URL
+  - Error 11: Server connection error → Hardware modem reboot
+  - Error 22: PDP connection issue → Reset PSD/CSD connection (R5 only)
+  - Error 26/44: Timeout/connection lost → Send WiFi notification
+  - Error 73: SSL error → Re-import certificate and reset HTTPS profile
+- Modem hardware reboot uses GPIO 16 (transistor control to cut power)
+- Script waits 2 minutes after system boot before executing
+
+### Serial Communication
+- All UART ports must be enabled in `/boot/firmware/config.txt`
+- Permissions reset after reboot, must be re-granted via cron @reboot
+- Read functions use custom timeout logic to handle slow modem responses
+- Special handling for multi-line AT command responses using `wait_for_lines` parameter
+
+### Time Synchronization
+- DS3231 RTC module maintains time when no network available
+- RTC timestamp stored in SQLite (`timestamp_table`)
+- Script compares server datetime (from HTTP headers) with RTC
+- Auto-updates RTC if difference > 60 seconds
+- Handles RTC reset condition (year 2000) and disconnection
+
+### LED Indicators
+- GPIO 23 (blue LED): Successful data transmission
+- GPIO 24 (red LED): Transmission errors
+- Uses thread locking to prevent GPIO conflicts
+
+### Web Interface
+- Apache DocumentRoot set to `/var/www/nebuleair_pro_4g`
+- `html/launcher.php` provides REST-like API for all operations
+- Uses shell_exec() to run Python scripts with proper sudo permissions
+- Configuration updates modify SQLite database, not JSON files
+
+### Security Considerations
+- www-data user has sudo access to specific commands (defined in /etc/sudoers)
+- Terminal command execution in launcher.php has whitelist of allowed commands
+- No sensitive credentials should be committed (all in database/config files)
+
+## Boot Sequence
+
+1. Grant serial/I2C permissions (cron @reboot)
+2. Check WiFi connection, start hotspot if needed (`boot_hotspot.sh`)
+3. Start SARA modem initialization (`SARA/reboot/start.py`)
+4. Systemd timers begin sensor data collection
+5. SARA transmission loop begins after 2-minute delay
+
+## Cron Jobs
+
+Located in `/var/www/nebuleair_pro_4g/cron_jobs`:
+- @reboot: Permissions setup, hotspot check, SARA initialization
+- Daily 00:00: Truncate log files

GPIO/control.py

@@ -0,0 +1,40 @@
+'''
+   ____ ____ ___ ___  
+  / ___|  _ \_ _/ _ \ 
+ | |  _| |_) | | | | |
+ | |_| |  __/| | |_| |
+  \____|_|  |___\___/ 
+                      
+script to control GPIO output
+
+GPIO 16 -> SARA 5V
+GPIO 20 -> SARA PWR ON
+
+option 1:
+CLI tool like pinctrl
+pinctrl set 16 op
+pinctrl set 16 dh
+pinctrl set 16 dl
+
+option 2:
+python library RPI.GPIO
+
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/GPIO/control.py
+'''
+
+import RPi.GPIO as GPIO
+import time
+
+selected_GPIO = 16 
+
+GPIO.setmode(GPIO.BCM)  # Use BCM numbering
+GPIO.setup(selected_GPIO, GPIO.OUT)  # Set GPIO17 as an output
+
+while True:
+    GPIO.output(selected_GPIO, GPIO.HIGH)  # Turn ON
+    time.sleep(1)  # Wait 1 sec
+    GPIO.output(selected_GPIO, GPIO.LOW)   # Turn OFF
+    time.sleep(1)  # Wait 1 sec
+
+

MPPT/read.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+  __  __ ____  ____ _____ 
+ |  \/  |  _ \|  _ \_   _|
+ | |\/| | |_) | |_) || |  
+ | |  | |  __/|  __/ | |  
+ |_|  |_|_|   |_|    |_|  
+
+MPPT Chargeur solaire Victron interface UART
+
+MPPT connections
+5V / Rx / TX / GND
+RPI connection
+-- / GPIO9 / GPIO8 / GND
+* pas besoin de connecter le 5V (le GND uniquement)
+
+Fixed version - properly handles continuous data stream
+"""
+
+import serial
+import time
+import sqlite3
+import os
+
+# ===== LOGGING CONFIGURATION =====
+# Set to True to enable all print statements, False to run silently
+DEBUG_MODE = False
+
+# Alternative: Use environment variable (can be set in systemd service)
+# DEBUG_MODE = os.environ.get('MPPT_DEBUG', 'false').lower() == 'true'
+
+# Alternative: Check if running under systemd
+# DEBUG_MODE = os.isatty(1)  # True if running in terminal, False if systemd/cron
+
+# Alternative: Use different log levels
+# LOG_LEVEL = "ERROR"  # Options: "DEBUG", "INFO", "ERROR", "NONE"
+# =================================
+
+# Connect to the SQLite database
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+# Logging function
+def log(message, level="INFO"):
+    """Print message only if DEBUG_MODE is True"""
+    if DEBUG_MODE:
+        print(message)
+    # Alternative: could write to a log file instead
+    # with open('/var/log/mppt.log', 'a') as f:
+    #     f.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} [{level}] {message}\n")
+
+
+def read_vedirect(port='/dev/ttyAMA4', baudrate=19200, timeout=10):
+    """
+    Read and parse data from Victron MPPT controller
+    Returns parsed data as a dictionary
+    """
+    required_keys = ['V', 'I', 'VPV', 'PPV', 'CS']  # Essential keys we need
+    
+    try:
+        log(f"Opening serial port {port} at {baudrate} baud...")
+        ser = serial.Serial(port, baudrate, timeout=1)
+        
+        # Clear any buffered data
+        ser.reset_input_buffer()
+        time.sleep(0.5)
+        
+        # Initialize data dictionary
+        data = {}
+        start_time = time.time()
+        lines_read = 0
+        blocks_seen = 0
+        
+        while time.time() - start_time < timeout:
+            try:
+                line = ser.readline().decode('utf-8', errors='ignore').strip()
+                
+                if not line:
+                    continue
+                
+                lines_read += 1
+                
+                # Check if this line contains tab-separated key-value pair
+                if '\t' in line:
+                    parts = line.split('\t', 1)
+                    if len(parts) == 2:
+                        key, value = parts
+                        data[key] = value
+                        log(f"{key}: {value}")
+                
+                # Check for checksum line (end of block)
+                elif line.startswith('Checksum'):
+                    blocks_seen += 1
+                    log(f"--- End of block {blocks_seen} ---")
+                    
+                    # Check if we have all required keys
+                    missing_keys = [key for key in required_keys if key not in data]
+                    
+                    if not missing_keys:
+                        log(f"✓ Complete data block received after {lines_read} lines!")
+                        ser.close()
+                        return data
+                    else:
+                        log(f"Block {blocks_seen} incomplete, missing: {', '.join(missing_keys)}")
+                        # Don't clear data, maybe we missed the beginning of first block
+                        if blocks_seen > 1:
+                            # If we've seen multiple blocks and still missing data,
+                            # something is wrong
+                            log("Multiple incomplete blocks, clearing data...")
+                            data = {}
+                
+            except UnicodeDecodeError as e:
+                log(f"Decode error: {e}", "ERROR")
+                continue
+            except Exception as e:
+                log(f"Error reading line: {e}", "ERROR")
+                continue
+        
+        # Timeout reached
+        log(f"Timeout after {timeout}s, read {lines_read} lines, saw {blocks_seen} blocks")
+        ser.close()
+        
+        # If we have some data but not all required keys, return what we have
+        if data and len(data) >= len(required_keys) - 1:
+            log("Returning partial data...")
+            return data
+            
+    except serial.SerialException as e:
+        log(f"Serial port error: {e}", "ERROR")
+    except Exception as e:
+        log(f"Unexpected error: {e}", "ERROR")
+    
+    return None
+
+
+def parse_values(data):
+    """Convert string values to appropriate types"""
+    if not data:
+        return None
+        
+    parsed = {}
+    
+    # Define conversions for each key
+    conversions = {
+        'PID': str,
+        'FW': int,
+        'SER#': str,
+        'V': lambda x: float(x)/1000,  # Convert mV to V
+        'I': lambda x: float(x)/1000,  # Convert mA to A
+        'VPV': lambda x: float(x)/1000 if x != '---' else 0,  # Convert mV to V
+        'PPV': int,
+        'CS': int,
+        'MPPT': int,
+        'OR': str,
+        'ERR': int,
+        'LOAD': str,
+        'IL': lambda x: float(x)/1000,  # Convert mA to A
+        'H19': float,  # Total energy absorbed in kWh (already in kWh)
+        'H20': float,  # Total energy discharged in kWh
+        'H21': int,   # Maximum power today (W)
+        'H22': float, # Energy generated today (kWh)
+        'H23': int,   # Maximum power yesterday (W)
+        'HSDS': int   # Day sequence number
+    }
+    
+    # Convert values according to their type
+    for key, value in data.items():
+        if key in conversions:
+            try:
+                parsed[key] = conversions[key](value)
+            except (ValueError, TypeError) as e:
+                log(f"Conversion error for {key}={value}: {e}", "ERROR")
+                parsed[key] = value  # Keep as string if conversion fails
+        else:
+            parsed[key] = value
+    
+    return parsed
+
+
+def get_charger_status(cs_value):
+    """Convert CS numeric value to human-readable status"""
+    status_map = {
+        0: "Off",
+        2: "Fault",
+        3: "Bulk",
+        4: "Absorption",
+        5: "Float",
+        6: "Storage",
+        7: "Equalize",
+        9: "Inverting",
+        11: "Power supply",
+        245: "Starting-up",
+        247: "Repeated absorption",
+        252: "External control"
+    }
+    return status_map.get(cs_value, f"Unknown ({cs_value})")
+
+
+def get_mppt_status(mppt_value):
+    """Convert MPPT value to human-readable status"""
+    mppt_map = {
+        0: "Off",
+        1: "Voltage or current limited",
+        2: "MPP Tracker active"
+    }
+    return mppt_map.get(mppt_value, f"Unknown ({mppt_value})")
+
+
+if __name__ == "__main__":
+    log("=== Victron MPPT Reader ===")
+    log(f"Started at: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Read data
+    raw_data = read_vedirect()
+    
+    if raw_data:
+        # Parse data
+        parsed_data = parse_values(raw_data)
+        
+        if parsed_data:
+            # Display summary
+            log("\n===== MPPT Status Summary =====")
+            log(f"Product: {parsed_data.get('PID', 'Unknown')} (FW: {parsed_data.get('FW', '?')})")
+            log(f"Serial: {parsed_data.get('SER#', 'Unknown')}")
+            log(f"\nBattery: {parsed_data.get('V', 0):.2f}V, {parsed_data.get('I', 0):.2f}A")
+            log(f"Solar Panel: {parsed_data.get('VPV', 0):.2f}V, {parsed_data.get('PPV', 0)}W")
+            log(f"Charger Status: {get_charger_status(parsed_data.get('CS', 0))}")
+            log(f"MPPT Status: {get_mppt_status(parsed_data.get('MPPT', 0))}")
+            log(f"Load Output: {parsed_data.get('LOAD', 'Unknown')}, {parsed_data.get('IL', 0):.2f}A")
+            log(f"\nToday's Energy: {parsed_data.get('H22', 0)}kWh (Max: {parsed_data.get('H21', 0)}W)")
+            log(f"Total Energy: {parsed_data.get('H19', 0)}kWh")
+            
+            # Validate critical values
+            battery_voltage = parsed_data.get('V', 0)
+            
+            if battery_voltage > 0:
+                # Get timestamp
+                try:
+                    cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+                    row = cursor.fetchone()
+                    rtc_time_str = row[1] if row else time.strftime('%Y-%m-%d %H:%M:%S')
+                except:
+                    rtc_time_str = time.strftime('%Y-%m-%d %H:%M:%S')
+                
+                # Extract values for database
+                battery_current = parsed_data.get('I', 0)
+                solar_voltage = parsed_data.get('VPV', 0)
+                solar_power = parsed_data.get('PPV', 0)
+                charger_status = parsed_data.get('CS', 0)
+                
+                # Save to database
+                try:
+                    cursor.execute('''
+                        INSERT INTO data_MPPT (timestamp, battery_voltage, battery_current, solar_voltage, solar_power, charger_status) 
+                        VALUES (?, ?, ?, ?, ?, ?)''', 
+                        (rtc_time_str, battery_voltage, battery_current, solar_voltage, solar_power, charger_status))
+                    
+                    conn.commit()
+                    log(f"\n✓ Data saved to database at {rtc_time_str}")
+                    
+                except sqlite3.Error as e:
+                    # Always log database errors regardless of DEBUG_MODE
+                    if not DEBUG_MODE:
+                        print(f"Database error: {e}")
+                    else:
+                        log(f"\n✗ Database error: {e}", "ERROR")
+                    conn.rollback()
+            else:
+                log("\n✗ Invalid data: Battery voltage is zero or missing", "ERROR")
+        else:
+            log("\n✗ Failed to parse data", "ERROR")
+    else:
+        log("\n✗ No valid data received from MPPT controller", "ERROR")
+        log("\nPossible issues:")
+        log("- Check serial connection (TX/RX/GND)")
+        log("- Verify port is /dev/ttyAMA4")
+        log("- Ensure MPPT is powered on")
+        log("- Check baudrate (should be 19200)")
+    
+    # Always close the connection
+    conn.close()
+    log("\nDone.")

NPM/get_data.py

@@ -14,9 +14,9 @@ import serial
 import requests
 import json
 import sys
+import time
 
 parameter = sys.argv[1:]  # Exclude the script name
-#print("Parameters received:")
 port='/dev/'+parameter[0]
 
 ser = serial.Serial(
@@ -34,42 +34,93 @@ ser.write(b'\x81\x11\x6E')      #data10s
 while True:
     try:
         byte_data = ser.readline()
-        #print(byte_data)
+        
+        # Convert raw data to hex string for debugging
+        raw_hex = byte_data.hex() if byte_data else ""
+        
+        # Check if we received data
+        if not byte_data or len(byte_data) < 15:
+            data = {
+                'PM1': 0.0,
+                'PM25': 0.0,
+                'PM10': 0.0,
+                'sleep': 0,
+                'degradedState': 0,
+                'notReady': 0,
+                'heatError': 0,
+                't_rhError': 0,
+                'fanError': 0,
+                'memoryError': 0,
+                'laserError': 0,
+                'raw': raw_hex,
+                'message': f"No data received or incomplete frame (length: {len(byte_data)})"
+            }
+            json_data = json.dumps(data)
+            print(json_data)
+            break
+        
         stateByte = int.from_bytes(byte_data[2:3], byteorder='big')
         Statebits = [int(bit) for bit in bin(stateByte)[2:].zfill(8)]
         PM1 = int.from_bytes(byte_data[9:11], byteorder='big')/10
         PM25 = int.from_bytes(byte_data[11:13], byteorder='big')/10
         PM10 = int.from_bytes(byte_data[13:15], byteorder='big')/10
-        #print(f"State: {Statebits}")
-        #print(f"PM1: {PM1}")
-        #print(f"PM25: {PM25}")
-        #print(f"PM10: {PM10}")
-        #create JSON
+        
+        # Create JSON with raw data and status message
         data = {
-            'capteurID': 'nebuleairpro1',
-            'sondeID':'USB2',
             'PM1': PM1,
             'PM25': PM25,
             'PM10': PM10,
-            'sleep' : Statebits[0],
-            'degradedState' : Statebits[1],
-            'notReady' : Statebits[2],
-            'heatError' : Statebits[3],
-            't_rhError' : Statebits[4],
-            'fanError' : Statebits[5],
-            'memoryError' : Statebits[6],
-            'laserError' : Statebits[7]
+            'sleep': Statebits[0],
+            'degradedState': Statebits[1],
+            'notReady': Statebits[2],
+            'heatError': Statebits[3],
+            't_rhError': Statebits[4],
+            'fanError': Statebits[5],
+            'memoryError': Statebits[6],
+            'laserError': Statebits[7],
+            'raw': raw_hex,
+            'message': 'OK' if sum(Statebits[1:]) == 0 else 'Sensor error detected'
         }
         json_data = json.dumps(data)
         print(json_data)
         break
+        
     except KeyboardInterrupt:
-        print("User interrupt encountered. Exiting...")
+        data = {
+            'PM1': 0.0,
+            'PM25': 0.0,
+            'PM10': 0.0,
+            'sleep': 0,
+            'degradedState': 0,
+            'notReady': 0,
+            'heatError': 0,
+            't_rhError': 0,
+            'fanError': 0,
+            'memoryError': 0,
+            'laserError': 0,
+            'raw': '',
+            'message': 'User interrupt encountered'
+        }
+        print(json.dumps(data))
         time.sleep(3)
         exit()
-    except:
-        # for all other kinds of error, but not specifying which one
-        print("Unknown error...")
+        
+    except Exception as e:
+        data = {
+            'PM1': 0.0,
+            'PM25': 0.0,
+            'PM10': 0.0,
+            'sleep': 0,
+            'degradedState': 0,
+            'notReady': 0,
+            'heatError': 0,
+            't_rhError': 0,
+            'fanError': 0,
+            'memoryError': 0,
+            'laserError': 0,
+            'raw': '',
+            'message': f'Error: {str(e)}'
+        }
+        print(json.dumps(data))
         time.sleep(3)
-        exit()
-
+        exit()

NPM/get_data_modbus_v2_1.py

@@ -0,0 +1,177 @@
+'''
+  _   _ ____  __  __ 
+ | \ | |  _ \|  \/  |
+ |  \| | |_) | |\/| |
+ | |\  |  __/| |  | |
+ |_| \_|_|   |_|  |_|
+
+Script to get NPM data via Modbus
+
+Improved version with data stream lenght check
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/NPM/get_data_modbus_v3.py
+
+Modbus RTU
+[Slave Address][Function Code][Starting Address][Quantity of Registers][CRC]
+
+Pour récupérer
+ les concentrations en PM1, PM10 et PM2.5 (a partir du registre 0x38)
+ les 5 cannaux
+ la température et l'humidité à l'intérieur du capteur
+Donnée actualisée toutes les 10 secondes
+
+Request
+\x01\x03\x00\x38\x00\x55\...\...
+
+\x01        Slave Address (slave device address)
+\x03        Function code (read multiple holding registers)
+\x00\x38    Starting Address (The request starts reading from holding register address x38 or 56)
+\x00\x55    Quantity of Registers (Requests to read x55 or 85 consecutive registers starting from address 56)
+\...\...    Cyclic Redundancy Check (checksum )
+
+'''
+import serial
+import requests
+import json
+import sys
+import crcmod
+import sqlite3
+import time
+
+# Connect to the SQLite database
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+# Load the configuration data
+npm_solo_port = "/dev/ttyAMA5"  #port du NPM solo
+
+#GET RTC TIME from SQlite
+cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+row = cursor.fetchone()  # Get the first (and only) row
+rtc_time_str = row[1]  # '2025-02-07 12:30:45'
+
+# Initialize serial port
+ser = serial.Serial(
+    port=npm_solo_port,
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout=2
+)
+
+# Define Modbus CRC-16 function
+crc16 = crcmod.predefined.mkPredefinedCrcFun('modbus')
+
+# Request frame without CRC
+data = b'\x01\x03\x00\x38\x00\x55'
+
+# Calculate and append CRC
+crc = crc16(data)
+crc_low = crc & 0xFF
+crc_high = (crc >> 8) & 0xFF
+request = data + bytes([crc_low, crc_high])
+
+# Clear serial buffer before sending
+ser.flushInput()
+
+# Send request
+ser.write(request)
+time.sleep(0.2)  # Wait for sensor to respond
+
+# Read response
+response_length = 2 + 1 + (2 * 85) + 2  # Address + Function + Data + CRC
+byte_data = ser.read(response_length)
+
+# Validate response length
+if len(byte_data) < response_length:
+    print("[ERROR] Incomplete response received:", byte_data.hex())
+    exit()
+
+# Verify CRC
+received_crc = int.from_bytes(byte_data[-2:], byteorder='little')
+calculated_crc = crc16(byte_data[:-2])
+
+if received_crc != calculated_crc:
+    print("[ERROR] CRC check failed! Corrupted data received.")
+    exit()
+
+# Convert response to hex for debugging
+formatted = ''.join(f'\\x{byte:02x}' for byte in byte_data)
+#print("Response:", formatted)
+
+# Extract and print PM values
+def extract_value(byte_data, register, scale=1, single_register=False, round_to=None):
+    REGISTER_START = 56
+    offset = (register - REGISTER_START) * 2 + 3
+
+    if single_register:
+        value = int.from_bytes(byte_data[offset:offset+2], byteorder='big')
+    else:
+        lsw = int.from_bytes(byte_data[offset:offset+2], byteorder='big')  
+        msw = int.from_bytes(byte_data[offset+2:offset+4], byteorder='big')  
+        value = (msw << 16) | lsw
+
+    value = value / scale
+
+    if round_to == 0:
+        return int(value)
+    elif round_to is not None:
+        return round(value, round_to)
+    else:
+        return value
+
+pm1_10s = extract_value(byte_data, 56, 1000, round_to=1)
+pm25_10s = extract_value(byte_data, 58, 1000, round_to=1)
+pm10_10s = extract_value(byte_data, 60, 1000, round_to=1)
+
+#print("10 sec concentration:")
+#print(f"PM1: {pm1_10s}")
+#print(f"PM2.5: {pm25_10s}")
+#print(f"PM10: {pm10_10s}")
+
+# Extract values for 5 channels
+channel_1 = extract_value(byte_data, 128,  round_to=0)  # 0.2 - 0.5μm
+channel_2 = extract_value(byte_data, 130,  round_to=0)  # 0.5 - 1.0μm
+channel_3 = extract_value(byte_data, 132,  round_to=0)  # 1.0 - 2.5μm
+channel_4 = extract_value(byte_data, 134,  round_to=0)  # 2.5 - 5.0μm
+channel_5 = extract_value(byte_data, 136,  round_to=0)  # 5.0 - 10.0μm
+
+#print(f"Channel 1 (0.2->0.5): {channel_1}")
+#print(f"Channel 2 (0.5->1.0): {channel_2}")
+#print(f"Channel 3 (1.0->2.5): {channel_3}")
+#print(f"Channel 4 (2.5->5.0): {channel_4}")
+#print(f"Channel 5 (5.0->10.): {channel_5}")
+
+        
+# Retrieve relative humidity from register 106 (0x6A)
+relative_humidity = extract_value(byte_data, 106, 100, single_register=True)
+# Retrieve temperature from register 106 (0x6A)
+temperature = extract_value(byte_data, 107, 100, single_register=True)
+
+#print(f"Internal Relative Humidity: {relative_humidity} %")
+#print(f"Internal temperature: {temperature} °C")
+
+
+
+cursor.execute('''
+INSERT INTO data_NPM_5channels (timestamp,PM_ch1, PM_ch2, PM_ch3, PM_ch4, PM_ch5) VALUES (?,?,?,?,?,?)'''
+, (rtc_time_str,channel_1,channel_2,channel_3,channel_4,channel_5))
+
+cursor.execute('''
+INSERT INTO data_NPM (timestamp,PM1, PM25, PM10, temp_npm, hum_npm) VALUES (?,?,?,?,?,?)'''
+, (rtc_time_str,pm1_10s,pm25_10s,pm10_10s,temperature,relative_humidity  ))
+
+# Commit and close the connection
+conn.commit()
+
+conn.close()

NPM/get_data_modbus_v3.py

@@ -29,6 +29,8 @@ Request
 \x00\x55    Quantity of Registers (Requests to read x55 or 85 consecutive registers starting from address 56)
 \...\...    Cyclic Redundancy Check (checksum )
 
+MAJ 2026 --> renvoie des 0 si pas de réponse du NPM
+
 '''
 import serial
 import requests
@@ -52,128 +54,144 @@ def load_config(config_file):
         return {}
 
 # Load the configuration data
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-config = load_config(config_file)
-npm_solo_port = config.get('NPM_solo_port', '')  #port du NPM solo
+npm_solo_port = "/dev/ttyAMA5"  #port du NPM solo
 
 #GET RTC TIME from SQlite
 cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
 row = cursor.fetchone()  # Get the first (and only) row
 rtc_time_str = row[1]  # '2025-02-07 12:30:45'
 
-# Initialize serial port
-ser = serial.Serial(
-    port=npm_solo_port,
-    baudrate=115200,
-    parity=serial.PARITY_EVEN,
-    stopbits=serial.STOPBITS_ONE,
-    bytesize=serial.EIGHTBITS,
-    timeout=2
-)
+# Initialize default error values
+pm1_10s = 0
+pm25_10s = 0
+pm10_10s = 0
+channel_1 = 0
+channel_2 = 0
+channel_3 = 0
+channel_4 = 0
+channel_5 = 0
+relative_humidity = 0
+temperature = 0
 
-# Define Modbus CRC-16 function
-crc16 = crcmod.predefined.mkPredefinedCrcFun('modbus')
+try:
+    # Initialize serial port
+    ser = serial.Serial(
+        port=npm_solo_port,
+        baudrate=115200,
+        parity=serial.PARITY_EVEN,
+        stopbits=serial.STOPBITS_ONE,
+        bytesize=serial.EIGHTBITS,
+        timeout=2
+    )
 
-# Request frame without CRC
-data = b'\x01\x03\x00\x38\x00\x55'
+    # Define Modbus CRC-16 function
+    crc16 = crcmod.predefined.mkPredefinedCrcFun('modbus')
 
-# Calculate and append CRC
-crc = crc16(data)
-crc_low = crc & 0xFF
-crc_high = (crc >> 8) & 0xFF
-request = data + bytes([crc_low, crc_high])
+    # Request frame without CRC
+    data = b'\x01\x03\x00\x38\x00\x55'
 
-# Clear serial buffer before sending
-ser.flushInput()
+    # Calculate and append CRC
+    crc = crc16(data)
+    crc_low = crc & 0xFF
+    crc_high = (crc >> 8) & 0xFF
+    request = data + bytes([crc_low, crc_high])
 
-# Send request
-ser.write(request)
-time.sleep(0.2)  # Wait for sensor to respond
+    # Clear serial buffer before sending
+    ser.flushInput()
 
-# Read response
-response_length = 2 + 1 + (2 * 85) + 2  # Address + Function + Data + CRC
-byte_data = ser.read(response_length)
+    # Send request
+    ser.write(request)
+    time.sleep(0.2)  # Wait for sensor to respond
 
-# Validate response length
-if len(byte_data) < response_length:
-    print("[ERROR] Incomplete response received:", byte_data.hex())
-    exit()
+    # Read response
+    response_length = 2 + 1 + (2 * 85) + 2  # Address + Function + Data + CRC
+    byte_data = ser.read(response_length)
 
-# Verify CRC
-received_crc = int.from_bytes(byte_data[-2:], byteorder='little')
-calculated_crc = crc16(byte_data[:-2])
+    # Validate response length
+    if len(byte_data) < response_length:
+        print(f"[ERROR] Incomplete response received: {byte_data.hex()}")
+        raise Exception("Incomplete response")
 
-if received_crc != calculated_crc:
-    print("[ERROR] CRC check failed! Corrupted data received.")
-    exit()
+    # Verify CRC
+    received_crc = int.from_bytes(byte_data[-2:], byteorder='little')
+    calculated_crc = crc16(byte_data[:-2])
 
-# Convert response to hex for debugging
-formatted = ''.join(f'\\x{byte:02x}' for byte in byte_data)
-#print("Response:", formatted)
+    if received_crc != calculated_crc:
+        print("[ERROR] CRC check failed! Corrupted data received.")
+        raise Exception("CRC check failed")
 
-# Extract and print PM values
-def extract_value(byte_data, register, scale=1, single_register=False, round_to=None):
-    REGISTER_START = 56
-    offset = (register - REGISTER_START) * 2 + 3
+    # Convert response to hex for debugging
+    formatted = ''.join(f'\\x{byte:02x}' for byte in byte_data)
+    #print("Response:", formatted)
 
-    if single_register:
-        value = int.from_bytes(byte_data[offset:offset+2], byteorder='big')
-    else:
-        lsw = int.from_bytes(byte_data[offset:offset+2], byteorder='big')  
-        msw = int.from_bytes(byte_data[offset+2:offset+4], byteorder='big')  
-        value = (msw << 16) | lsw
+    # Extract and print PM values
+    def extract_value(byte_data, register, scale=1, single_register=False, round_to=None):
+        REGISTER_START = 56
+        offset = (register - REGISTER_START) * 2 + 3
 
-    value = value / scale
+        if single_register:
+            value = int.from_bytes(byte_data[offset:offset+2], byteorder='big')
+        else:
+            lsw = int.from_bytes(byte_data[offset:offset+2], byteorder='big')  
+            msw = int.from_bytes(byte_data[offset+2:offset+4], byteorder='big')  
+            value = (msw << 16) | lsw
 
-    if round_to == 0:
-        return int(value)
-    elif round_to is not None:
-        return round(value, round_to)
-    else:
-        return value
+        value = value / scale
 
-pm1_10s = extract_value(byte_data, 56, 1000, round_to=1)
-pm25_10s = extract_value(byte_data, 58, 1000, round_to=1)
-pm10_10s = extract_value(byte_data, 60, 1000, round_to=1)
+        if round_to == 0:
+            return int(value)
+        elif round_to is not None:
+            return round(value, round_to)
+        else:
+            return value
 
-#print("10 sec concentration:")
-#print(f"PM1: {pm1_10s}")
-#print(f"PM2.5: {pm25_10s}")
-#print(f"PM10: {pm10_10s}")
+    pm1_10s = extract_value(byte_data, 56, 1000, round_to=1)
+    pm25_10s = extract_value(byte_data, 58, 1000, round_to=1)
+    pm10_10s = extract_value(byte_data, 60, 1000, round_to=1)
 
-# Extract values for 5 channels
-channel_1 = extract_value(byte_data, 128,  round_to=0)  # 0.2 - 0.5μm
-channel_2 = extract_value(byte_data, 130,  round_to=0)  # 0.5 - 1.0μm
-channel_3 = extract_value(byte_data, 132,  round_to=0)  # 1.0 - 2.5μm
-channel_4 = extract_value(byte_data, 134,  round_to=0)  # 2.5 - 5.0μm
-channel_5 = extract_value(byte_data, 136,  round_to=0)  # 5.0 - 10.0μm
+    #print("10 sec concentration:")
+    #print(f"PM1: {pm1_10s}")
+    #print(f"PM2.5: {pm25_10s}")
+    #print(f"PM10: {pm10_10s}")
 
-#print(f"Channel 1 (0.2->0.5): {channel_1}")
-#print(f"Channel 2 (0.5->1.0): {channel_2}")
-#print(f"Channel 3 (1.0->2.5): {channel_3}")
-#print(f"Channel 4 (2.5->5.0): {channel_4}")
-#print(f"Channel 5 (5.0->10.): {channel_5}")
+    # Extract values for 5 channels
+    channel_1 = extract_value(byte_data, 128,  round_to=0)  # 0.2 - 0.5μm
+    channel_2 = extract_value(byte_data, 130,  round_to=0)  # 0.5 - 1.0μm
+    channel_3 = extract_value(byte_data, 132,  round_to=0)  # 1.0 - 2.5μm
+    channel_4 = extract_value(byte_data, 134,  round_to=0)  # 2.5 - 5.0μm
+    channel_5 = extract_value(byte_data, 136,  round_to=0)  # 5.0 - 10.0μm
 
-        
-# Retrieve relative humidity from register 106 (0x6A)
-relative_humidity = extract_value(byte_data, 106, 100, single_register=True)
-# Retrieve temperature from register 106 (0x6A)
-temperature = extract_value(byte_data, 107, 100, single_register=True)
+    #print(f"Channel 1 (0.2->0.5): {channel_1}")
+    #print(f"Channel 2 (0.5->1.0): {channel_2}")
+    #print(f"Channel 3 (1.0->2.5): {channel_3}")
+    #print(f"Channel 4 (2.5->5.0): {channel_4}")
+    #print(f"Channel 5 (5.0->10.): {channel_5}")
 
-#print(f"Internal Relative Humidity: {relative_humidity} %")
-#print(f"Internal temperature: {temperature} °C")
+            
+    # Retrieve relative humidity from register 106 (0x6A)
+    relative_humidity = extract_value(byte_data, 106, 100, single_register=True)
+    # Retrieve temperature from register 106 (0x6A)
+    temperature = extract_value(byte_data, 107, 100, single_register=True)
 
+    #print(f"Internal Relative Humidity: {relative_humidity} %")
+    #print(f"Internal temperature: {temperature} °C")
 
+    ser.close()
 
-cursor.execute('''
-INSERT INTO data_NPM_5channels (timestamp,PM_ch1, PM_ch2, PM_ch3, PM_ch4, PM_ch5) VALUES (?,?,?,?,?,?)'''
-, (rtc_time_str,channel_1,channel_2,channel_3,channel_4,channel_5))
+except Exception as e:
+    print(f"[ERROR] Sensor communication failed: {e}")
+    # Variables already set to -1 at the beginning
 
-cursor.execute('''
-INSERT INTO data_NPM (timestamp,PM1, PM25, PM10, temp_npm, hum_npm) VALUES (?,?,?,?,?,?)'''
-, (rtc_time_str,pm1_10s,pm25_10s,pm10_10s,temperature,relative_humidity  ))
+finally:
+    # Always save data to database, even if all values are -1
+    cursor.execute('''
+    INSERT INTO data_NPM_5channels (timestamp,PM_ch1, PM_ch2, PM_ch3, PM_ch4, PM_ch5) VALUES (?,?,?,?,?,?)'''
+    , (rtc_time_str, channel_1, channel_2, channel_3, channel_4, channel_5))
 
-# Commit and close the connection
-conn.commit()
+    cursor.execute('''
+    INSERT INTO data_NPM (timestamp,PM1, PM25, PM10, temp_npm, hum_npm) VALUES (?,?,?,?,?,?)'''
+    , (rtc_time_str, pm1_10s, pm25_10s, pm10_10s, temperature, relative_humidity))
 
-conn.close()
+    # Commit and close the connection
+    conn.commit()
+    conn.close()

README.md

@@ -28,17 +28,19 @@ Line by line installation.
 
 ```
 sudo apt update
-sudo apt install git gh apache2 php php-sqlite3 python3 python3-pip jq autossh i2c-tools python3-smbus -y
-sudo pip3 install pyserial requests RPi.GPIO adafruit-circuitpython-bme280 crcmod psutil ntplib pytz --break-system-packages
+sudo apt install git gh apache2 sqlite3 php php-sqlite3 python3 python3-pip jq autossh i2c-tools python3-smbus -y
+sudo pip3 install pyserial requests RPi.GPIO adafruit-circuitpython-bme280 crcmod psutil ntplib pytz gpiozero adafruit-circuitpython-ads1x15 numpy nsrt-mk3-dev --break-system-packages
 sudo mkdir -p /var/www/.ssh
 sudo ssh-keygen -t rsa -b 4096 -f /var/www/.ssh/id_rsa -N ""
 sudo ssh-copy-id -i /var/www/.ssh/id_rsa.pub -p 50221 airlab_server1@aircarto.fr
 sudo git clone http://gitea.aircarto.fr/PaulVua/nebuleair_pro_4g.git /var/www/nebuleair_pro_4g
 sudo mkdir /var/www/nebuleair_pro_4g/logs
 sudo touch /var/www/nebuleair_pro_4g/logs/app.log /var/www/nebuleair_pro_4g/logs/loop.log /var/www/nebuleair_pro_4g/wifi_list.csv
-sudo cp /var/www/nebuleair_pro_4g/config.json.dist /var/www/nebuleair_pro_4g/config.json
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/create_db.py
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/set_config.py
 sudo chmod -R 777 /var/www/nebuleair_pro_4g/
 git config --global core.fileMode false
+git -C /var/www/nebuleair_pro_4g config core.fileMode false
 git config --global --add safe.directory /var/www/nebuleair_pro_4g
 sudo crontab /var/www/nebuleair_pro_4g/cron_jobs
 sudo /usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/create_db.py
@@ -57,6 +59,8 @@ ALL ALL=(ALL) NOPASSWD: /usr/bin/nmcli, /usr/sbin/reboot
 www-data ALL=(ALL) NOPASSWD: /usr/bin/git pull
 www-data ALL=(ALL) NOPASSWD: /usr/bin/ssh
 www-data ALL=(ALL) NOPASSWD: /usr/bin/python3 *
+www-data ALL=(ALL) NOPASSWD: /bin/systemctl *
+www-data ALL=(ALL) NOPASSWD: /var/www/nebuleair_pro_4g/*
 ```
 ## Serial
 
@@ -208,4 +212,28 @@ This can be doned with script boot_hotspot.sh.
 @reboot /var/www/nebuleair_pro_4g/boot_hotspot.sh
 ```
 
+## Claude Code
+
+Instructions to use claude code on the RPI.
+
+### Install NPM
+
+```
+sudo apt install -y nodejs npm
+node -v
+npm -v
+```
+
+### Install Claude
+
+```
+sudo npm install -g @anthropic-ai/claude-code
+```
+
+### Run claude
+
+```
+claude
+```
+
 

RTC/set_with_NTP.py

@@ -1,11 +1,15 @@
+#!/usr/bin/python3
 """
-Script to set the RTC using an NTP server.
+  ____ _____ ____ 
+ |  _ \_   _/ ___|
+ | |_) || || |    
+ |  _ < | || |___ 
+ |_| \_\|_| \____|
+
+Script to set the RTC using an NTP server (script used by web UI)
 RPI needs to be connected to the internet (WIFI).
 Requires ntplib and pytz:
 sudo pip3 install ntplib pytz --break-system-packages
-
-/usr/bin/python3 /var/www/nebuleair_pro_4g/RTC/set_with_NTP.py
-
 """
 import smbus2
 import time
@@ -49,49 +53,131 @@ def set_time(bus, year, month, day, hour, minute, second):
     ])
 
 def read_time(bus):
-    """Read the RTC time."""
-    data = bus.read_i2c_block_data(DS3231_ADDR, REG_TIME, 7)
-    second = bcd_to_dec(data[0] & 0x7F)
-    minute = bcd_to_dec(data[1])
-    hour = bcd_to_dec(data[2] & 0x3F)
-    day = bcd_to_dec(data[4])
-    month = bcd_to_dec(data[5])
-    year = bcd_to_dec(data[6]) + 2000
-    return (year, month, day, hour, minute, second)
+    """Read the RTC time and validate the values."""
+    try:
+        data = bus.read_i2c_block_data(DS3231_ADDR, REG_TIME, 7)
+        
+        # Convert from BCD
+        second = bcd_to_dec(data[0] & 0x7F)
+        minute = bcd_to_dec(data[1])
+        hour = bcd_to_dec(data[2] & 0x3F)
+        day = bcd_to_dec(data[4])
+        month = bcd_to_dec(data[5])
+        year = bcd_to_dec(data[6]) + 2000
+        
+        # Print raw values for debugging
+        print(f"Raw RTC values: {data}")
+        print(f"Decoded values: Y:{year} M:{month} D:{day} H:{hour} M:{minute} S:{second}")
+        
+        # Validate date values
+        if not (1 <= month <= 12):
+            print(f"Invalid month value: {month}, using default")
+            month = 1
+            
+        # Check days in month (simplified)
+        days_in_month = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if not (1 <= day <= days_in_month[month]):
+            print(f"Invalid day value: {day} for month {month}, using default")
+            day = 1
+            
+        # Validate time values
+        if not (0 <= hour <= 23):
+            print(f"Invalid hour value: {hour}, using default")
+            hour = 0
+            
+        if not (0 <= minute <= 59):
+            print(f"Invalid minute value: {minute}, using default")
+            minute = 0
+            
+        if not (0 <= second <= 59):
+            print(f"Invalid second value: {second}, using default")
+            second = 0
+            
+        return (year, month, day, hour, minute, second)
+        
+    except Exception as e:
+        print(f"Error reading RTC: {e}")
+        # Return a safe default date (2023-01-01 00:00:00)
+        return (2023, 1, 1, 0, 0, 0)
 
 def get_internet_time():
     """Get the current time from an NTP server."""
     ntp_client = ntplib.NTPClient()
-    response = ntp_client.request('pool.ntp.org')
-    utc_time = datetime.utcfromtimestamp(response.tx_time)
-    return utc_time
+    # Try multiple NTP servers in case one fails
+    servers = ['pool.ntp.org', 'time.google.com', 'time.windows.com', 'time.apple.com']
+    
+    for server in servers:
+        try:
+            print(f"Trying NTP server: {server}")
+            response = ntp_client.request(server, timeout=2)
+            utc_time = datetime.utcfromtimestamp(response.tx_time)
+            print(f"Successfully got time from {server}")
+            return utc_time
+        except Exception as e:
+            print(f"Failed to get time from {server}: {e}")
+    
+    # If all servers fail, raise exception
+    raise Exception("All NTP servers failed")
 
 def main():
-    bus = smbus2.SMBus(1)
-
-    # Get the current time from the RTC
-    year, month, day, hours, minutes, seconds = read_time(bus)
-    rtc_time = datetime(year, month, day, hours, minutes, seconds)
-
-    # Get current UTC time from an NTP server
     try:
-        internet_utc_time = get_internet_time()
-        print(f"Time from Internet (UTC)     : {internet_utc_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        bus = smbus2.SMBus(1)
+        
+        # Test if RTC is accessible
+        try:
+            bus.read_byte(DS3231_ADDR)
+            print("RTC module is accessible")
+        except Exception as e:
+            print(f"Error accessing RTC module: {e}")
+            print("Please check connections and I2C configuration")
+            return
+
+        # Get the current time from the RTC
+        try:
+            year, month, day, hours, minutes, seconds = read_time(bus)
+            # Create datetime object with validation to handle invalid dates
+            rtc_time = datetime(year, month, day, hours, minutes, seconds)
+            print(f"Actual RTC Time              : {rtc_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        except ValueError as e:
+            print(f"Invalid date/time read from RTC: {e}")
+            print("Will proceed with setting RTC from internet time")
+            rtc_time = None
+
+        # Get current UTC time from an NTP server
+        try:
+            internet_utc_time = get_internet_time()
+            print(f"Time from Internet (UTC)     : {internet_utc_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        except Exception as e:
+            print(f"Error retrieving time from the internet: {e}")
+            if rtc_time is None:
+                print("Cannot proceed without either valid RTC time or internet time")
+                return
+            print("Will keep current RTC time")
+            return
+
+        # Set the RTC to UTC time
+        print("Setting RTC to internet time...")
+        set_time(bus, internet_utc_time.year, internet_utc_time.month, internet_utc_time.day, 
+                internet_utc_time.hour, internet_utc_time.minute, internet_utc_time.second)
+
+        # Read and print the new time from RTC
+        print("Reading back new RTC time...")
+        year, month, day, hour, minute, second = read_time(bus)
+        rtc_time_new = datetime(year, month, day, hour, minute, second)
+        print(f"New RTC Time (UTC)           : {rtc_time_new.strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        # Calculate difference to verify accuracy
+        time_diff = abs((rtc_time_new - internet_utc_time).total_seconds())
+        print(f"Time difference             : {time_diff:.2f} seconds")
+        
+        if time_diff > 5:
+            print("Warning: RTC time differs significantly from internet time")
+            print("You may need to retry or check RTC module")
+        else:
+            print("RTC successfully synchronized with internet time")
+            
     except Exception as e:
-        print(f"Error retrieving time from the internet: {e}")
-        return
-
-    # Print current RTC time
-    print(f"Actual RTC Time              : {rtc_time.strftime('%Y-%m-%d %H:%M:%S')}")
-
-    # Set the RTC to UTC time
-    set_time(bus, internet_utc_time.year, internet_utc_time.month, internet_utc_time.day, 
-             internet_utc_time.hour, internet_utc_time.minute, internet_utc_time.second)
-
-    # Read and print the new time from RTC
-    year, month, day, hour, minute, second = read_time(bus)
-    rtc_time_new = datetime(year, month, day, hour, minute, second)
-    print(f"New RTC Time (UTC)           : {rtc_time_new.strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"Unexpected error: {e}")
 
 if __name__ == "__main__":
-    main()
+    main()

RTC/set_with_browserTime.py

@@ -1,5 +1,11 @@
 """
-Script to set the RTC using the browser time.
+  ____ _____ ____ 
+ |  _ \_   _/ ___|
+ | |_) || || |    
+ |  _ < | || |___ 
+ |_| \_\|_| \____|
+
+Script to set the RTC using the browser time (script used by the web UI).
 
 /usr/bin/python3 /var/www/nebuleair_pro_4g/RTC/set_with_browserTime.py '2024-01-30 12:48:39'
 

SARA/PPP/README.md

@@ -0,0 +1,14 @@
+# PPP activation
+
+Une fois la connexion PPP activée on peut retrouver la connexion pp0 avec `ifconfig`.
+
+### Test avec curl
+
+On peut forcer l'utilisation du réseau pp0 avec curl:
+
+`curl --interface ppp0 https://ifconfig.me`
+
+ou avec ping:
+
+`ping -I ppp0 google.com`
+

SARA/PPP/activate_ppp.sh

@@ -0,0 +1,4 @@
+
+sudo pppd /dev/ttyAMA2 115200 \
+connect '/usr/sbin/chat -v -s "" "AT" OK "ATD*99#" CONNECT' \
+noauth debug dump nodetach nocrtscts

SARA/R5/setPDP.py

@@ -0,0 +1,121 @@
+'''
+  ____    _    ____      _    
+ / ___|  / \  |  _ \    / \   
+ \___ \ / _ \ | |_) |  / _ \  
+  ___) / ___ \|  _ <  / ___ \ 
+ |____/_/   \_\_| \_\/_/   \_\
+                              
+Script to set the PDP context for the SARA R5
+
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/R5/setPDP.py
+
+'''
+import serial
+import time
+import sys
+import json
+import re
+
+
+ser_sara = serial.Serial(
+    port='/dev/ttyAMA2',
+    baudrate=115200, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2, wait_for_lines=None, debug=True):
+    '''
+    Fonction très importante !!!
+    Reads the complete response from a serial connection and waits for specific lines.
+    '''
+    if wait_for_lines is None:
+        wait_for_lines = []  # Default to an empty list if not provided
+
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+    start_time = time.time()
+
+    while True:
+        elapsed_time = time.time() - start_time  # Time since function start
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+
+            # Decode and check for any target line
+            decoded_response = response.decode('utf-8', errors='replace')
+            for target_line in wait_for_lines:
+                if target_line in decoded_response:
+                    if debug:
+                        print(f"[DEBUG] 🔎 Found target line: {target_line} (in {elapsed_time:.2f}s)")
+                    return decoded_response  # Return response immediately if a target line is found
+        elif time.time() > end_time:
+            if debug:
+                print(f"[DEBUG] Timeout reached. No more data received.")
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    # Final response and debug output
+    total_elapsed_time = time.time() - start_time
+    if debug:
+        print(f"[DEBUG] ⏱️ elapsed time: {total_elapsed_time:.2f}s. ⏱️")
+    # Check if the elapsed time exceeded 10 seconds
+    if total_elapsed_time > 10 and debug:
+        print(f"[ALERT] 🚨 The operation took too long 🚨")
+        print(f'<span style="color: red;font-weight: bold;">[ALERT] ⚠️{total_elapsed_time:.2f}s⚠️</span>')
+
+    return response.decode('utf-8', errors='replace')  # Return the full response if no target line is found
+
+try:
+    print('Start script')
+
+    # 1. Check connection
+    print('➡️Check SARA R5 connexion')
+    command = f'ATI0\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_1 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+    print(response_SARA_1, end="")
+    time.sleep(1)
+
+    # 2. Activate PDP context 1
+    print('➡️Activate PDP context 1')
+    command = f'AT+CGACT=1,1\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+    print(response_SARA_2, end="")
+    time.sleep(1)
+
+    # 2. Set the PDP type
+    print('➡️Set the PDP type to IPv4 referring to the outputof the +CGDCONT read command')
+    command = f'AT+UPSD=0,0,0\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+    print(response_SARA_3, end="")
+    time.sleep(1)
+
+    # 2. Profile #0 is mapped on CID=1.
+    print('➡️Profile #0 is mapped on CID=1.')
+    command = f'AT+UPSD=0,100,1\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+    print(response_SARA_3, end="")
+    time.sleep(1)
+
+    # 2. Set the PDP type
+    print('➡️Activate the PSD profile #0: the IPv4 address is already assigned by the network.')
+    command = f'AT+UPSDA=0,3\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK","+UUPSDA"])
+    print(response_SARA_3, end="")
+    time.sleep(1)
+
+   
+
+except Exception as e:
+    print("An error occurred:", e)
+    traceback.print_exc()  # This prints the full traceback

SARA/SSL/full_test_HTTP.py

@@ -25,23 +25,8 @@ url = parameter[1]  # ex: data.mobileair.fr
 
 profile_id = 3
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2, wait_for_line=None):
     response = bytearray()

SARA/SSL/full_test_HTTPS.py

@@ -26,23 +26,8 @@ url = parameter[1]  # ex: data.mobileair.fr
 
 profile_id = 3
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
     response = bytearray()

SARA/SSL/full_test_HTTPS_POST.py

@@ -28,23 +28,8 @@ url = parameter[1]  # ex: data.mobileair.fr
 endpoint = parameter[2]
 profile_id = 2
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def color_text(text, color):
     colors = {

SARA/SSL/full_test_HTTP_POST.py

@@ -31,23 +31,8 @@ endpoint = parameter[2]
 
 profile_id = 3
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
     response = bytearray()

SARA/SSL/prepareUspotProfile.py

@@ -21,23 +21,8 @@ port='/dev/'+parameter[0] # ex: ttyAMA2
 url = parameter[1]  # ex: data.mobileair.fr
 
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
     response = bytearray()

SARA/SSL/prepareUspotProfile_V2.py

@@ -23,24 +23,8 @@ parameter = sys.argv[1:]  # Exclude the script name
 port='/dev/'+parameter[0] # ex: ttyAMA2
 url = parameter[1]  # ex: data.mobileair.fr
 
-
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-send_uSpot = config.get('send_uSpot', False) 
+baudrate = 115200
+send_uSpot = False
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
     response = bytearray()

SARA/SSL/sara_add_certif_v2.py

@@ -14,19 +14,7 @@ parameter = sys.argv[1:]  # Exclude the script name
 port = '/dev/' + parameter[0]  # e.g., ttyAMA2
 timeout = float(parameter[1])  # e.g., 2 seconds
 
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-config = load_config(config_file)
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
     response = bytearray()

SARA/UDP/receiveUDP_downlink.py

@@ -0,0 +1,12 @@
+'''
+  ____    _    ____      _    
+ / ___|  / \  |  _ \    / \   
+ \___ \ / _ \ | |_) |  / _ \  
+  ___) / ___ \|  _ <  / ___ \ 
+ |____/_/   \_\_| \_\/_/   \_\
+                              
+Script to read UDP message
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/UDP/receiveUDP_downlink.py
+
+'''

SARA/UDP/sendUDP_message.py

@@ -0,0 +1,129 @@
+'''
+  ____    _    ____      _    
+ / ___|  / \  |  _ \    / \   
+ \___ \ / _ \ | |_) |  / _ \  
+  ___) / ___ \|  _ <  / ___ \ 
+ |____/_/   \_\_| \_\/_/   \_\
+                              
+Script to send UDP message
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/UDP/sendUDP_message.py
+
+'''
+import serial
+import time
+import sys
+import json
+import re
+
+
+
+ser_sara = serial.Serial(
+    port='/dev/ttyAMA2',
+    baudrate=115200, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2, wait_for_lines=None, debug=True):
+    '''
+    Fonction très importante !!!
+    Reads the complete response from a serial connection and waits for specific lines.
+    '''
+    if wait_for_lines is None:
+        wait_for_lines = []  # Default to an empty list if not provided
+
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+    start_time = time.time()
+
+    while True:
+        elapsed_time = time.time() - start_time  # Time since function start
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+
+            # Decode and check for any target line
+            decoded_response = response.decode('utf-8', errors='replace')
+            for target_line in wait_for_lines:
+                if target_line in decoded_response:
+                    if debug:
+                        print(f"[DEBUG] 🔎 Found target line: {target_line} (in {elapsed_time:.2f}s)")
+                    return decoded_response  # Return response immediately if a target line is found
+        elif time.time() > end_time:
+            if debug:
+                print(f"[DEBUG] Timeout reached. No more data received.")
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    # Final response and debug output
+    total_elapsed_time = time.time() - start_time
+    if debug:
+        print(f"[DEBUG] ⏱️ elapsed time: {total_elapsed_time:.2f}s. ⏱️")
+    # Check if the elapsed time exceeded 10 seconds
+    if total_elapsed_time > 10 and debug:
+        print(f"[ALERT] 🚨 The operation took too long 🚨")
+        print(f'<span style="color: red;font-weight: bold;">[ALERT] ⚠️{total_elapsed_time:.2f}s⚠️</span>')
+
+    return response.decode('utf-8', errors='replace')  # Return the full response if no target line is found
+
+try:
+    print('Start script')
+
+    # Increase verbosity
+    command = f'AT+CMEE=2\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_1 = read_complete_response(ser_sara, wait_for_lines=["OK", "ERROR"])
+    print(response_SARA_1, end="")
+    time.sleep(1)
+
+    # 1. Create SOCKET
+    print('➡️Create SOCKET')
+    command = f'AT+USOCR=17\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_1 = read_complete_response(ser_sara, wait_for_lines=["OK", "ERROR"])
+    print(response_SARA_1, end="")
+    time.sleep(1)
+
+    # 2. Retreive Socket ID
+    match = re.search(r'\+USOCR:\s*(\d+)', response_SARA_1)
+    if match:
+        socket_id = match.group(1)
+        print(f"Socket ID: {socket_id}")
+    else:
+        print("Failed to extract socket ID")
+
+            
+    #3. Connect to UDP server
+    print("Connect to server:")
+    command = f'AT+USOCO={socket_id},"192.168.0.20",4242\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["OK", "+CME ERROR", "ERROR"], debug=False)
+    print(response_SARA_2)
+
+    # 4. Write data and send
+    print("Write data:")
+    command = f'AT+USOWR={socket_id},10\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["@","OK", "+CME ERROR", "ERROR"], debug=False)
+    print(response_SARA_2)
+
+    ser_sara.write("1234567890".encode())
+    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["@","OK", "+CME ERROR", "ERROR"], debug=False)
+    print(response_SARA_2)
+
+    #Close socket
+    print("Close socket:")
+    command = f'AT+USOCL={socket_id}\r'
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["OK", "+CME ERROR", "ERROR"], debug=False)
+    print(response_SARA_2)
+       
+
+except Exception as e:
+    print("An error occurred:", e)
+    traceback.print_exc()  # This prints the full traceback

SARA/cellLocate/server_conf.py

@@ -0,0 +1,103 @@
+'''
+  ____    _    ____      _    
+ / ___|  / \  |  _ \    / \   
+ \___ \ / _ \ | |_) |  / _ \  
+  ___) / ___ \|  _ <  / ___ \ 
+ |____/_/   \_\_| \_\/_/   \_\
+                              
+Script to Configures the network connection to a Multi GNSS Assistance (MGA) server used also per CellLocate
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/cellLocate/server_conf.py ttyAMA2 1
+
+AT+UGSRV="cell-live1.services.u-blox.com","cell-live2.services.u-blox.com","XkEKfGqVSbmNE1eZfBZm4Q"
+
+
+'''
+
+import serial
+import time
+import sys
+import json
+
+parameter = sys.argv[1:]  # Exclude the script name
+port='/dev/'+parameter[0] # ex: ttyAMA2
+timeout = float(parameter[1])  # ex:2
+
+
+#get baudrate
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+# Define the config file path
+config_file = '/var/www/nebuleair_pro_4g/config.json'
+# Load the configuration data
+config = load_config(config_file)
+# Access the shared variables
+baudrate = config.get('SaraR4_baudrate', 115200)
+
+ser = serial.Serial(
+    port=port,  #USB0 or ttyS0
+    baudrate=baudrate, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = timeout
+)
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2, wait_for_lines=None, debug=True):
+    '''
+    Fonction très importante !!!
+    Reads the complete response from a serial connection and waits for specific lines.
+    '''
+    if wait_for_lines is None:
+        wait_for_lines = []  # Default to an empty list if not provided
+
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+    start_time = time.time()
+
+    while True:
+        elapsed_time = time.time() - start_time  # Time since function start
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+
+            # Decode and check for any target line
+            decoded_response = response.decode('utf-8', errors='replace')
+            for target_line in wait_for_lines:
+                if target_line in decoded_response:
+                    if debug:
+                        print(f"[DEBUG] 🔎 Found target line: {target_line} (in {elapsed_time:.2f}s)")
+                    return decoded_response  # Return response immediately if a target line is found
+        elif time.time() > end_time:
+            if debug:
+                print(f"[DEBUG] Timeout reached. No more data received.")
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    # Final response and debug output
+    total_elapsed_time = time.time() - start_time
+    if debug:
+        print(f"[DEBUG] ⏱️ elapsed time: {total_elapsed_time:.2f}s. ⏱️")
+    # Check if the elapsed time exceeded 10 seconds
+    if total_elapsed_time > 10 and debug:
+        print(f"[ALERT] 🚨 The operation took too long 🚨")
+        print(f'<span style="color: red;font-weight: bold;">[ALERT] ⚠️{total_elapsed_time:.2f}s⚠️</span>')
+
+    return response.decode('utf-8', errors='replace')  # Return the full response if no target line is found
+
+
+#command = f'ATI\r'
+command = f'AT+UGSRV="cell-live1.services.u-blox.com","cell-live2.services.u-blox.com","XkEKfGqVSbmNE1eZfBZm4Q"\r'
+ser.write((command + '\r').encode('utf-8'))
+
+response = read_complete_response(ser, wait_for_lines=["+UULOC"])
+print(response)

SARA/reboot/start.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -13,57 +13,112 @@ Script that starts at the boot of the RPI (with cron)
 
 '''
 import serial
+import RPi.GPIO as GPIO
 import time
 import sys
 import json
 import re
+import sqlite3
+import traceback
 
-#get data from config
-def load_config(config_file):
+
+#GPIO
+SARA_power_GPIO = 16 
+SARA_ON_GPIO = 20
+
+GPIO.setmode(GPIO.BCM)  # Use BCM numbering
+GPIO.setup(SARA_power_GPIO, GPIO.OUT)  # Set GPIO17 as an output
+
+# database connection
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+#get config data from SQLite table
+def load_config_sqlite():
+    """
+    Load configuration data from SQLite config table
+    
+    Returns:
+        dict: Configuration data with proper type conversion
+    """
     try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
+
+        # Query the config table
+        cursor.execute("SELECT key, value, type FROM config_table")
+        rows = cursor.fetchall()
+        
+        # Create config dictionary
+        config_data = {}
+        for key, value, type_name in rows:
+            # Convert value based on its type
+            if type_name == 'bool':
+                config_data[key] = value == '1' or value == 'true'
+            elif type_name == 'int':
+                config_data[key] = int(value)
+            elif type_name == 'float':
+                config_data[key] = float(value)
+            else:
+                config_data[key] = value
+        
         return config_data
+        
     except Exception as e:
-        print(f"Error loading config file: {e}")
+        print(f"Error loading config from SQLite: {e}")
         return {}
 
-#Fonction pour mettre à jour le JSON de configuration
-def update_json_key(file_path, key, value):
+def update_sqlite_config(key, value):
     """
-    Updates a specific key in a JSON file with a new value.
+    Updates a specific key in the SQLite config_table with a new value.
 
-    :param file_path: Path to the JSON file.
-    :param key: The key to update in the JSON file.
+    :param key: The key to update in the config_table.
     :param value: The new value to assign to the key.
     """
     try:
-        # Load the existing data
-        with open(file_path, "r") as file:
-            data = json.load(file)
+
+        # Check if the key exists and get its type
+        cursor.execute("SELECT type FROM config_table WHERE key = ?", (key,))
+        result = cursor.fetchone()
         
-        # Check if the key exists in the JSON file
-        if key in data:
-            data[key] = value  # Update the key with the new value
-        else:
-            print(f"Key '{key}' not found in the JSON file.")
+        if result is None:
+            print(f"Key '{key}' not found in the config_table.")
+            conn.close()
             return
         
-        # Write the updated data back to the file
-        with open(file_path, "w") as file:
-            json.dump(data, file, indent=2)  # Use indent for pretty printing
+        # Get the type of the value from the database
+        value_type = result[0]
         
-        print(f"💾 updating '{key}' to '{value}'.")
+        # Convert the value to the appropriate string representation based on its type
+        if value_type == 'bool':
+            # Convert Python boolean or string 'true'/'false' to '1'/'0'
+            if isinstance(value, bool):
+                str_value = '1' if value else '0'
+            else:
+                str_value = '1' if str(value).lower() in ('true', '1', 'yes', 'y') else '0'
+        elif value_type == 'int':
+            str_value = str(int(value))
+        elif value_type == 'float':
+            str_value = str(float(value))
+        else:
+            str_value = str(value)
+        
+        # Update the value in the database
+        cursor.execute("UPDATE config_table SET value = ? WHERE key = ?", (str_value, key))
+        
+        # Commit the changes and close the connection
+        conn.commit()
+   
+        print(f"💾 Updated '{key}' to '{value}' in database.")
     except Exception as e:
-        print(f"Error updating the JSON file: {e}")
+        print(f"Error updating the SQLite database: {e}")
 
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
+#Load config
+config = load_config_sqlite()
+#config
 baudrate = config.get('SaraR4_baudrate', 115200)       #baudrate du sara R4
 device_id = config.get('deviceID', '').upper()         #device ID en maj
 
+sara_r5_DPD_setup = False
+
 ser_sara = serial.Serial(
     port='/dev/ttyAMA2',
     baudrate=baudrate, #115200 ou 9600
@@ -120,20 +175,46 @@ def read_complete_response(serial_connection, timeout=2, end_of_response_timeout
 try:
     print('<h3>Start reboot python script</h3>')
 
+    #First we need to power on the module (if connected to mosfet via gpio16)
+    GPIO.output(SARA_power_GPIO, GPIO.HIGH)
+    time.sleep(5)
+
     #check modem status
+    #Attention:
+        # SARA R4 response: Manufacturer: u-blox Model: SARA-R410M-02B
+        # SArA R5 response: SARA-R500S-01B-00
     print("⚙️Check SARA Status")
     command = f'ATI\r'
     ser_sara.write(command.encode('utf-8'))
     response_SARA_ATI = read_complete_response(ser_sara, wait_for_lines=["IMEI"])
     print(response_SARA_ATI)
-    match = re.search(r"Model:\s*(.+)", response_SARA_ATI)
-    model = match.group(1).strip() if match else "Unknown"  # Strip unwanted characters
-    print(f" Model: {model}")
-    update_json_key(config_file, "modem_version", model)
+
+    # Check for SARA model with more robust regex
+    model = "Unknown"
+    if "SARA-R410M" in response_SARA_ATI:
+        model = "SARA-R410M"
+        print("📱 Detected SARA R4 modem")
+    elif "SARA-R500" in response_SARA_ATI:
+        model = "SARA-R500"
+        print("📱 Detected SARA R5 modem")
+        sara_r5_DPD_setup = True
+    else:
+        # Fallback to regex match if direct string match fails
+        match = re.search(r"Model:\s*([A-Za-z0-9\-]+)", response_SARA_ATI)
+        if match:
+            model = match.group(1).strip()
+        else:
+            model = "Unknown"
+            print("⚠️ Could not identify modem model")
+
+    print(f"🔍 Model: {model}")
+    update_sqlite_config("modem_version", model)
     time.sleep(1)
     
-
-    # 1. Set AIRCARTO URL
+    '''
+    AIRCARTO
+    '''
+    # 1. Set AIRCARTO URL (profile id = 0)
     print('➡️Set aircarto URL')
     aircarto_profile_id = 0
     aircarto_url="data.nebuleair.fr"
@@ -143,26 +224,155 @@ try:
     print(response_SARA_1)
     time.sleep(1)
 
-    #2. Set uSpot URL
-    print('➡️Set uSpot URL')
+    '''
+    uSpot
+    '''
+    print("➡️➡️Set uSpot URL with SSL")
+
+    security_profile_id = 1
     uSpot_profile_id = 1
     uSpot_url="api-prod.uspot.probesys.net"
-    command = f'AT+UHTTP={uSpot_profile_id},1,"{uSpot_url}"\r'
-    ser_sara.write(command.encode('utf-8'))
-    response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+
+
+    #step 1: import the certificate
+    print("➡️ import certificate")
+    certificate_name = "e6"
+    with open("/var/www/nebuleair_pro_4g/SARA/SSL/certificate/e6.pem", "rb") as cert_file:
+        certificate = cert_file.read()
+    size_of_string = len(certificate)
+
+    # AT+USECMNG=0,<type>,<internal_name>,<data_size>
+    # type-> 0 -> trusted root CA
+    command = f'AT+USECMNG=0,0,"{certificate_name}",{size_of_string}\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_1 = read_complete_response(ser_sara)
+    print(response_SARA_1)
+
+    time.sleep(0.5)
+  
+    print("➡️ add certificate")
+    ser_sara.write(certificate)
+    response_SARA_2 = read_complete_response(ser_sara)
     print(response_SARA_2)
+
+    time.sleep(0.5)
+
+    # op_code:  0 -> certificate validation level 
+        # param_val : 0 -> Level 0 No validation; 1-> Level 1 Root certificate validation
+    print("➡️Set the security profile (params)")
+    certification_level=0
+    command = f'AT+USECPRF={security_profile_id},0,{certification_level}\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5b = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5b)
+    time.sleep(0.5)
+
+    # op_code:  1 -> minimum SSL/TLS version
+        # param_val : 0 -> any; server can use any version for the connection; 1-> LSv1.0; 2->TLSv1.1; 3->TLSv1.2;
+    print("➡️Set the security profile (params)")
+    minimum_SSL_version = 0
+    command = f'AT+USECPRF={security_profile_id},1,{minimum_SSL_version}\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5bb = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5bb)
+    time.sleep(0.5)
+
+    #op_code: 2 ->  legacy cipher suite selection
+        # 0 (factory-programmed value): a list of default cipher suites is proposed at the beginning of handshake process, and a cipher suite will be negotiated among the cipher suites proposed in the list.
+    print("➡️Set cipher")
+    cipher_suite = 0
+    command = f'AT+USECPRF={security_profile_id},2,{cipher_suite}\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5cc = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5cc)
+    time.sleep(0.5)
+
+        # op_code:  3 -> trusted root certificate internal name
+    print("➡️Set the security profile (choose cert)")
+    command = f'AT+USECPRF={security_profile_id},3,"{certificate_name}"\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5c = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5c)
+    time.sleep(0.5)
+
+     # op_code:  10 -> SNI (server name indication)
+    print("➡️Set the SNI")
+    command = f'AT+USECPRF={security_profile_id},10,"{uSpot_url}"\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5cf = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5cf)
+    time.sleep(0.5)
+
+    #step 4: set url (op_code = 1)
+    print("➡️SET URL")
+    command = f'AT+UHTTP={uSpot_profile_id},1,"{uSpot_url}"\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_5 = read_complete_response(ser_sara,  wait_for_lines=["OK"])
+    print(response_SARA_5)
     time.sleep(1)
 
-    print("set port 81")
-    command = f'AT+UHTTP={uSpot_profile_id},5,81\r'
+    #step 4: set PORT (op_code = 5)
+    print("➡️SET PORT")
+    port = 443
+    command = f'AT+UHTTP={uSpot_profile_id},5,{port}\r'
     ser_sara.write((command + '\r').encode('utf-8'))
     response_SARA_55 = read_complete_response(ser_sara, wait_for_lines=["OK"])
     print(response_SARA_55)
     time.sleep(1)
+    
+    #step 4: set url to SSL (op_code = 6) (http_secure = 1 for HTTPS)(USECMNG_PROFILE = 2)
+    print("➡️SET SSL")
+    http_secure = 1
+    command = f'AT+UHTTP={uSpot_profile_id},6,{http_secure},{security_profile_id}\r'
+
+    ser_sara.write(command.encode('utf-8'))
+    response_SARA_5fg = read_complete_response(ser_sara, wait_for_lines=["OK"])
+    print(response_SARA_5fg)
+    time.sleep(1)
+
+
+    '''
+    SARA R5
+    '''
+
+    if sara_r5_DPD_setup:
+        print("➡️➡️SARA R5 PDP SETUP")
+        # 2. Activate PDP context 1
+        print('➡️Activate PDP context 1')
+        command = f'AT+CGACT=1,1\r'
+        ser_sara.write(command.encode('utf-8'))
+        response_SARA_2 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+        print(response_SARA_2, end="")
+        time.sleep(1)
+
+        # 2. Set the PDP type
+        print('➡️Set the PDP type to IPv4 referring to the outputof the +CGDCONT read command')
+        command = f'AT+UPSD=0,0,0\r'
+        ser_sara.write(command.encode('utf-8'))
+        response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+        print(response_SARA_3, end="")
+        time.sleep(1)
+
+        # 2. Profile #0 is mapped on CID=1.
+        print('➡️Profile #0 is mapped on CID=1.')
+        command = f'AT+UPSD=0,100,1\r'
+        ser_sara.write(command.encode('utf-8'))
+        response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK"])
+        print(response_SARA_3, end="")
+        time.sleep(1)
+
+        # 2. Set the PDP type
+        print('➡️Activate the PSD profile #0: the IPv4 address is already assigned by the network.')
+        command = f'AT+UPSDA=0,3\r'
+        ser_sara.write(command.encode('utf-8'))
+        response_SARA_3 = read_complete_response(ser_sara, wait_for_lines=["OK","+UUPSDA"])
+        print(response_SARA_3, end="")
+        time.sleep(1)
+
 
     #3. Get localisation (CellLocate)
-    mode = 2
-    sensor = 2 
+    mode = 2    #single shot position
+    sensor = 2  #use cellular CellLocate® location information
     response_type = 0
     timeout_s = 2
     accuracy_m = 1
@@ -176,12 +386,12 @@ try:
         latitude = match.group(1)
         longitude = match.group(2)
         print(f"📍 Latitude: {latitude}, Longitude: {longitude}")
+            #update sqlite table
+        update_sqlite_config("latitude_raw", float(latitude))
+        update_sqlite_config("longitude_raw", float(longitude))
     else:
         print("❌ Failed to extract coordinates.")
 
-    #update config.json
-    update_json_key(config_file, "latitude_raw", float(latitude))
-    update_json_key(config_file, "longitude_raw", float(longitude))
 
     time.sleep(1)
 

SARA/sara.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -6,7 +6,9 @@
  |____/_/   \_\_| \_\/_/   \_\
                               
 Script to see if the SARA-R410 is running
-ex: 
+ex:
+python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 ATI 2
+ex 1 (get SIM infos)
 python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+CCID? 2
 ex 2 (turn on blue light):
 python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+UGPIOC=16,2 2
@@ -14,6 +16,8 @@ ex 3 (reconnect network)
 python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+COPS=1,2,20801 20
 ex 4 (get HTTP Profiles)
 python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+UHTTP? 2
+ex 5 (get IP addr)
+python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+CGPADDR=1 2
 
 '''
 
@@ -28,68 +32,64 @@ port='/dev/'+parameter[0] # ex: ttyAMA2
 command = parameter[1]  # ex: AT+CCID?
 timeout = float(parameter[2])  # ex:2
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
 # Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
-
-ser = serial.Serial(
-    port=port,  #USB0 or ttyS0
-    baudrate=baudrate, #115200 ou 9600
-    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
-    stopbits=serial.STOPBITS_ONE,
-    bytesize=serial.EIGHTBITS,
-    timeout = timeout
-)
-
-ser.write((command + '\r').encode('utf-8'))
-
-#ser.write(b'ATI\r')            #General Information
-#ser.write(b'AT+CCID?\r')       #SIM card number
-#ser.write(b'AT+CPIN?\r')       #Check the status of the SIM card
-#ser.write(b'AT+CIND?\r')       #Indication state (last number is SIM detection: 0 no SIM detection, 1 SIM detected, 2 not available)
-#ser.write(b'AT+UGPIOR=?\r')   #Reads the current value of the specified GPIO pin
-#ser.write(b'AT+UGPIOC?\r')     #GPIO select configuration
-#ser.write(b'AT+COPS=?\r')     #Check the network and cellular technology the modem is currently using
-#ser.write(b'AT+COPS=1,2,20801') #connext to orange
-#ser.write(b'AT+CFUN=?\r')     #Selects/read the level of functionality 
-#ser.write(b'AT+URAT=?\r')     #Radio Access Technology 
-#ser.write(b'AT+USIMSTAT?')
-#ser.write(b'AT+IPR=115200')           #Check/Define baud rate
-#ser.write(b'AT+CMUX=?')
-
-
+baudrate = 115200
 
 try:
+
+    ser = serial.Serial(
+        port=port,  #USB0 or ttyS0
+        baudrate=baudrate, #115200 ou 9600
+        parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+        stopbits=serial.STOPBITS_ONE,
+        bytesize=serial.EIGHTBITS,
+        timeout = timeout
+    )
+
+    ser.write((command + '\r').encode('utf-8'))
+
+    #ser.write(b'ATI\r')            #General Information
+    #ser.write(b'AT+CCID?\r')       #SIM card number
+    #ser.write(b'AT+CPIN?\r')       #Check the status of the SIM card
+    #ser.write(b'AT+CIND?\r')       #Indication state (last number is SIM detection: 0 no SIM detection, 1 SIM detected, 2 not available)
+    #ser.write(b'AT+UGPIOR=?\r')   #Reads the current value of the specified GPIO pin
+    #ser.write(b'AT+UGPIOC?\r')     #GPIO select configuration
+    #ser.write(b'AT+COPS=?\r')     #Check the network and cellular technology the modem is currently using
+    #ser.write(b'AT+COPS=1,2,20801') #connext to orange
+    #ser.write(b'AT+CFUN=?\r')     #Selects/read the level of functionality 
+    #ser.write(b'AT+URAT=?\r')     #Radio Access Technology 
+    #ser.write(b'AT+USIMSTAT?')
+    #ser.write(b'AT+IPR=115200')           #Check/Define baud rate
+    #ser.write(b'AT+CMUX=?')
+
+
     # Read lines until a timeout occurs
     response_lines = []
-    while True:
-        line = ser.readline().decode('utf-8').strip()
-        if not line:
-            break  # Break the loop if an empty line is encountered
-        response_lines.append(line)
+    start_time = time.time()
+
+    while (time.time() - start_time) < timeout:
+        line = ser.readline().decode('utf-8', errors='ignore').strip()
+        if line:
+            response_lines.append(line)
+
+    # Check if we received any data
+    if not response_lines:
+        print(f"ERROR: No response received from {port} after sending command: {command}")
+        sys.exit(1)
 
     # Print the response
     for line in response_lines:
         print(line)
 
 except serial.SerialException as e:
-    print(f"Error: {e}")
-
+    print(f"ERROR: Serial communication error: {e}")
+    sys.exit(1)
+except Exception as e:
+    print(f"ERROR: Unexpected error: {e}")
+    sys.exit(1)
 finally:
-    if ser.is_open:
+    # Close the serial port if it's open
+    if 'ser' in locals() and ser.is_open:
         ser.close()
-        #print("Serial closed")
+
 

SARA/sara_checkDNS.py

@@ -0,0 +1,63 @@
+r'''
+  ____    _    ____      _    
+ / ___|  / \  |  _ \    / \   
+ \___ \ / _ \ | |_) |  / _ \  
+  ___) / ___ \|  _ <  / ___ \ 
+ |____/_/   \_\_| \_\/_/   \_\
+                              
+Script to resolve DNS (get IP from domain name) with AT+UDNSRN command
+Ex:
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_checkDNS.py ttyAMA2 data.nebuleair.fr
+To do: need to add profile id as parameter
+
+'''
+
+import serial
+import time
+import sys
+import json
+
+parameter = sys.argv[1:]  # Exclude the script name
+#print("Parameters received:")
+port='/dev/'+parameter[0] # ex: ttyAMA2
+url = parameter[1]  # ex: data.mobileair.fr
+
+baudrate = 115200
+
+ser = serial.Serial(
+    port=port,  #USB0 or ttyS0
+    baudrate=baudrate, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+command = f'AT+UDNSRN=0,"{url}"\r'
+ser.write((command + '\r').encode('utf-8'))
+
+print("****")
+print("DNS check")
+
+try:
+    # Read lines until a timeout occurs
+    response_lines = []
+    while True:
+        line = ser.readline().decode('utf-8').strip()
+        if not line:
+            break  # Break the loop if an empty line is encountered
+        response_lines.append(line)
+
+    # Print the response
+    for line in response_lines:
+        print(line)
+
+except serial.SerialException as e:
+    print(f"Error: {e}")
+
+finally:
+    if ser.is_open:
+        ser.close()
+        print("****")
+        #print("Serial closed")
+

SARA/sara_connectNetwork.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -26,22 +26,54 @@ networkID = parameter[1]  # ex: 20801
 timeout = float(parameter[2])  # ex:2
 
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
 
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2, wait_for_lines=None, debug=True):
+    '''
+    Fonction très importante !!!
+    Reads the complete response from a serial connection and waits for specific lines.
+    '''
+    if wait_for_lines is None:
+        wait_for_lines = []  # Default to an empty list if not provided
+
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+    start_time = time.time()
+
+    while True:
+        elapsed_time = time.time() - start_time  # Time since function start
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+
+            # Decode and check for any target line
+            decoded_response = response.decode('utf-8', errors='replace')
+            for target_line in wait_for_lines:
+                if target_line in decoded_response:
+                    if debug:
+                        print(f"[DEBUG] 🔎 Found target line: {target_line} (in {elapsed_time:.2f}s)")
+                    return decoded_response  # Return response immediately if a target line is found
+        elif time.time() > end_time:
+            if debug:
+                print(f"[DEBUG] Timeout reached. No more data received.")
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    # Final response and debug output
+    total_elapsed_time = time.time() - start_time
+    if debug:
+        print(f"[DEBUG] ⏱️ elapsed time: {total_elapsed_time:.2f}s. ⏱️")
+    # Check if the elapsed time exceeded 10 seconds
+    if total_elapsed_time > 10 and debug:
+        print(f"[ALERT] 🚨 The operation took too long 🚨")
+        print(f'<span style="color: red;font-weight: bold;">[ALERT] ⚠️{total_elapsed_time:.2f}s⚠️</span>')
+
+    return response.decode('utf-8', errors='replace')  # Return the full response if no target line is found
+
+
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0
@@ -57,17 +89,11 @@ ser.write((command + '\r').encode('utf-8'))
 
 
 try:
-    # Read lines until a timeout occurs
-    response_lines = []
-    while True:
-        line = ser.readline().decode('utf-8').strip()
-        if not line:
-            break  # Break the loop if an empty line is encountered
-        response_lines.append(line)
-
-    # Print the response
-    for line in response_lines:
-        print(line)
+    response = read_complete_response(ser, wait_for_lines=["OK", "ERROR"],timeout=5, end_of_response_timeout=120, debug=True)
+    
+    print('<p class="text-danger-emphasis">')
+    print(response)
+    print("</p>", end="")
 
 except serial.SerialException as e:
     print(f"Error: {e}")

SARA/sara_eraseMessage.py

@@ -11,22 +11,7 @@ parameter = sys.argv[1:]  # Exclude the script name
 port='/dev/'+parameter[0] # ex: ttyAMA2
 message = parameter[1]  # ex: Hello
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0

SARA/sara_google_ping.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -18,24 +18,7 @@ import sys
 import json
 
 
-
-
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port='/dev/ttyAMA2',

SARA/sara_ping.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -17,23 +17,7 @@ import json
 # SARA R4 UHTTPC profile IDs
 aircarto_profile_id = 0
 
-
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser_sara = serial.Serial(
     port='/dev/ttyAMA2',
@@ -89,13 +73,31 @@ def read_complete_response(serial_connection, timeout=2, end_of_response_timeout
     return response.decode('utf-8', errors='replace')  # Return the full response if no target line is found
 
 
+def extract_error_code(response):
+    """
+    Extract just the error code from AT+UHTTPER response
+    """
+    for line in response.split('\n'):
+        if '+UHTTPER' in line:
+            try:
+                # Split the line and get the third value (error code)
+                parts = line.split(':')[1].strip().split(',')
+                if len(parts) >= 3:
+                    error_code = int(parts[2])
+                    return error_code
+            except:
+                pass
+    
+    # Return None if we couldn't find the error code
+    return None
+
 try:
     #3. Send to endpoint (with device ID)
     print("Send data (GET REQUEST):")
     command= f'AT+UHTTPC={aircarto_profile_id},1,"/ping.php","aircarto_server_response.txt"\r'                                                                                            
     ser_sara.write(command.encode('utf-8'))
 
-    response_SARA_3 = read_complete_response(ser_sara, timeout=5, end_of_response_timeout=120, wait_for_lines=["+UUHTTPCR", "+CME ERROR"], debug=True)
+    response_SARA_3 = read_complete_response(ser_sara, timeout=5, end_of_response_timeout=20, wait_for_lines=["+UUHTTPCR", "+CME ERROR"], debug=True)
 
     print(response_SARA_3)
      # si on recoit la réponse UHTTPCR
@@ -111,7 +113,36 @@ try:
             parts = http_response.split(',')
              # 2.1 code 0 (HTTP failed) ⛔⛔⛔
             if len(parts) == 3 and parts[-1] == '0':  # The third value indicates success
-                print("⛔ATTENTION: HTTP operation failed")
+                print("⛔⛔ATTENTION: HTTP operation failed")
+                #get error code
+                print("Getting error code (11->Server connection error, 73->Secure socket connect error)")
+                command = f'AT+UHTTPER={aircarto_profile_id}\r'
+                ser_sara.write(command.encode('utf-8'))    
+                response_SARA_9 = read_complete_response(ser_sara, wait_for_lines=["OK"], debug=False)
+                print('<p class="text-danger-emphasis">')
+                print(response_SARA_9)
+                print("</p>", end="")
+                # Extract just the error code
+                error_code = extract_error_code(response_SARA_9)
+                if error_code is not None:
+                    # Display interpretation based on error code
+                    if error_code == 0:
+                        print('<p class="text-success">No error detected</p>')
+                    elif error_code == 4:
+                        print('<p class="text-danger">Error 4: Invalid server Hostname</p>')
+                    elif error_code == 11:
+                        print('<p class="text-danger">Error 11: Server connection error</p>')
+                    elif error_code == 22:
+                        print('<p class="text-danger">Error 22: PSD or CSD connection not established</p>')
+                    elif error_code == 73:
+                        print('<p class="text-danger">Error 73: Secure socket connect error</p>')
+                    else:
+                        print(f'<p class="text-danger">Unknown error code: {error_code}</p>')
+                else:
+                    print('<p class="text-danger">Could not extract error code from response</p>')
+                    
+
+
             # 2.2 code 1 (HHTP succeded)
             else:
                 # Si la commande HTTP a réussi 

SARA/sara_readMessage.py

@@ -11,22 +11,7 @@ parameter = sys.argv[1:]  # Exclude the script name
 port='/dev/'+parameter[0] # ex: ttyAMA2
 message = parameter[1]  # ex: Hello
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0

SARA/sara_sendMessage.py

@@ -12,22 +12,7 @@ port='/dev/'+parameter[0] # ex: ttyAMA2
 endpoint = parameter[1]  # ex: /pro_4G/notif_message.php
 profile_id = parameter[2]
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0

SARA/sara_setAPN.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -21,23 +21,7 @@ port='/dev/'+parameter[0] # ex: ttyAMA2
 apn_address = parameter[1]  # ex: data.mono
 timeout = float(parameter[2])  # ex:2
 
-
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0
@@ -49,6 +33,8 @@ ser = serial.Serial(
 )
 
 command = f'AT+CGDCONT=1,"IP","{apn_address}"\r'
+#command = f'AT+CGDCONT=1,"IPV4V6","{apn_address}"\r'
+#command = f'AT+CGDCONT=1,"IP","{apn_address}",0,0\r'
 ser.write((command + '\r').encode('utf-8'))
 
 

SARA/sara_setURL.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____    _    ____      _    
  / ___|  / \  |  _ \    / \   
  \___ \ / _ \ | |_) |  / _ \  
@@ -8,7 +8,6 @@
 Script to set the URL for a HTTP request
 Ex:
 /usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_setURL.py ttyAMA2 data.nebuleair.fr 0
-To do: need to add profile id as parameter
 
 First profile id:
     AT+UHTTP=0,1,"data.nebuleair.fr"
@@ -28,22 +27,7 @@ url = parameter[1]  # ex: data.mobileair.fr
 profile_id = parameter[2] #ex: 0
 
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0

SARA/sara_setURL_uSpot_noSSL.py

@@ -40,22 +40,7 @@ def read_complete_response(serial_connection, timeout=2, end_of_response_timeout
 
     return response.decode('utf-8', errors='replace')
 
-#get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser_sara = serial.Serial(
     port=port,  #USB0 or ttyS0

SARA/sara_writeMessage.py

@@ -12,21 +12,7 @@ port='/dev/'+parameter[0] # ex: ttyAMA2
 message = parameter[1]  # ex: Hello
 
 #get baudrate
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
-
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-# Load the configuration data
-config = load_config(config_file)
-# Access the shared variables
-baudrate = config.get('SaraR4_baudrate', 115200)
+baudrate = 115200
 
 ser = serial.Serial(
     port=port,  #USB0 or ttyS0

boot_hotspot.sh

@@ -2,9 +2,10 @@
 
 # Script to check if wifi is connected and start hotspot if not
 # will also retreive unique RPi ID and store it to deviceID.txt
+# script that starts at boot:
+# @reboot /var/www/nebuleair_pro_4g/boot_hotspot.sh >> /var/www/nebuleair_pro_4g/logs/app.log 2>&1
 
 OUTPUT_FILE="/var/www/nebuleair_pro_4g/wifi_list.csv"
-JSON_FILE="/var/www/nebuleair_pro_4g/config.json"
 
 
 echo "-------------------"
@@ -12,28 +13,52 @@ echo "-------------------"
 
 echo "NebuleAir pro started at $(date)"
 
-# Blink GPIO 23 and 24 five times
-for i in {1..5}; do
-    # Turn GPIO 23 and 24 ON
-    gpioset gpiochip0 23=1 24=1
-    #echo "LEDs ON"
-    sleep 1
-    
-    # Turn GPIO 23 and 24 OFF
-    gpioset gpiochip0 23=0 24=0
-    #echo "LEDs OFF"
-    sleep 1
-done
+chmod -R 777 /var/www/nebuleair_pro_4g/
 
-echo "getting SARA R4 serial number"
+# Blink GPIO 23 and 24 five times (starts OFF, stays OFF at end)
+#gpioset -c gpiochip0 -t 1s,1s,1s,1s,1s,1s,1s,1s,1s,1s,0 23=0 24=0
+
+# Blink GPIO 23 and 24 five times (starts OFF, stays OFF at end)
+python3 << 'EOF'
+import RPi.GPIO as GPIO
+import time
+
+GPIO.setmode(GPIO.BCM)
+GPIO.setwarnings(False)
+GPIO.setup(23, GPIO.OUT)
+GPIO.setup(24, GPIO.OUT)
+
+for _ in range(5):
+    GPIO.output(23, GPIO.HIGH)
+    GPIO.output(24, GPIO.HIGH)
+    time.sleep(1)
+    GPIO.output(23, GPIO.LOW)
+    GPIO.output(24, GPIO.LOW)
+    time.sleep(1)
+
+GPIO.cleanup()
+EOF
+
+echo "getting RPI serial number"
 # Get the last 8 characters of the serial number and write to text file
 serial_number=$(cat /proc/cpuinfo | grep Serial | awk '{print substr($3, length($3) - 7)}')
-# Use jq to update the "deviceID" in the JSON file
-jq --arg serial_number "$serial_number" '.deviceID = $serial_number' "$JSON_FILE" > temp.json && mv temp.json "$JSON_FILE"
+
+# update Sqlite database (only if not already set, i.e., still has default value 'XXXX')
+echo "Updating SQLite database with device ID: $serial_number"
+sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "UPDATE config_table SET value='$serial_number' WHERE key='deviceID' AND value='XXXX';"
+
 echo "id: $serial_number"
 
-#get the SSH port for tunneling
-SSH_TUNNEL_PORT=$(jq -r '.sshTunnel_port' "$JSON_FILE")
+# Get deviceID from SQLite config_table (may be different from serial_number if manually configured)
+DEVICE_ID=$(sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "SELECT value FROM config_table WHERE key='deviceID'")
+echo "Device ID from database: $DEVICE_ID"
+
+# Get deviceName from SQLite config_table for use in hotspot SSID
+DEVICE_NAME=$(sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "SELECT value FROM config_table WHERE key='deviceName'")
+echo "Device Name from database: $DEVICE_NAME"
+
+# Get SSH tunnel port from SQLite config_table
+SSH_TUNNEL_PORT=$(sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "SELECT value FROM config_table WHERE key='sshTunnel_port'")
 
 #need to wait for the network manager to be ready
 sleep 20
@@ -47,23 +72,20 @@ if [ "$STATE" == "30 (disconnected)" ]; then
     # Perform a wifi scan and save its output to a csv file    
     # nmcli device wifi list
     nmcli -f SSID,SIGNAL,SECURITY device wifi list | awk 'BEGIN { OFS=","; print "SSID,SIGNAL,SECURITY" } NR>1 { print $1,$2,$3 }' > "$OUTPUT_FILE"
-    # Start the hotspot
-    echo "Starting hotspot..."
-    sudo nmcli device wifi hotspot ifname wlan0 ssid nebuleair_pro password nebuleaircfg
-
-    # Update JSON to reflect hotspot mode
-    jq --arg status "hotspot" '.WIFI_status = $status' "$JSON_FILE" > temp.json && mv temp.json "$JSON_FILE"
+    # Start the hotspot with SSID based on deviceName
+    echo "Starting hotspot with SSID: $DEVICE_NAME"
+    sudo nmcli device wifi hotspot ifname wlan0 ssid "$DEVICE_NAME" password nebuleaircfg
 
+    # Update SQLite to reflect hotspot mode
+    sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "UPDATE config_table SET value='hotspot' WHERE key='WIFI_status'"
 
 else
     echo "🛜Success: wlan0 is connected!🛜"
     CONN_SSID=$(nmcli -g GENERAL.CONNECTION device show wlan0)
     echo "Connection: $CONN_SSID"
 
-    #update config JSON file
-    jq --arg status "connected" '.WIFI_status = $status' "$JSON_FILE" > temp.json && mv temp.json "$JSON_FILE"
-
-    sudo chmod 777 "$JSON_FILE"
+    # Update SQLite to reflect hotspot mode
+    sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "UPDATE config_table SET value='connected' WHERE key='WIFI_status'"
 
     # Lancer le tunnel SSH
     #echo "Démarrage du tunnel SSH sur le port $SSH_TUNNEL_PORT..."

connexion.sh

@@ -2,26 +2,49 @@
 echo "-------"
 echo "Start connexion shell script at $(date)"
 
+# Get deviceName from database for hotspot SSID
+DEVICE_NAME=$(sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "SELECT value FROM config_table WHERE key='deviceName'")
+echo "Device Name: $DEVICE_NAME"
 
-#disable hotspot
-echo "Disable Hotspot:"
-sudo nmcli connection down Hotspot
-sleep 10
+# Find and disable any active hotspot connection
+echo "Disable Hotspot..."
+# Get all wireless connections that are currently active (excludes the target WiFi)
+ACTIVE_HOTSPOT=$(nmcli -t -f NAME,TYPE,DEVICE connection show --active | grep ':802-11-wireless:wlan0' | cut -d: -f1)
+
+if [ -n "$ACTIVE_HOTSPOT" ]; then
+    echo "Disabling hotspot connection: $ACTIVE_HOTSPOT"
+    sudo nmcli connection down "$ACTIVE_HOTSPOT"
+else
+    echo "No active hotspot found"
+fi
+
+sleep 5
 
 echo "Start connection with:"
 echo "SSID: $1"
-echo "Password: $2"
+echo "Password: [HIDDEN]"
 sudo nmcli device wifi connect "$1" password "$2"
 
-#check if connection is successfull
+# Check if connection is successful
 if [ $? -eq 0 ]; then
-    echo "Connection to $1 is successfull"
+    echo "Connection to $1 is successful"
+
+    # Update SQLite to reflect connected status
+    sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "UPDATE config_table SET value='connected' WHERE key='WIFI_status'"
+    echo "Updated database: WIFI_status = connected"
 else
     echo "Connection to $1 failed"
     echo "Restarting hotspot..."
-    #enable hotspot
-    sudo nmcli connection up Hotspot
+
+    # Recreate hotspot with current deviceName as SSID
+    sudo nmcli device wifi hotspot ifname wlan0 ssid "$DEVICE_NAME" password nebuleaircfg
+
+    # Update SQLite to reflect hotspot mode
+    sqlite3 /var/www/nebuleair_pro_4g/sqlite/sensors.db "UPDATE config_table SET value='hotspot' WHERE key='WIFI_status'"
+    echo "Updated database: WIFI_status = hotspot"
+    echo "Hotspot restarted with SSID: $DEVICE_NAME"
 fi
+
 echo "End connexion shell script"
 echo "-------"
 

cron_jobs

@@ -4,4 +4,10 @@
 
 @reboot sleep 30 && /usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/reboot/start.py >> /var/www/nebuleair_pro_4g/logs/app.log 2>&1
 
-0 0 * * * > /var/www/nebuleair_pro_4g/logs/master.log
+#0 0 * * * > /var/www/nebuleair_pro_4g/logs/master.log
+#0 0 * * * > /var/www/nebuleair_pro_4g/logs/master_errors.log
+#0 0 * * * > /var/www/nebuleair_pro_4g/logs/app.log
+
+0 0 * * * find /var/www/nebuleair_pro_4g/logs -name "*.log" -type f -exec truncate -s 0 {} \;
+
+

envea/read_ref.py

@@ -1,6 +1,7 @@
 import serial
 import time
 import sys
+import re
 
 parameter = sys.argv[1:]  # Exclude the script name
 #print("Parameters received:")
@@ -61,8 +62,46 @@ def read_cairsens(port, baudrate=9600, parity=serial.PARITY_NONE, stopbits=seria
 
         # ASCII characters
         ascii_data = ''.join(chr(b) if 0x20 <= b <= 0x7E else '.' for b in raw_bytes)
-        print(f"Valeurs converties en ASCII : {ascii_data}")
+        sensor_type = "Unknown"  # ou None, selon ton besoin
+        sensor_measurement = "Unknown"
+        sensor_range =  "Unknown"
 
+        letters = re.findall(r'[A-Za-z]', ascii_data)
+        if len(letters) >= 1:
+            #print(f"First letter found: {letters[0]}")
+            if letters[0] == "C":
+                sensor_type = "Cairclip"
+        if len(letters) >= 2:
+            #print(f"Second letter found: {letters[1]}")
+            if letters[1] == "A":
+                sensor_measurement = "Ammonia(NH3)"
+            if letters[1] == "C":
+                sensor_measurement = "O3 and NO2"
+            if letters[1] == "G":
+                sensor_measurement = "CH4"
+            if letters[1] == "H":
+                sensor_measurement = "H2S"
+            if letters[1] == "N":
+                sensor_measurement = "NO2"
+        if len(letters) >= 3:
+            #print(f"Thrisd letter found: {letters[2]}")
+            if letters[2] == "B":
+                sensor_range = "0-250 ppb"
+            if letters[2] == "M":
+                sensor_range = "0-1ppm"
+            if letters[2] == "V":
+                sensor_range = "0-20 ppm"
+            if letters[2] == "P":
+                sensor_range = "PACKET data block ?"
+
+        if len(letters) < 1:
+            print("No letter found in the ASCII data.")
+
+        print(f"Valeurs converties en ASCII : {sensor_type} {sensor_measurement} {sensor_range}")
+
+        #print(f"Sensor type: {sensor_type}")
+        #print(f"Sensor measurment: {sensor_measurement}")
+        #print(f"Sensor range: {sensor_range}")
         # Numeric values
         numeric_values = [b for b in raw_bytes]
         print(f"Valeurs numériques : {numeric_values}")

envea/read_ref_v2.py

@@ -0,0 +1,224 @@
+"""
+  _____ _   ___     _______    _    
+ | ____| \ | \ \   / / ____|  / \   
+ |  _| |  \| |\ \ / /|  _|   / _ \  
+ | |___| |\  | \ V / | |___ / ___ \ 
+ |_____|_| \_|  \_/  |_____/_/   \_\
+                                    
+Gather data from envea Sensors and store them to the SQlite table
+Use the RTC time for the timestamp
+
+This script is run by a service nebuleair-envea-data.service
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_ref_v2.py ttyAMA4
+
+ATTENTION --> read_ref.py fonctionne mieux
+"""
+
+import serial
+import time
+import sys
+
+parameter = sys.argv[1:]  # Exclude the script name
+port='/dev/'+parameter[0]
+
+# Mapping dictionaries
+COMPOUND_MAP = {
+    'A': 'Ammonia',
+    'B': 'Benzene',
+    'C': 'Carbon Monoxide',
+    'D': 'Hydrogen Sulfide',
+    'E': 'Ethylene',
+    'F': 'Formaldehyde',
+    'G': 'Gasoline',
+    'H': 'Hydrogen',
+    'I': 'Isobutylene',
+    'J': 'Jet Fuel',
+    'K': 'Kerosene',
+    'L': 'Liquified Petroleum Gas',
+    'M': 'Methane',
+    'N': 'Nitrogen Dioxide',
+    'O': 'Ozone',
+    'P': 'Propane',
+    'Q': 'Quinoline',
+    'R': 'Refrigerant',
+    'S': 'Sulfur Dioxide',
+    'T': 'Toluene',
+    'U': 'Uranium Hexafluoride',
+    'V': 'Vinyl Chloride',
+    'W': 'Water Vapor',
+    'X': 'Xylene',
+    'Y': 'Yttrium',
+    'Z': 'Zinc'
+}
+
+RANGE_MAP = {
+    'A': '0-10 ppm',
+    'B': '0-250 ppb',
+    'C': '0-1000 ppm',
+    'D': '0-50 ppm',
+    'E': '0-100 ppm',
+    'F': '0-5 ppm',
+    'G': '0-500 ppm',
+    'H': '0-2000 ppm',
+    'I': '0-200 ppm',
+    'J': '0-300 ppm',
+    'K': '0-400 ppm',
+    'L': '0-600 ppm',
+    'M': '0-800 ppm',
+    'N': '0-20 ppm',
+    'O': '0-1 ppm',
+    'P': '0-5000 ppm',
+    'Q': '0-150 ppm',
+    'R': '0-750 ppm',
+    'S': '0-25 ppm',
+    'T': '0-350 ppm',
+    'U': '0-450 ppm',
+    'V': '0-550 ppm',
+    'W': '0-650 ppm',
+    'X': '0-850 ppm',
+    'Y': '0-950 ppm',
+    'Z': '0-1500 ppm'
+}
+
+INTERFACE_MAP = {
+    0x01: 'USB',
+    0x02: 'UART',
+    0x03: 'I2C',
+    0x04: 'SPI'
+}
+
+def parse_cairsens_data(hex_data):
+    """
+    Parse the extracted hex data from CAIRSENS sensor.
+    
+    :param hex_data: Hexadecimal string of extracted data (indices 11-28)
+    :return: Dictionary with parsed information
+    """
+    # Convert hex to bytes for easier processing
+    raw_bytes = bytes.fromhex(hex_data)
+    
+    # Initialize result dictionary
+    result = {
+        'device_type': 'Unknown',
+        'compound': 'Unknown',
+        'range': 'Unknown',
+        'interface': 'Unknown',
+        'raw_data': hex_data
+    }
+    
+    if len(raw_bytes) >= 4:  # Ensure we have at least 4 bytes
+        # First byte: Device type check
+        first_char = chr(raw_bytes[0]) if 0x20 <= raw_bytes[0] <= 0x7E else '?'
+        if first_char == 'C':
+            result['device_type'] = 'CAIRCLIP'
+        else:
+            result['device_type'] = f'Unknown ({first_char})'
+        
+        # Second byte: Compound mapping
+        second_char = chr(raw_bytes[1]) if 0x20 <= raw_bytes[1] <= 0x7E else '?'
+        result['compound'] = COMPOUND_MAP.get(second_char, f'Unknown ({second_char})')
+        
+        # Third byte: Range mapping
+        third_char = chr(raw_bytes[2]) if 0x20 <= raw_bytes[2] <= 0x7E else '?'
+        result['range'] = RANGE_MAP.get(third_char, f'Unknown ({third_char})')
+        
+        # Fourth byte: Interface (raw byte value)
+        interface_byte = raw_bytes[3]
+        result['interface'] = INTERFACE_MAP.get(interface_byte, f'Unknown (0x{interface_byte:02X})')
+        result['interface_raw'] = f'0x{interface_byte:02X}'
+    
+    return result
+
+def read_cairsens(port, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, databits=serial.EIGHTBITS, timeout=1):
+    """
+    Lit les données de la sonde CAIRSENS via UART.
+    /usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_ref_v2.py ttyAMA4
+
+    
+    :param port: Le port série utilisé (ex: 'COM1' ou '/dev/ttyAMA0').
+    :param baudrate: Le débit en bauds (ex: 9600).
+    :param parity: Le bit de parité (serial.PARITY_NONE, serial.PARITY_EVEN, serial.PARITY_ODD).
+    :param stopbits: Le nombre de bits de stop (serial.STOPBITS_ONE, serial.STOPBITS_TWO).
+    :param databits: Le nombre de bits de données (serial.FIVEBITS, serial.SIXBITS, serial.SEVENBITS, serial.EIGHTBITS).
+    :param timeout: Temps d'attente maximal pour la lecture (en secondes).
+    :return: Les données reçues sous forme de chaîne de caractères.
+    """
+    try:
+        # Ouvrir la connexion série
+        ser = serial.Serial(
+            port=port,
+            baudrate=baudrate,
+            parity=parity,
+            stopbits=stopbits,
+            bytesize=databits,
+            timeout=timeout
+        )
+        print(f"Connexion ouverte sur {port} à {baudrate} bauds.")
+
+        # Attendre un instant pour stabiliser la connexion
+        time.sleep(2)
+
+        # Envoyer une commande à la sonde (si nécessaire)
+        # Adapter cette ligne selon la documentation de la sonde
+        #ser.write(b'\r\n')  
+        ser.write(b'\xFF\x02\x13\x30\x01\x02\x03\x04\x05\x06\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1C\xD1\x61\x03')     
+
+        # Lire les données reçues
+        data = ser.readline()
+        print(f"Données reçues brutes : {data}")
+
+        # Convertir les données en hexadécimal
+        hex_data = data.hex()  # Convertit en chaîne hexadécimale
+        formatted_hex = ' '.join(hex_data[i:i+2] for i in range(0, len(hex_data), 2))  # Formate avec des espaces
+        print(f"Données reçues en hexadécimal : {formatted_hex}")
+
+        # Extraire les valeurs de l'index 11 à 28 (indices 22 à 56 en hex string)
+        extracted_hex = hex_data[22:56]  # Each byte is 2 hex chars, so 11*2=22 to 28*2=56
+        print(f"Valeurs hexadécimales extraites (11 à 28) : {extracted_hex}")
+
+        # Parse the extracted data
+        parsed_data = parse_cairsens_data(extracted_hex)
+        
+        # Display parsed information
+        print("\n=== CAIRSENS SENSOR INFORMATION ===")
+        print(f"Device Type: {parsed_data['device_type']}")
+        print(f"Compound: {parsed_data['compound']}")
+        print(f"Range: {parsed_data['range']}")
+        print(f"Interface: {parsed_data['interface']} ({parsed_data.get('interface_raw', 'N/A')})")
+        print(f"Raw Data: {parsed_data['raw_data']}")
+        print("=====================================")
+
+        # Convertir en ASCII et en valeurs numériques (pour debug)
+        if extracted_hex:
+            raw_bytes = bytes.fromhex(extracted_hex)
+            ascii_data = ''.join(chr(b) if 0x20 <= b <= 0x7E else '.' for b in raw_bytes)
+            print(f"Valeurs converties en ASCII : {ascii_data}")
+            
+            numeric_values = [b for b in raw_bytes]
+            print(f"Valeurs numériques : {numeric_values}")
+
+        # Fermer la connexion
+        ser.close()
+        print("Connexion fermée.")
+
+        return parsed_data
+
+    except serial.SerialException as e:
+        print(f"Erreur de connexion série : {e}")
+        return None
+    except Exception as e:
+        print(f"Erreur générale : {e}")
+        return None
+
+# Exemple d'utilisation
+if __name__ == "__main__":
+    port = port  # Remplacez par votre port série (ex: /dev/ttyAMA0 sur Raspberry Pi)
+    baudrate = 9600  # Débit en bauds (à vérifier dans la documentation)
+    parity = serial.PARITY_NONE  # Parité (NONE, EVEN, ODD)
+    stopbits = serial.STOPBITS_ONE  # Bits de stop (ONE, TWO)
+    databits = serial.EIGHTBITS  # Bits de données (FIVEBITS, SIXBITS, SEVENBITS, EIGHTBITS)
+
+    data = read_cairsens(port, baudrate, parity, stopbits, databits)
+    if data:
+        print(f"\nRésultat final : {data}")

envea/read_value.py

@@ -44,9 +44,9 @@ def read_cairsens(port, baudrate=9600, parity=serial.PARITY_NONE, stopbits=seria
 
 
         # Lire les données reçues
-        #data = ser.read_until(b'\n')  # Lire jusqu'à la fin de ligne ou un autre délimiteur
+        data = ser.read_until(b'\n')  # Lire jusqu'à la fin de ligne ou un autre délimiteur
         data = ser.readline()
-        #print(f"Données reçues brutes : {data}")
+        print(f"Données reçues brutes : {data}")
         #print(f"Données reçues (utf-8) : {data.decode('utf-8').strip()}")
 
         # Extraire le 20ème octet

envea/read_value_v2.py

@@ -8,7 +8,9 @@
 Gather data from envea Sensors and store them to the SQlite table
 Use the RTC time for the timestamp
 
-/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_value_v2.py
+This script is run by a service nebuleair-envea-data.service
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_value_v2.py -d
 
 """
 
@@ -18,41 +20,59 @@ import time
 import traceback
 import sqlite3
 from datetime import datetime
+import sys
+
+# Set DEBUG to True to enable debug prints, False to disable
+DEBUG = False  # Change this to False to disable debug output
+
+# You can also control debug via command line argument
+if len(sys.argv) > 1 and sys.argv[1] in ['--debug', '-d']:
+    DEBUG = True
+elif len(sys.argv) > 1 and sys.argv[1] in ['--quiet', '-q']:
+    DEBUG = False
+
+def debug_print(message):
+    """Print debug messages only if DEBUG is True"""
+    if DEBUG:
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f"[{timestamp}] {message}")
+
+debug_print("=== ENVEA Sensor Reader Started ===")
 
 # Connect to the SQLite database
-conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
-cursor = conn.cursor()
+try:
+    conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+    cursor = conn.cursor()
+except Exception as e:
+    debug_print(f"✗ Failed to connect to database: {e}")
+    sys.exit(1)
 
-#GET RTC TIME from SQlite
-cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
-row = cursor.fetchone()  # Get the first (and only) row
-rtc_time_str = row[1]  # '2025-02-07 12:30:45'
+# GET RTC TIME from SQlite
+try:
+    cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+    row = cursor.fetchone()  # Get the first (and only) row
+    rtc_time_str = row[1]  # '2025-02-07 12:30:45'
+except Exception as e:
+    debug_print(f"✗ Failed to get RTC time: {e}")
+    rtc_time_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    debug_print(f"  Using system time instead: {rtc_time_str}")
 
-# Function to load config data
-def load_config(config_file):
-    try:
-        with open(config_file, 'r') as file:
-            config_data = json.load(file)
-        return config_data
-    except Exception as e:
-        print(f"Error loading config file: {e}")
-        return {}
+# Fetch connected ENVEA sondes from SQLite config table
+try:
+    cursor.execute("SELECT port, name, coefficient FROM envea_sondes_table WHERE connected = 1")
+    connected_envea_sondes = cursor.fetchall()  # List of tuples (port, name, coefficient)
+    debug_print(f"✓ Found {len(connected_envea_sondes)} connected ENVEA sensors")
+    for port, name, coefficient in connected_envea_sondes:
+        debug_print(f"  - {name}: port={port}, coefficient={coefficient}")
+except Exception as e:
+    debug_print(f"✗ Failed to fetch connected sensors: {e}")
+    connected_envea_sondes = []
 
-# Define the config file path
-config_file = '/var/www/nebuleair_pro_4g/config.json'
-
-# Load the configuration data
-config = load_config(config_file)
-
-# Initialize sensors and serial connections
-envea_sondes = config.get('envea_sondes', [])
-connected_envea_sondes = [sonde for sonde in envea_sondes if sonde.get('connected', False)]
 serial_connections = {}
 
 if connected_envea_sondes:
-    for device in connected_envea_sondes:
-        port = device.get('port', 'Unknown')
-        name = device.get('name', 'Unknown')
+    debug_print("\n--- Opening Serial Connections ---")
+    for port, name, coefficient in connected_envea_sondes:
         try:
             serial_connections[name] = serial.Serial(
                 port=f'/dev/{port}',
@@ -62,60 +82,101 @@ if connected_envea_sondes:
                 bytesize=serial.EIGHTBITS,
                 timeout=1
             )
+            debug_print(f"✓ Opened serial port for {name} on /dev/{port}")
         except serial.SerialException as e:
-            print(f"Error opening serial port for {name}: {e}")
+            debug_print(f"✗ Error opening serial port for {name}: {e}")
+else:
+    debug_print("! No connected ENVEA sensors found in configuration")
 
-global data_h2s, data_no2, data_o3
+# Initialize sensor data variables
+global data_h2s, data_no2, data_o3, data_co, data_nh3, data_so2
 data_h2s = 0
 data_no2 = 0
 data_o3 = 0
 data_co = 0
 data_nh3 = 0
+data_so2 = 0
 
 try:
     if connected_envea_sondes:
-        for device in connected_envea_sondes:
-            name = device.get('name', 'Unknown')
-            coefficient = device.get('coefficient', 1)
+        debug_print("\n--- Reading Sensor Data ---")
+        for port, name, coefficient in connected_envea_sondes:
             if name in serial_connections:
                 serial_connection = serial_connections[name]
                 try:
-                    serial_connection.write(
-                        b"\xFF\x02\x13\x30\x01\x02\x03\x04\x05\x06\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x12\xAF\x88\x03"
-                    )
+                    debug_print(f"Reading from {name}...")
+                    
+                    # Send command to sensor
+                    command = b"\xFF\x02\x13\x30\x01\x02\x03\x04\x05\x06\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x12\xAF\x88\x03"
+                    serial_connection.write(command)
+                    debug_print(f"  → Sent command: {command.hex()}")
+                    
+                    # Read response
                     data_envea = serial_connection.readline()
+                    debug_print(f"  ← Received {len(data_envea)} bytes: {data_envea.hex()}")
+                    
                     if len(data_envea) >= 20:
-                        byte_20 = data_envea[19] * coefficient
+                        byte_20 = data_envea[19]
+                        raw_value = byte_20
+                        calculated_value = byte_20 * coefficient
+                        debug_print(f"  → Byte 20 value: {raw_value} (0x{raw_value:02X})")
+                        debug_print(f"  → Calculated value: {raw_value} × {coefficient} = {calculated_value}")
+                        
                         if name == "h2s":
-                            data_h2s = byte_20
+                            data_h2s = calculated_value
                         elif name == "no2":
-                            data_no2 = byte_20
+                            data_no2 = calculated_value
                         elif name == "o3":
-                            data_o3 = byte_20
+                            data_o3 = calculated_value
+                        elif name == "co":
+                            data_co = calculated_value
+                        elif name == "nh3":
+                            data_nh3 = calculated_value
+                        elif name == "so2":
+                            data_so2 = calculated_value
+                        
+                        debug_print(f"  ✓ {name.upper()} = {calculated_value}")
+                    else:
+                        debug_print(f"  ✗ Response too short (expected ≥20 bytes)")
+                        
                 except serial.SerialException as e:
-                    print(f"Error communicating with {name}: {e}")
+                    debug_print(f"✗ Error communicating with {name}: {e}")
+            else:
+                debug_print(f"! No serial connection available for {name}")
+                
 except Exception as e:
-    print("An error occurred while gathering data:", e)
+    debug_print(f"\n✗ An error occurred while gathering data: {e}")
     traceback.print_exc()
 
+# Display all collected data
+debug_print(f"\n--- Collected Sensor Data ---")
+debug_print(f"H2S: {data_h2s} ppb")
+debug_print(f"NO2: {data_no2} ppb")
+debug_print(f"O3:  {data_o3} ppb")
+debug_print(f"CO:  {data_co} ppb")
+debug_print(f"NH3: {data_nh3} ppb")
+debug_print(f"SO2: {data_so2} ppb")
 
-#print(f"  H2S: {data_h2s}, NO2: {data_no2}, O3: {data_o3}")
-
-#save to sqlite database
+# Save to sqlite database
 try:
     cursor.execute('''
-    INSERT INTO data_envea (timestamp,h2s, no2, o3, co, nh3) VALUES (?,?,?,?,?,?)'''
-    , (rtc_time_str,data_h2s,data_no2,data_o3,data_co,data_nh3  ))
-
+    INSERT INTO data_envea (timestamp, h2s, no2, o3, co, nh3, so2) VALUES (?,?,?,?,?,?,?)'''
+    , (rtc_time_str, data_h2s, data_no2, data_o3, data_co, data_nh3, data_so2))
+    
     # Commit and close the connection
     conn.commit()
-
-    #print("Sensor data saved successfully!")
-
+    
 except Exception as e:
-    print(f"Database error: {e}")    
+    debug_print(f"✗ Database error: {e}")
+    traceback.print_exc()
 
+# Close serial connections
+if serial_connections:
+    for name, connection in serial_connections.items():
+        try:
+            connection.close()
+        except:
+            pass
 
 conn.close()
-
-
+debug_print("\n=== ENVEA Sensor Reader Finished ===\n")

html/assets/js/i18n.js

@@ -0,0 +1,129 @@
+/**
+ * NebuleAir i18n - Lightweight internationalization system
+ * Works offline with local JSON translation files
+ * Stores language preference in SQLite database
+ */
+
+const i18n = {
+    currentLang: 'fr', // Default language
+    translations: {},
+
+    /**
+     * Initialize i18n system
+     * Loads language preference from server and applies translations
+     */
+    async init() {
+        try {
+            // Load language preference from server (SQLite database)
+            const response = await fetch('launcher.php?type=get_language');
+            const data = await response.json();
+            this.currentLang = data.language || 'fr';
+        } catch (error) {
+            console.warn('Could not load language preference, using default (fr):', error);
+            this.currentLang = 'fr';
+        }
+
+        // Load translations and apply
+        await this.loadTranslations(this.currentLang);
+        this.applyTranslations();
+    },
+
+    /**
+     * Load translation file for specified language
+     * @param {string} lang - Language code (fr, en)
+     */
+    async loadTranslations(lang) {
+        try {
+            const response = await fetch(`lang/${lang}.json`);
+            this.translations = await response.json();
+            console.log(`Translations loaded for: ${lang}`);
+        } catch (error) {
+            console.error(`Failed to load translations for ${lang}:`, error);
+        }
+    },
+
+    /**
+     * Apply translations to all elements with data-i18n attribute
+     */
+    applyTranslations() {
+        document.querySelectorAll('[data-i18n]').forEach(element => {
+            const key = element.getAttribute('data-i18n');
+            const translation = this.get(key);
+
+            if (translation) {
+                // Handle different element types
+                if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+                    if (element.type === 'button' || element.type === 'submit') {
+                        element.value = translation;
+                    } else {
+                        element.placeholder = translation;
+                    }
+                } else {
+                    element.textContent = translation;
+                }
+            } else {
+                console.warn(`Translation not found for key: ${key}`);
+            }
+        });
+
+        // Update HTML lang attribute
+        document.documentElement.lang = this.currentLang;
+
+        // Update language switcher dropdown
+        const languageSwitcher = document.getElementById('languageSwitcher');
+        if (languageSwitcher) {
+            languageSwitcher.value = this.currentLang;
+        }
+    },
+
+    /**
+     * Get translation by key (supports nested keys with dot notation)
+     * @param {string} key - Translation key (e.g., 'sensors.title')
+     * @returns {string} Translated string or key if not found
+     */
+    get(key) {
+        const keys = key.split('.');
+        let value = this.translations;
+
+        for (const k of keys) {
+            if (value && typeof value === 'object' && k in value) {
+                value = value[k];
+            } else {
+                return key; // Return key if translation not found
+            }
+        }
+
+        return value;
+    },
+
+    /**
+     * Change language and reload translations
+     * @param {string} lang - Language code (fr, en)
+     */
+    async setLanguage(lang) {
+        if (lang === this.currentLang) return;
+
+        this.currentLang = lang;
+
+        // Save to server (SQLite database)
+        try {
+            await fetch(`launcher.php?type=set_language&language=${lang}`);
+        } catch (error) {
+            console.error('Failed to save language preference:', error);
+        }
+
+        // Reload translations and apply
+        await this.loadTranslations(lang);
+        this.applyTranslations();
+
+        // Emit custom event for other scripts to react to language change
+        document.dispatchEvent(new CustomEvent('languageChanged', { detail: { language: lang } }));
+    }
+};
+
+// Auto-initialize when DOM is ready
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => i18n.init());
+} else {
+    i18n.init();
+}

html/database.html

@@ -26,6 +26,10 @@
     .offcanvas-backdrop {
       z-index: 1040;
     }
+    /* Highlight most recent data row with light green background */
+    .most-recent-row {
+      background-color: #d4edda !important;
+    }
   </style>
 </head>
 <body>
@@ -49,58 +53,70 @@
       </aside>
       <!-- Main content -->
       <main class="col-md-10 ms-sm-auto col-lg-11 offset-md-2 offset-lg-1 px-md-4">
-        <h1 class="mt-4">Base de données</h1>
-        <p>Le capteur enregistre en local les données de mesures. Vous pouvez ici les consulter et les télécharger.</p>
-       
+        <h1 class="mt-4" data-i18n="database.title">Base de données</h1>
+        <p data-i18n="database.description">Le capteur enregistre en local les données de mesures. Vous pouvez ici les consulter et les télécharger.</p>
+
         <div class="row mb-3">
 
-          <div class="col-sm-5">
-            <div class="card text-dark bg-light">
+          <div class="col-lg-4 col-md-6 mb-3">
+            <div class="card text-dark bg-light h-100">
               <div class="card-body">
-                <h5 class="card-title">Consulter la base de donnée</h5>
+                <h5 class="card-title" data-i18n="database.viewDatabase">Consulter la base de donnée</h5>
                   <!-- Dropdown to select number of records -->
                   <div class="d-flex align-items-center mb-3">
-                    <label for="records_limit" class="form-label me-2">Nombre de mesures:</label>
+                    <label for="records_limit" class="form-label me-2" data-i18n="database.numberOfMeasures">Nombre de mesures:</label>
                     <select id="records_limit" class="form-select w-auto">
-                        <option value="10" selected>10 dernières</option>
-                        <option value="20">20 dernières</option>
-                        <option value="30">30 dernières</option>
+                        <option value="10" selected data-i18n="database.last10">10 dernières</option>
+                        <option value="20" data-i18n="database.last20">20 dernières</option>
+                        <option value="30" data-i18n="database.last30">30 dernières</option>
                     </select>
                 </div>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_NPM',getSelectedLimit(),false)">Mesures PM</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_BME280',getSelectedLimit(),false)">Mesures Temp/Hum</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_NPM_5channels',getSelectedLimit(),false)">Mesures PM (5 canaux)</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_envea',getSelectedLimit(),false)">Sonde Cairsens</button>
-                <button class="btn btn-warning" onclick="get_data_sqlite('timestamp_table',getSelectedLimit(),false)">Timestamp Table</button>
-
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NPM',getSelectedLimit(),false)" data-i18n="database.pmMeasures">Mesures PM</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_BME280',getSelectedLimit(),false)" data-i18n="database.tempHumMeasures">Mesures Temp/Hum</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NPM_5channels',getSelectedLimit(),false)" data-i18n="database.pm5Channels">Mesures PM (5 canaux)</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_envea',getSelectedLimit(),false)" data-i18n="database.cairsensProbe">Sonde Cairsens</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NOISE',getSelectedLimit(),false)" data-i18n="database.noiseProbe">Sonde bruit</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_WIND',getSelectedLimit(),false)" data-i18n="database.windProbe">Sonde Vent</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_MPPT',getSelectedLimit(),false)" data-i18n="database.battery">Batterie</button>
+                <button class="btn btn-warning mb-2" onclick="get_data_sqlite('timestamp_table',getSelectedLimit(),false)" data-i18n="database.timestampTable">Timestamp Table</button>
               </div>
             </div>
           </div>
-      
-          <div class="col-sm-5">
-            <div class="card text-dark bg-light">
+
+          <div class="col-lg-4 col-md-6 mb-3">
+            <div class="card text-dark bg-light h-100">
               <div class="card-body">
-                <h5 class="card-title">Télécharger les données</h5>
+                <h5 class="card-title" data-i18n="database.downloadData">Télécharger les données</h5>
                 <!-- Date selection for download -->
                 <div class="d-flex align-items-center gap-3 mb-3">
-                   <label for="start_date" class="form-label">Date de début:</label>
+                   <label for="start_date" class="form-label" data-i18n="database.startDate">Date de début:</label>
                     <input type="date" id="start_date" class="form-control w-auto">
-                    <label for="end_date" class="form-label">Date de fin:</label>
+                    <label for="end_date" class="form-label" data-i18n="database.endDate">Date de fin:</label>
                     <input type="date" id="end_date" class="form-control w-auto">
                 </div>
 
-
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_NPM',10,true, getStartDate(), getEndDate())">Mesures PM</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_BME280',10,true, getStartDate(), getEndDate())">Mesures Temp/Hum</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_NPM_5channels',10,true, getStartDate(), getEndDate())">Mesures PM (5 canaux)</button>
-                <button class="btn btn-primary" onclick="get_data_sqlite('data_envea',10,true, getStartDate(), getEndDate())">Sonde Cairsens</button>
-
-                </table>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NPM',10,true, getStartDate(), getEndDate())" data-i18n="database.pmMeasures">Mesures PM</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_BME280',10,true, getStartDate(), getEndDate())" data-i18n="database.tempHumMeasures">Mesures Temp/Hum</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NPM_5channels',10,true, getStartDate(), getEndDate())" data-i18n="database.pm5Channels">Mesures PM (5 canaux)</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_envea',10,true, getStartDate(), getEndDate())" data-i18n="database.cairsensProbe">Sonde Cairsens</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_NOISE',10,true, getStartDate(), getEndDate())" data-i18n="database.noiseProbe">Sonde Bruit</button>
+                <button class="btn btn-primary mb-2" onclick="get_data_sqlite('data_mppt',10,true, getStartDate(), getEndDate())" data-i18n="database.battery">Batterie</button>
               </div>
             </div>
           </div>
 
-        <div>
+          <div class="col-lg-4 col-md-12 mb-3">
+            <div class="card text-white bg-danger h-100">
+              <div class="card-body">
+                <h5 class="card-title" data-i18n="database.dangerZone">Zone dangereuse</h5>
+                <p class="card-text" data-i18n="database.dangerWarning">Attention: Cette action est irréversible!</p>
+                <button class="btn btn-dark btn-lg w-100 mb-2" onclick="emptySensorTables()" data-i18n="database.emptyAllTables">Vider toutes les tables de capteurs</button>
+                <small class="d-block mt-2" data-i18n="database.emptyTablesNote">Note: Les tables de configuration et horodatage seront préservées.</small>
+              </div>
+            </div>
+          </div>
+
+        </div>
 
         <div class="row mt-2">
           <div id="table_data"></div>
@@ -116,6 +132,8 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
  document.addEventListener('DOMContentLoaded', function () {
@@ -127,6 +145,19 @@
         { id: 'sidebar_mobile', file: 'sidebar.html' }
     ];
 
+    let loadedCount = 0;
+    const totalElements = elementsToLoad.length;
+
+    function applyTranslationsWhenReady() {
+        if (typeof i18n !== 'undefined' && i18n.translations && Object.keys(i18n.translations).length > 0) {
+            console.log("Applying translations to dynamically loaded content");
+            i18n.applyTranslations();
+        } else {
+            // Retry after a short delay if translations aren't loaded yet
+            setTimeout(applyTranslationsWhenReady, 100);
+        }
+    }
+
     elementsToLoad.forEach(({ id, file }) => {
         fetch(file)
             .then(response => response.text())
@@ -135,11 +166,22 @@
                 if (element) {
                     element.innerHTML = data;
                 }
+                loadedCount++;
+
+                // Re-apply translations after all dynamic content is loaded
+                if (loadedCount === totalElements) {
+                    applyTranslationsWhenReady();
+                }
             })
             .catch(error => console.error(`Error loading ${file}:`, error));
     });
 
-    
+    // Also listen for language change events to re-apply translations
+    document.addEventListener('languageChanged', function() {
+        console.log("Language changed, re-applying translations");
+        i18n.applyTranslations();
+    });
+
 });
 
 
@@ -147,42 +189,55 @@
 
   
 
-    window.onload = function() {
-    fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
-        .then(response => response.json()) // Parse response as JSON
-        .then(data => {
-          console.log("Getting config file (onload)");
-            //get device ID
-            const deviceID = data.deviceID.trim().toUpperCase();
-            //document.getElementById('pageTitle_plus_ID').innerText = 'token: ' + deviceID;
-
-             //get device Name
-             const deviceName = data.deviceName;
-           
-           const elements = document.querySelectorAll('.sideBar_sensorName');
-           elements.forEach((element) => {
-               element.innerText = deviceName;
-           });
+window.onload = function() {
 
 
-            //get local RTC
-            $.ajax({
-                url: 'launcher.php?type=RTC_time',
-                dataType: 'text', // Specify that you expect a JSON response
-                method: 'GET', // Use GET or POST depending on your needs
-                success: function(response) {
-                            console.log("Local RTC: " + response);
-                            const RTC_Element = document.getElementById("RTC_time");
-                            RTC_Element.textContent = response;
-                        },
-                        error: function(xhr, status, error) {
-                            console.error('AJAX request failed:', status, error);
-                        }
+  //NEW way to get data from SQLITE
+  $.ajax({
+  url: 'launcher.php?type=get_config_sqlite',
+  dataType:'json',
+  //dataType: 'json', // Specify that you expect a JSON response
+  method: 'GET', // Use GET or POST depending on your needs
+  success: function(response) {
+              console.log("Getting SQLite config table:");
+              console.log(response);
+
+              //get device Name (for the side bar)
+              const deviceName = response.deviceName;
+              const elements = document.querySelectorAll('.sideBar_sensorName');
+              elements.forEach((element) => {
+                    element.innerText = deviceName;
                 });
 
-        })
-        .catch(error => console.error('Error loading config.json:', error));
-        }
+                      //device name html page title
+            if (response.deviceName) {
+            document.title = response.deviceName;
+            }
+                
+          },
+          error: function(xhr, status, error) {
+              console.error('AJAX request failed:', status, error);
+          }
+  }); //end ajax
+
+
+  //get local RTC
+  $.ajax({
+      url: 'launcher.php?type=RTC_time',
+      dataType: 'text', // Specify that you expect a JSON response
+      method: 'GET', // Use GET or POST depending on your needs
+      success: function(response) {
+                  console.log("Local RTC: " + response);
+                  const RTC_Element = document.getElementById("RTC_time");
+                  RTC_Element.textContent = response;
+              },
+              error: function(xhr, status, error) {
+                  console.error('AJAX request failed:', status, error);
+              }
+      }); //end AJAX
+
+
+}
 
 
 
@@ -199,7 +254,6 @@ function get_data_sqlite(table, limit, download , startDate = "", endDate = "")
 
   console.log(url);
   
-
   $.ajax({
     url: url,
     dataType: 'text', // Specify that you expect a JSON response
@@ -260,14 +314,40 @@ function get_data_sqlite(table, limit, download , startDate = "", endDate = "")
           tableHTML += `
               <th>Timestamp</th>
           `;
+      }else if (table === "data_WIND") {
+          tableHTML += `
+              <th>Timestamp</th>
+              <th>speed (km/h)</th>
+              <th>Direction (V)</th>
+          `;
+      }else if (table === "data_MPPT") {
+          tableHTML += `
+              <th>Timestamp</th>
+              <th>Battery Voltage</th>
+              <th>Battery Current</th>
+              <th> solar_voltage</th>
+              <th> solar_power</th>
+              <th> charger_status</th>
+
+          `;
+      }else if (table === "data_NOISE") {
+          tableHTML += `
+              <th>Timestamp</th>
+              <th>Curent LEQ</th>
+              <th>DB_A_value</th>
+              
+          `;
       }
 
+
       tableHTML += `</tr></thead><tbody>`;
 
     // Loop through rows and create table rows
-    rows.forEach(row => {
+    rows.forEach((row, index) => {
         let columns = row.replace(/[()]/g, "").split(", "); // Remove parentheses and split
-        tableHTML += "<tr>";
+        // Add special class to first row (most recent data)
+        const rowClass = index === 0 ? ' class="most-recent-row"' : '';
+        tableHTML += `<tr${rowClass}>`;
 
           if (table === "data_NPM") {
                     tableHTML += `
@@ -310,6 +390,28 @@ function get_data_sqlite(table, limit, download , startDate = "", endDate = "")
                     tableHTML += `
                         <td>${columns[1]}</td>
                     `;
+                }else if (table === "data_WIND") {
+                    tableHTML += `
+                        <td>${columns[0]}</td>
+                        <td>${columns[1]}</td>
+                        <td>${columns[2]}</td>
+                    `;
+                }else if (table === "data_MPPT") {
+                    tableHTML += `
+                        <td>${columns[0]}</td>
+                        <td>${columns[1]}</td>
+                        <td>${columns[2]}</td>
+                        <td>${columns[3]}</td>
+                        <td>${columns[4]}</td>
+                        <td>${columns[5]}</td>
+                    `;
+                }else if (table === "data_NOISE") {
+                    tableHTML += `
+                        <td>${columns[0]}</td>
+                        <td>${columns[1]}</td>
+                        <td>${columns[2]}</td>
+                        
+                    `;
                 }
 
                 tableHTML += "</tr>";
@@ -373,6 +475,74 @@ function downloadCSV(response, table) {
     document.body.removeChild(a);
 }
 
+// Function to empty all sensor tables
+function emptySensorTables() {
+    // Show confirmation dialog
+    const confirmed = confirm(
+        "WARNING: This will permanently delete ALL sensor data from the database!\n\n" +
+        "The following tables will be emptied:\n" +
+        "- data_NPM\n" +
+        "- data_NPM_5channels\n" +
+        "- data_BME280\n" +
+        "- data_envea\n" +
+        "- data_WIND\n" +
+        "- data_MPPT\n" +
+        "- data_NOISE\n\n" +
+        "Configuration and timestamp tables will be preserved.\n\n" +
+        "Are you absolutely sure you want to continue?"
+    );
+
+    if (!confirmed) {
+        console.log("Empty sensor tables operation cancelled by user");
+        return;
+    }
+
+    // Show loading message
+    const tableDataDiv = document.getElementById("table_data");
+    tableDataDiv.innerHTML = '<div class="alert alert-info">Emptying sensor tables... Please wait...</div>';
+
+    // Make AJAX request to empty tables
+    $.ajax({
+        url: 'launcher.php?type=empty_sensor_tables',
+        dataType: 'json',
+        method: 'GET',
+        success: function(response) {
+            console.log("Empty sensor tables response:", response);
+
+            if (response.success) {
+                // Show success message
+                let message = '<div class="alert alert-success">';
+                message += '<h5>Success!</h5>';
+                message += '<p>' + response.message + '</p>';
+
+                if (response.tables_processed && response.tables_processed.length > 0) {
+                    message += '<p><strong>Tables emptied:</strong></p><ul>';
+                    response.tables_processed.forEach(table => {
+                        message += `<li>${table.name}: ${table.deleted} records deleted</li>`;
+                    });
+                    message += '</ul>';
+                }
+
+                message += '</div>';
+                tableDataDiv.innerHTML = message;
+            } else {
+                // Show error message
+                tableDataDiv.innerHTML = `<div class="alert alert-danger">
+                    <h5>Error!</h5>
+                    <p>${response.message || response.error || 'Unknown error occurred'}</p>
+                </div>`;
+            }
+        },
+        error: function(xhr, status, error) {
+            console.error('AJAX request failed:', status, error);
+            tableDataDiv.innerHTML = `<div class="alert alert-danger">
+                <h5>Error!</h5>
+                <p>Failed to empty sensor tables: ${error}</p>
+            </div>`;
+        }
+    });
+}
+
 
 </script>
 

html/index.html

@@ -51,16 +51,16 @@
         </aside>
       <!-- Main content -->
       <main class="col-md-9 ms-sm-auto col-lg-10 offset-md-3 offset-lg-2 px-md-4">
-        <h1 class="mt-4">Votre capteur</h1>
-        <p>Bienvenue sur votre interface de configuration de votre capteur.</p>
-        
+        <h1 class="mt-4" data-i18n="home.title">Votre capteur</h1>
+        <p data-i18n="home.welcome">Bienvenue sur votre interface de configuration de votre capteur.</p>
+
         <div class="row mb-3">
 
           <!-- Card  NPM values -->
           <div class="col-sm-4 mt-2">
-          <div class="card"> 
+          <div class="card">
             <div class="card-body">
-              <h5 class="card-title">Mesures PM</h5>
+              <h5 class="card-title" data-i18n="home.pmMeasures">Mesures PM</h5>
               <canvas id="sensorPMChart" style="width: 100%; max-width: 600px; height: 200px;"></canvas>
             </div>
           </div>
@@ -68,14 +68,14 @@
 
           <!-- Card  Linux Stats -->
           <div class="col-sm-4 mt-2">
-            <div class="card"> 
+            <div class="card">
               <div class="card-body">
-                <h5 class="card-title">Linux stats</h5>
-                <p class="card-text">Disk usage (total size <span id="disk_size"></span> Gb) </p>
+                <h5 class="card-title" data-i18n="home.linuxStats">Statistiques Linux</h5>
+                <p class="card-text"><span data-i18n="home.diskUsage">Utilisation du disque (taille totale</span> <span id="disk_size"></span> Gb) </p>
                 <div id="disk_space"></div>
-                <p class="card-text">Memory usage (total size <span id="memory_size"></span> Mb) </p>
+                <p class="card-text"><span data-i18n="home.memoryUsage">Utilisation de la mémoire (taille totale</span> <span id="memory_size"></span> Mb) </p>
                 <div id="memory_space"></div>
-                <p class="card-text"> Database size: <span id="database_size"></span> </p>
+                <p class="card-text"><span data-i18n="home.databaseSize">Taille de la base de données:</span> <span id="database_size"></span> </p>
               </div>
             </div>
           </div>
@@ -108,6 +108,8 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
  document.addEventListener('DOMContentLoaded', function () {
@@ -135,6 +137,35 @@
 
 window.onload = function() {
 
+    //NEW way to get data from SQLITE
+    $.ajax({
+    url: 'launcher.php?type=get_config_sqlite',
+    dataType:'json',
+    //dataType: 'json', // Specify that you expect a JSON response
+    method: 'GET', // Use GET or POST depending on your needs
+    success: function(response) {
+                console.log("Getting SQLite config table:");
+                console.log(response);
+
+                //get device Name (for the side bar)
+                const deviceName = response.deviceName;
+                const elements = document.querySelectorAll('.sideBar_sensorName');
+                elements.forEach((element) => {
+                      element.innerText = deviceName;
+                  });
+
+                        //device name html page title
+      if (response.deviceName) {
+      document.title = response.deviceName;
+    }
+                  
+            },
+            error: function(xhr, status, error) {
+                console.error('AJAX request failed:', status, error);
+            }
+    }); //end ajax
+
+    /* OLD way of getting config data
     fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
         .then(response => response.json()) // Parse response as JSON
         .then(data => {
@@ -151,7 +182,12 @@ window.onload = function() {
             elements.forEach((element) => {
                 element.innerText = deviceName;
             });
-
+            
+        //end fetch config
+        })
+        .catch(error => console.error('Error loading config.json:', error));
+        //end windows on load
+      */
             //get local RTC
             $.ajax({
                 url: 'launcher.php?type=RTC_time',
@@ -421,10 +457,6 @@ window.onload = function() {
 
 
 
-        //end fetch config
-        })
-        .catch(error => console.error('Error loading config.json:', error));
-        //end windows on load
       }
 
 </script>

html/lang/README.md

@@ -0,0 +1,247 @@
+# NebuleAir i18n System
+
+Lightweight internationalization (i18n) system for NebuleAir web interface.
+
+## Features
+
+- **Offline-first**: Works completely offline with local JSON translation files
+- **Database-backed**: Language preference stored in SQLite `config_table`
+- **Automatic**: Translations apply on page load and when language changes
+- **Simple API**: Easy-to-use data attributes and JavaScript API
+
+## Quick Start
+
+### 1. Include i18n.js in your HTML page
+
+```html
+<script src="assets/js/i18n.js"></script>
+```
+
+The i18n system will automatically initialize when the page loads.
+
+### 2. Add translation keys to HTML elements
+
+Use the `data-i18n` attribute to mark elements for translation:
+
+```html
+<h1 data-i18n="page.title">Titre en français</h1>
+<p data-i18n="page.description">Description en français</p>
+<button data-i18n="common.submit">Soumettre</button>
+```
+
+The text content serves as a fallback if translations aren't loaded.
+
+### 3. Add translations to JSON files
+
+Edit `lang/fr.json` and `lang/en.json`:
+
+```json
+{
+  "page": {
+    "title": "Mon Titre",
+    "description": "Ma description"
+  },
+  "common": {
+    "submit": "Soumettre"
+  }
+}
+```
+
+Translation keys use dot notation for nested objects.
+
+## Translation Files
+
+- **`fr.json`**: French translations (default)
+- **`en.json`**: English translations
+
+### File Structure Example
+
+```json
+{
+  "common": {
+    "save": "Enregistrer",
+    "cancel": "Annuler",
+    "delete": "Supprimer"
+  },
+  "navigation": {
+    "home": "Accueil",
+    "settings": "Paramètres"
+  },
+  "sensors": {
+    "title": "Capteurs",
+    "description": "Liste des capteurs"
+  }
+}
+```
+
+## JavaScript API
+
+### Get Current Language
+
+```javascript
+const currentLang = i18n.currentLang; // 'fr' or 'en'
+```
+
+### Change Language Programmatically
+
+```javascript
+await i18n.setLanguage('en'); // Switch to English
+```
+
+### Get Translation in JavaScript
+
+```javascript
+const translation = i18n.get('sensors.title'); // Returns translated string
+```
+
+### Manual Translation Application
+
+If you dynamically create HTML elements, call `applyTranslations()` after adding them to the DOM:
+
+```javascript
+// Create new element
+const div = document.createElement('div');
+div.setAttribute('data-i18n', 'mypage.newElement');
+div.textContent = 'Fallback text';
+document.body.appendChild(div);
+
+// Apply translations
+i18n.applyTranslations();
+```
+
+### Listen for Language Changes
+
+```javascript
+document.addEventListener('languageChanged', (event) => {
+  console.log('Language changed to:', event.detail.language);
+  // Reload dynamic content, update charts, etc.
+});
+```
+
+## Special Cases
+
+### Input Placeholders
+
+For input fields, the translation applies to the `placeholder` attribute:
+
+```html
+<input type="text" data-i18n="form.emailPlaceholder" placeholder="Email...">
+```
+
+### Button Values
+
+For input buttons, the translation applies to the `value` attribute:
+
+```html
+<input type="submit" data-i18n="common.submit" value="Submit">
+```
+
+### Dynamic Content
+
+For content created with JavaScript (like sensor cards), add `data-i18n` attributes to your template strings and call `i18n.applyTranslations()` after inserting into the DOM.
+
+## Example: Migrating an Existing Page
+
+### Before (French only):
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Capteurs</title>
+</head>
+<body>
+  <h1>Liste des capteurs</h1>
+  <button onclick="getData()">Obtenir les données</button>
+</body>
+</html>
+```
+
+### After (Multilingual):
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title data-i18n="sensors.pageTitle">Capteurs</title>
+  <script src="assets/js/i18n.js"></script>
+</head>
+<body>
+  <h1 data-i18n="sensors.title">Liste des capteurs</h1>
+  <button onclick="getData()" data-i18n="common.getData">Obtenir les données</button>
+</body>
+</html>
+```
+
+**Add to `lang/fr.json`:**
+```json
+{
+  "sensors": {
+    "pageTitle": "Capteurs",
+    "title": "Liste des capteurs"
+  },
+  "common": {
+    "getData": "Obtenir les données"
+  }
+}
+```
+
+**Add to `lang/en.json`:**
+```json
+{
+  "sensors": {
+    "pageTitle": "Sensors",
+    "title": "Sensor List"
+  },
+  "common": {
+    "getData": "Get Data"
+  }
+}
+```
+
+## Backend Integration
+
+### Get Language Preference
+
+```javascript
+const response = await fetch('launcher.php?type=get_language');
+const data = await response.json();
+console.log(data.language); // 'fr' or 'en'
+```
+
+### Set Language Preference
+
+```javascript
+const response = await fetch('launcher.php?type=set_language&language=en');
+const data = await response.json();
+console.log(data.success); // true
+```
+
+Language preference is stored in SQLite `config_table` with key `language`.
+
+## Completed Pages
+
+- ✅ **sensors.html** - Fully translated with French/English support
+
+## TODO: Pages to Migrate
+
+- ⏳ index.html
+- ⏳ admin.html
+- ⏳ wifi.html
+- ⏳ saraR4.html
+- ⏳ map.html
+
+## Tips
+
+1. **Reuse common translations**: Put frequently used strings (buttons, actions, status messages) in the `common` section
+2. **Keep keys descriptive**: Use `sensors.bme280.title` instead of `s1` for maintainability
+3. **Test both languages**: Always verify that both French and English translations display correctly
+4. **Fallback text**: Always provide fallback text in HTML for graceful degradation
+
+## Support
+
+For issues or questions about the i18n system, refer to the implementation in:
+- `/html/assets/js/i18n.js` - Core translation library
+- `/html/lang/fr.json` - French translations
+- `/html/lang/en.json` - English translations
+- `/html/sensors.html` - Example implementation

html/lang/en.json

@@ -0,0 +1,105 @@
+{
+  "common": {
+    "getData": "Get Data",
+    "loading": "Loading...",
+    "error": "Error",
+    "startRecording": "Start recording",
+    "stopRecording": "Stop recording"
+  },
+  "sensors": {
+    "title": "Measurement Sensors",
+    "description": "Your NebuleAir sensor is equipped with one or more probes that measure environmental variables. Measurements are automatic, but you can verify their operation here.",
+    "npm": {
+      "title": "NextPM",
+      "description": "Particulate matter sensor.",
+      "headerUart": "UART Port"
+    },
+    "bme280": {
+      "title": "BME280 Temp/Humidity Sensor",
+      "description": "Temperature and humidity sensor on I2C port.",
+      "headerI2c": "I2C Port",
+      "temp": "Temperature",
+      "hum": "Humidity",
+      "press": "Pressure"
+    },
+    "noise": {
+      "title": "Decibel Meter",
+      "description": "Noise sensor on I2C port.",
+      "headerI2c": "I2C Port"
+    },
+    "envea": {
+      "title": "Envea Probe",
+      "description": "Gas sensor."
+    }
+  },
+  "wifi": {
+    "title": "WIFI Connection",
+    "description": "WIFI connection is not mandatory but it allows you to perform updates and enable remote control.",
+    "status": "Status",
+    "connected": "Connected",
+    "hotspot": "Hotspot",
+    "disconnected": "Disconnected",
+    "scan": "Scan",
+    "connect": "Connect",
+    "enterPassword": "Enter password for"
+  },
+  "admin": {
+    "title": "Administration",
+    "parameters": "Parameters (config)",
+    "deviceName": "Device Name",
+    "deviceID": "Device ID",
+    "modemVersion": "Modem Version"
+  },
+  "sidebar": {
+    "home": "Home",
+    "sensors": "Sensors",
+    "database": "Database",
+    "modem4g": "4G Modem",
+    "wifi": "WIFI",
+    "logs": "Logs",
+    "map": "Map",
+    "terminal": "Terminal",
+    "admin": "Admin"
+  },
+  "home": {
+    "title": "Your Sensor",
+    "welcome": "Welcome to your sensor configuration interface.",
+    "pmMeasures": "PM Measurements",
+    "linuxStats": "Linux Statistics",
+    "diskUsage": "Disk usage (total size",
+    "memoryUsage": "Memory usage (total size",
+    "databaseSize": "Database size:"
+  },
+  "database": {
+    "title": "Database",
+    "description": "The sensor records measurement data locally. You can view and download it here.",
+    "viewDatabase": "View Database",
+    "numberOfMeasures": "Number of measurements:",
+    "last10": "Last 10",
+    "last20": "Last 20",
+    "last30": "Last 30",
+    "pmMeasures": "PM Measurements",
+    "tempHumMeasures": "Temp/Hum Measurements",
+    "pm5Channels": "PM Measurements (5 channels)",
+    "cairsensProbe": "Cairsens Probe",
+    "noiseProbe": "Noise Probe",
+    "windProbe": "Wind Probe",
+    "battery": "Battery",
+    "timestampTable": "Timestamp Table",
+    "downloadData": "Download Data",
+    "startDate": "Start date:",
+    "endDate": "End date:",
+    "dangerZone": "Danger Zone",
+    "dangerWarning": "Warning: This action is irreversible!",
+    "emptyAllTables": "Empty all sensor tables",
+    "emptyTablesNote": "Note: Configuration and timestamp tables will be preserved."
+  },
+  "logs": {
+    "title": "The Log",
+    "description": "The log allows you to know if the sensor processes are running correctly.",
+    "saraLogs": "Sara logs",
+    "bootLogs": "Boot logs",
+    "refresh": "Refresh",
+    "clear": "Clear"
+  }
+}

html/lang/fr.json

@@ -0,0 +1,105 @@
+{
+  "common": {
+    "getData": "Obtenir les données",
+    "loading": "Chargement...",
+    "error": "Erreur",
+    "startRecording": "Démarrer l'enregistrement",
+    "stopRecording": "Arrêter l'enregistrement"
+  },
+  "sensors": {
+    "title": "Les sondes de mesure",
+    "description": "Votre capteur NebuleAir est équipé de une ou plusieurs sondes qui permettent de mesurer certaines variables environnementales. La mesure est automatique mais vous pouvez ici vous assurer de leur bon fonctionnement.",
+    "npm": {
+      "title": "NextPM",
+      "description": "Capteur particules fines.",
+      "headerUart": "Port UART"
+    },
+    "bme280": {
+      "title": "Capteur Temp/Humidité BME280",
+      "description": "Capteur température et humidité sur le port I2C.",
+      "headerI2c": "Port I2C",
+      "temp": "Température",
+      "hum": "Humidité",
+      "press": "Pression"
+    },
+    "noise": {
+      "title": "Sonomètre",
+      "description": "Capteur bruit sur le port I2C.",
+      "headerI2c": "Port I2C"
+    },
+    "envea": {
+      "title": "Sonde Envea",
+      "description": "Capteur gaz."
+    }
+  },
+  "wifi": {
+    "title": "Connexion WIFI",
+    "description": "La connexion WIFI n'est pas obligatoire mais elle vous permet d'effectuer des mises à jour et d'activer le contrôle à distance.",
+    "status": "Statut",
+    "connected": "Connecté",
+    "hotspot": "Point d'accès",
+    "disconnected": "Déconnecté",
+    "scan": "Scanner",
+    "connect": "Se connecter",
+    "enterPassword": "Entrer le mot de passe pour"
+  },
+  "admin": {
+    "title": "Administration",
+    "parameters": "Paramètres (config)",
+    "deviceName": "Nom de l'appareil",
+    "deviceID": "ID de l'appareil",
+    "modemVersion": "Version du modem"
+  },
+  "sidebar": {
+    "home": "Accueil",
+    "sensors": "Capteurs",
+    "database": "Base de données",
+    "modem4g": "Modem 4G",
+    "wifi": "WIFI",
+    "logs": "Logs",
+    "map": "Carte",
+    "terminal": "Terminal",
+    "admin": "Admin"
+  },
+  "home": {
+    "title": "Votre capteur",
+    "welcome": "Bienvenue sur votre interface de configuration de votre capteur.",
+    "pmMeasures": "Mesures PM",
+    "linuxStats": "Statistiques Linux",
+    "diskUsage": "Utilisation du disque (taille totale",
+    "memoryUsage": "Utilisation de la mémoire (taille totale",
+    "databaseSize": "Taille de la base de données:"
+  },
+  "database": {
+    "title": "Base de données",
+    "description": "Le capteur enregistre en local les données de mesures. Vous pouvez ici les consulter et les télécharger.",
+    "viewDatabase": "Consulter la base de donnée",
+    "numberOfMeasures": "Nombre de mesures:",
+    "last10": "10 dernières",
+    "last20": "20 dernières",
+    "last30": "30 dernières",
+    "pmMeasures": "Mesures PM",
+    "tempHumMeasures": "Mesures Temp/Hum",
+    "pm5Channels": "Mesures PM (5 canaux)",
+    "cairsensProbe": "Sonde Cairsens",
+    "noiseProbe": "Sonde bruit",
+    "windProbe": "Sonde Vent",
+    "battery": "Batterie",
+    "timestampTable": "Timestamp Table",
+    "downloadData": "Télécharger les données",
+    "startDate": "Date de début:",
+    "endDate": "Date de fin:",
+    "dangerZone": "Zone dangereuse",
+    "dangerWarning": "Attention: Cette action est irréversible!",
+    "emptyAllTables": "Vider toutes les tables de capteurs",
+    "emptyTablesNote": "Note: Les tables de configuration et horodatage seront préservées."
+  },
+  "logs": {
+    "title": "Le journal",
+    "description": "Le journal des logs permet de savoir si les processus du capteur se déroulent correctement.",
+    "saraLogs": "Sara logs",
+    "bootLogs": "Boot logs",
+    "refresh": "Refresh",
+    "clear": "Clear"
+  }
+}

html/logs.html

@@ -49,26 +49,30 @@
         </aside>
       <!-- Main content -->
       <main class="col-md-10 ms-sm-auto col-lg-11 offset-md-2 offset-lg-1 px-md-4">
-        <h1 class="mt-4">Le journal</h1>
-        <p>Le journal des logs permet de savoir si les processus du capteur se déroulent correctement.</p>
+        <h1 class="mt-4" data-i18n="logs.title">Le journal</h1>
+        <p data-i18n="logs.description">Le journal des logs permet de savoir si les processus du capteur se déroulent correctement.</p>
         <div class="row">
           <!-- card 1 -->
           <div class="col-lg-6 col-12">
             <div class="card" style="height: 80vh;">
               <div class="card-header">
-                Master logs  <button type="submit" class="btn btn-secondary btn-sm" onclick="clear_loopLogs()">Clear</button>
+                <span data-i18n="logs.saraLogs">Sara logs</span>
+                <button type="submit" class="btn btn-secondary btn-sm" id="refresh-master-log" data-i18n="logs.refresh">Refresh</button>
+                <button type="submit" class="btn btn-secondary btn-sm" onclick="clear_loopLogs()" data-i18n="logs.clear">Clear</button>
+
                   <span id="script_running"></span>
               </div>
               <div class="card-body overflow-auto" id="card_loop_content">
 
-              </div> 
+              </div>
             </div>
           </div>
           <!-- card 2 -->
           <div class="col-lg-6 col-12">
             <div class="card" style="height: 80vh;">
               <div class="card-header">
-                Boot logs
+                <span data-i18n="logs.bootLogs">Boot logs</span>
+                <button type="submit" class="btn btn-secondary btn-sm" id="refresh-boot-log" data-i18n="logs.refresh">Refresh</button>
               </div>
               <div class="card-body overflow-auto" id="card_boot_content">
 
@@ -86,6 +90,8 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
  document.addEventListener('DOMContentLoaded', function () {
@@ -111,65 +117,17 @@
     const boot_card_content = document.getElementById('card_boot_content');
 
     //Getting Master logs
-    console.log("Getting master logs");
+    console.log("Getting SARA logs");
+    displayLogFile('../logs/sara_service.log', loop_card_content, true, 1000);
+    
+    console.log("Getting app/boot logs");
+    displayLogFile('../logs/app.log', boot_card_content, true, 1000);
 
-    fetch('../logs/master.log')
-      .then((response) => {
-        console.log("OK");
-
-        if (!response.ok) {
-          throw new Error('Failed to fetch the log file.');
-        }
-        return response.text();
-      })
-      .then((data) => {
-        const lines = data.split('\n');
-
-        // Format log content
-        const formattedLog = lines
-          .map((line) => line.trim()) // Remove extra whitespace
-          .filter((line) => line) // Remove empty lines
-          .join('<br>'); // Join formatted lines with line breaks
-
-          loop_card_content.innerHTML = `<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0;">${formattedLog}</pre>`;
-          loop_card_content.scrollTop = loop_card_content.scrollHeight; // Scroll to the bottom
-
-        })
-      .catch((error) => {
-        console.error(error);
-        loop_card_content.textContent = 'Error loading log file.';
-      });
-
-      console.log("Getting app/boot logs");
-
-      //Getting App logs
-      fetch('../logs/app.log')
-      .then((response) => {
-        console.log("OK");
-        
-        if (!response.ok) {
-          throw new Error('Failed to fetch the log file.');
-        }
-        return response.text();
-      })
-      .then((data) => {
-        const lines = data.split('\n');
-
-        // Format log content
-        const formattedLog = lines
-          .map((line) => line.trim()) // Remove extra whitespace
-          .filter((line) => line) // Remove empty lines
-          .join('<br>'); // Join formatted lines with line breaks
-
-          boot_card_content.innerHTML = `<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0;">${formattedLog}</pre>`;
-          boot_card_content.scrollTop = loop_card_content.scrollHeight; // Scroll to the bottom
-
-        })
-      .catch((error) => {
-        console.error(error);
-        boot_card_content.textContent = 'Error loading log file.';
-      });
-        
+    // Setup master log with refresh button
+    setupLogRefreshButton('refresh-master-log', '../logs/sara_service.log', 'card_loop_content', 3000);
+            
+    // Setup boot log with refresh button
+    setupLogRefreshButton('refresh-boot-log', '../logs/app.log', 'card_boot_content', 300);
 
 
 });
@@ -179,41 +137,121 @@ window.onload = function() {
   getModem_busy_status();
   setInterval(getModem_busy_status, 2000);
 
-    fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
-        .then(response => response.json()) // Parse response as JSON
-        .then(data => {
-          console.log("Getting config file (onload)");
-            //get device ID
-            const deviceID = data.deviceID.trim().toUpperCase();
-           // document.getElementById('pageTitle_plus_ID').innerText = 'token: ' + deviceID;
-             //get device Name
-             const deviceName = data.deviceName;
-           
-           const elements = document.querySelectorAll('.sideBar_sensorName');
-           elements.forEach((element) => {
-               element.innerText = deviceName;
-           });
+  //NEW way to get config (SQLite)
+  $.ajax({
+    url: 'launcher.php?type=get_config_sqlite',
+    dataType:'json',
+    //dataType: 'json', // Specify that you expect a JSON response
+    method: 'GET', // Use GET or POST depending on your needs
+    success: function(response) {
+      console.log("Getting SQLite config table:");
+      console.log(response);
+
+      //device name_side bar
+      const elements = document.querySelectorAll('.sideBar_sensorName');
+        elements.forEach((element) => {
+            element.innerText = response.deviceName;
+        });
+
+      //device name html page title
+      if (response.deviceName) {
+      document.title = response.deviceName;
+    }
+
+  },
+  error: function(xhr, status, error) {
+      console.error('AJAX request failed:', status, error);
+  }
+    });//end AJAX
 
 
-            //get local RTC
-            $.ajax({
-                url: 'launcher.php?type=RTC_time',
-                dataType: 'text', // Specify that you expect a JSON response
-                method: 'GET', // Use GET or POST depending on your needs
-                success: function(response) {
-                            console.log("Local RTC: " + response);
-                            const RTC_Element = document.getElementById("RTC_time");
-                            RTC_Element.textContent = response;
-                        },
-                        error: function(xhr, status, error) {
-                            console.error('AJAX request failed:', status, error);
-                        }
-                });
+  //get local RTC
+  $.ajax({
+      url: 'launcher.php?type=RTC_time',
+      dataType: 'text', // Specify that you expect a JSON response
+      method: 'GET', // Use GET or POST depending on your needs
+      success: function(response) {
+                  console.log("Local RTC: " + response);
+                  const RTC_Element = document.getElementById("RTC_time");
+                  RTC_Element.textContent = response;
+              },
+              error: function(xhr, status, error) {
+                  console.error('AJAX request failed:', status, error);
+              }
+      });
 
-        })
-        .catch(error => console.error('Error loading config.json:', error));
-        }
 
+    }//end onload
+
+function displayLogFile(logFilePath, containerElement, scrollToBottom = true, maxLines = 0) {
+  // Show loading indicator
+  containerElement.innerHTML = '<div class="text-center"><i>Loading log file...</i></div>';
+  
+  return fetch(logFilePath)
+    .then((response) => {
+      if (!response.ok) {
+        throw new Error(`Failed to fetch the log file: ${response.status} ${response.statusText}`);
+      }
+      return response.text();
+    })
+    .then((data) => {
+      // Split the log into lines
+      let lines = data.split('\n');
+      
+      // Apply max lines limit if specified
+      if (maxLines > 0 && lines.length > maxLines) {
+        lines = lines.slice(-maxLines); // Get only the last N lines
+      }
+      
+      // Format log content
+      const formattedLog = lines
+        .map((line) => line.trim()) // Remove extra whitespace
+        .filter((line) => line)     // Remove empty lines
+        .join('<br>');              // Join formatted lines with line breaks
+      
+      // Display the formatted log
+      containerElement.innerHTML = `<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0;">${formattedLog}</pre>`;
+      
+      // Scroll to bottom if requested
+      if (scrollToBottom) {
+        containerElement.scrollTop = containerElement.scrollHeight;
+      }
+      
+      return formattedLog; // Return the formatted log in case the caller needs it
+    })
+    .catch((error) => {
+      console.error(`Error loading log file ${logFilePath}:`, error);
+      containerElement.innerHTML = `<div class="text-danger">Error loading log file: ${error.message}</div>`;
+      throw error; // Re-throw the error for the caller to handle if needed
+    });
+}
+
+/**
+ * Set up a refresh button for a log file
+ * @param {string} buttonId - ID of the button element
+ * @param {string} logFilePath - Path to the log file
+ * @param {string} containerId - ID of the container to display the log in
+ * @param {number} maxLines - Maximum number of lines to display (0 for all)
+ */
+ function setupLogRefreshButton(buttonId, logFilePath, containerId, maxLines = 0) {
+  console.log("Refreshing logs");
+  
+  const button = document.getElementById(buttonId);
+  const container = document.getElementById(containerId);
+  
+  if (!button || !container) {
+    console.error('Button or container element not found');
+    return;
+  }
+  
+  // Initial load
+  displayLogFile(logFilePath, container, true, maxLines);
+  
+  // Set up button click handler
+  button.addEventListener('click', () => {
+    displayLogFile(logFilePath, container, true, maxLines);
+  });
+}
 
 function clear_loopLogs(){
     console.log("Clearing loop logs");

html/saraR4.html

@@ -59,19 +59,20 @@
         </div>
 
         <span id="modem_status_message"></span>
+      <!-- 
         <h3>
           Status 
             <span id="modem-status" class="badge">Loading...</span>
           </h3>
-          
+          -->
           <div class="row mb-3">
 
-            <div class="col-sm-3">
+            <div class="col-sm-2">
               <div class="card">
              
                 <div class="card-body">
                   <p class="card-text">General information. </p>
-                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'ATI', 2)">Get Data</button>
+                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'ATI', 1)">Get Data</button>
                   <div id="loading_ttyAMA2_ATI" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
                   <div id="response_ttyAMA2_ATI"></div>
       
@@ -84,7 +85,7 @@
            
                 <div class="card-body">
                   <p class="card-text">SIM card information.</p>
-                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'AT+CCID?', 2)">Get Data</button>
+                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'AT+CCID?', 1)">Get Data</button>
                   <div id="loading_ttyAMA2_AT_CCID_" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
                   <div id="response_ttyAMA2_AT_CCID_"></div>
                 </div>
@@ -109,7 +110,7 @@
               <div class="card">
                 <div class="card-body">
                   <p class="card-text">Signal strength </p>
-                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'AT+CSQ', 2)">Get Data</button>
+                  <button class="btn btn-primary" onclick="getData_saraR4('ttyAMA2', 'AT+CSQ', 1)">Get Data</button>
                   <div id="loading_ttyAMA2_AT_CSQ" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
                   <div id="response_ttyAMA2_AT_CSQ"></div>
                   </table>
@@ -121,7 +122,7 @@
               <div class="card">
                 <div class="card-body">
                   <p class="card-text">Modem Reset </p>
-                  <button class="btn btn-danger" onclick="getData_saraR4('ttyAMA2', 'AT+CFUN=15', 2)">Reset</button>
+                  <button class="btn btn-danger" onclick="getData_saraR4('ttyAMA2', 'AT+CFUN=15', 1)">Reset</button>
                   <div id="loading_ttyAMA2_AT_CFUN_15" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
                   <div id="response_ttyAMA2_AT_CFUN_15"></div>
                   </table>
@@ -251,6 +252,34 @@
             </div>
           </div>
         </div>
+
+        <div class="col-sm-4">
+          <div class="card">
+            <div class="card-body">
+              <p class="card-text">Setup PSD connection.</p>
+              <button class="btn btn-primary" onclick="PSD_setup()">Start</button>
+              <div id="loading_PSD" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+              <div id="response_psd_setup"></div>
+            </div>
+          </div>
+        </div>
+
+        <div class="col-sm-3">
+          <div class="card">
+          
+            <div class="card-body">
+              <p class="card-text">Setup Server Hostname.</p>
+              <div class="input-group input-group-sm mb-3">
+                <span class="input-group-text" id="inputGroup-sizing-sm">Server name</span>
+                <input type="text" id="messageInput_server" class="form-control" aria-label="Sizing example input" aria-describedby="inputGroup-sizing-sm">
+              </div>
+              <button class="btn btn-primary" onclick="setupServerHostname('ttyAMA2', document.getElementById('messageInput_server').value, 0)">Set</button>
+              <div id="loading_serverHostname" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+              <div id="response_serverHostname"></div>
+            </div>
+          </div>
+        </div>
+        
     
  
       </div>
@@ -304,7 +333,20 @@
       
       
         </div>
-    
+
+        <!-- toast -->
+
+        <div class="toast-container position-fixed bottom-0 end-0 p-3">
+          <div id="liveToast" class="toast align-items-center text-bg-primary border-1" role="alert" aria-live="assertive" aria-atomic="true">
+            <div class="d-flex">
+              <div class="toast-body">
+                Hello, world! This is a toast message.
+              </div>
+              <button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast" aria-label="Close"></button>
+            </div>
+          </div>
+      </div>
+
     </main>
     </div>
   </div>
@@ -315,40 +357,122 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
- document.addEventListener('DOMContentLoaded', function () {
-    const elementsToLoad = [
-        { id: 'topbar', file: 'topbar.html' },
-        { id: 'sidebar', file: 'sidebar.html' },
-        { id: 'sidebar_mobile', file: 'sidebar.html' }
-    ];
+document.addEventListener('DOMContentLoaded', function () {
+  const elementsToLoad = [
+      { id: 'topbar', file: 'topbar.html' },
+      { id: 'sidebar', file: 'sidebar.html' },
+      { id: 'sidebar_mobile', file: 'sidebar.html' }
+  ];
 
-    elementsToLoad.forEach(({ id, file }) => {
-        fetch(file)
-            .then(response => response.text())
-            .then(data => {
-                const element = document.getElementById(id);
-                if (element) {
-                    element.innerHTML = data;
+  elementsToLoad.forEach(({ id, file }) => {
+      fetch(file)
+          .then(response => response.text())
+          .then(data => {
+              const element = document.getElementById(id);
+              if (element) {
+                  element.innerHTML = data;
+              }
+          })
+          .catch(error => console.error(`Error loading ${file}:`, error));
+  });
+
+  //OLD way to retreive data from JSON
+  /*
+  fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
+      .then(response => response.json()) // Parse response as JSON
+      .then(data => {
+        console.log("Getting config file (onload)");
+          //modem config mode 
+        const check_modem_configMode = document.getElementById("check_modem_configMode");
+        check_modem_configMode.checked = data.modem_config_mode;
+        console.log("Modem configuration: " + data.modem_config_mode);
+      })
+  */
+
+  //NEW way to get data from SQLITE
+  $.ajax({
+    url: 'launcher.php?type=get_config_sqlite',
+    dataType:'json',
+    //dataType: 'json', // Specify that you expect a JSON response
+    method: 'GET', // Use GET or POST depending on your needs
+    success: function(response) {
+                console.log("Getting SQLite config table:");
+                console.log(response);
+                //modem_version
+                const modem_version_html = document.getElementById("modem_version");
+                modem_version_html.innerText = response.modem_version;
+
+                // Set checkbox state based on the response data
+                const check_modem_configMode = document.getElementById("check_modem_configMode");
+                if (check_modem_configMode) {
+                    check_modem_configMode.checked = response.modem_config_mode;
+                    console.log("Modem configuration: " + response.modem_config_mode);
+                } else {
+                    console.error("Checkbox element not found");
                 }
-            })
-            .catch(error => console.error(`Error loading ${file}:`, error));
-    });
-
-    fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
-        .then(response => response.json()) // Parse response as JSON
-        .then(data => {
-          console.log("Getting config file (onload)");
-            //modem config mode 
-          const check_modem_configMode = document.getElementById("check_modem_configMode");
-          check_modem_configMode.checked = data.modem_config_mode;
-          console.log("Modem configuration: " + data.modem_config_mode);
-        
-        })
 
+            },
+            error: function(xhr, status, error) {
+                console.error('AJAX request failed:', status, error);
+            }
+    }); 
+  
 });
 
+window.onload = function() {
+  getModem_busy_status();
+  setInterval(getModem_busy_status, 1000);
+
+  //NEW way to get config (SQLite)
+  $.ajax({
+    url: 'launcher.php?type=get_config_sqlite',
+    dataType:'json',
+    //dataType: 'json', // Specify that you expect a JSON response
+    method: 'GET', // Use GET or POST depending on your needs
+    success: function(response) {
+      console.log("Getting SQLite config table:");
+      console.log(response);
+      //device name_side bar
+      const elements = document.querySelectorAll('.sideBar_sensorName');
+        elements.forEach((element) => {
+            element.innerText = response.deviceName;
+        });
+              //device name html page title
+      if (response.deviceName) {
+      document.title = response.deviceName;
+    }
+  },
+  error: function(xhr, status, error) {
+      console.error('AJAX request failed:', status, error);
+  }
+    });//end AJAX
+
+
+  //get local RTC
+  $.ajax({
+      url: 'launcher.php?type=RTC_time',
+      dataType: 'text', // Specify that you expect a JSON response
+      method: 'GET', // Use GET or POST depending on your needs
+      success: function(response) {
+                  console.log("Local RTC: " + response);
+                  const RTC_Element = document.getElementById("RTC_time");
+                  RTC_Element.textContent = response;
+
+              },
+              error: function(xhr, status, error) {
+                  console.error('AJAX request failed:', status, error);
+              }
+      });
+
+
+ 
+      }
+
+
 function getData_saraR4(port, command, timeout){
         console.log("Data from SaraR4");
         console.log("Port: " + port );
@@ -359,6 +483,8 @@ function getData_saraR4(port, command, timeout){
         console.log(safeCommand);
         
         $("#loading_"+port+"_"+safeCommand).show();
+        $("#response_"+port+"_"+safeCommand).empty();
+
 
                 $.ajax({
                 url: 'launcher.php?type=sara&port='+port+'&command='+encodeURIComponent(command)+'&timeout='+timeout,
@@ -430,8 +556,10 @@ function getData_saraR4(port, command, timeout){
                             } else{
                               // si c'est une commande AT normale
                               // Replace newline characters with <br> tags
-                            const formattedResponse = response.replace(/\n/g, "<br>");
+                            const formattedResponse = response.replace(/\n/g, "<br>")
+                                                              .replace(/\b(OK)\b/g, '<span style="color: green; font-weight: bold;">$1</span>');;
                             $("#response_"+port+"_"+safeCommand).html(formattedResponse);
+
                             }
                         },
                         error: function(xhr, status, error) {
@@ -462,6 +590,28 @@ function connectNetwork_saraR4(port, networkID, timeout){
           });
       }
 
+function setupServerHostname(port, serverName, timeout){
+  console.log(" Setupt server hostname "+serverName+"):");
+  $("#loading_serverHostname").show();
+          $.ajax({
+          url: 'launcher.php?type=sara_setupHostname&port='+port+'&networkID='+encodeURIComponent(serverName)+'&profileID=0',
+          dataType:'text',
+          //dataType: 'json', // Specify that you expect a JSON response
+          method: 'GET', // Use GET or POST depending on your needs
+          success: function(response) {
+                      console.log(response);
+                      $("#loading_serverHostname").hide();
+                      // Replace newline characters with <br> tags
+                      const formattedResponse = response.replace(/\n/g, "<br>");
+                      $("#response_serverHostname").html(formattedResponse);
+
+                  },
+                  error: function(xhr, status, error) {
+                      console.error('AJAX request failed:', status, error);
+                  }
+          });
+      }
+
 function mqtt_getConfig_saraR4(port, timeout){
   console.log("GET MQTT config (port "+port+"):");
   $("#loading_mqtt_getConfig").show();
@@ -575,6 +725,7 @@ function setURL_saraR4(port, url){
 
 function ping_test(port, url){
   console.log("Test ping to data.nebuleair.fr:");
+  $("#response_ping").empty();
   $("#loading_ping").show();
           $.ajax({
           url: 'launcher.php?type=sara_ping',
@@ -594,6 +745,27 @@ function ping_test(port, url){
           });
       }
 
+function PSD_setup(port, url){
+  console.log("Setup PSD connection:");
+  $("#loading_PSD").show();
+          $.ajax({
+          url: 'launcher.php?type=sara_psd_setup',
+          dataType: 'text',
+          //dataType: 'json', // Specify that you expect a JSON response
+          method: 'GET', // Use GET or POST depending on your needs
+          success: function(response) {
+                      console.log(response);
+                      $("#loading_PSD").hide();
+                      // Replace newline characters with <br> tags
+                      const formattedResponse = response.replace(/\n/g, "<br>");
+                      $("#response_psd_setup").html(formattedResponse);
+                  },
+                  error: function(xhr, status, error) {
+                      console.error('AJAX request failed:', status, error);
+                  }
+          });
+      }    
+
 function writeMessage_saraR4(port, message, type){
   console.log(type +" message to SARA R4 memory (port "+port+" and message "+message+"):");
   $("#loading_"+port+"_message_write").show();
@@ -700,84 +872,75 @@ function getModem_busy_status() {
 }
 
 function update_modem_configMode(param, checked){
+  //change ('modem_config_mode', '0', 'bool') inside SQLITE db
+  // response type: {"success":true,"message":"Configuration updated successfully","param":"modem_config_mode","value":"0","type":"bool"}
+  const toastLiveExample = document.getElementById('liveToast')
+  const toastBody = toastLiveExample.querySelector('.toast-body');
+
   console.log("updating modem config mode to :" + checked);
   $.ajax({
-      url: 'launcher.php?type=update_config&param='+param+'&value='+checked,
-      dataType: 'text', // Specify that you expect a JSON response
+      url: 'launcher.php?type=update_config_sqlite&param='+param+'&value='+checked,
+      dataType: 'json', // Specify that you expect a JSON response
       method: 'GET', // Use GET or POST depending on your needs
       cache: false, // Prevent AJAX from caching
       success: function(response) {
-                  console.log(response);
+        
+                console.log("AJAX success:");
+                console.log(response);
+
+                // Format the response nicely
+                  let formattedMessage = '';
+                  
+                  if (response.success) {
+                      // Success message
+                      toastLiveExample.classList.remove('text-bg-danger');
+                      toastLiveExample.classList.add('text-bg-success');
+                      
+                      formattedMessage = `
+                        <strong>Success!</strong><br>
+                        Parameter: ${response.param || param}<br>
+                        Value: ${response.value || checked}<br>
+                        ${response.message || ''}
+                      `;
+                  } else {
+                      // Error message
+                      toastLiveExample.classList.remove('text-bg-success');
+                      toastLiveExample.classList.add('text-bg-danger');
+                      
+                      formattedMessage = `
+                        <strong>Error!</strong><br>
+                        ${response.error || 'Unknown error'}<br>
+                        Parameter: ${response.param || param}
+                      `;
+                  }
+                  
+                  // Update the toast body with formatted content
+                  toastBody.innerHTML = formattedMessage;
+                  // Show the toast
+                const toastBootstrap = bootstrap.Toast.getOrCreateInstance(toastLiveExample)
+                toastBootstrap.show()
+
+
               },
               error: function(xhr, status, error) {
                   console.error('AJAX request failed:', status, error);
+                  // Update toast with error message
+                  toastBody.textContent = 'Error: ' + error;
+                  
+                  // Set toast to danger color
+                  toastLiveExample.classList.remove('text-bg-success');
+                  toastLiveExample.classList.add('text-bg-danger');
+                  
+                  // Show the toast for errors too
+                  const toastBootstrap = bootstrap.Toast.getOrCreateInstance(toastLiveExample);
+                  toastBootstrap.show();
               }
       });
 }
 
 
 
-window.onload = function() {
-  getModem_busy_status();
-  setInterval(getModem_busy_status, 1000);
 
-    fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
-        .then(response => response.json()) // Parse response as JSON
-        .then(data => {
-            //get device ID
-            const deviceID = data.deviceID.trim().toUpperCase();
-            //document.getElementById('pageTitle_plus_ID').innerText = 'token: ' + deviceID;
-             //get device Name
-             const deviceName = data.deviceName;
-
-             //get modem version
-             const modem_version = data.modem_version;
-             const modem_version_html = document.getElementById("modem_version");
-             modem_version_html.textContent = modem_version;
-
-
-           
-           const elements = document.querySelectorAll('.sideBar_sensorName');
-           elements.forEach((element) => {
-               element.innerText = deviceName;
-           });
-
-
-            //get SARA_R4 connection status
-            const SARA_statusElement = document.getElementById("modem-status");
-            console.log("SARA R4 is: " + data.SARA_R4_network_status);
-            
-            if (data.SARA_R4_network_status === "connected") {
-              SARA_statusElement.textContent = "Connected";
-              SARA_statusElement.className = "badge text-bg-success";
-            } else if (data.SARA_R4_network_status === "disconnected") {
-              SARA_statusElement.textContent = "Disconnected";
-              SARA_statusElement.className = "badge text-bg-danger";
-            } else {
-              SARA_statusElement.textContent = "Unknown";
-              SARA_statusElement.className = "badge text-bg-secondary";
-            }
-
-            //get local RTC
-            $.ajax({
-                url: 'launcher.php?type=RTC_time',
-                dataType: 'text', // Specify that you expect a JSON response
-                method: 'GET', // Use GET or POST depending on your needs
-                success: function(response) {
-                            console.log("Local RTC: " + response);
-                            const RTC_Element = document.getElementById("RTC_time");
-                            RTC_Element.textContent = response;
-
-                        },
-                        error: function(xhr, status, error) {
-                            console.error('AJAX request failed:', status, error);
-                        }
-                });
-  
-
-        })
-        .catch(error => console.error('Error loading config.json:', error));
-      }
 </script>
 
 </body>

html/sensors.html

@@ -49,11 +49,11 @@
         </aside>
       <!-- Main content -->
       <main class="col-md-10 ms-sm-auto col-lg-11 offset-md-2 offset-lg-1 px-md-4">
-        <h1 class="mt-4">Les sondes de mesure</h1>
-        <p>Votre capteur NebuleAir est équipé de une ou plusieurs sondes qui permettent de mesurer certaines variables environnementales. La mesure
+        <h1 class="mt-4" data-i18n="sensors.title">Les sondes de mesure</h1>
+        <p data-i18n="sensors.description">Votre capteur NebuleAir est équipé de une ou plusieurs sondes qui permettent de mesurer certaines variables environnementales. La mesure
         est automatique mais vous pouvez ici vous assurer de leur bon fonctionnement.
         </p>
-        <div class="row mb-3" id="card-container"></div>  
+        <div class="row mb-3" id="card-container"></div>
     </main>
     </div>
   </div>
@@ -64,6 +64,8 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
  document.addEventListener('DOMContentLoaded', function () {
@@ -101,7 +103,7 @@ function getNPM_values(port){
 
                         $("#loading_"+port).hide();
                         // Create an array of the desired keys
-                        const keysToShow = ["PM1", "PM25", "PM10"];
+                        const keysToShow = ["PM1", "PM25", "PM10","message"];
                         // Error messages mapping
                         const errorMessages = {
                             "notReady": "Sensor is not ready",
@@ -144,40 +146,50 @@ function getNPM_values(port){
         }
         
 function getENVEA_values(port, name){
-      console.log("Data from Envea "+ name+" (port "+port+"):");
-      $("#loading_envea"+name).show();
+    console.log("Data from Envea " + name + " (port " + port + "):");
+    $("#loading_envea" + name).show();
 
-            $.ajax({
-              url: 'launcher.php?type=envea&port='+port+'&name='+name,
-              dataType: 'json', // Specify that you expect a JSON response
-              method: 'GET', // Use GET or POST depending on your needs
-              success: function(response) {
-                        console.log(response);
-                        const tableBody = document.getElementById("data-table-body_envea"+name);
-                        tableBody.innerHTML = "";
+    $.ajax({
+        url: 'launcher.php?type=envea&port=' + port + '&name=' + name,
+        dataType: 'json',
+        method: 'GET',
+        success: function(response) {
+            console.log(response);
+            const tableBody = document.getElementById("data-table-body_envea" + name);
+            tableBody.innerHTML = "";
 
-                        $("#loading_envea"+name).hide();
-                        // Create an array of the desired keys
-                       // Create an array of the desired keys
-                       const keysToShow = [name];
-                        // Add only the specified elements to the table
-                        keysToShow.forEach(key => {
-                            if (response !== undefined) { // Check if the key exists in the response
-                                const value = response;
-                                $("#data-table-body_envea"+name).append(`
-                                    <tr>
-                                        <td>${key}</td>
-                                        <td>${value} ppb</td>
-                                    </tr>
-                                `);
-                            }
-                        });
-                    },
-                    error: function(xhr, status, error) {
-                        console.error('AJAX request failed:', status, error);
-                    }
+            $("#loading_envea" + name).hide();
+
+            const keysToShow = [name];
+            keysToShow.forEach(key => {
+                if (response !== undefined) {
+                    const value = response;
+                    $("#data-table-body_envea" + name).append(`
+                        <tr>
+                            <td>${key}</td>
+                            <td>${value} ppb</td>
+                        </tr>
+                    `);
+                }
             });
+        },
+        error: function(xhr, status, error) {
+            console.error('AJAX request failed:', status, error);
+            const tableBody = document.getElementById("data-table-body_envea" + name);
+            $("#loading_envea" + name).hide();
+
+            tableBody.innerHTML = `
+                <tr>
+                    <td colspan="2" class="text-danger">
+                        ❌ Error: unable to get data from sensor.<br>
+                        <small>${status}: ${error}</small>
+                    </td>
+                </tr>
+            `;
         }
+    });
+}
+
 
 function getNoise_values(){
       console.log("Data from I2C Noise Sensor:");
@@ -261,143 +273,192 @@ function getBME280_values(){
 
 
 window.onload = function() {
-    fetch('../config.json') // Replace 'deviceID.txt' with 'config.json'
-        .then(response => response.json()) // Parse response as JSON
-        .then(data => {
-            //get device ID
-            const deviceID = data.deviceID.trim().toUpperCase();
-            //document.getElementById('pageTitle_plus_ID').innerText = 'token: ' + deviceID;
-            //get device Name
-            const deviceName = data.deviceName;
-                      
-                      const elements = document.querySelectorAll('.sideBar_sensorName');
-                      elements.forEach((element) => {
-                          element.innerText = deviceName;
-                      });
+
+  //NEW way to get config (SQLite)
+  let mainConfig = {}; // Store main config for use in sensor card creation
+
+$.ajax({
+  url: 'launcher.php?type=get_config_sqlite',
+  dataType:'json',
+  //dataType: 'json', // Specify that you expect a JSON response
+  method: 'GET', // Use GET or POST depending on your needs
+  success: function(response) {
+    console.log("Getting SQLite config table:");
+    console.log(response);
+
+    mainConfig = response; // Store for later use
+
+    //device name_side bar
+    const elements = document.querySelectorAll('.sideBar_sensorName');
+      elements.forEach((element) => {
+          element.innerText = response.deviceName;
+      });
+
+    // After getting main config, create sensor cards
+    createSensorCards(mainConfig);
+
+    },
+error: function(xhr, status, error) {
+    console.error('AJAX request failed:', status, error);
+}
+  });//end AJAX
+
+ //Function to create sensor cards based on config
+ function createSensorCards(config) {
+      console.log("Creating sensor cards with config:");
+      console.log(config);
+
+    const container = document.getElementById('card-container'); // Conteneur des cartes
+
+    //creates NPM card (by default)
+
+    const cardHTML = `
+      <div class="col-sm-3">
+        <div class="card">
+          <div class="card-header" data-i18n="sensors.npm.headerUart">
+            Port UART
+          </div>
+          <div class="card-body">
+            <h5 class="card-title" data-i18n="sensors.npm.title">NextPM</h5>
+            <p class="card-text" data-i18n="sensors.npm.description">Capteur particules fines.</p>
+            <button class="btn btn-primary" onclick="getNPM_values('ttyAMA5')" data-i18n="common.getData">Get Data</button>
+            <br>
+            <div id="loading_ttyAMA5" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+            <table class="table table-striped-columns">
+              <tbody id="data-table-body_ttyAMA5"></tbody>
+            </table>
+          </div>
+        </div>
+      </div>`;
+
+    container.innerHTML += cardHTML; // Add the I2C card if condition is met
 
 
+ //creates i2c BME280 card
+ if (config.BME280) {
+    const i2C_BME_HTML = `
+      <div class="col-sm-3">
+        <div class="card">
+          <div class="card-header" data-i18n="sensors.bme280.headerI2c">
+            Port I2C
+          </div>
+          <div class="card-body">
+            <h5 class="card-title" data-i18n="sensors.bme280.title">BME280 Temp/Hum sensor</h5>
+            <p class="card-text" data-i18n="sensors.bme280.description">Capteur température et humidité sur le port I2C.</p>
+            <button class="btn btn-primary mb-1" onclick="getBME280_values()" data-i18n="common.getData">Get Data</button>
+            <br>
+            <div id="loading_BME280" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+            <table class="table table-striped-columns">
+              <tbody id="data-table-body_BME280"></tbody>
+            </table>
+          </div>
+        </div>
+      </div>`;
 
-            //get local RTC
-            $.ajax({
-                url: 'launcher.php?type=RTC_time',
-                dataType: 'text', // Specify that you expect a JSON response
-                method: 'GET', // Use GET or POST depending on your needs
-                success: function(response) {
-                            console.log("Local RTC: " + response);
-                            const RTC_Element = document.getElementById("RTC_time");
-                            RTC_Element.textContent = response;
+    container.innerHTML += i2C_BME_HTML; // Add the I2C card if condition is met
+  }
 
-                        },
-                        error: function(xhr, status, error) {
-                            console.error('AJAX request failed:', status, error);
-                        }
-                });
+    //creates i2c sound card
+    if (config.NOISE) {
+    const i2C_HTML = `
+      <div class="col-sm-3">
+        <div class="card">
+          <div class="card-header" data-i18n="sensors.noise.headerI2c">
+            Port I2C
+          </div>
+          <div class="card-body">
+            <h5 class="card-title" data-i18n="sensors.noise.title">Decibel Meter</h5>
+            <p class="card-text" data-i18n="sensors.noise.description">Capteur bruit sur le port I2C.</p>
+            <button class="btn btn-primary mb-1" onclick="getNoise_values()" data-i18n="common.getData">Get Data</button>
+            <br>
+            <button class="btn btn-success" onclick="startNoise()" data-i18n="common.startRecording">Start recording</button>
+            <button class="btn btn-danger" onclick="stopNoise()" data-i18n="common.stopRecording">Stop recording</button>
+            <div id="loading_noise" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+            <table class="table table-striped-columns">
+              <tbody id="data-table-body_noise"></tbody>
+            </table>
+          </div>
+        </div>
+      </div>`;
 
-            const container = document.getElementById('card-container'); // Conteneur des cartes
-            
-            //creates NPM cards
-            const NPM_ports = data.NextPM_ports; // Récupère les ports
-            NPM_ports.forEach((port, index) => {
-              const cardHTML = `
-                <div class="col-sm-3">
-                  <div class="card">
-                    <div class="card-header">
-                      Port UART ${port.replace('ttyAMA', '')}
-                    </div>
-                    <div class="card-body">
-                      <h5 class="card-title">NextPM ${String.fromCharCode(65 + index)}</h5>
-                      <p class="card-text">Capteur particules fines.</p>
-                      <button class="btn btn-primary" onclick="getNPM_values('${port}')">Get Data</button>
-                      <div id="loading_${port}" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
-                      <table class="table table-striped-columns">
-                        <tbody id="data-table-body_${port}"></tbody>
-                      </table>
-                    </div>
-                  </div>
-                </div>`;
-              container.innerHTML += cardHTML; // Ajouter la carte au conteneur
-            });
+    container.innerHTML += i2C_HTML; // Add the I2C card if condition is met
+  }
 
-            //creates ENVEA cards
-            const ENVEA_sensors = data.envea_sondes.filter(sonde => sonde.connected); // Filter only connected sondes
+  //Si on a des SONDES ENVEA connectée il faut faire un deuxième call dans la table envea_sondes_table
+  //creates ENVEA cards
+  if (config.envea) {
+    console.log("Need to display ENVEA sondes");
+    //getting config_scripts table
+    $.ajax({
+      url: 'launcher.php?type=get_envea_sondes_table_sqlite',
+      dataType:'json',
+      //dataType: 'json', // Specify that you expect a JSON response
+      method: 'GET', // Use GET or POST depending on your needs
+      success: function(sondes) {
+        console.log("Getting SQLite envea sondes table:");
+        console.log(sondes);
+        const ENVEA_sensors = sondes.filter(sonde => sonde.connected); // Filter only connected sondes
 
-            ENVEA_sensors.forEach((sensor, index) => {
-                const port = sensor.port; // Port from the sensor object
-                const name = sensor.name; // Port from the sensor object
-                const coefficient = sensor.coefficient;
-              const cardHTML = `
-                <div class="col-sm-3">
-                  <div class="card">
-                    <div class="card-header">
-                      Port UART ${port.replace('ttyAMA', '')}
-                    </div>
-                    <div class="card-body">
-                      <h5 class="card-title">Sonde Envea ${name}</h5>
-                      <p class="card-text">Capteur gas.</p>
-                      <button class="btn btn-primary" onclick="getENVEA_values('${port}','${name}','${coefficient}')">Get Data</button>
-                      <div id="loading_envea${name}" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
-                      <table class="table table-striped-columns">
-                        <tbody id="data-table-body_envea${name}"></tbody>
-                      </table>
-                    </div>
-                  </div>
-                </div>`;
-              container.innerHTML += cardHTML; // Ajouter la carte au conteneur
-            });
+        ENVEA_sensors.forEach((sensor, index) => {
+            const port = sensor.port; // Port from the sensor object
+            const name = sensor.name; // Port from the sensor object
+            const coefficient = sensor.coefficient;
+          const cardHTML = `
+            <div class="col-sm-3">
+              <div class="card">
+                <div class="card-header">
+                  Port UART ${port.replace('ttyAMA', '')}
+                </div>
+                <div class="card-body">
+                  <h5 class="card-title">Sonde Envea ${name}</h5>
+                  <p class="card-text" data-i18n="sensors.envea.description">Capteur gas.</p>
+                  <button class="btn btn-primary" onclick="getENVEA_values('${port}','${name}')" data-i18n="common.getData">Get Data</button>
+                  <div id="loading_envea${name}" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
+                  <table class="table table-striped-columns">
+                    <tbody id="data-table-body_envea${name}"></tbody>
+                  </table>
+                </div>
+              </div>
+            </div>`;
+          container.innerHTML += cardHTML; // Ajouter la carte au conteneur
+        });
 
-            //creates i2c BME280 card
-            if (data["BME280/get_data_v2.py"]) {
-              const i2C_BME_HTML = `
-                <div class="col-sm-3">
-                  <div class="card">
-                    <div class="card-header">
-                      Port I2C
-                    </div>
-                    <div class="card-body">
-                      <h5 class="card-title">BME280 Temp/Hum sensor</h5>
-                      <p class="card-text">Capteur température et humidité sur le port I2C.</p>
-                      <button class="btn btn-primary mb-1" onclick="getBME280_values()">Get Data</button>
-                      <br>
-                      <div id="loading_BME280" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
-                      <table class="table table-striped-columns">
-                        <tbody id="data-table-body_BME280"></tbody>
-                      </table>
-                    </div>
-                  </div>
-                </div>`;
-              
-              container.innerHTML += i2C_BME_HTML; // Add the I2C card if condition is met
-            }
+        // Apply translations to dynamically created Envea cards
+        i18n.applyTranslations();
+                
 
-             //creates i2c sound card
-             if (data.i2C_sound) {
-              const i2C_HTML = `
-                <div class="col-sm-3">
-                  <div class="card">
-                    <div class="card-header">
-                      Port I2C
-                    </div>
-                    <div class="card-body">
-                      <h5 class="card-title">Decibel Meter</h5>
-                      <p class="card-text">Capteur bruit sur le port I2C.</p>
-                      <button class="btn btn-primary mb-1" onclick="getNoise_values()">Get Data</button>
-                      <br>
-                      <button class="btn btn-success" onclick="startNoise()">Start recording</button>
-                      <button class="btn btn-danger" onclick="stopNoise()">Stop recording</button>
-                      <div id="loading_noise" class="spinner-border spinner-border-sm" style="display: none;" role="status"></div>
-                      <table class="table table-striped-columns">
-                        <tbody id="data-table-body_noise"></tbody>
-                      </table>
-                    </div>
-                  </div>
-                </div>`;
-              
-              container.innerHTML += i2C_HTML; // Add the I2C card if condition is met
-            }
 
-        })
-        .catch(error => console.error('Error loading config.json:', error));
-      }
+    },
+    error: function(xhr, status, error) {
+        console.error('AJAX request failed:', status, error);
+    }
+      });//end AJAX envea Sondes
+
+
+  }//end if envea
+
+  // Apply translations to all dynamically created sensor cards
+  i18n.applyTranslations();
+
+  } // end createSensorCards function
+
+    //get local RTC
+    $.ajax({
+      url: 'launcher.php?type=RTC_time',
+      dataType: 'text', // Specify that you expect a JSON response
+      method: 'GET', // Use GET or POST depending on your needs
+      success: function(response) {
+                  console.log("Local RTC: " + response);
+                  const RTC_Element = document.getElementById("RTC_time");
+                  RTC_Element.textContent = response;
+
+              },
+              error: function(xhr, status, error) {
+                  console.error('AJAX request failed:', status, error);
+              }
+      });
+
+} //end windows onload
 </script>
 
 </body>

html/sidebar.html

@@ -4,34 +4,34 @@
         <svg class="bi me-2" width="16" height="16" fill="currentColor" aria-hidden="true">
             <use xlink:href="assets/icons/bootstrap-icons.svg#house"></use>
         </svg>
-        Home
+        <span data-i18n="sidebar.home">Accueil</span>
       </a>
       <a class="nav-link text-white" href="sensors.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-thermometer-sun" viewBox="0 0 16 16">
             <path d="M5 12.5a1.5 1.5 0 1 1-2-1.415V2.5a.5.5 0 0 1 1 0v8.585A1.5 1.5 0 0 1 5 12.5"/>
             <path d="M1 2.5a2.5 2.5 0 0 1 5 0v7.55a3.5 3.5 0 1 1-5 0zM3.5 1A1.5 1.5 0 0 0 2 2.5v7.987l-.167.15a2.5 2.5 0 1 0 3.333 0L5 10.486V2.5A1.5 1.5 0 0 0 3.5 1m5 1a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-1 0v-1a.5.5 0 0 1 .5-.5m4.243 1.757a.5.5 0 0 1 0 .707l-.707.708a.5.5 0 1 1-.708-.708l.708-.707a.5.5 0 0 1 .707 0M8 5.5a.5.5 0 0 1 .5-.5 3 3 0 1 1 0 6 .5.5 0 0 1 0-1 2 2 0 0 0 0-4 .5.5 0 0 1-.5-.5M12.5 8a.5.5 0 0 1 .5-.5h1a.5.5 0 1 1 0 1h-1a.5.5 0 0 1-.5-.5m-1.172 2.828a.5.5 0 0 1 .708 0l.707.708a.5.5 0 0 1-.707.707l-.708-.707a.5.5 0 0 1 0-.708M8.5 12a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-1 0v-1a.5.5 0 0 1 .5-.5"/>
           </svg>
-        Capteurs
+        <span data-i18n="sidebar.sensors">Capteurs</span>
       </a>
       <a class="nav-link text-white" href="database.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-database" viewBox="0 0 16 16">
           <path d="M4.318 2.687C5.234 2.271 6.536 2 8 2s2.766.27 3.682.687C12.644 3.125 13 3.627 13 4c0 .374-.356.875-1.318 1.313C10.766 5.729 9.464 6 8 6s-2.766-.27-3.682-.687C3.356 4.875 3 4.373 3 4c0-.374.356-.875 1.318-1.313M13 5.698V7c0 .374-.356.875-1.318 1.313C10.766 8.729 9.464 9 8 9s-2.766-.27-3.682-.687C3.356 7.875 3 7.373 3 7V5.698c.271.202.58.378.904.525C4.978 6.711 6.427 7 8 7s3.022-.289 4.096-.777A5 5 0 0 0 13 5.698M14 4c0-1.007-.875-1.755-1.904-2.223C11.022 1.289 9.573 1 8 1s-3.022.289-4.096.777C2.875 2.245 2 2.993 2 4v9c0 1.007.875 1.755 1.904 2.223C4.978 15.71 6.427 16 8 16s3.022-.289 4.096-.777C13.125 14.755 14 14.007 14 13zm-1 4.698V10c0 .374-.356.875-1.318 1.313C10.766 11.729 9.464 12 8 12s-2.766-.27-3.682-.687C3.356 10.875 3 10.373 3 10V8.698c.271.202.58.378.904.525C4.978 9.71 6.427 10 8 10s3.022-.289 4.096-.777A5 5 0 0 0 13 8.698m0 3V13c0 .374-.356.875-1.318 1.313C10.766 14.729 9.464 15 8 15s-2.766-.27-3.682-.687C3.356 13.875 3 13.373 3 13v-1.302c.271.202.58.378.904.525C4.978 12.71 6.427 13 8 13s3.022-.289 4.096-.777c.324-.147.633-.323.904-.525"/>
         </svg>
-      
-        DataBase
+
+        <span data-i18n="sidebar.database">Base de données</span>
       </a>
       <a class="nav-link text-white" href="saraR4.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-reception-4" viewBox="0 0 16 16">
             <path d="M0 11.5a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5v2a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1-.5-.5zm4-3a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5v5a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1-.5-.5zm4-3a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5v8a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1-.5-.5zm4-3a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5v11a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1-.5-.5z"/>
           </svg>
-        Modem 4G
+        <span data-i18n="sidebar.modem4g">Modem 4G</span>
       </a>
       <a class="nav-link text-white" href="wifi.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-wifi" viewBox="0 0 16 16">
             <path d="M15.384 6.115a.485.485 0 0 0-.047-.736A12.44 12.44 0 0 0 8 3C5.259 3 2.723 3.882.663 5.379a.485.485 0 0 0-.048.736.52.52 0 0 0 .668.05A11.45 11.45 0 0 1 8 4c2.507 0 4.827.802 6.716 2.164.205.148.49.13.668-.049"/>
             <path d="M13.229 8.271a.482.482 0 0 0-.063-.745A9.46 9.46 0 0 0 8 6c-1.905 0-3.68.56-5.166 1.526a.48.48 0 0 0-.063.745.525.525 0 0 0 .652.065A8.46 8.46 0 0 1 8 7a8.46 8.46 0 0 1 4.576 1.336c.206.132.48.108.653-.065m-2.183 2.183c.226-.226.185-.605-.1-.75A6.5 6.5 0 0 0 8 9c-1.06 0-2.062.254-2.946.704-.285.145-.326.524-.1.75l.015.015c.16.16.407.19.611.09A5.5 5.5 0 0 1 8 10c.868 0 1.69.201 2.42.56.203.1.45.07.61-.091zM9.06 12.44c.196-.196.198-.52-.04-.66A2 2 0 0 0 8 11.5a2 2 0 0 0-1.02.28c-.238.14-.236.464-.04.66l.706.706a.5.5 0 0 0 .707 0l.707-.707z"/>
           </svg>
-         WIFI
+         <span data-i18n="sidebar.wifi">WIFI</span>
       </a>
       <a class="nav-link text-white" href="logs.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-journal-code" viewBox="0 0 16 16">
@@ -39,19 +39,27 @@
             <path d="M3 0h10a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2v-1h1v1a1 1 0 0 0 1 1h10a1 1 0 0 0 1-1V2a1 1 0 0 0-1-1H3a1 1 0 0 0-1 1v1H1V2a2 2 0 0 1 2-2"/>
             <path d="M1 5v-.5a.5.5 0 0 1 1 0V5h.5a.5.5 0 0 1 0 1h-2a.5.5 0 0 1 0-1zm0 3v-.5a.5.5 0 0 1 1 0V8h.5a.5.5 0 0 1 0 1h-2a.5.5 0 0 1 0-1zm0 3v-.5a.5.5 0 0 1 1 0v.5h.5a.5.5 0 0 1 0 1h-2a.5.5 0 0 1 0-1z"/>
           </svg>
-        Logs
+        <span data-i18n="sidebar.logs">Logs</span>
       </a>
+      <!-- Hidden: Not ready yet
       <a class="nav-link text-white" href="map.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-geo-alt-fill" viewBox="0 0 16 16">
           <path d="M8 16s6-5.686 6-10A6 6 0 0 0 2 6c0 4.314 6 10 6 10m0-7a3 3 0 1 1 0-6 3 3 0 0 1 0 6"/>
         </svg>
-        Carte
+        <span data-i18n="sidebar.map">Carte</span>
       </a>
+      <a class="nav-link text-white" href="terminal.html">
+        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-terminal-fill" viewBox="0 0 16 16">
+          <path d="M0 3a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2V3zm9.5 5.5h-3a.5.5 0 0 0 0 1h3a.5.5 0 0 0 0-1zm-6.354-.354a.5.5 0 1 0 .708.708l2-2a.5.5 0 0 0 0-.708l-2-2a.5.5 0 1 0-.708.708L4.793 6.5 3.146 8.146z"/>
+        </svg>
+        <span data-i18n="sidebar.terminal">Terminal</span>
+      </a>
+      -->
       <a class="nav-link text-white" href="admin.html">
         <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-tools" viewBox="0 0 16 16">
             <path d="M1 0 0 1l2.2 3.081a1 1 0 0 0 .815.419h.07a1 1 0 0 1 .708.293l2.675 2.675-2.617 2.654A3.003 3.003 0 0 0 0 13a3 3 0 1 0 5.878-.851l2.654-2.617.968.968-.305.914a1 1 0 0 0 .242 1.023l3.27 3.27a.997.997 0 0 0 1.414 0l1.586-1.586a.997.997 0 0 0 0-1.414l-3.27-3.27a1 1 0 0 0-1.023-.242L10.5 9.5l-.96-.96 2.68-2.643A3.005 3.005 0 0 0 16 3q0-.405-.102-.777l-2.14 2.141L12 4l-.364-1.757L13.777.102a3 3 0 0 0-3.675 3.68L7.462 6.46 4.793 3.793a1 1 0 0 1-.293-.707v-.071a1 1 0 0 0-.419-.814zm9.646 10.646a.5.5 0 0 1 .708 0l2.914 2.915a.5.5 0 0 1-.707.707l-2.915-2.914a.5.5 0 0 1 0-.708M3 11l.471.242.529.026.287.445.445.287.026.529L5 13l-.242.471-.026.529-.445.287-.287.445-.529.026L3 15l-.471-.242L2 14.732l-.287-.445L1.268 14l-.026-.529L1 13l.242-.471.026-.529.445-.287.287-.445.529-.026z"/>
           </svg>
-        Admin
+        <span data-i18n="sidebar.admin">Admin</span>
       </a>
 
        <!-- New content at the bottom -->

html/terminal.html

@@ -0,0 +1,413 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>NebuleAir - Terminal</title>
+  <link rel="stylesheet" href="assets/css/bootstrap.min.css">
+  <style>
+    body {
+      overflow-x: hidden;
+    }
+    #sidebar a.nav-link {
+        position: relative;
+        display: flex;
+        align-items: center;
+    }
+    #sidebar a.nav-link:hover {
+        background-color: rgba(0, 0, 0, 0.5);
+    }
+    #sidebar a.nav-link svg {
+        margin-right: 8px; /* Add spacing between icons and text */
+    }
+    #sidebar {
+      transition: transform 0.3s ease-in-out;
+    }
+    .offcanvas-backdrop {
+      z-index: 1040;
+    }
+    #terminal {
+      width: 100%;
+      min-height: 400px;
+      max-height: 400px;
+      overflow-y: auto;
+      background-color: #000;
+      color: #00ff00;
+      font-family: monospace;
+      padding: 10px;
+      border-radius: 5px;
+      white-space: pre-wrap;
+      word-wrap: break-word;
+    }
+    #cmdLine {
+      width: 100%;
+      background-color: #000;
+      color: #00ff00;
+      font-family: monospace;
+      padding: 10px;
+      border: none;
+      border-radius: 0 0 5px 5px;
+      margin-top: -1px;
+    }
+    #cmdLine:focus {
+      outline: none;
+    }
+    .command-container {
+      display: none;
+    }
+    .password-popup {
+      display: none;
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background-color: rgba(0, 0, 0, 0.5);
+      z-index: 2000;
+      justify-content: center;
+      align-items: center;
+    }
+    .password-container {
+      background-color: white;
+      padding: 20px;
+      border-radius: 5px;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.3);
+      width: 300px;
+    }
+    .limited-commands {
+      background-color: #f8f9fa;
+      padding: 15px;
+      border-radius: 5px;
+      margin-bottom: 15px;
+    }
+    .limited-commands code {
+      white-space: nowrap;
+      margin-right: 10px;
+      margin-bottom: 5px;
+      display: inline-block;
+    }
+  </style>
+</head>
+<body>
+  <!-- Topbar -->
+  <span id="topbar"></span>
+
+  <!-- Sidebar Offcanvas for Mobile -->
+  <div class="offcanvas offcanvas-start text-white bg-dark" tabindex="-1" id="sidebarOffcanvas" aria-labelledby="sidebarOffcanvasLabel">
+    <div class="offcanvas-header">
+      <h5 class="offcanvas-title" id="sidebarOffcanvasLabel">NebuleAir</h5>
+      <button type="button" class="btn-close btn-close-white" data-bs-dismiss="offcanvas" aria-label="Close"></button>
+    </div>
+    <div class="offcanvas-body" id="sidebar_mobile">
+    </div>
+  </div>
+
+  <div class="container-fluid mt-5">
+    <div class="row">
+      <!-- Side bar -->
+      <aside class="col-md-2 col-lg-1 d-none d-md-block vh-100 position-fixed bg-dark text-white" id="sidebar">
+      </aside>
+      <!-- Main content -->
+      <main class="col-md-10 ms-sm-auto col-lg-11 offset-md-2 offset-lg-1 px-md-4">
+        <h1 class="mt-4">Terminal Console</h1>
+        
+        <div class="row mb-3">
+          <div class="col-12">
+            <div class="alert alert-warning">
+              <strong>Warning:</strong> This terminal provides direct access to system commands. 
+              Use with caution as improper commands may affect system functionality.
+            </div>
+
+            <div class="limited-commands">
+              <h5>Quick Commands:</h5>
+              <div>
+                <code onclick="insertCommand('ls -la')">ls -la</code>
+                <code onclick="insertCommand('df -h')">df -h</code>
+                <code onclick="insertCommand('free -h')">free -h</code>
+                <code onclick="insertCommand('uptime')">uptime</code>
+                <code onclick="insertCommand('systemctl status master_nebuleair.service')">service status</code>
+                <code onclick="insertCommand('cat /var/www/nebuleair_pro_4g/config.json')">view config</code>
+              </div>
+            </div>
+            
+            <div class="card">
+              <div class="card-header d-flex justify-content-between align-items-center">
+                <h5 class="mb-0">Command Console</h5>
+                <div>
+                  <button id="accessBtn" class="btn btn-primary me-2">Access Terminal</button>
+                  <button id="clearBtn" class="btn btn-secondary" disabled>Clear</button>
+                </div>
+              </div>
+              <div class="card-body p-0">
+                <div class="command-container" id="commandContainer">
+                  <div id="terminal">Welcome to NebuleAir Terminal Console
+                    Type your commands below. Type 'help' for a list of commands.
+                    </div>
+                  <input type="text" id="cmdLine" placeholder="Enter command..." disabled>
+                </div>
+                <div id="errorMsg" class="alert alert-danger m-3" style="display:none;"></div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+    </div>
+  </div>
+
+  <!-- Password Modal -->
+  <div class="password-popup" id="passwordModal">
+    <div class="password-container">
+      <h5>Authentication Required</h5>
+      <p>Please enter the admin password to access the terminal:</p>
+      <div class="mb-3">
+        <input type="password" class="form-control" id="adminPassword" placeholder="Password">
+      </div>
+      <div class="mb-3 d-flex justify-content-between">
+        <button class="btn btn-secondary" id="cancelPasswordBtn">Cancel</button>
+        <button class="btn btn-primary" id="submitPasswordBtn">Submit</button>
+      </div>
+      <div id="passwordError" class="text-danger mt-2" style="display:none;"></div>
+    </div>
+  </div>
+
+  <!-- JAVASCRIPT -->
+  <!-- Link Ajax locally -->
+  <script src="assets/jquery/jquery-3.7.1.min.js"></script>
+  <!-- Link Bootstrap JS and Popper.js locally -->
+  <script src="assets/js/bootstrap.bundle.js"></script>
+
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      const elementsToLoad = [
+        { id: 'topbar', file: 'topbar.html' },
+        { id: 'sidebar', file: 'sidebar.html' },
+        { id: 'sidebar_mobile', file: 'sidebar.html' }
+      ];
+
+      elementsToLoad.forEach(({ id, file }) => {
+        fetch(file)
+          .then(response => response.text())
+          .then(data => {
+            const element = document.getElementById(id);
+            if (element) {
+              element.innerHTML = data;
+            }
+          })
+          .catch(error => console.error(`Error loading ${file}:`, error));
+      });
+
+      // Initialize elements
+      initializeElements();
+    });
+
+    window.onload = function() {
+
+        //NEW way to get config (SQLite)
+        $.ajax({
+        url: 'launcher.php?type=get_config_sqlite',
+        dataType:'json',
+        //dataType: 'json', // Specify that you expect a JSON response
+        method: 'GET', // Use GET or POST depending on your needs
+        success: function(response) {
+        console.log("Getting SQLite config table:");
+        console.log(response);
+
+        
+        //device name_side bar
+        const elements = document.querySelectorAll('.sideBar_sensorName');
+            elements.forEach((element) => {
+                element.innerText = response.deviceName;
+            });
+
+        },
+        error: function(xhr, status, error) {
+        console.error('AJAX request failed:', status, error);
+        }
+        });//end AJAX
+    }
+
+    // Add admin password (should be changed to something more secure)
+    const ADMIN_PASSWORD = "123plouf";
+
+    // Global variables
+    let terminal;
+    let cmdLine;
+    let commandContainer;
+    let accessBtn;
+    let clearBtn;
+    let passwordModal;
+    let adminPassword;
+    let submitPasswordBtn;
+    let cancelPasswordBtn;
+    let passwordError;
+    let errorMsg;
+    let commandHistory = [];
+    let historyIndex = -1;
+
+    // Initialize DOM references after document is loaded
+    function initializeElements() {
+      terminal = document.getElementById('terminal');
+      cmdLine = document.getElementById('cmdLine');
+      commandContainer = document.getElementById('commandContainer');
+      accessBtn = document.getElementById('accessBtn');
+      clearBtn = document.getElementById('clearBtn');
+      passwordModal = document.getElementById('passwordModal');
+      adminPassword = document.getElementById('adminPassword');
+      submitPasswordBtn = document.getElementById('submitPasswordBtn');
+      cancelPasswordBtn = document.getElementById('cancelPasswordBtn');
+      passwordError = document.getElementById('passwordError');
+      errorMsg = document.getElementById('errorMsg');
+
+      // Set up event listeners
+      accessBtn.addEventListener('click', function() {
+        passwordModal.style.display = 'flex';
+        adminPassword.value = ''; // Clear password field
+        passwordError.style.display = 'none';
+        adminPassword.focus();
+      });
+
+      // Password submit button
+      submitPasswordBtn.addEventListener('click', function() {
+        if (adminPassword.value === ADMIN_PASSWORD) {
+          passwordModal.style.display = 'none';
+          enableTerminal();
+        } else {
+          passwordError.textContent = 'Invalid password';
+          passwordError.style.display = 'block';
+        }
+      });
+      
+      // Enter key for password
+      adminPassword.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+          submitPasswordBtn.click();
+        }
+      });
+      
+      // Cancel password button
+      cancelPasswordBtn.addEventListener('click', function() {
+        passwordModal.style.display = 'none';
+      });
+
+      // Clear button
+      clearBtn.addEventListener('click', function() {
+        terminal.innerHTML = 'Terminal cleared.\n';
+      });
+
+      // Command line input events
+      cmdLine.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+          const command = cmdLine.value.trim();
+          if (command) {
+            executeCommand(command);
+            commandHistory.push(command);
+            historyIndex = commandHistory.length;
+            cmdLine.value = '';
+          }
+        }
+      });
+
+      // Command history navigation with arrow keys
+      cmdLine.addEventListener('keydown', function(e) {
+        if (e.key === 'ArrowUp') {
+          if (historyIndex > 0) {
+            historyIndex--;
+            cmdLine.value = commandHistory[historyIndex];
+          }
+          e.preventDefault();
+        } else if (e.key === 'ArrowDown') {
+          if (historyIndex < commandHistory.length - 1) {
+            historyIndex++;
+            cmdLine.value = commandHistory[historyIndex];
+          } else {
+            historyIndex = commandHistory.length;
+            cmdLine.value = '';
+          }
+          e.preventDefault();
+        }
+      });
+    }
+
+    // Enable terminal access
+    function enableTerminal() {
+      commandContainer.style.display = 'block';
+      cmdLine.disabled = false;
+      clearBtn.disabled = false;
+      accessBtn.textContent = 'Authenticated';
+      accessBtn.classList.remove('btn-primary');
+      accessBtn.classList.add('btn-success');
+      accessBtn.disabled = true;
+      cmdLine.focus();
+    }
+
+    // Insert a predefined command
+    function insertCommand(cmd) {
+      // Only allow insertion if terminal is enabled
+      if (cmdLine.disabled === false) {
+        cmdLine.value = cmd;
+        cmdLine.focus();
+      } else {
+        // Alert user that they need to authenticate first
+        alert('Please access the terminal first by clicking "Access Terminal" and entering the password.');
+      }
+    }
+
+    // Execute a command
+    function executeCommand(command) {
+      // Add command to terminal with user prefix
+      terminal.innerHTML += `<span style="color: cyan;">user@nebuleair</span>:<span style="color: yellow;">~</span>$ ${command}\n`;
+      terminal.scrollTop = terminal.scrollHeight;
+
+      // Handle special commands
+      if (command === 'clear') {
+        terminal.innerHTML = 'Terminal cleared.\n';
+        return;
+      }
+
+
+      // Filter dangerous commands
+      const dangerousCommands = [
+        'rm -rf /', 'rm -rf /*', 'rm -rf ~', 'rm -rf ~/*',
+        'mkfs', 'dd if=/dev/zero', 'dd if=/dev/random',
+        '>>', '>', '|', ';', '&&', '||',
+        'wget', 'curl', 'ssh', 'scp', 'nc',
+        'chmod -R', 'chown -R'
+      ];
+
+      // Check for dangerous commands or command chaining
+      const hasDangerousCommand = dangerousCommands.some(cmd => command.includes(cmd));
+      if (hasDangerousCommand || command.includes('&') || command.includes(';') || command.includes('|')) {
+        terminal.innerHTML += '<span style="color: red;">Error: This command is not allowed for security reasons.</span>\n';
+        terminal.scrollTop = terminal.scrollHeight;
+        return;
+      }
+
+      // Execute the command via AJAX
+      $.ajax({
+        url: 'launcher.php?type=execute_command',
+        method: 'POST',
+        dataType:'json',
+        data: {
+          type: 'execute_command',
+          command: command
+        },
+        success: function(response) {
+            console.log(response);
+            
+            if (response.success) {
+                // Add command output to terminal
+                terminal.innerHTML += `<span style="color: #00ff00;">${response.output}</span>\n`;
+            } else {
+                terminal.innerHTML += `<span style="color: red;">Error: ${response.message}</span>\n`;
+            }
+            terminal.scrollTop = terminal.scrollHeight;
+            },
+        error: function(xhr, status, error) {
+          terminal.innerHTML += `<span style="color: red;">Error executing command: ${error}</span>\n`;
+          terminal.scrollTop = terminal.scrollHeight;
+        }
+      });
+    }
+  </script>
+</body>
+</html>

html/topbar.html

@@ -6,12 +6,18 @@
         </a>      
         <div class="d-flex">
             <button class="btn btn-outline-light d-md-none me-2" type="button" data-bs-toggle="offcanvas" data-bs-target="#sidebarOffcanvas" aria-controls="sidebarOffcanvas" aria-label="Toggle Sidebar">☰</button>
-           
+
              <!-- Centered text -->
                <!--
              <span id="pageTitle_plus_ID" class="position-absolute top-50 start-50 translate-middle">Texte au milieu</span>
                 -->
-            
+
+            <!-- Language Switcher -->
+            <select class="form-select form-select-sm me-2" id="languageSwitcher" style="width: auto; background-color: #6c757d; color: white; border-color: white;" onchange="i18n.setLanguage(this.value)">
+                <option value="fr" style="background-color: #6c757d; color: white;">🇫🇷 FR</option>
+                <option value="en" style="background-color: #6c757d; color: white;">🇬🇧 EN</option>
+            </select>
+
             <button type="button" class="btn btn-outline-light" id="RTC_time">loading...</button>
         </div>
     </div>

html/wifi.html

@@ -117,6 +117,8 @@
 <script src="assets/jquery/jquery-3.7.1.min.js"></script>
 <!-- Link Bootstrap JS and Popper.js locally -->
 <script src="assets/js/bootstrap.bundle.js"></script>
+<!-- i18n translation system -->
+<script src="assets/js/i18n.js"></script>
 
 <script>
  document.addEventListener('DOMContentLoaded', function () {
@@ -302,6 +304,11 @@ function get_internet(){
                element.innerText = deviceName;
            });
 
+                 //device name html page title
+      if (response.deviceName) {
+      document.title = response.deviceName;
+    }
+
 
             //get wifi connection status
             const WIFI_statusElement = document.getElementById("wifi-status");

installation_part1.sh

@@ -23,40 +23,27 @@ fi
 
 # Update and install necessary packages
 info "Updating package list and installing necessary packages..."
-sudo apt update && sudo apt install -y git gh apache2 php php-sqlite3 python3 python3-pip jq autossh i2c-tools python3-smbus || error "Failed to install required packages."
+sudo apt update && sudo apt install -y git gh apache2 sqlite3 php php-sqlite3 python3 python3-pip jq autossh i2c-tools python3-smbus python3-rpi.gpio || error "Failed to install required packages."
 
 # Install Python libraries
 info "Installing Python libraries..."
-sudo pip3 install pyserial requests RPi.GPIO adafruit-circuitpython-bme280 crcmod psutil ntplib pytz --break-system-packages || error "Failed to install Python libraries."
-
-# Ask user if they want to set up SSH keys
-read -p "Do you want to set up an SSH key for /var/www? (y/n): " answer
-answer=${answer,,}  # Convert to lowercase
-
-if [[ "$answer" == "y" ]]; then
-    info "Setting up SSH keys..."
-    
-    sudo mkdir -p /var/www/.ssh
-    sudo chmod 700 /var/www/.ssh
-    
-    if [[ ! -f /var/www/.ssh/id_rsa ]]; then
-        sudo ssh-keygen -t rsa -b 4096 -f /var/www/.ssh/id_rsa -N ""
-        success "SSH key generated successfully."
-    else
-        warning "SSH key already exists. Skipping key generation."
-    fi
-    
-    sudo ssh-copy-id -i /var/www/.ssh/id_rsa.pub -p 50221 airlab_server1@aircarto.fr || warning "Failed to copy SSH key. Please check the server connection."
-
-    success "SSH setup complete!"
-else
-    warning "Skipping SSH key setup."
-fi
+sudo pip3 install pyserial requests adafruit-circuitpython-bme280 crcmod psutil gpiozero ntplib adafruit-circuitpython-ads1x15 nsrt-mk3-dev pytz --break-system-packages || error "Failed to install Python libraries."
 
 # Clone the repository (check if it exists first)
 REPO_DIR="/var/www/nebuleair_pro_4g"
 if [[ -d "$REPO_DIR" ]]; then
-    warning "Repository already exists. Skipping clone."
+    warning "Repository already exists. Will update instead of clone."
+    # Save current directory
+    local current_dir=$(pwd)
+    # Navigate to repository directory
+    cd "$REPO_DIR"
+    # Stash any local changes
+    sudo git stash || warning "Failed to stash local changes"
+    # Pull latest changes
+    sudo git pull || error "Failed to pull latest changes"
+    # Return to original directory
+    cd "$current_dir"
+    success "Repository updated successfully!"
 else
     info "Cloning the NebuleAir Pro 4G repository..."
     sudo git clone http://gitea.aircarto.fr/PaulVua/nebuleair_pro_4g.git "$REPO_DIR" || error "Failed to clone repository."
@@ -66,7 +53,6 @@ fi
 info "Setting up repository files and permissions..."
 sudo mkdir -p "$REPO_DIR/logs"
 sudo touch "$REPO_DIR/logs/app.log" "$REPO_DIR/logs/master.log" "$REPO_DIR/logs/master_errors.log" "$REPO_DIR/wifi_list.csv"
-sudo cp "$REPO_DIR/config.json.dist" "$REPO_DIR/config.json"
 sudo chmod -R 755 "$REPO_DIR/"
 sudo chown -R www-data:www-data "$REPO_DIR/"
 sudo git config --global core.fileMode false
@@ -91,6 +77,15 @@ else
     warning "Database creation script not found."
 fi
 
+# Set config
+info "Set config..."
+if [[ -f "$REPO_DIR/sqlite/set_config.py" ]]; then
+    sudo /usr/bin/python3 "$REPO_DIR/sqlite/set_config.py" || error "Failed to set config."
+    success "Databases created successfully."
+else
+    warning "Database creation script not found."
+fi
+
 # Configure Apache
 info "Configuring Apache..."
 APACHE_CONF="/etc/apache2/sites-available/000-default.conf"
@@ -104,13 +99,48 @@ fi
 
 # Add sudo authorization (prevent duplicate entries)
 info "Setting up sudo authorization..."
-if ! sudo grep -q "/usr/bin/nmcli" /etc/sudoers; then
-    echo -e "ALL ALL=(ALL) NOPASSWD: /usr/bin/nmcli, /usr/sbin/reboot\nwww-data ALL=(ALL) NOPASSWD: /usr/bin/git pull\nwww-data ALL=(ALL) NOPASSWD: /usr/bin/ssh\nwww-data ALL=(ALL) NOPASSWD: /usr/bin/python3 *" | sudo tee -a /etc/sudoers > /dev/null
-    success "Sudo authorization added."
+SUDOERS_FILE="/etc/sudoers"
+
+# First, fix any existing syntax errors
+if sudo visudo -c 2>&1 | grep -q "syntax error"; then
+    warning "Syntax error detected in sudoers file. Attempting to fix..."
+    # Remove the problematic line if it exists
+    sudo sed -i '/www-data ALL=(ALL) NOPASSWD: \/usr\/bin\/python3 \* www-data/d' "$SUDOERS_FILE"
+fi
+
+# Add proper sudo rules (each on a separate line)
+if ! sudo grep -q "/usr/bin/nmcli" "$SUDOERS_FILE"; then
+    # Create a temporary file with the new rules
+    cat <<EOF | sudo tee /tmp/sudoers_additions > /dev/null
+# NebuleAir Pro 4G sudo rules
+ALL ALL=(ALL) NOPASSWD: /usr/bin/nmcli, /usr/sbin/reboot
+www-data ALL=(ALL) NOPASSWD: /usr/bin/git pull
+www-data ALL=(ALL) NOPASSWD: /usr/bin/ssh
+www-data ALL=(ALL) NOPASSWD: /usr/bin/python3 *
+www-data ALL=(ALL) NOPASSWD: /bin/systemctl *
+www-data ALL=(ALL) NOPASSWD: /var/www/nebuleair_pro_4g/*
+EOF
+    
+    # Validate the temporary file
+    if sudo visudo -c -f /tmp/sudoers_additions; then
+        # Append to sudoers if valid
+        sudo cat /tmp/sudoers_additions >> "$SUDOERS_FILE"
+        success "Sudo authorization added."
+    else
+        error "Failed to add sudo rules - syntax validation failed."
+    fi
+    
+    # Clean up
+    sudo rm -f /tmp/sudoers_additions
 else
     warning "Sudo authorization already set. Skipping."
 fi
 
+# Validate sudoers file after changes
+if ! sudo visudo -c; then
+    error "Sudoers file has syntax errors! Please fix manually with 'sudo visudo'"
+fi
+
 # Open all UART serial ports (avoid duplication)
 info "Configuring UART serial ports..."
 if ! grep -q "enable_uart=1" /boot/firmware/config.txt; then
@@ -133,6 +163,12 @@ success "I2C ports enabled."
 info "Creates sqlites databases..."
 /usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/create_db.py
 
+# Final sudoers check
+if sudo visudo -c; then
+    success "Sudoers file is valid."
+else
+    error "Sudoers file has errors! System may not function correctly."
+fi
 
 # Completion message
 success "Setup completed successfully!"

installation_part2.sh

@@ -22,46 +22,72 @@ error() { echo -e "${RED}[ERROR]${NC} $1"; exit 1; }
 if [[ "$EUID" -ne 0 ]]; then
     error "This script must be run as root. Use 'sudo ./installation.sh'"
 fi
-
+REPO_DIR="/var/www/nebuleair_pro_4g"
 #set up the RTC
 info "Set up the RTC"
 /usr/bin/python3 /var/www/nebuleair_pro_4g/RTC/set_with_NTP.py
 
+#Wake up SARA
+info "Wake Up SARA"
+pinctrl set 16 op
+pinctrl set 16 dh
+sleep 5
+
+#Check SARA connection (ATI)
+info "Check SARA connection (ATI)"
+/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 ATI 2
+
 #set up SARA R4 APN
-info "Set up Monogoto APN"
-/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_setAPN.py ttyAMA2 data.mono 2
+#info "Set up Monogoto APN"
+#/usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara_setAPN.py ttyAMA2 data.mono 2
 
 #activate blue network led on the SARA R4
 info "Activate blue LED"
 /usr/bin/python3 /var/www/nebuleair_pro_4g/SARA/sara.py ttyAMA2 AT+UGPIOC=16,2 2
 
 #Connect to network
-info "Connect SARA R4 to network"
-python3 /var/www/nebuleair_pro_4g/SARA/sara_connectNetwork.py ttyAMA2 20810 60
+#info "Connect SARA R4 to network"
+#python3 /var/www/nebuleair_pro_4g/SARA/sara_connectNetwork.py ttyAMA2 20810 60
 
-#Add master_nebuleair.service
-SERVICE_FILE="/etc/systemd/system/master_nebuleair.service"
-info "Setting up systemd service for master_nebuleair..."
+#Need to create the two service
+# 1. start the scripts to set-up the services
+# 2. rtc_save_to_db
+
+#1. set-up the services (SARA, NPM, BME280, etc)
+info "Setting up systemd services..."
+    
+if [[ -f "$REPO_DIR/services/setup_services.sh" ]]; then
+    sudo chmod +x "$REPO_DIR/services/setup_services.sh"
+    sudo "$REPO_DIR/services/setup_services.sh" || warning "Failed to set up systemd services"
+    success "Systemd services set up successfully."
+else
+    warning "Systemd services setup script not found."
+fi
+
+#2. Add rtc_save_to_db.service
+SERVICE_FILE_2="/etc/systemd/system/rtc_save_to_db.service"
+info "Setting up systemd service for rtc_save_to_db..."
 
 # Create the systemd service file (overwrite if necessary)
-sudo bash -c "cat > $SERVICE_FILE" <<EOF
+sudo bash -c "cat > $SERVICE_FILE_2" <<EOF
 [Unit]
-Description=Master manager for the Python loop scripts
+Description=RTC Save to DB Script
 After=network.target
 
 [Service]
-ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/master.py
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/RTC/save_to_db.py
 Restart=always
+RestartSec=1
 User=root
 WorkingDirectory=/var/www/nebuleair_pro_4g
-StandardOutput=append:/var/www/nebuleair_pro_4g/logs/master.log
-StandardError=append:/var/www/nebuleair_pro_4g/logs/master_errors.log
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/rtc_save_to_db.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/rtc_save_to_db_errors.log
 
 [Install]
 WantedBy=multi-user.target
 EOF
 
-success "Systemd service file created: $SERVICE_FILE"
+success "Systemd service file created: $SERVICE_FILE_2"
 
 # Reload systemd to recognize the new service
 info "Reloading systemd daemon..."
@@ -69,8 +95,8 @@ sudo systemctl daemon-reload
 
 # Enable the service to start on boot
 info "Enabling the service to start on boot..."
-sudo systemctl enable master_nebuleair.service
+sudo systemctl enable rtc_save_to_db.service
 
 # Start the service immediately
 info "Starting the service..."
-sudo systemctl start master_nebuleair.service
+sudo systemctl start rtc_save_to_db.service

master.py

@@ -1,100 +0,0 @@
-'''
-  __  __           _            
- |  \/  | __ _ ___| |_ ___ _ __ 
- | |\/| |/ _` / __| __/ _ \ '__|
- | |  | | (_| \__ \ ||  __/ |   
- |_|  |_|\__,_|___/\__\___|_|   
-                                
-Master Python script that will trigger other scripts at every chosen time pace
-This script is triggered as a systemd service used as an alternative to cronjobs
-
-Attention: 
-    to do -> prevent SARA R4 Script to run again if it's taking more than 60 secs to finish (using a lock file ??) 
-
-First time: need to create the service file
-
---> sudo nano /etc/systemd/system/master_nebuleair.service
-
-⬇️
-[Unit]
-Description=Master manager for the Python loop scripts
-After=network.target
-
-[Service]
-ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/master.py
-Restart=always
-User=root
-WorkingDirectory=/var/www/nebuleair_pro_4g
-StandardOutput=append:/var/www/nebuleair_pro_4g/logs/master.log
-StandardError=append:/var/www/nebuleair_pro_4g/logs/master_errors.log
-
-[Install]
-WantedBy=multi-user.target
-⬆️
-
-Reload systemd (first time after creating the service):
-    sudo systemctl daemon-reload
-
-Enable (once), start (once and after stopping) and restart (after modification)systemd:
-    sudo systemctl enable master_nebuleair.service
-    sudo systemctl start master_nebuleair.service
-    sudo systemctl restart master_nebuleair.service
-
-Check the service status:
-    sudo systemctl status master_nebuleair.service
-
-
-Specific scripts can be disabled with config.json
-    Exemple: stop gathering data from NPM
-    Exemple: stop sending data with SARA R4
-
-'''
-import time
-import threading
-import subprocess
-import json
-import os
-
-# Base directory where scripts are stored
-SCRIPT_DIR = "/var/www/nebuleair_pro_4g/"
-CONFIG_FILE = "/var/www/nebuleair_pro_4g/config.json"
-
-def load_config():
-    """Load the configuration file to determine which scripts to run."""
-    with open(CONFIG_FILE, "r") as f:
-        return json.load(f)
-
-def run_script(script_name, interval, delay=0):
-    """Run a script in a synchronized loop with an optional start delay."""
-    script_path = os.path.join(SCRIPT_DIR, script_name)  # Build full path
-    next_run = time.monotonic() + delay  # Apply the initial delay
-
-    while True:
-        config = load_config()
-        if config.get(script_name, True):  # Default to True if not found
-            subprocess.run(["python3", script_path])
-        
-        # Wait until the next exact interval
-        next_run += interval
-        sleep_time = max(0, next_run - time.monotonic())  # Prevent negative sleep times
-        time.sleep(sleep_time)
-
-# Define scripts and their execution intervals (seconds)
-SCRIPTS = [
-    #("RTC/save_to_db.py", 1, 0),                # SAVE RTC time every 1 second, no delay
-    ("NPM/get_data_modbus_v3.py", 10, 0),       # Get NPM data (modbus 5 channels) every 10s, with 2s delay
-    ("envea/read_value_v2.py", 10, 0),          # Get NPM data (modbus 5 channels) every 10s, with 2s delay
-    ("loop/SARA_send_data_v2.py", 60, 1),       # Send data every 60 seconds, with 2s delay
-    ("BME280/get_data_v2.py", 120, 0),          # Get BME280 data every 120 seconds, no delay
-    ("sqlite/flush_old_data.py", 86400, 0)        # flush old data inside db every day ()
-]
-
-# Start threads for enabled scripts
-for script_name, interval, delay in SCRIPTS:
-    thread = threading.Thread(target=run_script, args=(script_name, interval, delay), daemon=True)
-    thread.start()
-
-# Keep the main script running
-while True:
-    time.sleep(1)
-

old/config.json.dist

@@ -5,8 +5,11 @@
   "RTC/save_to_db.py": true,
   "BME280/get_data_v2.py": true,
   "envea/read_value_v2.py": false,
+  "MPPT/read.py": false,
+  "windMeter/read.py": false,
   "sqlite/flush_old_data.py": true,
   "deviceID": "XXXX",
+  "npm_5channel": false,
   "latitude_raw": 0,
   "longitude_raw":0,
   "latitude_precision": 0,
@@ -25,7 +28,7 @@
   "SARA_R4_general_status": "connected",
   "SARA_R4_SIM_status": "connected",
   "SARA_R4_network_status": "connected",
-  "SARA_R4_neworkID": 0,
+  "SARA_R4_neworkID": 20810,
   "WIFI_status": "connected",
   "MQTT_GUI": false,
   "send_aircarto": true,

old/master.py

@@ -0,0 +1,166 @@
+'''
+  __  __           _            
+ |  \/  | __ _ ___| |_ ___ _ __ 
+ | |\/| |/ _` / __| __/ _ \ '__|
+ | |  | | (_| \__ \ ||  __/ |   
+ |_|  |_|\__,_|___/\__\___|_|   
+                                
+Master Python script that will trigger other scripts at every chosen time pace
+This script is triggered as a systemd service used as an alternative to cronjobs
+
+Attention: 
+    to do -> prevent SARA R4 Script to run again if it's taking more than 60 secs to finish (using a lock file ??) 
+
+First time: need to create the service file
+
+--> sudo nano /etc/systemd/system/master_nebuleair.service
+
+⬇️
+[Unit]
+Description=Master manager for the Python loop scripts
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/master.py
+Restart=always
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/master.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/master_errors.log
+
+[Install]
+WantedBy=multi-user.target
+⬆️
+
+Reload systemd (first time after creating the service):
+    sudo systemctl daemon-reload
+
+Enable (once), start (once and after stopping) and restart (after modification)systemd:
+    sudo systemctl enable master_nebuleair.service
+    sudo systemctl start master_nebuleair.service
+    sudo systemctl restart master_nebuleair.service
+
+Check the service status:
+    sudo systemctl status master_nebuleair.service
+
+
+Specific scripts can be disabled with config.json
+    Exemple: stop gathering data from NPM
+    Exemple: stop sending data with SARA R4
+
+'''
+import time
+import threading
+import subprocess
+import os
+import sqlite3
+
+
+# Base directory where scripts are stored
+SCRIPT_DIR = "/var/www/nebuleair_pro_4g/"
+DB_PATH = "/var/www/nebuleair_pro_4g/sqlite/sensors.db"
+
+# Lock file path for SARA script
+SARA_LOCK_FILE = "/var/www/nebuleair_pro_4g/sara_script.lock"
+
+
+def is_script_enabled(script_name):
+    """Check if a script is enabled in the database."""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        cursor.execute(
+            "SELECT enabled FROM config_scripts_table WHERE script_path = ?",
+            (script_name,)
+        )
+        
+        result = cursor.fetchone()
+        conn.close()
+        
+        if result is None:
+            return True  # Default to enabled if not found in database
+        
+        return bool(result[0])
+    except Exception:
+        # If any database error occurs, default to enabled
+        return True
+
+
+def create_lock_file():
+    """Create a lock file for the SARA script."""
+    with open(SARA_LOCK_FILE, 'w') as f:
+        f.write(str(int(time.time())))
+
+
+def remove_lock_file():
+    """Remove the SARA script lock file."""
+    if os.path.exists(SARA_LOCK_FILE):
+        os.remove(SARA_LOCK_FILE)
+
+
+def is_script_locked():
+    """Check if the SARA script is currently locked."""
+    if not os.path.exists(SARA_LOCK_FILE):
+        return False
+    
+    # Check if lock is older than 60 seconds (stale)
+    with open(SARA_LOCK_FILE, 'r') as f:
+        try:
+            lock_time = int(f.read().strip())
+            if time.time() - lock_time > 60:
+                # Lock is stale, remove it
+                remove_lock_file()
+                return False
+        except ValueError:
+            # Invalid lock file content
+            remove_lock_file()
+            return False
+    
+    return True
+
+
+def run_script(script_name, interval, delay=0):
+    """Run a script in a synchronized loop with an optional start delay."""
+    script_path = os.path.join(SCRIPT_DIR, script_name)  # Build full path
+    next_run = time.monotonic() + delay  # Apply the initial delay
+
+    while True:
+        if is_script_enabled(script_name):
+            # Special handling for SARA script to prevent concurrent runs
+            if script_name == "loop/SARA_send_data_v2.py":
+                if not is_script_locked():
+                    create_lock_file()
+                    try:
+                        subprocess.run(["python3", script_path], timeout=200)
+                    finally:
+                        remove_lock_file()
+            else:
+                # Run other scripts normally
+                subprocess.run(["python3", script_path])
+        
+        # Wait until the next exact interval
+        next_run += interval
+        sleep_time = max(0, next_run - time.monotonic())  # Prevent negative sleep times
+        time.sleep(sleep_time)
+
+
+# Define scripts and their execution intervals (seconds)
+SCRIPTS = [
+    # Format: (script_name, interval_in_seconds, start_delay_in_seconds)
+    ("NPM/get_data_modbus_v3.py", 10, 0),       # Get NPM data (modbus 5 channels) every 10s
+    ("envea/read_value_v2.py", 10, 0),          # Get Envea data every 10s
+    ("loop/SARA_send_data_v2.py", 60, 1),       # Send data every 60 seconds, with 1s delay
+    ("BME280/get_data_v2.py", 120, 0),          # Get BME280 data every 120 seconds
+    ("MPPT/read.py", 120, 0),                   # Get MPPT data every 120 seconds
+    ("sqlite/flush_old_data.py", 86400, 0)      # Flush old data inside db every day
+]
+
+# Start threads for scripts
+for script_name, interval, delay in SCRIPTS:
+    thread = threading.Thread(target=run_script, args=(script_name, interval, delay), daemon=True)
+    thread.start()
+
+# Keep the main script running
+while True:
+    time.sleep(1)

services/README.md

@@ -0,0 +1,18 @@
+# NebuleAir Pro Services
+
+Les scripts importants tournent à l'aide d'un service et d'un timer associé.
+
+Pour les installer:
+
+sudo chmod +x /var/www/nebuleair_pro_4g/services/setup_services.sh
+sudo /var/www/nebuleair_pro_4g/services/setup_services.sh
+
+Supprimer l'ancien master:
+sudo systemctl stop master_nebuleair.service
+sudo systemctl disable master_nebuleair.service
+
+# Check les services
+
+SARA: 
+sudo systemctl status nebuleair-sara-data.service
+

services/check_services.sh

@@ -0,0 +1,277 @@
+#!/bin/bash
+# File: /var/www/nebuleair_pro_4g/services/check_services.sh
+# Purpose: Check status of all NebuleAir services and logs
+# Version with fixed color handling for proper table display
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
+
+# Service list
+SERVICES=("npm" "envea" "sara" "bme280" "mppt" "db-cleanup" "noise")
+
+# Function to print header
+print_header() {
+    local text="$1"
+    echo ""
+    echo -e "${BLUE}${BOLD}=== $text ===${NC}"
+    echo -e "${BLUE}$(printf '%.0s=' {1..70})${NC}"
+}
+
+# Function to print section
+print_section() {
+    local text="$1"
+    echo ""
+    echo -e "${CYAN}${BOLD}--- $text ---${NC}"
+}
+
+# Function to print a separator line
+print_separator() {
+    echo "+--------------------------+-----------+-----------+-------------+-------------+-------------------------+"
+}
+
+# Clear screen for clean output
+clear
+
+# Main header
+print_header "NebuleAir Services Status Report"
+echo -e "Generated on: $(date '+%Y-%m-%d %H:%M:%S')"
+
+# Timer Schedule
+print_section "Active Timers Schedule"
+echo ""
+systemctl list-timers --no-pager | head -n 1
+systemctl list-timers --no-pager | grep nebuleair || echo "No active nebuleair timers found"
+
+# Service Status Overview with fixed color handling
+print_section "Service Status Overview"
+echo ""
+print_separator
+printf "| %-24s | %-9s | %-9s | %-11s | %-11s | %-23s |\n" "Service" "Svc State" "Svc Boot" "Timer State" "Timer Boot" "Health Status"
+print_separator
+
+for service in "${SERVICES[@]}"; do
+    # Check the actual service and timer names (with -data suffix)
+    full_service_name="nebuleair-${service}-data"
+    
+    # Get raw status values
+    service_status=$(systemctl is-active ${full_service_name}.service 2>/dev/null | tr -d '\n' || echo "not-found")
+    service_enabled=$(systemctl is-enabled ${full_service_name}.service 2>/dev/null | tr -d '\n' || echo "not-found")
+    timer_status=$(systemctl is-active ${full_service_name}.timer 2>/dev/null | tr -d '\n' || echo "not-found")
+    timer_enabled=$(systemctl is-enabled ${full_service_name}.timer 2>/dev/null | tr -d '\n' || echo "not-found")
+    
+    # Check if files exist and override if not found
+    if ! systemctl list-unit-files | grep -q "^${full_service_name}.service" &>/dev/null; then
+        service_status="not-found"
+        service_enabled="not-found"
+    fi
+    if ! systemctl list-unit-files | grep -q "^${full_service_name}.timer" &>/dev/null; then
+        timer_status="not-found"
+        timer_enabled="not-found"
+    fi
+    
+    # Create display strings without embedded colors for table cells
+    case $service_status in
+        "active") svc_st_display="active"; svc_st_color="${GREEN}" ;;
+        "inactive") svc_st_display="inactive"; svc_st_color="${DIM}" ;;
+        "activating") svc_st_display="starting"; svc_st_color="${YELLOW}" ;;
+        "not-found") svc_st_display="missing"; svc_st_color="${RED}" ;;
+        *) svc_st_display="$service_status"; svc_st_color="${RED}" ;;
+    esac
+    
+    case $service_enabled in
+        "enabled"|"static") svc_en_display="enabled"; svc_en_color="${GREEN}" ;;
+        "disabled") svc_en_display="disabled"; svc_en_color="${YELLOW}" ;;
+        "not-found") svc_en_display="missing"; svc_en_color="${RED}" ;;
+        *) svc_en_display="$service_enabled"; svc_en_color="${YELLOW}" ;;
+    esac
+    
+    case $timer_status in
+        "active") tim_st_display="active"; tim_st_color="${GREEN}" ;;
+        "inactive") tim_st_display="inactive"; tim_st_color="${RED}" ;;
+        "not-found") tim_st_display="missing"; tim_st_color="${RED}" ;;
+        *) tim_st_display="$timer_status"; tim_st_color="${RED}" ;;
+    esac
+    
+    case $timer_enabled in
+        "enabled"|"static") tim_en_display="enabled"; tim_en_color="${GREEN}" ;;
+        "disabled") tim_en_display="disabled"; tim_en_color="${YELLOW}" ;;
+        "not-found") tim_en_display="missing"; tim_en_color="${RED}" ;;
+        *) tim_en_display="$timer_enabled"; tim_en_color="${YELLOW}" ;;
+    esac
+    
+    # Determine health status
+    if [[ "$timer_status" == "active" ]]; then
+        if [[ "$timer_enabled" == "enabled" || "$timer_enabled" == "static" ]]; then
+            health_display="✓ OK"
+            health_color="${GREEN}"
+        else
+            health_display="⚠ Boot disabled"
+            health_color="${YELLOW}"
+        fi
+    elif [[ "$timer_status" == "inactive" ]]; then
+        health_display="✗ Timer stopped"
+        health_color="${RED}"
+    else
+        health_display="✗ Timer missing"
+        health_color="${RED}"
+    fi
+    
+    # Print row with colors applied outside of printf formatting
+    printf "| %-24s | " "$full_service_name"
+    printf "${svc_st_color}%-9s${NC} | " "$svc_st_display"
+    printf "${svc_en_color}%-9s${NC} | " "$svc_en_display"
+    printf "${tim_st_color}%-11s${NC} | " "$tim_st_display"
+    printf "${tim_en_color}%-11s${NC} | " "$tim_en_display"
+    printf "${health_color}%-23s${NC} |\n" "$health_display"
+done
+print_separator
+
+# Understanding the table
+echo ""
+echo -e "${DIM}Note: For timer-based services, it's normal for the service to be 'inactive' and 'disabled'.${NC}"
+echo -e "${DIM}      What matters is that the timer is 'active' and 'enabled'.${NC}"
+
+# Configuration Issues
+print_section "Configuration Issues"
+echo ""
+issues_found=false
+
+for service in "${SERVICES[@]}"; do
+    full_service_name="nebuleair-${service}-data"
+    
+    timer_status=$(systemctl is-active ${full_service_name}.timer 2>/dev/null | tr -d '\n' || echo "not-found")
+    timer_enabled=$(systemctl is-enabled ${full_service_name}.timer 2>/dev/null | tr -d '\n' || echo "not-found")
+    
+    # Check if timer exists
+    if ! systemctl list-unit-files | grep -q "^${full_service_name}.timer" &>/dev/null; then
+        timer_status="not-found"
+        timer_enabled="not-found"
+    fi
+    
+    if [[ "$timer_status" != "active" || ("$timer_enabled" != "enabled" && "$timer_enabled" != "static") ]]; then
+        issues_found=true
+        echo -e "  ${RED}•${NC} ${BOLD}$full_service_name${NC}"
+        if [[ "$timer_status" == "not-found" ]]; then
+            echo -e "    ${RED}→${NC} Timer unit file is missing"
+        elif [[ "$timer_status" != "active" ]]; then
+            echo -e "    ${RED}→${NC} Timer is not running (status: $timer_status)"
+        fi
+        if [[ "$timer_enabled" == "not-found" ]]; then
+            echo -e "    ${RED}→${NC} Timer unit file is missing"
+        elif [[ "$timer_enabled" != "enabled" && "$timer_enabled" != "static" ]]; then
+            echo -e "    ${YELLOW}→${NC} Timer won't start on boot (status: $timer_enabled)"
+        fi
+        echo ""
+    fi
+done
+
+if [[ "$issues_found" == "false" ]]; then
+    echo -e "  ${GREEN}✓${NC} All timers are properly configured!"
+fi
+
+# Recent Executions - Simplified
+print_section "Last Execution Status"
+echo ""
+printf "  %-12s %-20s %s\n" "Service" "Last Run" "Status"
+printf "  %-12s %-20s %s\n" "-------" "--------" "------"
+
+for service in "${SERVICES[@]}"; do
+    full_service_name="nebuleair-${service}-data"
+    
+    # Get last execution time and status
+    last_log=$(journalctl -u ${full_service_name}.service -n 3 --no-pager 2>/dev/null | grep -E "(Started|Finished|Failed)" | tail -1)
+    
+    if [[ -n "$last_log" ]]; then
+        timestamp=$(echo "$last_log" | awk '{print $1, $2, $3}')
+        if echo "$last_log" | grep -q "Finished"; then
+            status="${GREEN}✓ Success${NC}"
+        elif echo "$last_log" | grep -q "Failed"; then
+            status="${RED}✗ Failed${NC}"
+        elif echo "$last_log" | grep -q "Started"; then
+            status="${YELLOW}⟳ Running${NC}"
+        else
+            status="${DIM}- Unknown${NC}"
+        fi
+        printf "  %-12s %-20s %b\n" "$service" "$timestamp" "$status"
+    else
+        printf "  %-12s %-20s %b\n" "$service" "-" "${DIM}- No data${NC}"
+    fi
+done
+
+# Summary
+print_section "Summary"
+echo ""
+
+working=0
+needs_attention=0
+
+for service in "${SERVICES[@]}"; do
+    full_service_name="nebuleair-${service}-data"
+    timer_status=$(systemctl is-active ${full_service_name}.timer 2>/dev/null | tr -d '\n')
+    timer_enabled=$(systemctl is-enabled ${full_service_name}.timer 2>/dev/null | tr -d '\n')
+    
+    if [[ "$timer_status" == "active" ]] && [[ "$timer_enabled" == "enabled" || "$timer_enabled" == "static" ]]; then
+        ((working++))
+    else
+        ((needs_attention++))
+    fi
+done
+
+total=${#SERVICES[@]}
+
+# Visual progress bar
+echo -n "  Overall Health: ["
+for ((i=1; i<=10; i++)); do
+    if ((i <= working * 10 / total)); then
+        echo -n -e "${GREEN}▰${NC}"
+    else
+        echo -n -e "${RED}▱${NC}"
+    fi
+done
+echo -e "] ${working}/${total}"
+
+echo ""
+echo -e "  ${GREEN}✓${NC} Working properly: ${BOLD}$working${NC} services"
+echo -e "  ${RED}✗${NC} Need attention:  ${BOLD}$needs_attention${NC} services"
+
+# Quick Commands
+print_section "Quick Commands"
+echo ""
+echo -e "  ${BOLD}Fix a timer that needs attention:${NC}"
+echo "    $ sudo systemctl enable --now nebuleair-[service]-data.timer"
+echo ""
+echo -e "  ${BOLD}View live logs:${NC}"
+echo "    $ sudo journalctl -u nebuleair-[service]-data.service -f"
+echo ""
+echo -e "  ${BOLD}Check timer details:${NC}"
+echo "    $ systemctl status nebuleair-[service]-data.timer"
+echo ""
+echo -e "  ${BOLD}Run service manually:${NC}"
+echo "    $ sudo systemctl start nebuleair-[service]-data.service"
+
+# Specific fixes needed
+if [[ $needs_attention -gt 0 ]]; then
+    echo ""
+    echo -e "${YELLOW}${BOLD}Recommended Actions:${NC}"
+    for service in "${SERVICES[@]}"; do
+        full_service_name="nebuleair-${service}-data"
+        timer_status=$(systemctl is-active ${full_service_name}.timer 2>/dev/null | tr -d '\n')
+        timer_enabled=$(systemctl is-enabled ${full_service_name}.timer 2>/dev/null | tr -d '\n')
+        
+        if [[ "$timer_status" != "active" ]] && [[ "$timer_status" != "not-found" ]]; then
+            echo -e "  ${RED}→${NC} sudo systemctl start ${full_service_name}.timer"
+        fi
+        if [[ "$timer_enabled" != "enabled" ]] && [[ "$timer_enabled" != "static" ]] && [[ "$timer_enabled" != "not-found" ]]; then
+            echo -e "  ${YELLOW}→${NC} sudo systemctl enable ${full_service_name}.timer"
+        fi
+    done
+fi
+
+echo ""

services/setup_services.sh

@@ -0,0 +1,260 @@
+#!/bin/bash
+# File: /var/www/nebuleair_pro_4g/services/setup_services.sh
+# Purpose: Set up all systemd services for NebuleAir data collection
+# to install: 
+#   sudo chmod +x /var/www/nebuleair_pro_4g/services/setup_services.sh
+#   sudo /var/www/nebuleair_pro_4g/services/setup_services.sh
+
+echo "Setting up NebuleAir systemd services and timers..."
+
+# Create directory for logs if it doesn't exist
+mkdir -p /var/www/nebuleair_pro_4g/logs
+
+# Create service and timer files for NPM Data
+cat > /etc/systemd/system/nebuleair-npm-data.service << 'EOL'
+[Unit]
+Description=NebuleAir NPM Data Collection Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/NPM/get_data_modbus_v3.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/npm_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/npm_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-npm-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir NPM Data Collection every 10 seconds
+Requires=nebuleair-npm-data.service
+
+[Timer]
+OnBootSec=10s
+OnUnitActiveSec=10s
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for Envea Data
+cat > /etc/systemd/system/nebuleair-envea-data.service << 'EOL'
+[Unit]
+Description=NebuleAir Envea Data Collection Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/envea/read_value_v2.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/envea_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/envea_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-envea-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir Envea Data Collection every 10 seconds
+Requires=nebuleair-envea-data.service
+
+[Timer]
+OnBootSec=10s
+OnUnitActiveSec=10s
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for SARA Data (No Lock File Needed)
+cat > /etc/systemd/system/nebuleair-sara-data.service << 'EOL'
+[Unit]
+Description=NebuleAir SARA Data Transmission Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/loop/SARA_send_data_v2.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/sara_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/sara_service_errors.log
+RuntimeMaxSec=200s
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-sara-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir SARA Data Transmission every 60 seconds
+Requires=nebuleair-sara-data.service
+
+[Timer]
+OnBootSec=60s
+OnUnitActiveSec=60s
+AccuracySec=1s
+# This is the key setting that prevents overlap
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for BME280 Data
+cat > /etc/systemd/system/nebuleair-bme280-data.service << 'EOL'
+[Unit]
+Description=NebuleAir BME280 Data Collection Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/BME280/get_data_v2.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/bme280_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/bme280_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-bme280-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir BME280 Data Collection every 120 seconds
+Requires=nebuleair-bme280-data.service
+
+[Timer]
+OnBootSec=120s
+OnUnitActiveSec=120s
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for MPPT Data
+cat > /etc/systemd/system/nebuleair-mppt-data.service << 'EOL'
+[Unit]
+Description=NebuleAir MPPT Data Collection Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/MPPT/read.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/mppt_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/mppt_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-mppt-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir MPPT Data Collection every 120 seconds
+Requires=nebuleair-mppt-data.service
+
+[Timer]
+OnBootSec=120s
+OnUnitActiveSec=120s
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for noise Data (every minutes)
+cat > /etc/systemd/system/nebuleair-noise-data.service << 'EOL'
+[Unit]
+Description=NebuleAir noise Data Collection Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/sound_meter/NSRT_mk4_get_data.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/noise_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/noise_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-noise-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir MPPT Data Collection every 120 seconds
+Requires=nebuleair-noise-data.service
+
+[Timer]
+OnBootSec=60s
+OnUnitActiveSec=60s
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Create service and timer files for Database Cleanup
+cat > /etc/systemd/system/nebuleair-db-cleanup-data.service << 'EOL'
+[Unit]
+Description=NebuleAir Database Cleanup Service
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/flush_old_data.py
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/db_cleanup_service.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/db_cleanup_service_errors.log
+
+[Install]
+WantedBy=multi-user.target
+EOL
+
+cat > /etc/systemd/system/nebuleair-db-cleanup-data.timer << 'EOL'
+[Unit]
+Description=Run NebuleAir Database Cleanup daily
+Requires=nebuleair-db-cleanup-data.service
+
+[Timer]
+OnBootSec=1h
+OnUnitActiveSec=24h
+AccuracySec=1h
+
+[Install]
+WantedBy=timers.target
+EOL
+
+# Reload systemd to recognize new services
+systemctl daemon-reload
+
+# Enable and start all timers
+echo "Enabling and starting all services..."
+for service in npm envea sara bme280 mppt db-cleanup noise; do
+    systemctl enable nebuleair-$service-data.timer
+    systemctl start nebuleair-$service-data.timer
+    echo "Started nebuleair-$service-data timer"
+done
+
+echo "Checking status of all timers..."
+systemctl list-timers | grep nebuleair
+
+echo "Setup complete. All NebuleAir services are now running."
+echo "To check the status of a specific service:"
+echo "  sudo systemctl status nebuleair-npm-data.service"
+echo "To view logs for a specific service:"
+echo "  sudo journalctl -u nebuleair-npm-data.service"
+echo "To restart a specific timer:"
+echo "  sudo systemctl restart nebuleair-npm-data.timer"

sound_meter/NSRT_MK4_change_config.py

@@ -0,0 +1,55 @@
+'''
+  ____   ___  _   _ _   _ ____  
+ / ___| / _ \| | | | \ | |  _ \ 
+ \___ \| | | | | | |  \| | | | |
+  ___) | |_| | |_| | |\  | |_| |
+ |____/ \___/ \___/|_| \_|____/ 
+                                
+python3 /var/www/nebuleair_pro_4g/sound_meter/NSRT_MK4_change_config.py
+
+1.Intervalle d'enregistrement 
+L'intervalle d'enregistrement définit le temps entre deux points successifs enregistrés. 
+Cela définit également la période d'intégration pour le LEQ, et la période d'observation pour L-min et L-max et Lpeak.  
+L'intervalle d'enregistrement peut être réglé de 125 ms (1/8ème) à 2 H par incréments de 125 ms. 
+
+some parameters can be changed:
+write_tau(tau: float)       -> time constant
+write_fs(frequency: int)    -> sampling freq
+
+'''
+
+import nsrt_mk3_dev
+#from nsrt_mk3_dev import Weighting
+#from nsrt_mk3_dev.nsrt_mk3_dev import NsrtMk3Dev, Weighting
+from enum import Enum
+
+class Weighting(Enum):
+    DB_A = 1
+    DB_C = 2
+    DB_Z = 3
+
+nsrt = nsrt_mk3_dev.NsrtMk3Dev('/dev/ttyACM0')
+
+#####################
+#change time constant
+nsrt.write_tau(1)
+#####################
+
+#####################
+#change Weighting curve
+# - Weighting.DB_A  (A-weighting - most common for environmental noise)
+# - Weighting.DB_C  (C-weighting - for peak measurements)
+# - Weighting.DB_Z  (Z-weighting - linear/flat response)
+nsrt.write_weighting(Weighting.DB_A)
+#####################
+
+freq_level = nsrt.read_fs()             #current sampling frequency
+time_constant = nsrt.read_tau()         #reads the current time constant
+leq_level = nsrt.read_leq()             #current running LEQ and starts the integration of a new LEQ.
+weighting = nsrt.read_weighting()       #weighting curve that is currently selected
+weighted_level = nsrt.read_level()      #current running level in dB.
+
+print(f'current sampling freq : {freq_level} Hz')
+print(f'current time constant : {time_constant} s')
+print(f'current LEQ level:         {leq_level:0.2f} dB')
+print(f'{weighting} value:      {weighted_level:0.2f} dBA')

sound_meter/NSRT_mk4_get_data.py

@@ -0,0 +1,72 @@
+'''
+  ____   ___  _   _ _   _ ____  
+ / ___| / _ \| | | | \ | |  _ \ 
+ \___ \| | | | | | |  \| | | | |
+  ___) | |_| | |_| | |\  | |_| |
+ |____/ \___/ \___/|_| \_|____/ 
+                                
+python3 /var/www/nebuleair_pro_4g/sound_meter/NSRT_mk4_get_data.py
+
+Script to get data from the NSRT_MK4 Sound Level Meter
+
+triggered by a systemd service
+sudo systemctl status nebuleair-noise-data.service
+
+Need to install "nsrt_mk3_dev"
+
+1.Intervalle d'enregistrement 
+L'intervalle d'enregistrement définit le temps entre deux points successifs enregistrés. 
+Cela définit également la période d'intégration pour le LEQ, et la période d'observation pour L-min et L-max et Lpeak.  
+L'intervalle d'enregistrement peut être réglé de 125 ms (1/8ème) à 2 H par incréments de 125 ms. 
+
+some parameters can be changed:
+write_tau(tau: float)       -> time constant
+write_fs(frequency: int)    -> sampling freq
+
+'''
+
+import nsrt_mk3_dev
+import sqlite3
+
+nsrt = nsrt_mk3_dev.NsrtMk3Dev('/dev/ttyACM0')
+
+# Connect to the SQLite database
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+#GET RTC TIME from SQlite
+cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+row = cursor.fetchone()  # Get the first (and only) row
+rtc_time_str = row[1]  # '2025-02-07 12:30:45'
+
+freq_level = nsrt.read_fs()             #current sampling frequency
+time_constant = nsrt.read_tau()         #reads the current time constant
+leq_level = nsrt.read_leq()             #current running LEQ and starts the integration of a new LEQ.
+weighting = nsrt.read_weighting()       #weighting curve that is currently selected ( A ou C)
+weighted_level = nsrt.read_level()      #current running level in dB.
+
+#print(f'current sampling freq : {freq_level} Hz')
+#print(f'current time constant : {time_constant} s')
+#print(f'current LEQ level:         {leq_level:0.2f} dB')
+#print(f'{weighting} value:      {weighted_level:0.2f} dBA')
+# Round values to 2 decimal places before saving
+leq_level_rounded = round(leq_level, 2)
+weighted_level_rounded = round(weighted_level, 2)
+
+#save to db
+#save to sqlite database
+try:
+  cursor.execute('''
+  INSERT INTO data_NOISE (timestamp,current_LEQ, DB_A_value) VALUES (?,?,?)'''
+  , (rtc_time_str,leq_level_rounded,weighted_level_rounded))
+
+  # Commit and close the connection
+  conn.commit()
+
+  #print("Sensor data saved successfully!")
+
+except Exception as e:
+  print(f"Database error: {e}")    
+
+
+conn.close()

sqlite/create_db.py

@@ -1,4 +1,4 @@
-'''
+r'''
   ____   ___  _     _ _       
  / ___| / _ \| |   (_) |_ ___ 
  \___ \| | | | |   | | __/ _ \
@@ -18,6 +18,26 @@ import sqlite3
 conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
 cursor = conn.cursor()
 
+#create a config table
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS config_table  (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    type TEXT NOT NULL
+)
+""")
+
+#creates a config table for envea sondes
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS envea_sondes_table   (
+     id INTEGER PRIMARY KEY AUTOINCREMENT,
+    connected INTEGER NOT NULL,
+    port TEXT NOT NULL,
+    name TEXT NOT NULL,
+    coefficient REAL NOT NULL
+)
+""")
+
 # Create a table timer
 cursor.execute("""
 CREATE TABLE IF NOT EXISTS timestamp_table  (
@@ -30,7 +50,14 @@ cursor.execute("""
     VALUES (1, CURRENT_TIMESTAMP);
 """)
 
-
+#create a modem status table
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS modem_status (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT,
+    status TEXT
+)
+""")
 
 # Create a table NPM
 cursor.execute("""
@@ -62,7 +89,8 @@ CREATE TABLE IF NOT EXISTS data_envea (
     h2s REAL,
     nh3 REAL,
     co REAL,
-    o3 REAL
+    o3 REAL,
+    so2 REAL
 )
 """)
 
@@ -78,7 +106,35 @@ CREATE TABLE IF NOT EXISTS data_NPM_5channels (
 )
 """)
 
+# Create a table WIND
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS data_WIND (
+    timestamp TEXT,
+    wind_speed REAL,
+    wind_direction REAL
+)
+""")
 
+# Create a table MPPT
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS data_MPPT (
+    timestamp TEXT,
+    battery_voltage REAL,
+    battery_current REAL,
+    solar_voltage REAL,
+    solar_power REAL,
+    charger_status INTEGER
+)
+""")
+
+# Create a table noise capture (NSRT mk4)
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS data_NOISE (
+    timestamp TEXT,
+    current_LEQ REAL,
+    DB_A_value REAL
+)
+""")
 
 # Commit and close the connection
 conn.commit()

sqlite/delete.py

@@ -0,0 +1,232 @@
+'''
+  ____   ___  _     _ _       
+ / ___| / _ \| |   (_) |_ ___ 
+ \___ \| | | | |   | | __/ _ \
+  ___) | |_| | |___| | ||  __/
+ |____/ \__\_\_____|_|\__\___|
+                              
+Script to delete a table from sqlite database
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/delete.py table_name [--confirm]
+
+Available tables are:
+data_NPM
+data_NPM_5channels
+data_BME280
+data_envea
+timestamp_table
+data_MPPT
+data_WIND
+modem_status
+config_table
+envea_sondes_table
+
+Examples:
+# Will ask for confirmation
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/delete.py data_NPM
+
+# Skip confirmation prompt
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/delete.py data_NPM --confirm
+
+# List all tables
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/delete.py --list
+'''
+
+import sqlite3
+import sys
+import os
+from datetime import datetime
+
+def list_tables(cursor):
+    """List all tables in the database"""
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+    tables = cursor.fetchall()
+    
+    print("\n📋 Available tables:")
+    print("-" * 40)
+    for table in tables:
+        # Get row count for each table
+        cursor.execute(f"SELECT COUNT(*) FROM {table[0]}")
+        count = cursor.fetchone()[0]
+        print(f"  {table[0]} ({count} rows)")
+    print("-" * 40)
+
+def get_table_info(cursor, table_name):
+    """Get information about a table"""
+    try:
+        # Check if table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        if not cursor.fetchone():
+            return None
+        
+        # Get row count
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+        row_count = cursor.fetchone()[0]
+        
+        # Get table schema
+        cursor.execute(f"PRAGMA table_info({table_name})")
+        columns = cursor.fetchall()
+        
+        return {
+            'row_count': row_count,
+            'columns': columns
+        }
+    except sqlite3.Error as e:
+        print(f"Error getting table info: {e}")
+        return None
+
+def backup_table(cursor, table_name, db_path):
+    """Create a backup of the table before deletion"""
+    try:
+        backup_dir = os.path.dirname(db_path)
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_file = os.path.join(backup_dir, f"{table_name}_backup_{timestamp}.sql")
+        
+        # Get table schema
+        cursor.execute(f"SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        create_sql = cursor.fetchone()
+        
+        if create_sql:
+            with open(backup_file, 'w') as f:
+                # Write table creation SQL
+                f.write(f"-- Backup of table {table_name} created on {datetime.now()}\n")
+                f.write(f"{create_sql[0]};\n\n")
+                
+                # Write data
+                cursor.execute(f"SELECT * FROM {table_name}")
+                rows = cursor.fetchall()
+                
+                if rows:
+                    # Get column names
+                    cursor.execute(f"PRAGMA table_info({table_name})")
+                    columns = [col[1] for col in cursor.fetchall()]
+                    
+                    f.write(f"-- Data for table {table_name}\n")
+                    for row in rows:
+                        values = []
+                        for value in row:
+                            if value is None:
+                                values.append('NULL')
+                            elif isinstance(value, str):
+                                escaped_value = value.replace("'", "''")
+                                values.append(f"'{escaped_value}'")
+                            else:
+                                values.append(str(value))
+                        
+                        f.write(f"INSERT INTO {table_name} ({', '.join(columns)}) VALUES ({', '.join(values)});\n")
+            
+            print(f"✓ Table backed up to: {backup_file}")
+            return backup_file
+    except Exception as e:
+        print(f"⚠️  Backup failed: {e}")
+        return None
+
+def delete_table(cursor, table_name, create_backup=True, db_path=None):
+    """Delete a table from the database"""
+    
+    # Get table info first
+    table_info = get_table_info(cursor, table_name)
+    if not table_info:
+        print(f"❌ Table '{table_name}' does not exist!")
+        return False
+    
+    print(f"\n📊 Table Information:")
+    print(f"   Name: {table_name}")
+    print(f"   Rows: {table_info['row_count']}")
+    print(f"   Columns: {len(table_info['columns'])}")
+    
+    # Create backup if requested
+    backup_file = None
+    if create_backup and db_path:
+        print(f"\n💾 Creating backup...")
+        backup_file = backup_table(cursor, table_name, db_path)
+    
+    try:
+        # Delete the table
+        cursor.execute(f"DROP TABLE {table_name}")
+        print(f"\n✅ Table '{table_name}' deleted successfully!")
+        
+        if backup_file:
+            print(f"   Backup saved: {backup_file}")
+        
+        return True
+        
+    except sqlite3.Error as e:
+        print(f"❌ Error deleting table: {e}")
+        return False
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 delete_table.py <table_name> [--confirm] [--no-backup]")
+        print("       python3 delete_table.py --list")
+        sys.exit(1)
+    
+    db_path = "/var/www/nebuleair_pro_4g/sqlite/sensors.db"
+    
+    # Check if database exists
+    if not os.path.exists(db_path):
+        print(f"❌ Database not found: {db_path}")
+        sys.exit(1)
+    
+    # Parse arguments
+    args = sys.argv[1:]
+    
+    if '--list' in args:
+        # List all tables
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        list_tables(cursor)
+        conn.close()
+        return
+    
+    table_name = args[0]
+    skip_confirmation = '--confirm' in args
+    create_backup = '--no-backup' not in args
+    
+    try:
+        # Connect to database
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # List available tables first
+        list_tables(cursor)
+        
+        # Check if table exists
+        table_info = get_table_info(cursor, table_name)
+        if not table_info:
+            print(f"\n❌ Table '{table_name}' does not exist!")
+            conn.close()
+            sys.exit(1)
+        
+        # Confirmation prompt
+        if not skip_confirmation:
+            print(f"\n⚠️  WARNING: You are about to delete table '{table_name}'")
+            print(f"   This table contains {table_info['row_count']} rows")
+            if create_backup:
+                print(f"   A backup will be created before deletion")
+            else:
+                print(f"   NO BACKUP will be created (--no-backup flag used)")
+            
+            response = input(f"\nAre you sure you want to delete '{table_name}'? (yes/no): ").lower().strip()
+            
+            if response not in ['yes', 'y']:
+                print("❌ Operation cancelled")
+                conn.close()
+                sys.exit(0)
+        
+        # Perform deletion
+        success = delete_table(cursor, table_name, create_backup, db_path)
+        
+        if success:
+            conn.commit()
+            print(f"\n🎉 Operation completed successfully!")
+        else:
+            print(f"\n❌ Operation failed!")
+            
+        conn.close()
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

sqlite/empty_sensor_tables.py

@@ -0,0 +1,204 @@
+'''
+  ____   ___  _     _ _
+ / ___| / _ \| |   (_) |_ ___
+ \___ \| | | | |   | | __/ _ \
+  ___) | |_| | |___| | ||  __/
+ |____/ \__\_\_____|_|\__\___|
+
+Script to empty (delete all data from) sensor tables in the SQLite database
+This script empties sensor data tables but preserves:
+- timestamp_table
+- config_table
+- envea_sondes_table
+- config_scripts_table
+
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/empty_sensor_tables.py
+'''
+
+import sqlite3
+import sys
+import json
+
+def table_exists(cursor, table_name):
+    """Check if a table exists in the database"""
+    try:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        return cursor.fetchone() is not None
+    except sqlite3.Error as e:
+        print(f"[ERROR] Failed to check if table '{table_name}' exists: {e}")
+        return False
+
+
+def get_table_count(cursor, table_name):
+    """Get the number of records in a table"""
+    try:
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+        return cursor.fetchone()[0]
+    except sqlite3.Error as e:
+        print(f"[WARNING] Could not get count for table '{table_name}': {e}")
+        return 0
+
+
+def empty_table(cursor, table_name):
+    """Delete all records from a specific table"""
+    try:
+        # Get record count before deletion
+        initial_count = get_table_count(cursor, table_name)
+
+        if initial_count == 0:
+            print(f"[INFO] Table '{table_name}' is already empty")
+            return True, 0
+
+        # Delete all records
+        cursor.execute(f"DELETE FROM {table_name}")
+        deleted_count = cursor.rowcount
+
+        print(f"[SUCCESS] Deleted {deleted_count} records from '{table_name}'")
+        return True, deleted_count
+
+    except sqlite3.Error as e:
+        print(f"[ERROR] Failed to empty table '{table_name}': {e}")
+        return False, 0
+
+
+def main():
+    result = {
+        'success': False,
+        'message': '',
+        'tables_processed': [],
+        'total_deleted': 0
+    }
+
+    try:
+        # Connect to the SQLite database
+        print("[INFO] Connecting to database...")
+        conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+        cursor = conn.cursor()
+
+        # Check database connection
+        cursor.execute("SELECT sqlite_version()")
+        version = cursor.fetchone()[0]
+        print(f"[INFO] Connected to SQLite version: {version}")
+
+        # List of sensor tables to empty (EXCLUDING timestamp_table and config tables)
+        sensor_tables = [
+            "data_NPM",
+            "data_NPM_5channels",
+            "data_BME280",
+            "data_envea",
+            "data_WIND",
+            "data_MPPT",
+            "data_NOISE",
+            "modem_status"
+        ]
+
+        # Tables to PRESERVE (not empty)
+        preserved_tables = [
+            "timestamp_table",
+            "config_table",
+            "envea_sondes_table",
+            "config_scripts_table"
+        ]
+
+        print(f"[INFO] Will empty the following sensor tables: {', '.join(sensor_tables)}")
+        print(f"[INFO] Will preserve the following tables: {', '.join(preserved_tables)}")
+
+        # Check which tables actually exist
+        existing_tables = []
+        missing_tables = []
+
+        for table in sensor_tables:
+            if table_exists(cursor, table):
+                existing_tables.append(table)
+                record_count = get_table_count(cursor, table)
+                print(f"[INFO] Table '{table}' exists with {record_count} records")
+            else:
+                missing_tables.append(table)
+                print(f"[WARNING] Table '{table}' does not exist - skipping")
+
+        if missing_tables:
+            print(f"[INFO] Missing tables: {', '.join(missing_tables)}")
+
+        if not existing_tables:
+            result['success'] = True
+            result['message'] = "No sensor tables found to empty"
+            print("[WARNING] No sensor tables found to empty!")
+            print(json.dumps(result))
+            return True
+
+        # Loop through existing tables and empty them
+        successful_operations = 0
+        failed_operations = 0
+        total_deleted = 0
+
+        for table in existing_tables:
+            success, deleted = empty_table(cursor, table)
+            if success:
+                successful_operations += 1
+                total_deleted += deleted
+                result['tables_processed'].append({
+                    'name': table,
+                    'deleted': deleted
+                })
+            else:
+                failed_operations += 1
+
+        # Commit changes
+        print("[INFO] Committing changes...")
+        conn.commit()
+        print("[SUCCESS] Changes committed successfully!")
+
+        # Run VACUUM to optimize database space
+        if total_deleted > 0:
+            print("[INFO] Running VACUUM to optimize database space...")
+            try:
+                cursor.execute("VACUUM")
+                print("[SUCCESS] Database optimized successfully!")
+            except sqlite3.Error as e:
+                print(f"[WARNING] VACUUM failed: {e}")
+
+        # Summary
+        print(f"\n[SUMMARY]")
+        print(f"Tables emptied successfully: {successful_operations}")
+        print(f"Tables with errors: {failed_operations}")
+        print(f"Tables skipped (missing): {len(missing_tables)}")
+        print(f"Total records deleted: {total_deleted}")
+
+        result['success'] = True
+        result['message'] = f"Successfully emptied {successful_operations} sensor tables. Total records deleted: {total_deleted}"
+        result['total_deleted'] = total_deleted
+
+        if failed_operations == 0:
+            print("[SUCCESS] All sensor tables emptied successfully!")
+        else:
+            result['message'] = f"Partial success: {successful_operations} tables emptied, {failed_operations} failed"
+            print("[WARNING] Some operations failed - check logs above")
+
+        # Output JSON result for web interface
+        print("\n[JSON_RESULT]")
+        print(json.dumps(result))
+
+        return failed_operations == 0
+
+    except sqlite3.Error as e:
+        result['message'] = f"Database error: {e}"
+        print(f"[ERROR] Database error: {e}")
+        print("\n[JSON_RESULT]")
+        print(json.dumps(result))
+        return False
+    except Exception as e:
+        result['message'] = f"Unexpected error: {e}"
+        print(f"[ERROR] Unexpected error: {e}")
+        print("\n[JSON_RESULT]")
+        print(json.dumps(result))
+        return False
+    finally:
+        # Always close the database connection
+        if 'conn' in locals():
+            conn.close()
+            print("[INFO] Database connection closed")
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

sqlite/flush_old_data.py

@@ -9,6 +9,9 @@ Script to flush (delete) data from a sqlite database
 
 /usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/flush_old_data.py
 
+Script that is triggered by a systemd
+sudo systemctl status nebuleair-db-cleanup-data.service
+
 Available table are
 
 data_NPM
@@ -16,56 +19,184 @@ data_NPM_5channels
 data_BME280
 data_envea
 timestamp_table
+data_MPPT
+data_NOISE
+data_WIND
 
 '''
 
 import sqlite3
 import datetime
+import sys
 
 
-# Connect to the SQLite database
-conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
-cursor = conn.cursor()
-
-#GET RTC TIME from SQlite
-cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
-row = cursor.fetchone()  # Get the first (and only) row
-
-if row:
-    rtc_time_str = row[1]  # Assuming timestamp is stored as TEXT (YYYY-MM-DD HH:MM:SS)
-    print(f"[INFO] Last recorded timestamp: {rtc_time_str}")
-
-    # Convert last_updated to a datetime object
-    last_updated = datetime.datetime.strptime(rtc_time_str, "%Y-%m-%d %H:%M:%S")
-
-    # Calculate the cutoff date (3 months before last_updated)
-    cutoff_date = last_updated - datetime.timedelta(days=60)
-    cutoff_date_str = cutoff_date.strftime("%Y-%m-%d %H:%M:%S")
-
-    print(f"[INFO] Deleting records older than: {cutoff_date_str}")
-
-    # List of tables to delete old data from
-    tables_to_clean = ["data_NPM", "data_NPM_5channels", "data_BME280", "data_envea"]
-
-    # Loop through each table and delete old data
-    for table in tables_to_clean:
-        delete_query = f"DELETE FROM {table} WHERE timestamp < ?"
-        cursor.execute(delete_query, (cutoff_date_str,))
-        print(f"[INFO] Deleted old records from {table}")
-
-    # **Commit changes before running VACUUM**
-    conn.commit()
-    print("[INFO] Changes committed successfully!")
-
-    # Now it's safe to run VACUUM
-    print("[INFO] Running VACUUM to optimize database space...")
-    cursor.execute("VACUUM")
-
-    print("[SUCCESS] Old data flushed successfully!")
-
-else:
-    print("[ERROR] No timestamp found in timestamp_table.")
+def table_exists(cursor, table_name):
+    """Check if a table exists in the database"""
+    try:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        return cursor.fetchone() is not None
+    except sqlite3.Error as e:
+        print(f"[ERROR] Failed to check if table '{table_name}' exists: {e}")
+        return False
 
 
-# Close the database connection
-conn.close()
+def get_table_count(cursor, table_name):
+    """Get the number of records in a table"""
+    try:
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+        return cursor.fetchone()[0]
+    except sqlite3.Error as e:
+        print(f"[WARNING] Could not get count for table '{table_name}': {e}")
+        return 0
+
+
+def delete_old_records(cursor, table_name, cutoff_date_str):
+    """Delete old records from a specific table"""
+    try:
+        # First check how many records will be deleted
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name} WHERE timestamp < ?", (cutoff_date_str,))
+        records_to_delete = cursor.fetchone()[0]
+        
+        if records_to_delete == 0:
+            print(f"[INFO] No old records to delete from '{table_name}'")
+            return True
+        
+        # Delete the records
+        cursor.execute(f"DELETE FROM {table_name} WHERE timestamp < ?", (cutoff_date_str,))
+        deleted_count = cursor.rowcount
+        
+        print(f"[SUCCESS] Deleted {deleted_count} old records from '{table_name}'")
+        return True
+        
+    except sqlite3.Error as e:
+        print(f"[ERROR] Failed to delete records from '{table_name}': {e}")
+        return False
+
+
+def main():
+    try:
+        # Connect to the SQLite database
+        print("[INFO] Connecting to database...")
+        conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+        cursor = conn.cursor()
+        
+        # Check database connection
+        cursor.execute("SELECT sqlite_version()")
+        version = cursor.fetchone()[0]
+        print(f"[INFO] Connected to SQLite version: {version}")
+
+        # GET RTC TIME from SQLite
+        print("[INFO] Getting timestamp from database...")
+        
+        # First check if timestamp_table exists
+        if not table_exists(cursor, "timestamp_table"):
+            print("[ERROR] timestamp_table does not exist!")
+            return False
+
+        cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+        row = cursor.fetchone()
+
+        if not row:
+            print("[ERROR] No timestamp found in timestamp_table.")
+            return False
+
+        rtc_time_str = row[1]  # Assuming timestamp is stored as TEXT (YYYY-MM-DD HH:MM:SS)
+        print(f"[INFO] Last recorded timestamp: {rtc_time_str}")
+
+        # Convert last_updated to a datetime object
+        try:
+            last_updated = datetime.datetime.strptime(rtc_time_str, "%Y-%m-%d %H:%M:%S")
+        except ValueError as e:
+            print(f"[ERROR] Invalid timestamp format: {e}")
+            return False
+
+        # Calculate the cutoff date (60 days before last_updated)
+        cutoff_date = last_updated - datetime.timedelta(days=60)
+        cutoff_date_str = cutoff_date.strftime("%Y-%m-%d %H:%M:%S")
+
+        print(f"[INFO] Deleting records older than: {cutoff_date_str}")
+
+        # List of tables to delete old data from
+        tables_to_clean = [
+            "data_NPM", 
+            "data_NPM_5channels", 
+            "data_BME280", 
+            "data_envea",
+            "data_WIND", 
+            "data_MPPT", 
+            "data_NOISE"
+        ]
+
+        # Check which tables actually exist
+        existing_tables = []
+        missing_tables = []
+        
+        for table in tables_to_clean:
+            if table_exists(cursor, table):
+                existing_tables.append(table)
+                record_count = get_table_count(cursor, table)
+                print(f"[INFO] Table '{table}' exists with {record_count} records")
+            else:
+                missing_tables.append(table)
+                print(f"[WARNING] Table '{table}' does not exist - skipping")
+
+        if missing_tables:
+            print(f"[INFO] Missing tables: {', '.join(missing_tables)}")
+        
+        if not existing_tables:
+            print("[WARNING] No tables found to clean!")
+            return True
+
+        # Loop through existing tables and delete old data
+        successful_deletions = 0
+        failed_deletions = 0
+        
+        for table in existing_tables:
+            if delete_old_records(cursor, table, cutoff_date_str):
+                successful_deletions += 1
+            else:
+                failed_deletions += 1
+
+        # Commit changes before running VACUUM
+        print("[INFO] Committing changes...")
+        conn.commit()
+        print("[SUCCESS] Changes committed successfully!")
+
+        # Only run VACUUM if at least some deletions were successful
+        if successful_deletions > 0:
+            print("[INFO] Running VACUUM to optimize database space...")
+            try:
+                cursor.execute("VACUUM")
+                print("[SUCCESS] Database optimized successfully!")
+            except sqlite3.Error as e:
+                print(f"[WARNING] VACUUM failed: {e}")
+
+        # Summary
+        print(f"\n[SUMMARY]")
+        print(f"Tables processed successfully: {successful_deletions}")
+        print(f"Tables with errors: {failed_deletions}")
+        print(f"Tables skipped (missing): {len(missing_tables)}")
+        
+        if failed_deletions == 0:
+            print("[SUCCESS] Old data flushed successfully!")
+            return True
+        else:
+            print("[WARNING] Some operations failed - check logs above")
+            return False
+
+    except sqlite3.Error as e:
+        print(f"[ERROR] Database error: {e}")
+        return False
+    except Exception as e:
+        print(f"[ERROR] Unexpected error: {e}")
+        return False
+    finally:
+        # Always close the database connection
+        if 'conn' in locals():
+            conn.close()
+            print("[INFO] Database connection closed")
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

sqlite/read.py

@@ -14,6 +14,8 @@ data_NPM_5channels
 data_BME280
 data_envea
 timestamp_table
+data_MPPT
+data_WIND
 
 '''
 
@@ -28,20 +30,17 @@ limit_num=parameter[1]
 conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
 cursor = conn.cursor()
 
-# Retrieve the last 10 sensor readings
-#cursor.execute("SELECT * FROM data_NPM ORDER BY timestamp DESC LIMIT 10")
-#cursor.execute("SELECT * FROM data_BME280 ORDER BY timestamp DESC LIMIT 10")
-#cursor.execute("SELECT * FROM timestamp_table")
+# Retrieve the last sensor readings based on insertion order (ROWID)
+# This ensures we get the most recently inserted data, regardless of timestamp value
 if table_name == "timestamp_table":
   cursor.execute("SELECT * FROM timestamp_table")
-
 else:
-  query = f"SELECT * FROM {table_name} ORDER BY timestamp DESC LIMIT ?"
+  # Order by ROWID DESC to get most recently inserted rows first
+  query = f"SELECT * FROM {table_name} ORDER BY ROWID DESC LIMIT ?"
   cursor.execute(query, (limit_num,))
 
-
 rows = cursor.fetchall()
-rows.reverse()  # Reverse the order in Python (to get ascending order)
+# Keep DESC order - most recently inserted data first
 
 
 # Display the results

sqlite/read_config.py

@@ -0,0 +1,43 @@
+'''
+  ____   ___  _     _ _       
+ / ___| / _ \| |   (_) |_ ___ 
+ \___ \| | | | |   | | __/ _ \
+  ___) | |_| | |___| | ||  __/
+ |____/ \__\_\_____|_|\__\___|
+                              
+Script to read data from a sqlite database
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/read_config.py config_table
+
+Available table are
+config_table
+config_scripts_table
+envea_sondes_table
+
+'''
+
+import sqlite3
+import sys
+parameter = sys.argv[1:]  # Exclude the script name
+#print("Parameters received:")
+table_name=parameter[0]
+
+
+# Connect to the SQLite database
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+# Retrieve the data
+query = f"SELECT * FROM {table_name}"
+cursor.execute(query)
+
+
+rows = cursor.fetchall()
+rows.reverse()  # Reverse the order in Python (to get ascending order)
+
+
+# Display the results
+for row in rows:
+    print(row)
+
+# Close the database connection
+conn.close()

sqlite/set_config.py

@@ -0,0 +1,110 @@
+r'''
+  ____   ___  _     _ _       
+ / ___| / _ \| |   (_) |_ ___ 
+ \___ \| | | | |   | | __/ _ \
+  ___) | |_| | |___| | ||  __/
+ |____/ \__\_\_____|_|\__\___|
+                              
+Script to set the config
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/set_config.py
+
+in case of readonly error:
+sudo chmod 777 /var/www/nebuleair_pro_4g/sqlite/sensors.db
+'''
+
+import sqlite3
+
+# Connect to (or create if not existent) the database
+conn = sqlite3.connect("/var/www/nebuleair_pro_4g/sqlite/sensors.db")
+cursor = conn.cursor()
+
+print(f"Connected to database")
+
+# Note: Using INSERT OR IGNORE to add only new configurations without overwriting existing ones
+print("Adding new configurations (existing ones will be preserved)")
+
+
+# Insert general configurations
+config_entries = [
+    ("modem_config_mode", "0", "bool"),
+    ("deviceID", "XXXX", "str"),
+    ("latitude_raw", "0", "int"),
+    ("longitude_raw", "0", "int"),
+    ("latitude_precision", "0", "int"),
+    ("longitude_precision", "0", "int"),
+    ("deviceName", "NebuleAir-proXXX", "str"),
+    ("SaraR4_baudrate", "115200", "int"),
+    ("NPM_solo_port", "/dev/ttyAMA5", "str"),
+    ("sshTunnel_port", "59228", "int"),
+    ("SARA_R4_general_status", "connected", "str"),
+    ("SARA_R4_SIM_status", "connected", "str"),
+    ("SARA_R4_network_status", "connected", "str"),
+    ("SARA_R4_neworkID", "20810", "int"),
+    ("WIFI_status", "connected", "str"),
+    ("send_aircarto", "1", "bool"),
+    ("send_uSpot", "0", "bool"),
+    ("send_miotiq", "0", "bool"),
+    ("npm_5channel", "0", "bool"),
+    ("envea", "0", "bool"),
+    ("windMeter", "0", "bool"),
+    ("BME280", "0", "bool"),
+    ("MPPT", "0", "bool"),
+    ("NOISE", "0", "bool"),
+    ("modem_version", "XXX", "str"),
+    ("language", "fr", "str")
+]
+
+for key, value, value_type in config_entries:
+    cursor.execute(
+        "INSERT OR IGNORE INTO config_table (key, value, type) VALUES (?, ?, ?)",
+        (key, value, value_type)
+    )
+
+# Clean up duplicate envea sondes first (keep only first occurrence of each name)
+print("Cleaning up duplicate envea sondes...")
+cursor.execute("""
+    DELETE FROM envea_sondes_table 
+    WHERE id NOT IN (
+        SELECT MIN(id) 
+        FROM envea_sondes_table 
+        GROUP BY name
+    )
+""")
+deleted_count = cursor.rowcount
+if deleted_count > 0:
+    print(f"Deleted {deleted_count} duplicate envea sonde entries")
+
+# Insert envea sondes (only if they don't already exist)
+# Attention pour le H2S il y a plusieurs sondes
+# H2S 1ppm -> coef 4
+# H2S 20ppm -> coef 1
+# H2S 200ppm -> coef 10
+
+envea_sondes = [
+    (False, "ttyAMA4", "h2s", 4),  #H2S
+    (False, "ttyAMA3", "no2", 1),
+    (False, "ttyAMA3", "nh3", 100),
+    (False, "ttyAMA3", "so2", 4),
+    (False, "ttyAMA2", "o3", 1)
+]
+
+for connected, port, name, coefficient in envea_sondes:
+    # Check if sensor with this name already exists
+    cursor.execute("SELECT COUNT(*) FROM envea_sondes_table WHERE name = ?", (name,))
+    exists = cursor.fetchone()[0] > 0
+    
+    if not exists:
+        cursor.execute(
+            "INSERT INTO envea_sondes_table (connected, port, name, coefficient) VALUES (?, ?, ?, ?)",
+            (1 if connected else 0, port, name, coefficient)
+        )
+        print(f"Added envea sonde: {name}")
+    else:
+        print(f"Envea sonde '{name}' already exists, skipping")
+
+
+# Commit and close the connection
+conn.commit()
+conn.close()
+
+print("Database updated successfully!")

update_firmware.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+
+# NebuleAir Pro 4G - Comprehensive Update Script
+# This script performs a complete system update including git pull,
+# config initialization, and service management
+# Non-interactive version for WebUI
+
+echo "======================================"
+echo "NebuleAir Pro 4G - Firmware Update"
+echo "======================================"
+echo "Started at: $(date)"
+echo ""
+
+# Set working directory
+cd /var/www/nebuleair_pro_4g
+
+# Ensure this script is executable
+chmod +x /var/www/nebuleair_pro_4g/update_firmware.sh
+
+# Function to print status messages
+print_status() {
+    echo "[$(date '+%H:%M:%S')] $1"
+}
+
+# Function to check command success
+check_status() {
+    if [ $? -eq 0 ]; then
+        print_status "✓ $1 completed successfully"
+    else
+        print_status "✗ $1 failed"
+        return 1
+    fi
+}
+
+# Step 1: Git operations
+print_status "Step 1: Updating firmware from repository..."
+
+# Disable filemode to prevent permission issues
+git -C /var/www/nebuleair_pro_4g config core.fileMode false
+check_status "Git fileMode disabled"
+
+# Fetch latest changes
+git fetch origin
+check_status "Git fetch"
+
+# Show current branch
+print_status "Current branch: $(git branch --show-current)"
+
+# Check for local changes
+if [ -n "$(git status --porcelain)" ]; then
+    print_status "Warning: Local changes detected, stashing..."
+    git stash push -m "Auto-stash before update $(date)"
+    check_status "Git stash"
+fi
+
+# Pull latest changes
+git pull origin $(git branch --show-current)
+check_status "Git pull"
+
+# Step 2: Update database configuration
+print_status ""
+print_status "Step 2: Updating database configuration..."
+/usr/bin/python3 /var/www/nebuleair_pro_4g/sqlite/set_config.py
+check_status "Database configuration update"
+
+# Step 3: Check and fix file permissions
+print_status ""
+print_status "Step 3: Checking file permissions..."
+sudo chmod +x /var/www/nebuleair_pro_4g/update_firmware.sh
+sudo chmod 755 /var/www/nebuleair_pro_4g/sqlite/*.py
+sudo chmod 755 /var/www/nebuleair_pro_4g/NPM/*.py
+sudo chmod 755 /var/www/nebuleair_pro_4g/BME280/*.py
+sudo chmod 755 /var/www/nebuleair_pro_4g/SARA/*.py
+sudo chmod 755 /var/www/nebuleair_pro_4g/envea/*.py
+sudo chmod 755 /var/www/nebuleair_pro_4g/MPPT/*.py 2>/dev/null
+check_status "File permissions update"
+
+# Step 4: Restart critical services if they exist
+print_status ""
+print_status "Step 4: Managing system services..."
+
+# List of services to check and restart
+services=(
+    "nebuleair-npm-data.timer"
+    "nebuleair-envea-data.timer"
+    "nebuleair-sara-data.timer"
+    "nebuleair-bme280-data.timer"
+    "nebuleair-mppt-data.timer"
+    "nebuleair-noise-data.timer"
+)
+
+for service in "${services[@]}"; do
+    if systemctl list-unit-files | grep -q "$service"; then
+        # Check if service is enabled before restarting
+        if systemctl is-enabled --quiet "$service" 2>/dev/null; then
+            print_status "Restarting enabled service: $service"
+            sudo systemctl restart "$service"
+            if systemctl is-active --quiet "$service"; then
+                print_status "✓ $service is running"
+            else
+                print_status "⚠ $service failed to start"
+            fi
+        else
+            print_status "ℹ Service $service is disabled, skipping restart"
+        fi
+    else
+        print_status "ℹ Service $service not found (may not be installed)"
+    fi
+done
+
+# Step 5: System health check
+print_status ""
+print_status "Step 5: System health check..."
+
+# Check disk space
+disk_usage=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
+if [ "$disk_usage" -gt 90 ]; then
+    print_status "⚠ Warning: Disk usage is high ($disk_usage%)"
+else
+    print_status "✓ Disk usage is acceptable ($disk_usage%)"
+fi
+
+# Check if database is accessible
+if [ -f "/var/www/nebuleair_pro_4g/sqlite/sensors.db" ]; then
+    print_status "✓ Database file exists"
+else
+    print_status "⚠ Warning: Database file not found"
+fi
+
+# Step 6: Final cleanup
+print_status ""
+print_status "Step 6: Cleaning up..."
+sudo find /var/www/nebuleair_pro_4g/logs -name "*.log" -size +10M -exec truncate -s 0 {} \;
+check_status "Log cleanup"
+
+print_status ""
+print_status "======================================"
+print_status "Update completed successfully!"
+print_status "======================================"
+
+exit 0

windMeter/ads115.py

@@ -0,0 +1,27 @@
+'''
+Script to test the abs115 an analog-to-digital converter
+sudo /usr/bin/python3 /var/www/nebuleair_pro_4g/windMeter/ads115.py
+
+'''
+import time
+import board
+import busio
+import adafruit_ads1x15.ads1115 as ADS
+from adafruit_ads1x15.analog_in import AnalogIn
+
+i2c = busio.I2C(board.SCL, board.SDA)
+ads = ADS.ADS1115(i2c)
+channel = AnalogIn(ads, ADS.P0)
+
+print("Testing ADS1115 readings...")
+readings = []
+
+for i in range(5):
+    voltage = channel.voltage
+    readings.append(voltage)
+    print(f"Voltage: {voltage:.6f}V")
+    time.sleep(1)
+
+# Calculate and display the mean
+mean_voltage = sum(readings) / len(readings)
+print(f"\nMean voltage: {mean_voltage:.6f}V")

windMeter/read.py

@@ -0,0 +1,140 @@
+'''
+ __        _____ _   _ ____  
+ \ \      / /_ _| \ | |  _ \ 
+  \ \ /\ / / | ||  \| | | | |
+   \ V  V /  | || |\  | |_| |
+    \_/\_/  |___|_| \_|____/ 
+
+Script to read wind speed from a Davis Anémomètre-girouette Vantage Pro (6410)
+https://www.shapemaker.io/blog/wind-speed-measurements-with-anemometer-and-a-raspberry-pi
+
+Connexion:
+black (wind speed )     -> gpio21
+green (wind direction)  -> ADS1115 (module I2C) 
+Yellow                  -> 5v
+RED                     -> GND
+
+Attention:  The Raspberry Pi doesn't have analog inputs, so we need an analog-to-digital converter (ADC) to read the wind direction.
+
+sudo /usr/bin/python3 /var/www/nebuleair_pro_4g/windMeter/read.py
+
+this need to run as a service
+
+--> sudo nano /etc/systemd/system/windMeter.service
+
+⬇️
+[Unit]
+Description=Master manager for the Python wind meter scripts
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/python3 /var/www/nebuleair_pro_4g/windMeter/read.py
+Restart=always
+User=root
+WorkingDirectory=/var/www/nebuleair_pro_4g
+StandardOutput=append:/var/www/nebuleair_pro_4g/logs/wind.log
+StandardError=append:/var/www/nebuleair_pro_4g/logs/wind_errors.log
+
+[Install]
+WantedBy=multi-user.target
+⬆️
+
+Reload systemd (first time after creating the service):
+    sudo systemctl daemon-reload
+
+Enable (once), start (once and after stopping) and restart (after modification)systemd:
+    sudo systemctl enable windMeter.service
+    sudo systemctl start windMeter.service
+    sudo systemctl restart windMeter.service
+
+Check the service status:
+    sudo systemctl status windMeter.service
+
+'''
+#!/usr/bin/python3
+import time
+import sqlite3
+import board
+import busio
+import numpy as np
+import threading
+import adafruit_ads1x15.ads1115 as ADS
+from adafruit_ads1x15.analog_in import AnalogIn
+from gpiozero import Button
+from datetime import datetime
+
+# Constants
+DB_PATH = "/var/www/nebuleair_pro_4g/sqlite/sensors.db"
+
+# Initialize I2C & ADS1115
+i2c = busio.I2C(board.SCL, board.SDA)
+ads = ADS.ADS1115(i2c)
+channel = AnalogIn(ads, ADS.P0)  # Connect to A0 on the ADS1115
+
+# Wind speed sensor setup
+wind_speed_sensor = Button(21)
+wind_count = 0
+wind_lock = threading.Lock()
+
+def spin():
+    global wind_count
+    with wind_lock:
+        wind_count += 1
+
+def reset_wind():
+    global wind_count
+    with wind_lock:
+        wind_count = 0
+
+wind_speed_sensor.when_activated = spin  # More reliable
+
+def calc_speed(spins, interval):
+    return spins * (2.25 / interval) * 1.60934  # Convert MPH to km/h
+
+def get_wind_direction():
+    voltage = channel.voltage
+    return voltage
+
+def save_to_database(wind_speed, wind_direction, spin_count):
+    """Save wind data to SQLite database."""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT * FROM timestamp_table LIMIT 1")
+        row = cursor.fetchone()
+        rtc_time_str = row[1] if row else datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        cursor.execute('''
+        INSERT INTO data_wind (timestamp, wind_speed, wind_direction)
+        VALUES (?, ?, ?)
+        ''', (rtc_time_str, round(wind_speed, 2), round(wind_direction, 2)))
+        
+        conn.commit()
+        conn.close()
+        print(f"Saved: {rtc_time_str}, {wind_speed:.2f} km/h, {wind_direction:.2f}V, Spins: {spin_count}")
+        
+    except Exception as e:
+        print(f"Database error: {e}")
+
+def main():
+    print("Wind monitoring started...")
+    
+    try:
+        while True:
+            reset_wind()
+            print("Measuring for 60 seconds...")
+            time.sleep(60)
+            
+            wind_speed_kmh = calc_speed(wind_count, 60)
+            wind_direction = get_wind_direction()
+            
+            save_to_database(wind_speed_kmh, wind_direction, wind_count)
+            
+    except KeyboardInterrupt:
+        print("\nMonitoring stopped.")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()

windMeter/read_wind_direction.py

@@ -0,0 +1,84 @@
+'''
+ __        _____ _   _ ____  
+ \ \      / /_ _| \ | |  _ \ 
+  \ \ /\ / / | ||  \| | | | |
+   \ V  V /  | || |\  | |_| |
+    \_/\_/  |___|_| \_|____/ 
+                             
+
+Script to read wind speed from a Davis Anémomètre-girouette Vantage Pro (6410)
+https://www.shapemaker.io/blog/wind-speed-measurements-with-anemometer-and-a-raspberry-pi
+
+Connexion:
+black (wind speed )     -> gpio21
+green (wind direction)  -> ADS1115 (module I2C) 
+Yellow                  -> 5v
+RED                     -> GND
+
+Attention:  The Raspberry Pi doesn't have analog inputs, so we need an analog-to-digital converter (ADC) to read the wind direction.
+
+sudo /usr/bin/python3 /var/www/nebuleair_pro_4g/windMeter/read_wind_direction.py
+
+'''
+import time
+import board
+import busio
+import adafruit_ads1x15.ads1115 as ADS
+from adafruit_ads1x15.analog_in import AnalogIn
+
+# Create the I2C bus and ADC object
+i2c = busio.I2C(board.SCL, board.SDA)
+ads = ADS.ADS1115(i2c)
+
+# Connect to the channel with your Davis wind vane
+wind_dir_sensor = AnalogIn(ads, ADS.P0)
+
+# Check the current voltage range
+min_voltage = 9999
+max_voltage = -9999
+
+def get_wind_direction():
+    """Get wind direction angle from Davis Vantage Pro2 wind vane"""
+    global min_voltage, max_voltage
+    
+    # Read voltage from ADS1115
+    voltage = wind_dir_sensor.voltage
+    
+    # Update min/max for calibration
+    if voltage < min_voltage:
+        min_voltage = voltage
+    if voltage > max_voltage:
+        max_voltage = voltage
+    
+    # We'll use a safer mapping approach
+    # Assuming the Davis sensor is linear from 0° to 360°
+    estimated_max = 3.859 # Initial estimate, will refine
+    
+    # Calculate angle with bounds checking
+    angle = (voltage / estimated_max) * 360.0
+    
+    # Ensure angle is in 0-360 range
+    angle = angle % 360
+    
+    return voltage, angle
+
+# Main loop
+try:
+    print("Reading wind direction. Press Ctrl+C to exit.")
+    print("Voltage, Angle, Min Voltage, Max Voltage")
+    while True:
+        voltage, angle = get_wind_direction()
+        print(f"{voltage:.3f}V, {angle:.1f}°, {min_voltage:.3f}V, {max_voltage:.3f}V")
+        time.sleep(1)
+except KeyboardInterrupt:
+    print("\nProgram stopped")
+    print(f"Observed voltage range: {min_voltage:.3f}V to {max_voltage:.3f}V")
+    
+    # Suggest calibration if we have enough data
+    if max_voltage > min_voltage:
+        print("\nSuggested calibration for your setup:")
+        print(f"max_voltage = {max_voltage:.3f}")
+        print(f"def get_wind_direction():")
+        print(f"    voltage = wind_dir_sensor.voltage")
+        print(f"    angle = (voltage / {max_voltage:.3f}) * 360.0")
+        print(f"    return angle % 360")

windMeter/read_wind_speed.py

@@ -0,0 +1,67 @@
+'''
+ __        _____ _   _ ____  
+ \ \      / /_ _| \ | |  _ \ 
+  \ \ /\ / / | ||  \| | | | |
+   \ V  V /  | || |\  | |_| |
+    \_/\_/  |___|_| \_|____/ 
+                             
+
+Script to read wind speed from a Davis Anémomètre-girouette Vantage Pro (6410)
+https://www.shapemaker.io/blog/wind-speed-measurements-with-anemometer-and-a-raspberry-pi
+
+Connexion:
+black (wind speed )     -> gpio21
+green (wind direction)  -> ADS1115 (module I2C) 
+Yellow                  -> 5v
+RED                     -> GND
+
+Attention:  The Raspberry Pi doesn't have analog inputs, so we need an analog-to-digital converter (ADC) to read the wind direction.
+
+sudo /usr/bin/python3 /var/www/nebuleair_pro_4g/windMeter/read_wind_speed.py
+
+'''
+
+
+import time
+from gpiozero import Button
+from signal import pause
+
+# Setup wind speed sensor on GPIO pin 21 (instead of 5)
+wind_speed_sensor = Button(21)
+wind_count = 0
+
+def spin():
+    global wind_count
+    wind_count = wind_count + 1
+
+def calc_speed(spins, interval):
+    # Davis anemometer formula: V = P*(2.25/T) in MPH
+    # P = pulses per sample period, T = sample period in seconds
+    wind_speed_mph = spins * (2.25 / interval)
+    return wind_speed_mph
+
+def reset_wind():
+    global wind_count
+    wind_count = 0
+
+# Register the event handler for the sensor
+wind_speed_sensor.when_pressed = spin
+
+try:
+    print("Wind speed measurement started. Press Ctrl+C to exit.")
+    
+    while True:
+        # Reset the counter
+        reset_wind()
+        
+        # Wait for 3 seconds and count rotations
+        print("Measuring for 3 seconds...")
+        time.sleep(3)
+        
+        # Calculate and display wind speed
+        wind_speed = calc_speed(wind_count, 3)
+        print(f"Wind count: {wind_count} spins")
+        print(f"Wind speed: {wind_speed:.2f} mph ({wind_speed * 1.60934:.2f} km/h)")
+        
+except KeyboardInterrupt:
+    print("\nMeasurement stopped by user")