Track reviewed status for discovered sensors

Changes: - Added 'reviewed' field to DiscoveredSensor dataclass - By default, only show new (unreviewed) pending sensors - Mark sensors as reviewed when shown in approval CLI - Add --all flag to show all pending sensors (including reviewed) - Add --ignored flag to show ignored sensors - Prevent repeatedly asking for approval of same sensor Usage: approve-sensors # Only new sensors approve-sensors --all # All pending sensors approve-sensors --ignored # Ignored sensors approve-sensors --all --ignored # Everything
Add standalone approve-sensors script
2025-12-27 20:33:14 +01:00 · 2025-12-27 20:28:36 +01:00 · 2025-12-27 15:03:19 +01:00 · 2025-12-27 14:54:52 +01:00 · 2025-12-27 14:30:21 +01:00 · 2025-12-27 14:22:22 +01:00
27 changed files with 3057 additions and 300 deletions
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -102,138 +102,70 @@ Using relative paths for portability across systems:
 ## Migration Phases
-### Phase 1: Preparation & Cleanup ✓ TODO
+### Phase 1: Preparation & Cleanup ✅ DONE (2025-12-27)
 **Goal**: Reorganize repository without breaking existing functionality
 **Notes**: 
 - Created modern Python package structure with src/ layout
 - Converted INI sensor config to JSON format (sensors.json.example)
 - Environment-based configuration instead of hardcoded values
 - DHT11 sensor functionality removed as planned
 - Legacy scripts preserved in legacy/ folder
 #### Tasks:
-1. Create new directory structure
+- ✅ Create new directory structure
-   ```bash
+- ✅ Create pyproject.toml with dependencies
-   mkdir -p src/sensorpajen
+- ✅ Remove DHT11 functionality
-   mkdir -p config
+- ✅ Move legacy scripts to legacy/ folder
-   mkdir -p legacy
+- ✅ Create config file templates (sensors.json.example, sensorpajen.env.example)
-   mkdir -p systemd
+- ✅ Preserve requirements.txt for backward compatibility
   mkdir -p debian
   ```
 2. Create pyproject.toml with dependencies:
   - bluepy
   - paho-mqtt
 3. Remove DHT11 functionality:
   - Delete temperatur_koksfonstret.py
   - Remove DHT11 cron job from documentation
   - Update README.md
 4. Move legacy scripts to legacy/ folder:
   - LYWSD03MMC.py
   - sendToMQTT.sh
   - startup.sh
   - sensorer.sh
   - sensorer.ini
   - bluetooth_utils.py
 5. Verify existing system still works with legacy scripts
 ---
-### Phase 2: Python Package Structure ✓ TODO
+### Phase 2: Python Package Structure ✅ DONE (2025-12-27)
 **Goal**: Create modern Python package with proper entry point
 **Notes**:
 - Used src/ layout for better packaging practices
 - Direct Python MQTT integration (no shell script callbacks)
 - ATC firmware BLE advertisement reading (passive scanning)
 - Watchdog thread for BLE connection recovery
 - Clean separation of concerns (config, MQTT, sensors, main)
 #### Tasks:
-1. Create `src/sensorpajen/__init__.py`
+- ✅ Created src/sensorpajen/__init__.py with version info
-   - Package initialization
+- ✅ Created src/sensorpajen/config.py
-   - Version information
+  - Environment variable loading with validation
-
+  - SensorConfig class for JSON sensor mapping
-2. Create `src/sensorpajen/config.py`
+  - Relative path resolution (PROJECT_ROOT)
-   - Environment variable loading
+  - Configuration validation and logging
-   - Configuration validation
+- ✅ Created src/sensorpajen/utils.py
-   - Default values
+  - Ported bluetooth_utils.py (MIT licensed, Colin GUYON)
-   - Fail-fast on missing required config
+  - BLE scanning and advertisement parsing
-   ```python
+- ✅ Created src/sensorpajen/mqtt_publisher.py
-   import os
+  - MQTTPublisher class with connection management
-   import json
+  - Direct publishing (replaces sendToMQTT.sh)
-   from pathlib import Path
+  - Automatic reconnection support
-
+  - Battery data publishing (optional)
-   # MQTT Configuration from environment
+- ✅ Created src/sensorpajen/sensor_reader.py
-   MQTT_HOST = os.environ.get("MQTT_HOST")
+  - SensorReader class for BLE scanning
-   MQTT_PORT = int(os.environ.get("MQTT_PORT", "1883"))
+  - ATC packet parsing
-   MQTT_USER = os.environ.get("MQTT_USER")
+  - Duplicate packet filtering
-   MQTT_PASSWORD = os.environ.get("MQTT_PASSWORD")
+  - Watchdog for BLE recovery
-   MQTT_CLIENT_ID = os.environ.get("MQTT_CLIENT_ID", "sensorpajen")
+  - Measurement dataclass
-   
+- ✅ Created src/sensorpajen/main.py
-   # Validate required config
+  - Application entry point
-   if not MQTT_HOST:
+  - Signal handling (SIGTERM, SIGINT)
-       raise RuntimeError("MQTT_HOST environment variable must be set")
+  - Graceful shutdown
-    (relative to project root)
+  - Logging to stdout for journald
   PROJECT_ROOT = Path(__file__).parent.parent.parent
   SENSOR_CONFIG_FILE = os.environ.get(
       "SENSOR_CONFIG_FILE",
       str(PROJECT_ROOT / "config
       str(Path.home() / ".config/sensorpajen/sensors.json")
   )
   # Bluetooth settings
   WATCHDOG_TIMEOUT = int(os.environ.get("WATCHDOG_TIMEOUT", "5"))
   ENABLE_BATTERY = os.environ.get("ENABLE_BATTERY", "true").lower() == "true"
   ```
 3. Create `src/sensorpajen/utils.py`
   - Port bluetooth_utils.py functionality
   - Clean up and modernize
 4. Create `src/sensorpajen/sensor_reader.py`
   - Extract sensor reading logic from LYWSD03MMC.py
   - Remove callback/shell script dependency
   - Direct Python MQTT integration
 5. Create `src/sensorpajen/mqtt_publisher.py`
   - MQTT client setup and connection
   - Publishing logic (replacing sendToMQTT.sh)
   - Error handling and reconnection
 6. Create `src/sensorpajen/main.py`
   - Entry point for the application
   - Signal handling (SIGTERM, SIGINT)
   - Logging setup (to stdout for journald)
   - Main loop
   ```python
   #!/usr/bin/env python3
   import logging
   import signal
   import sys
   from . import config
   from .sensor_reader import SensorReader
   from .mqtt_publisher import MQTTPublisher
   def main():
       logging.basicConfig(
           level=logging.INFO,
           format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
           stream=sys.stdout
       )
       logger = logging.getLogger(__name__)
       logger.info("Starting sensorpajen service")
       # Setup signal handlers
       def signal_handler(sig, frame):
           logger.info("Received shutdown signal")
           sys.exit(0)
       signal.signal(signal.SIGTERM, signal_handler)
       signal.signal(signal.SIGINT, signal_handler)
       # Main application logic here
       # ...
   if __name__ == "__main__":
       main()
   ```
 ---
-### Phase 3: Configuration Migration ✓ TODO
+### Phase 3: Configuration Migration ✅ DONE (2025-12-27)
 **Goal**: Replace .ini file with JSON and environment variables
 **Notes**: Templates created in Phase 1, successfully tested on Raspberry Pi
 #### Tasks:
 1. Create sensor mapping converter script
   - Read sensorer.ini
@@ -304,9 +236,11 @@ config/sensorpajen.env
   debian/files
   debian/*.log
   debian/*.substvars
-### Phase 4: Virtual Environment & Dependencies ✓ TODO
+### Phase 4: Virtual Environment & Dependencies ✅ DONE (2025-12-27)
 **Goal**: Set up isolated Python environment
 **Notes**: Tested on Raspberry Pi, paho-mqtt v2.x compatibility fixed
 #### Tasks:
 1. Create virtual environment:
   ```bash
@@ -332,97 +266,62 @@ config/sensorpajen.env
 4. Document virtual environment usage in README
---
+---✅ DONE (2025-12-27)
 ### Phase 5: Bluetooth Permissions ✓ TODO
 **Goal**: Allow non-root user to access Bluetooth
 **Notes**: Tested on Raspberry Pi with setcap on actual Python binary
 ### Phase 5: Bluetooth Permissions ✅ DONE (2025-12-27)
 **Goal**: Allow non-root user to access Bluetooth
 **Notes**: Tested on Raspberry Pi with setcap on actual Python binary
 #### Tasks:
-1. Add user to bluetooth group:
+- ✅ Bluetooth capabilities set with setcap
-   ```bash
+- ✅ Documented in SETUP_ON_PI.md with correct readlink -f usage
-   sudo usermod -a -G bluetooth fredrik
+- ✅ Tested successfully on Raspberry Pi
   ```
 2. Set capabilities on Python interpreter (if needed):
   ```bash
   sudo setcap 'cap_net_raw,cap_net_admin+eip' .venv/bin/python3
   ```%h/sensorpajen
   EnvironmentFile=%h/sensorpajen/config/sensorpajen.env
   ExecStart=%h/sensorpajen/.venv/bin/python -m sensorpajen.main
   Restart=always
   RestartSec=10
   # Bluetooth capabilities
   AmbientCapabilities=CAP_NET_RAW CAP_NET_ADMIN
   # Logging
   StandardOutput=journal
   StandardError=journal
   SyslogIdentifier=sensorpajen
   [Install]
   WantedBy=default.target
   ```
   Note: `%h` expands to the user's home directorycription=Sensorpajen - Bluetooth Temperature Sensor Monitor
   After=network.target bluetooth.target
   Wants=bluetooth.target
   [Service]
   Type=simple
   WorkingDirectory=/home/fredrik/dev/sensorpajen
   EnvironmentFile=/home/fredrik/.config/sensorpajen/sensorpajen.env
   ExecStart=/home/fredrik/dev/sensorpajen/.venv/bin/python -m sensorpajen.main
   Restart=always
   RestartSec=10
   # Bluetooth capabilities
   AmbientCapabilities=CAP_NET_RAW CAP_NET_ADMIN
   # Logging
   StandardOutput=journal
   StandardError=journal
   SyslogIdentifier=sensorpajen
   [Install]
   WantedBy=default.target
   ```
 2. Install service (user service):
   ```bash
   mkdir -p ~/.config/systemd/user/
   cp systemd/sensorpajen.service ~/.config/systemd/user/
   systemctl --user daemon-reload
   ```
 3. Enable lingering (service runs without login):
   ```bash
   sudo loginctl enable-linger fredrik
   ```
 4. Document systemd commands in README
 ---
-### Phase 7: Testing & Validation ✓ TODO
+### Phase 6: Systemd Service Creation ✅ DONE (2025-12-27)
-**Goal**: Verify new service works before removing legacy
+**Goal**: Create and configure systemd user service
 **Notes**:
 - User service for easier management (no sudo required)
 - Service ready for installation on Raspberry Pi
 - Comprehensive documentation provided
 - **Important discoveries**:
  - `AmbientCapabilities` does NOT work in user services (only system services)
  - Must use `setcap` on the Python binary instead
  - `NoNewPrivileges=true` prevents file capabilities from working - must be disabled
  - Capabilities must be set on actual binary, not symlinks: `setcap ... $(readlink -f python3)`
 #### Tasks:
-1. Stop legacy cron/tmux processes:
+- ✅ Created systemd/sensorpajen.service
-   ```bash
+- ✅ Created systemd/README.md with full documentation
-   crontab -e  # Comment out sensorpajen entries
+- ✅ Service management and troubleshooting guides included
-   tmux kill-session -t sensorer
+- ✅ Tested and verified working on Raspberry Pi
   ```
-2. Start new service:
+---
   ```bash
   systemctl --user start sensorpajen
   ```
-3. Monitor logs:
+### Phase 7: Testing & Validation ✅ DONE (2025-12-27)
-   ```bash
+**Goal**: Verify new service works before removing legacy
-   journalctl --user -u sensorpajen -f
+
-   ```APT Package Creation ✓ TODO
+**Notes**:
 - Service tested and running successfully
 - Legacy cron/tmux system stopped
 - All sensors reporting correctly via systemd service
 #### Tasks:
 - ✅ Stopped legacy cron/tmux processes
 - ✅ Started new systemd service
 - ✅ Monitored logs - no errors
 - ✅ Verified all 8 sensors reporting
 - ✅ Confirmed MQTT publishing working
 - ✅ Tested service restart and auto-recovery
 ---
 ### Phase 8: APT Package Creation ✓ TODO
 **Goal**: Create Debian package for easy installation on Raspberry Pi
 #### Tasks:
@@ -561,35 +460,7 @@ When installed via .deb package:
 ---
-### Phase 9: 
+### Phase 9: Cleanup & Documentation ✓ TODO
 4. Verify MQTT messages:
   ```bash
   mosquitto_sub -h 192.168.0.114 -u hasse -P casablanca -t "MiTemperature2/#" -v
   ```
 5. Test service restart:
   ```bash
   systemctl --user restart sensorpajen
   ```
 6. Test crash recovery (kill process, verify auto-restart)
 7. Test boot behavior:
   ```bash
   systemctl --user enable sensorpajen
   sudo reboot
   # After reboot, verify service is running
   systemctl --user status sensorpajen
   ```
 ---
 ### Phase 8: Cleanup & Document
 - [ ] Publish APT package to personal repository
 - [ ] Create automated build pipeline for .deb packages
 - [ ] Add support for multiple MQTT brokers
 - [ ] Implement configuration validation toolation ✓ TODO
 **Goal**: Remove legacy code and finalize documentation
 #### Tasks:
--- a/SETUP_ON_PI.md
+++ b/SETUP_ON_PI.md
@@ -0,0 +1,180 @@
 # Setup on Raspberry Pi - Testing Guide
 ## Prerequisites
 - Raspberry Pi with Bluetooth support
 - Raspberry Pi OS (Debian-based)
 - Git repository access
 - MQTT broker accessible from the Pi
 ## Quick Setup Steps
 ### 1. Pull Latest Changes
 ```bash
 cd ~/sensorpajen  # or wherever your repo is
 git pull origin master
 ```
 ### 2. Install System Dependencies
 ```bash
 # Install Bluetooth and build tools
 sudo apt update
 sudo apt install -y bluetooth bluez libbluetooth-dev python3-dev python3-pip python3-venv
 # Verify Bluetooth is working
 sudo systemctl status bluetooth
 ```
 ### 3. Create Virtual Environment
 ```bash
 cd ~/sensorpajen
 python3 -m venv .venv
 source .venv/bin/activate
 ```
 ### 4. Install Python Dependencies
 ```bash
 pip install --upgrade pip
 pip install pybluez bluepy paho-mqtt
 # Or install the package in development mode
 pip install -e .
 ```
 ### 5. Set Bluetooth Capabilities
 This allows Python to access Bluetooth without sudo:
 ```bash
 # Set capabilities on the actual Python binary (not the symlink)
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f .venv/bin/python3)
 # Verify it was set correctly
 getcap $(readlink -f .venv/bin/python3)
 # Should show: cap_net_raw,cap_net_admin+eip
 ```
 ### 6. Configure the Application
 ```bash
 # Copy configuration templates
 cp config/sensorpajen.env.example config/sensorpajen.env
 cp config/sensors.json.example config/sensors.json
 # Edit MQTT settings
 nano config/sensorpajen.env
 # Update MQTT_HOST, MQTT_USER, MQTT_PASSWORD
 # Verify/edit sensor list
 nano config/sensors.json
 # Should already have your 8 sensors from legacy config
 ```
 ### 7. Test Run
 ```bash
 # Make sure virtual environment is activated
 source .venv/bin/activate
 # Load environment variables
 export $(cat config/sensorpajen.env | grep -v '^#' | xargs)
 # Run the application
 python -m sensorpajen.main
 ```
 You should see:
 - Configuration being loaded
 - MQTT connection established
 - BLE scanning started
 - Sensor readings as they come in
 Press Ctrl+C to stop.
 ## Troubleshooting
 ### Bluetooth Permission Issues
 If you get permission errors:
 ```bash
 # Check if capabilities are set
 getcap $(readlink -f .venv/bin/python3)
 # If not set, run:
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f .venv/bin/python3)
 # Verify Bluetooth device is up
 sudo hciconfig hci0 up
 ```
 ### MQTT Connection Issues
 ```bash
 # Test MQTT connection
 mosquitto_sub -h 10.0.0.114 -u hasse -P casablanca -t "MiTemperature2/#" -v
 # Check if broker is accessible
 ping 192.168.0.114  # or your MQTT broker IP
 ```
 ### No Sensor Data
 ```bash
 # Check if sensors are in range and broadcasting
 sudo hcitool lescan
 # Check logs for specific errors
 python -m sensorpajen.main 2>&1 | tee test.log
 ```
 ### BluePy Installation Issues
 If bluepy fails to install:
 ```bash
 sudo apt install -y libglib2.0-dev
 pip install --no-cache-dir bluepy
 ```
 ## Environment Variables Reference
 Copy from `config/sensorpajen.env.example` and modify:
 ```bash
 # Required
 MQTT_HOST=192.168.0.114          # Your MQTT broker IP
 MQTT_USER=hasse                   # MQTT username
 MQTT_PASSWORD=casablanca          # MQTT password
 # Optional
 MQTT_PORT=1883                    # Default MQTT port
 MQTT_CLIENT_ID=mibridge          # Client identifier
 MQTT_TOPIC_PREFIX=MiTemperature2 # MQTT topic prefix
 # Application settings
 SENSOR_CONFIG_FILE=config/sensors.json  # Sensor config file
 WATCHDOG_TIMEOUT=5                # BLE watchdog timeout (seconds)
 ENABLE_BATTERY=true               # Include battery data
 LOG_LEVEL=INFO                    # DEBUG, INFO, WARNING, ERROR
 ```
 ## Viewing Logs
 ```bash
 # While running in terminal, logs go to stdout
 python -m sensorpajen.main
 # To save logs to file
 python -m sensorpajen.main 2>&1 | tee sensorpajen.log
 ```
 ## Next Steps
 Once testing is successful:
 1. Continue to Phase 4-6 in ROADMAP.md to set up systemd service
 2. Service will run automatically on boot
 3. Logs will be available via `journalctl --user -u sensorpajen`
 ## Returning to Development Machine
 All changes can be committed on the Pi and pushed back:
 ```bash
 # On Raspberry Pi
 git add -A
 git commit -m "Your changes"
 git push origin master
 # On development machine
 git pull origin master
 ```
 The development workflow works seamlessly from either machine!
--- a/TASKS.md
+++ b/TASKS.md
@@ -0,0 +1,271 @@
 # Tasks
 ## Task: Add Auto-Discovery and Approval Flow for Sensors
 ### Problem Statement
 Adding new sensors currently requires manually editing `sensors.json`, which is error-prone and inconvenient.
 The system should automatically detect new sensors and provide a controlled way for users to approve or ignore them.
 ---
 ## Goal
 Implement **automatic sensor discovery** with a **user approval workflow** that:
 * Detects new sensors automatically
 * Notifies the user when new sensors are discovered
 * Allows the user to approve or ignore sensors via a script
 * Automatically updates `sensors.json` for approved sensors
 * Restarts the service after configuration changes
 ---
 ## Scope
 ### In Scope
 * Sensor auto-discovery
 * Tracking newly discovered sensors
 * Notification via `ntfy`
 * Interactive user script for approving/ignoring sensors
 * Updating `sensors.json`
 * Restarting the service via systemd
 ### Out of Scope
 * Web UI
 * Authentication mechanisms beyond existing system access
 * Changes to sensor hardware or firmware
 * Long-term sensor management (removal, editing, etc.)
 ---
 ## Functional Requirements
 ### 1. Sensor Auto-Discovery
 * The service must detect sensors that are not present in `sensors.json`
 * Each newly discovered sensor must have a stable unique identifier
 * Discovered-but-unapproved sensors must **not** be added automatically
 ---
 ### 2. Discovered Sensor Storage
 * Newly discovered sensors must be stored in `config/discovered_sensors.json`
 * Stored data must include:
  * `mac` - MAC address (unique identifier)
  * `name` - Advertised device name (e.g., "ATC_1234AB")
  * `rssi` - Signal strength in dBm
  * `first_seen` - ISO timestamp of first discovery
  * `last_seen` - ISO timestamp of most recent advertisement
  * `sample_reading` - One example reading with temperature, humidity, battery data
  * `status` - One of: "pending", "approved", "ignored"
  * `ignored_at` - ISO timestamp when ignored (if status is "ignored")
  * `ignore_reason` - Optional user-provided reason for ignoring
 * Approved sensors must have their status updated to "approved"
 * Ignored sensors must remain in the file with status "ignored"
 ---
 ### 3. Notification via ntfy
 * When a new sensor is discovered:
  * Send a notification to the configured `ntfy` topic via curl
  * Include at least:
    * Sensor MAC address
    * Sensor name
    * Last seen timestamp
    * Instruction that user action is required
 * Configuration (in `config/sensorpajen.env`):
  * `NTFY_ENABLED` - true/false to enable/disable notifications
  * `NTFY_URL` - ntfy server URL (e.g., "https://ntfy.sh")
  * `NTFY_TOPIC` - Topic to publish to
  * `NTFY_TOKEN` - Authentication token (sent in header)
 * ntfy is optional - system must work without it:
  * If `NTFY_ENABLED=false`, skip notifications
  * If ntfy is unreachable, log error and continue
  * Discovery and approval must work even if ntfy fails
 * The user must only be notified once per discovered sensor
 ---
 ### 4. User Approval Script
 Provide a CLI command `sensorpajen approve-sensors` that:
 * Lists all sensors with status "pending" or "ignored"
 * For each sensor, displays:
  * MAC address
  * Advertised name (e.g., "ATC_1234AB")
  * Last seen timestamp
  * Sample reading (temperature, humidity, battery)
  * Current status (pending/ignored)
 * For each sensor, allows the user to:
  * Approve the sensor (add to `sensors.json`)
  * Ignore the sensor (mark as ignored)
  * Skip (leave as pending for later)
 * If approving:
  * Prompt for a sensor name (required, human-readable)
  * Pre-fill comment field with extended metadata (MAC, device name, last seen, sample reading)
  * Allow user to edit or keep the pre-filled comment (optional)
 * If ignoring:
  * Prompt for optional reason
  * Update status to "ignored" with timestamp
 * Interactive mode only (no batch/automated approval)
 ---
 ### 5. Updating sensors.json
 * When a sensor is approved:
  * Add it to `sensors.json` (only if MAC doesn't already exist)
  * Include:
    * `mac` - MAC address from discovery
    * `name` - User-provided human-readable name
    * `comment` - User-edited comment (pre-filled with metadata)
 * The file must remain valid JSON
 * Existing sensors must not be modified
 * If MAC already exists in `sensors.json`, skip adding (renaming is done manually in the file)
 * Update status to "approved" in `discovered_sensors.json`
 ---
 ### 6. Configuration Reload
 * The service must automatically reload `sensors.json` every 15 minutes
 * No service restart required after approval
 * If `sensors.json` is modified:
  * Load new sensor list
  * Start monitoring newly added sensors
  * Continue monitoring existing sensors without interruption
 * Log configuration reload events
 ---
 ## Non-Functional Requirements
 * Must be safe to run on a Raspberry Pi
 * Must not require a GUI
 * Must fail gracefully if:
  * `ntfy` is unreachable
  * The user aborts the approval script
 * Logging must clearly indicate:
  * Discovery events
  * Notifications sent
  * Approval or ignore decisions
 ---
 ## Acceptance Criteria
 * A new sensor is automatically detected and added to `discovered_sensors.json` with status "pending"
 * Extended metadata (MAC, name, RSSI, timestamps, sample reading) is stored
 * A notification is sent via `ntfy` when a sensor is discovered (if enabled)
 * The approval CLI command (`sensorpajen approve-sensors`) lists pending and ignored sensors
 * The CLI displays MAC, name, last seen, and sample reading for each sensor
 * The user can approve a sensor with a custom name
 * The comment field is pre-filled with metadata and user can edit it
 * The user can ignore a sensor with an optional reason
 * Previously ignored sensors can be approved in a later CLI run
 * Approved sensors appear correctly in `sensors.json` (mac + name + comment only)
 * Sensors already in `sensors.json` are not added again (no duplicates)
 * The service automatically reloads `sensors.json` every 15 minutes
 * New sensors are monitored without service restart
 * Ignored sensors are stored with `ignored_at` timestamp and optional `ignore_reason`
 * ntfy failures do not prevent discovery or approval workflow
 ---
 ## Notes for Implementation
 * Prefer environment-based configuration (no `.ini` files)
 * Keep the discovery logic separate from user interaction logic
 * Avoid race conditions between discovery and approval
 * Assume multiple sensors may be discovered before user action
 * Use MAC address as unique identifier for sensors
 * ntfy notification format: `curl -H "Authorization: Bearer $NTFY_TOKEN" -d "message" $NTFY_URL/$NTFY_TOPIC`
 * Config reload: Use a timer thread that checks file mtime or reloads every 15 minutes
 * Pre-filled comment example: `"MAC: A4:C1:38:12:34:56, Name: ATC_1234AB, Last seen: 2025-12-27T14:30:00, Temp: 21.5°C, Humidity: 45%, Battery: 87%"`
 ---
 ## Implementation Details
 ### File Locations
 * Discovered sensors: `config/discovered_sensors.json`
 * Known sensors: `config/sensors.json` (existing)
 * Configuration: `config/sensorpajen.env` (add ntfy settings)
 ### New CLI Command
 * Entry point: `sensorpajen approve-sensors`
 * Add to `pyproject.toml` under `[project.scripts]`
 ### Configuration Variables (add to sensorpajen.env)
 ```bash
 # ntfy notifications (optional)
 NTFY_ENABLED=true
 NTFY_URL=https://ntfy.sh
 NTFY_TOPIC=sensorpajen
 NTFY_TOKEN=tk_xxxxxxxxxxxxx
 # Config reload interval (seconds)
 CONFIG_RELOAD_INTERVAL=900  # 15 minutes
 ```
 ### discovered_sensors.json Structure
 ```json
 [
  {
    "mac": "A4:C1:38:12:34:56",
    "name": "ATC_1234AB",
    "rssi": -65,
    "first_seen": "2025-12-27T14:30:15",
    "last_seen": "2025-12-27T14:35:42",
    "sample_reading": {
      "temperature": 21.5,
      "humidity": 45,
      "battery_percent": 87,
      "battery_voltage": 2950
    },
    "status": "pending"
  },
  {
    "mac": "A4:C1:38:AB:CD:EF",
    "name": "ATC_ABCDEF",
    "rssi": -72,
    "first_seen": "2025-12-27T15:00:00",
    "last_seen": "2025-12-27T15:10:00",
    "sample_reading": {
      "temperature": 19.8,
      "humidity": 52,
      "battery_percent": 65,
      "battery_voltage": 2800
    },
    "status": "ignored",
    "ignored_at": "2025-12-27T15:15:00",
    "ignore_reason": "Test sensor, not needed"
  }
 ]
 ```
 ### sensors.json Entry (after approval)
 ```json
 {
  "mac": "A4:C1:38:12:34:56",
  "name": "Living Room",
  "comment": "MAC: A4:C1:38:12:34:56, Name: ATC_1234AB, Last seen: 2025-12-27T14:35:42, Temp: 21.5°C, Humidity: 45%, Battery: 87%"
 }
 ```
 ---
 If you want, I can also:
 * Split this into **multiple smaller tasks**
 * Add a **definition of done** section
 * Provide a **suggested file/module structure**
 * Write a **follow-up roadmap entry** for sensor management
 Just tell me how you want to evolve it next.
--- a/1
+++ b/1
@@ -0,0 +1 @@
 2.0.0-dev
--- a/config/discovered_sensors.json.example
+++ b/config/discovered_sensors.json.example
@@ -0,0 +1,32 @@
 [
  {
    "mac": "A4:C1:38:12:34:56",
    "name": "ATC_123456",
    "rssi": -65,
    "first_seen": "2025-12-27T10:30:15",
    "last_seen": "2025-12-27T10:35:42",
    "sample_reading": {
      "temperature": 21.5,
      "humidity": 45,
      "battery_percent": 87,
      "battery_voltage": 2950
    },
    "status": "pending"
  },
  {
    "mac": "A4:C1:38:AB:CD:EF",
    "name": "ATC_ABCDEF",
    "rssi": -72,
    "first_seen": "2025-12-27T11:00:00",
    "last_seen": "2025-12-27T11:10:00",
    "sample_reading": {
      "temperature": 19.8,
      "humidity": 52,
      "battery_percent": 65,
      "battery_voltage": 2800
    },
    "status": "ignored",
    "ignored_at": "2025-12-27T11:15:00",
    "ignore_reason": "Test sensor, not needed"
  }
 ]
--- a/config/sensorpajen.env.example
+++ b/config/sensorpajen.env.example
@@ -0,0 +1,22 @@
 # MQTT Configuration
 MQTT_HOST=192.168.0.114
 MQTT_PORT=1883
 MQTT_USER=hasse
 MQTT_PASSWORD=casablanca
 MQTT_CLIENT_ID=mibridge
 # Sensor Configuration (relative to project root)
 SENSOR_CONFIG_FILE=config/sensors.json
 DISCOVERED_SENSORS_FILE=config/discovered_sensors.json
 # Application Settings
 WATCHDOG_TIMEOUT=5
 ENABLE_BATTERY=true
 LOG_LEVEL=INFO
 CONFIG_RELOAD_INTERVAL=900  # 15 minutes in seconds
 # ntfy Notifications (optional)
 NTFY_ENABLED=false
 NTFY_URL=https://ntfy.sh
 NTFY_TOPIC=sensorpajen
 NTFY_TOKEN=
--- a/config/sensors.json.example
+++ b/config/sensors.json.example
@@ -0,0 +1,37 @@
 {
  "sensors": [
    {
      "mac": "A4:C1:38:98:7B:B6",
      "name": "mi_temp_1",
      "comment": "Example sensor - replace with your sensors"
    },
    {
      "mac": "A4:C1:38:29:03:0D",
      "name": "mi_temp_2"
    },
    {
      "mac": "A4:C1:38:62:CA:83",
      "name": "mi_temp_3"
    },
    {
      "mac": "A4:C1:38:D5:EA:63",
      "name": "mi_temp_4"
    },
    {
      "mac": "A4:C1:38:7C:9C:63",
      "name": "mi_temp_5"
    },
    {
      "mac": "A4:C1:38:68:2C:DA",
      "name": "mi_temp_6"
    },
    {
      "mac": "A4:C1:38:AD:74:2B",
      "name": "mi_temp_7"
    },
    {
      "mac": "A4:C1:38:46:9F:D1",
      "name": "mi_temp_8"
    }
  ]
 }
--- a/legacy/LYWSD03MMC.py
+++ b/legacy/LYWSD03MMC.py
--- a/legacy/bluetooth_utils.py
+++ b/legacy/bluetooth_utils.py
--- a/legacy/sendToMQTT.sh
+++ b/legacy/sendToMQTT.sh
--- a/legacy/sensorer.ini
+++ b/legacy/sensorer.ini
--- a/legacy/sensorer.sh
+++ b/legacy/sensorer.sh
--- a/legacy/startup.sh
+++ b/legacy/startup.sh
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -0,0 +1,64 @@
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "sensorpajen"
 version = "2.0.0-dev"
 description = "Bluetooth temperature sensor monitor for Xiaomi Mijia LYWSD03MMC"
 readme = "README.md"
 requires-python = ">=3.9"
 license = {text = "MIT"}
 authors = [
    {name = "Fredrik", email = "your@email.com"}
 ]
 keywords = ["bluetooth", "temperature", "sensor", "mqtt", "raspberry-pi"]
 classifiers = [
    "Development Status :: 4 - Beta",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.9",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
    "Operating System :: POSIX :: Linux",
    "Topic :: Home Automation",
 ]
 dependencies = [
    "bluepy>=1.3.0",
    "paho-mqtt>=1.6.0",
 ]
 [project.optional-dependencies]
 dev = [
    "pytest>=7.0",
    "pytest-cov>=4.0",
    "black>=23.0",
    "ruff>=0.1.0",
 ]
 [project.urls]
 Homepage = "https://github.com/yourusername/sensorpajen"
 Repository = "https://github.com/yourusername/sensorpajen"
 [project.scripts]
 sensorpajen = "sensorpajen.main:main"
 sensorpajen-approve-sensors = "sensorpajen.approve_sensors:main"
 [tool.setuptools.packages.find]
 where = ["src"]
 [tool.black]
 line-length = 100
 target-version = ["py39", "py310", "py311"]
 [tool.ruff]
 line-length = 100
 target-version = "py39"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
--- a/readme.md
+++ b/readme.md
@@ -1,33 +1,241 @@
 # Sensorpajen
 Raspberry Pi Zero W som läser av diverse mätere och rapporterar data till MQTT.
 Använder Xiaomi Mijia thermometer 2 samt inbyggd DHT11 sensor
-## Bluetooth termometrarna 
+Raspberry Pi service that monitors Xiaomi Mijia LYWSD03MMC Bluetooth temperature sensors and publishes data to MQTT.
 - LYWSD03MMC.py - script för att läsa av Mi Mijia Thermometer 2
 - sensorer.ini - config till LYWSD03MMC
 - sendToMQTT.sh - stödscript till LYWSD03MMC
 - bluetooth_utils.py - stödscript till LYWSD03MMC
-## Sensorer i pajen
+## Features
- - temperatur_koksfonstret.py - Läser av DHT 11 sensor kopplad till Pi, används av cron
+
- - sensorer.sh - script för att starta tmux vid boot, används av cron
+- 🌡️ Monitors 8 Xiaomi Mijia thermometers via Bluetooth (ATC firmware)
- 
+- 📡 Publishes temperature, humidity, and battery data to MQTT
-## Cronjobb 
+- 🔄 Automatic restart on failure
-```
+- 📊 Systemd service with journald logging
-@reboot /home/pi/sensorer.sh
+- 🔧 Modern Python package with virtual environment
-*/1 * * * * /home/pi/temperatur_koksfonstret.py 11 4
+- ⚙️ Configuration via environment variables and JSON
 ## Requirements
 - Raspberry Pi (tested on Raspberry Pi Zero W and newer)
 - Raspberry Pi OS (Debian-based)
 - Python 3.9+
 - Bluetooth adapter
 - MQTT broker
 - Xiaomi Mijia LYWSD03MMC sensors with ATC firmware
 ## Installation
 See [SETUP_ON_PI.md](SETUP_ON_PI.md) for complete installation instructions.
 ### Quick Start
 ```bash
 # Clone repository
 git clone <repo-url> ~/sensorpajen
 cd ~/sensorpajen
 # Create and activate virtual environment
 python3 -m venv .venv
 source .venv/bin/activate
 # Install dependencies
 pip install -e .
 # Configure
 cp config/sensorpajen.env.example config/sensorpajen.env
 cp config/sensors.json.example config/sensors.json
 nano config/sensorpajen.env  # Edit MQTT settings
 nano config/sensors.json     # Edit sensor MAC addresses
 # Set Bluetooth capabilities
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f .venv/bin/python3)
 # Install systemd service
 mkdir -p ~/.config/systemd/user/
 cp systemd/sensorpajen.service ~/.config/systemd/user/
 systemctl --user daemon-reload
 sudo loginctl enable-linger $USER
 # Start service
 systemctl --user enable sensorpajen
 systemctl --user start sensorpajen
 # Check status
 systemctl --user status sensorpajen
 journalctl --user -u sensorpajen -f
 ```
-## Flasha nya termometrar
+## Configuration
-  - Öppna och flasha bara en termometer i taget!!
+### MQTT Settings
  - Ha en permanent marker tillgänglig
  - Flashning måste göras från en mobil
-  1. Ta reda på termometerns mac-adress med någon bra app för Bluetooth BLE . Den heter något i stil med LYWSD03MMC (Om du bara startat en termometer så är det lätt att hitta)
+Edit `config/sensorpajen.env`:
-  2. Ladda ned senaste releasen av firmware här: https://github.com/atc1441/ATC_MiThermometer
+
-  3. Öppna den här webbsidan: https://atc1441.github.io/TelinkFlasher.html
+```bash
-  4. Tryck på Connect och sök upp den aktiva termometern. Den heter något i stil med LYWSD03MMC
+MQTT_HOST=192.168.1.10
-  5. Gör Do Activation och när den hittat Select Firmarware Start Flashing
+MQTT_PORT=1883
-  6. Anteckna mac-adressen från (1) och sätt ett id på termometern. Det ska senare in i filen sensorer.ini
+MQTT_USERNAME=username
-  7. Verifiera i din BLE läsare att termometern nu heter något i stil med ATC_XXXXXX. Om du missade att anteckna mac-adressen så är första delen alltid A4:C1:38 och XXXXXX i namnet är de sista tre delarna
+MQTT_PASSWORD=password
 MQTT_CLIENT_ID=sensorpajen
 MQTT_TOPIC_PREFIX=MiTemperature2
 ```
 ### Sensors
 Edit `config/sensors.json`:
 ```json
 [
  {
    "mac": "A4:C1:38:12:34:56",
    "name": "Living Room"
  },
  {
    "mac": "A4:C1:38:AB:CD:EF",
    "name": "Bedroom"
  }
 ]
 ```
 ## Service Management
 See [systemd/README.md](systemd/README.md) for detailed service management instructions.
 ```bash
 # Start/stop service
 systemctl --user start sensorpajen
 systemctl --user stop sensorpajen
 # Enable/disable autostart
 systemctl --user enable sensorpajen
 systemctl --user disable sensorpajen
 # View status
 systemctl --user status sensorpajen
 # View logs
 journalctl --user -u sensorpajen -f
 journalctl --user -u sensorpajen -n 100
 ```
 ## Flashing New Thermometers
 **Important**: Flash only one thermometer at a time!
 1. **Find MAC address**: Use a Bluetooth BLE app to find the thermometer's MAC address. It will appear as `LYWSD03MMC`.
 2. **Download firmware**: Get the latest ATC firmware from https://github.com/atc1441/ATC_MiThermometer
 3. **Flash firmware**:
   - Open https://atc1441.github.io/TelinkFlasher.html on your phone
   - Click "Connect" and select your thermometer (LYWSD03MMC)
   - Click "Do Activation"
   - When found, select firmware and click "Start Flashing"
 4. **Record MAC address**: Note the MAC address (from step 1) and label the thermometer physically with a permanent marker.
 5. **Add to configuration**: Add the MAC address and name to `config/sensors.json`
 6. **Verify**: The thermometer should now appear as `ATC_XXXXXX` where XXXXXX are the last 3 bytes of the MAC address. MAC addresses always start with `A4:C1:38`.
 ## Project Structure
 ```
 sensorpajen/
 ├── src/sensorpajen/         # Python package
 │   ├── main.py              # Application entry point
 │   ├── config.py            # Configuration management
 │   ├── mqtt_publisher.py    # MQTT client wrapper
 │   ├── sensor_reader.py     # Bluetooth sensor reader
 │   └── utils.py             # Bluetooth utilities
 ├── config/                  # Configuration files
 │   ├── sensorpajen.env.example
 │   └── sensors.json.example
 ├── systemd/                 # Systemd service files
 │   ├── sensorpajen.service
 │   └── README.md
 ├── legacy/                  # Old scripts (deprecated)
 ├── pyproject.toml          # Python package configuration
 └── README.md               # This file
 ```
 ## Troubleshooting
 ### Permission Denied Errors
 If you see `PermissionError: [Errno 1] Operation not permitted`:
 ```bash
 # Verify capabilities are set
 getcap $(readlink -f ~/sensorpajen/.venv/bin/python3)
 # Should show: cap_net_admin,cap_net_raw+eip
 # If not, set them:
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f ~/sensorpajen/.venv/bin/python3)
 # Restart service
 systemctl --user restart sensorpajen
 ```
 ### Service Won't Start
 ```bash
 # Check service status
 systemctl --user status sensorpajen
 # View logs
 journalctl --user -u sensorpajen -n 50
 # Common issues:
 # - Missing config files (check config/ directory)
 # - Wrong MQTT credentials (check config/sensorpajen.env)
 # - Bluetooth not enabled (sudo systemctl start bluetooth)
 ```
 ### MQTT Connection Issues
 ```bash
 # Test MQTT connection
 mosquitto_sub -h <MQTT_HOST> -u <USERNAME> -P <PASSWORD> -t "MiTemperature2/#" -v
 # Check logs for connection errors
 journalctl --user -u sensorpajen | grep -i mqtt
 ```
 ### No Sensor Data
 ```bash
 # Check if sensors are visible
 sudo hcitool lescan
 # Verify sensor MAC addresses in config/sensors.json
 # Make sure sensors have ATC firmware flashed
 # Check battery level (low battery can cause connection issues)
 ```
 ## Development
 ```bash
 # Clone and setup
 git clone <repo-url> ~/sensorpajen
 cd ~/sensorpajen
 python3 -m venv .venv
 source .venv/bin/activate
 pip install -e .
 # Run directly (without systemd)
 python -m sensorpajen.main
 # Run tests (when available)
 pytest
 ```
 ## Migration from Legacy System
 See [ROADMAP.md](ROADMAP.md) for the complete migration plan from the old cron/tmux-based system to the modern systemd service.
 ## License
 See license headers in individual source files.
 ## Credits
 - Bluetooth utilities based on work by Colin GUYON (MIT License)
 - ATC firmware by atc1441: https://github.com/atc1441/ATC_MiThermometer
--- a/scripts/approve-sensors.sh
+++ b/scripts/approve-sensors.sh
@@ -0,0 +1,23 @@
 #!/bin/bash
 # Wrapper script for approve-sensors that sets minimal required env vars
 # Get script directory
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
 # Set minimal required environment variables
 export MQTT_HOST="${MQTT_HOST:-localhost}"
 export MQTT_PORT="${MQTT_PORT:-1883}"
 # Load actual config if it exists (will override defaults)
 if [ -f "$PROJECT_ROOT/config/sensorpajen.env" ]; then
    set -a
    source "$PROJECT_ROOT/config/sensorpajen.env"
    set +a
 fi
 # Activate virtual environment
 source "$PROJECT_ROOT/.venv/bin/activate"
 # Run the approve-sensors command
 python -m sensorpajen.approve_sensors "$@"
--- a/src/sensorpajen/init.py
+++ b/src/sensorpajen/init.py
@@ -0,0 +1,10 @@
 """
 Sensorpajen - Bluetooth Temperature Sensor Monitor
 Monitors Xiaomi Mijia LYWSD03MMC Bluetooth temperature sensors
 and publishes data to MQTT broker.
 """
 __version__ = "2.0.0-dev"
 __author__ = "Fredrik"
 __license__ = "MIT"
--- a/src/sensorpajen/approve_sensors.py
+++ b/src/sensorpajen/approve_sensors.py
@@ -0,0 +1,303 @@
 #!/usr/bin/env python3
 """
 CLI tool for approving or ignoring discovered sensors.
 Interactive tool to manage pending and ignored sensors.
 """
 import sys
 import json
 import logging
 import argparse
 from pathlib import Path
 from typing import List
 from . import config
 from .discovery_manager import DiscoveryManager, DiscoveredSensor
 logger = logging.getLogger(__name__)
 def format_metadata_comment(sensor: DiscoveredSensor) -> str:
    """
    Format sensor metadata as a comment string.
    Args:
        sensor: Discovered sensor
    Returns:
        Formatted comment string
    """
    return (
        f"MAC: {sensor.mac}, "
        f"Name: {sensor.name}, "
        f"Last seen: {sensor.last_seen}, "
        f"Temp: {sensor.sample_reading.get('temperature', 'N/A')}°C, "
        f"Humidity: {sensor.sample_reading.get('humidity', 'N/A')}%, "
        f"Battery: {sensor.sample_reading.get('battery_percent', 'N/A')}%"
    )
 def display_sensor(sensor: DiscoveredSensor, index: int, total: int):
    """
    Display sensor information to the user.
    Args:
        sensor: Discovered sensor to display
        index: Current sensor number (1-based)
        total: Total number of sensors
    """
    print(f"\n{'='*70}")
    print(f"Sensor {index}/{total}")
    print(f"{'='*70}")
    print(f"MAC Address:  {sensor.mac}")
    print(f"Device Name:  {sensor.name}")
    print(f"Last Seen:    {sensor.last_seen}")
    print(f"Status:       {sensor.status}")
    if sensor.status == "ignored" and sensor.ignored_at:
        print(f"Ignored At:   {sensor.ignored_at}")
        if sensor.ignore_reason:
            print(f"Reason:       {sensor.ignore_reason}")
    # Display sample reading
    reading = sensor.sample_reading
    print(f"\nSample Reading:")
    print(f"  Temperature:  {reading.get('temperature', 'N/A')}°C")
    print(f"  Humidity:     {reading.get('humidity', 'N/A')}%")
    print(f"  Battery:      {reading.get('battery_percent', 'N/A')}%")
    print(f"  Voltage:      {reading.get('battery_voltage', 'N/A')}mV")
    print(f"{'='*70}")
 def get_user_choice() -> str:
    """
    Get user's choice for what to do with the sensor.
    Returns:
        User choice: 'a' (approve), 'i' (ignore), 's' (skip)
    """
    while True:
        choice = input("\n[A]pprove, [I]gnore, [S]kip, [Q]uit? ").strip().lower()
        if choice in ['a', 'i', 's', 'q']:
            return choice
        print("Invalid choice. Please enter A, I, S, or Q.")
 def approve_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
    """
    Approve a sensor and add it to sensors.json.
    Args:
        sensor: Sensor to approve
        manager: Discovery manager
    """
    # Check if sensor already exists in sensors.json
    sensor_config_path = Path(config.SENSOR_CONFIG_FILE)
    try:
        with open(sensor_config_path, 'r') as f:
            data = json.load(f)
        # Check for duplicates
        for existing_sensor in data.get('sensors', []):
            if existing_sensor.get('mac', '').upper() == sensor.mac:
                print(f"\n⚠️  Sensor {sensor.mac} already exists in sensors.json")
                print("   Renaming must be done manually in the file.")
                return
    except FileNotFoundError:
        # File doesn't exist yet, create with empty sensors list
        data = {'sensors': []}
    except json.JSONDecodeError as e:
        print(f"\n❌ Error: Invalid JSON in {sensor_config_path}: {e}")
        return
    # Get sensor name from user
    while True:
        name = input("\nEnter sensor name (required): ").strip()
        if name:
            break
        print("Sensor name cannot be empty.")
    # Pre-fill comment with metadata
    default_comment = format_metadata_comment(sensor)
    print(f"\nDefault comment:")
    print(f"  {default_comment}")
    edit = input("\nEdit comment? [y/N]: ").strip().lower()
    if edit == 'y':
        print("\nEnter comment (or press Enter to keep default):")
        comment = input("> ").strip()
        if not comment:
            comment = default_comment
    else:
        comment = default_comment
    # Add to sensors.json
    new_sensor = {
        "mac": sensor.mac,
        "name": name
    }
    if comment:
        new_sensor["comment"] = comment
    data.setdefault('sensors', []).append(new_sensor)
    try:
        with open(sensor_config_path, 'w') as f:
            json.dump(data, f, indent=2)
        print(f"\n✅ Sensor approved and added to sensors.json")
        print(f"   Name: {name}")
        print(f"   Configuration will be reloaded automatically within 15 minutes")
        # Mark as approved in discovery manager
        manager.approve(sensor.mac)
    except Exception as e:
        print(f"\n❌ Error saving to sensors.json: {e}")
 def ignore_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
    """
    Ignore a sensor.
    Args:
        sensor: Sensor to ignore
        manager: Discovery manager
    """
    reason = input("\nReason for ignoring (optional): ").strip()
    manager.ignore(sensor.mac, reason if reason else None)
    print(f"\n✅ Sensor ignored")
    if reason:
        print(f"   Reason: {reason}")
 def process_sensors(sensors: List[DiscoveredSensor], manager: DiscoveryManager):
    """
    Process list of sensors interactively.
    Args:
        sensors: List of sensors to process
        manager: Discovery manager
    """
    if not sensors:
        print("\n✅ No sensors to process")
        return
    print(f"\nFound {len(sensors)} sensor(s) to review")
    for i, sensor in enumerate(sensors, 1):
        # Mark as reviewed when shown
        manager.mark_reviewed(sensor.mac)
        display_sensor(sensor, i, len(sensors))
        choice = get_user_choice()
        if choice == 'q':
            print("\n👋 Exiting...")
            break
        elif choice == 'a':
            approve_sensor(sensor, manager)
        elif choice == 'i':
            ignore_sensor(sensor, manager)
        elif choice == 's':
            print("\n⏭️  Skipped")
            continue
 def main():
    """Main entry point for approve-sensors CLI."""
    # Parse command line arguments
    parser = argparse.ArgumentParser(
        description="Approve or ignore discovered Bluetooth sensors",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
 Examples:
  %(prog)s                    # Show only new pending sensors
  %(prog)s --all             # Show all pending sensors (including reviewed)
  %(prog)s --ignored         # Show only ignored sensors
  %(prog)s --all --ignored   # Show all sensors
        """
    )
    parser.add_argument(
        '--all', '-a',
        action='store_true',
        help='Show all pending sensors, including previously reviewed ones'
    )
    parser.add_argument(
        '--ignored', '-i',
        action='store_true',
        help='Show ignored sensors'
    )
    args = parser.parse_args()
    # Setup logging
    logging.basicConfig(
        level=logging.WARNING,
        format='%(levelname)s: %(message)s'
    )
    print("=" * 70)
    print("Sensorpajen - Approve Sensors")
    print("=" * 70)
    try:
        # Load discovery manager
        manager = DiscoveryManager()
        # Get sensors based on flags
        if args.all:
            pending = manager.get_pending()
            pending_label = "all pending"
        else:
            pending = manager.get_new_pending()
            pending_label = "new pending"
        ignored = manager.get_ignored() if args.ignored else []
        if not pending and not ignored:
            if args.all or args.ignored:
                print(f"\n✅ No {pending_label if pending else 'ignored'} sensors found")
            else:
                print("\n✅ No new sensors to review")
                all_pending = manager.get_pending()
                if all_pending:
                    print(f"\nThere are {len(all_pending)} previously reviewed pending sensor(s).")
                    print("Run with --all to review them again.")
            return 0
        # Process pending sensors
        if pending:
            print(f"\n📋 Processing {len(pending)} {pending_label} sensor(s)...")
            process_sensors(pending, manager)
        # Process ignored sensors if requested
        if ignored:
            if pending:
                print("\n" + "=" * 70)
            print(f"\n📋 Processing {len(ignored)} ignored sensor(s)...")
            process_sensors(ignored, manager)
        print("\n" + "=" * 70)
        print("Done!")
        print("=" * 70)
        return 0
    except KeyboardInterrupt:
        print("\n\n👋 Interrupted by user")
        return 1
    except Exception as e:
        logger.error(f"Error: {e}", exc_info=True)
        return 1
 if __name__ == "__main__":
    sys.exit(main())
--- a/src/sensorpajen/config.py
+++ b/src/sensorpajen/config.py
@@ -0,0 +1,142 @@
 """
 Configuration management for Sensorpajen.
 Loads configuration from environment variables with sensible defaults.
 Configuration files are loaded relative to the project root.
 """
 import os
 import json
 import logging
 from pathlib import Path
 from typing import Dict, List
 logger = logging.getLogger(__name__)
 # Determine project root (3 levels up from this file: src/sensorpajen/config.py)
 PROJECT_ROOT = Path(__file__).parent.parent.parent
 # MQTT Configuration from environment
 MQTT_HOST = os.environ.get("MQTT_HOST")
 MQTT_PORT = int(os.environ.get("MQTT_PORT", "1883"))
 MQTT_USER = os.environ.get("MQTT_USER")
 MQTT_PASSWORD = os.environ.get("MQTT_PASSWORD")
 MQTT_CLIENT_ID = os.environ.get("MQTT_CLIENT_ID", "sensorpajen")
 MQTT_TOPIC_PREFIX = os.environ.get("MQTT_TOPIC_PREFIX", "MiTemperature2")
 # Validate required MQTT configuration
 if not MQTT_HOST:
    raise RuntimeError(
        "MQTT_HOST environment variable must be set. "
        "Please configure config/sensorpajen.env"
    )
 # Sensor configuration file (relative to project root)
 SENSOR_CONFIG_FILE = os.environ.get(
    "SENSOR_CONFIG_FILE",
    str(PROJECT_ROOT / "config/sensors.json")
 )
 # Application settings
 WATCHDOG_TIMEOUT = int(os.environ.get("WATCHDOG_TIMEOUT", "5"))
 ENABLE_BATTERY = os.environ.get("ENABLE_BATTERY", "true").lower() == "true"
 LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
 # Bluetooth settings
 SKIP_IDENTICAL = int(os.environ.get("SKIP_IDENTICAL", "50"))
 DEBOUNCE = os.environ.get("DEBOUNCE", "true").lower() == "true"
 # ntfy notification settings (optional)
 NTFY_ENABLED = os.environ.get("NTFY_ENABLED", "false").lower() == "true"
 NTFY_URL = os.environ.get("NTFY_URL", "https://ntfy.sh")
 NTFY_TOPIC = os.environ.get("NTFY_TOPIC", "sensorpajen")
 NTFY_TOKEN = os.environ.get("NTFY_TOKEN", "")
 # Discovery settings
 DISCOVERED_SENSORS_FILE = os.environ.get(
    "DISCOVERED_SENSORS_FILE",
    str(PROJECT_ROOT / "config/discovered_sensors.json")
 )
 CONFIG_RELOAD_INTERVAL = int(os.environ.get("CONFIG_RELOAD_INTERVAL", "900"))  # 15 minutes
 class SensorConfig:
    """Manages sensor configuration from JSON file."""
    def __init__(self, config_file: str = SENSOR_CONFIG_FILE):
        """
        Initialize sensor configuration.
        Args:
            config_file: Path to sensors JSON configuration file
        """
        self.config_file = Path(config_file)
        self.sensors: Dict[str, str] = {}
        self.load()
    def load(self):
        """Load sensor configuration from JSON file."""
        if not self.config_file.exists():
            raise FileNotFoundError(
                f"Sensor configuration file not found: {self.config_file}\n"
                f"Please copy config/sensors.json.example to config/sensors.json "
                f"and configure your sensors."
            )
        try:
            with open(self.config_file, 'r') as f:
                data = json.load(f)
            # Convert sensors list to MAC -> name mapping
            for sensor in data.get('sensors', []):
                mac = sensor.get('mac', '').upper()
                name = sensor.get('name')
                if mac and name:
                    self.sensors[mac] = name
                    logger.debug(f"Loaded sensor: {mac} -> {name}")
            logger.info(f"Loaded {len(self.sensors)} sensors from {self.config_file}")
        except json.JSONDecodeError as e:
            raise RuntimeError(f"Invalid JSON in {self.config_file}: {e}")
        except Exception as e:
            raise RuntimeError(f"Error loading sensor config: {e}")
    def get_name(self, mac: str) -> str:
        """
        Get sensor name by MAC address.
        Args:
            mac: MAC address (any case)
        Returns:
            Sensor name or the MAC address if not found
        """
        return self.sensors.get(mac.upper(), mac)
    def get_all_macs(self) -> List[str]:
        """Get list of all configured MAC addresses."""
        return list(self.sensors.keys())
 def validate_config():
    """
    Validate configuration and log settings.
    Should be called at application startup.
    """
    logger.info("=== Sensorpajen Configuration ===")
    logger.info(f"MQTT Host: {MQTT_HOST}:{MQTT_PORT}")
    logger.info(f"MQTT User: {MQTT_USER}")
    logger.info(f"MQTT Client ID: {MQTT_CLIENT_ID}")
    logger.info(f"MQTT Topic Prefix: {MQTT_TOPIC_PREFIX}")
    logger.info(f"Sensor Config: {SENSOR_CONFIG_FILE}")
    logger.info(f"Discovered Sensors: {DISCOVERED_SENSORS_FILE}")
    logger.info(f"Watchdog Timeout: {WATCHDOG_TIMEOUT}s")
    logger.info(f"Battery Monitoring: {ENABLE_BATTERY}")
    logger.info(f"Config Reload Interval: {CONFIG_RELOAD_INTERVAL}s")
    logger.info(f"ntfy Enabled: {NTFY_ENABLED}")
    if NTFY_ENABLED:
        logger.info(f"ntfy URL: {NTFY_URL}/{NTFY_TOPIC}")
    logger.info(f"Log Level: {LOG_LEVEL}")
    logger.info("================================")
--- a/src/sensorpajen/discovery_manager.py
+++ b/src/sensorpajen/discovery_manager.py
@@ -0,0 +1,263 @@
 """
 Discovery manager for tracking and managing discovered sensors.
 Maintains a database of discovered sensors with their metadata and status.
 """
 import json
 import logging
 import subprocess
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional
 from dataclasses import dataclass, asdict
 from . import config
 logger = logging.getLogger(__name__)
@dataclass
 class DiscoveredSensor:
    """Represents a discovered sensor with metadata."""
    mac: str
    name: str
    rssi: int
    first_seen: str
    last_seen: str
    sample_reading: Dict[str, float]
    status: str = "pending"  # pending, approved, ignored
    reviewed: bool = False  # Has been shown in approval CLI
    ignored_at: Optional[str] = None
    ignore_reason: Optional[str] = None
 class DiscoveryManager:
    """Manages discovered sensors and their approval status."""
    def __init__(self, discovery_file: str = config.DISCOVERED_SENSORS_FILE):
        """
        Initialize discovery manager.
        Args:
            discovery_file: Path to discovered sensors JSON file
        """
        self.discovery_file = Path(discovery_file)
        self.sensors: Dict[str, DiscoveredSensor] = {}
        self.load()
    def load(self):
        """Load discovered sensors from JSON file."""
        if not self.discovery_file.exists():
            logger.info(f"Creating new discovered sensors file: {self.discovery_file}")
            self.discovery_file.parent.mkdir(parents=True, exist_ok=True)
            self.save()
            return
        try:
            with open(self.discovery_file, 'r') as f:
                data = json.load(f)
            for sensor_data in data:
                sensor = DiscoveredSensor(**sensor_data)
                self.sensors[sensor.mac.upper()] = sensor
            logger.info(f"Loaded {len(self.sensors)} discovered sensors")
        except json.JSONDecodeError as e:
            logger.error(f"Invalid JSON in {self.discovery_file}: {e}")
        except Exception as e:
            logger.error(f"Error loading discovered sensors: {e}")
    def save(self):
        """Save discovered sensors to JSON file."""
        try:
            # Ensure directory exists
            self.discovery_file.parent.mkdir(parents=True, exist_ok=True)
            # Convert sensors to list of dicts
            data = [asdict(sensor) for sensor in self.sensors.values()]
            with open(self.discovery_file, 'w') as f:
                json.dump(data, f, indent=2)
            logger.debug(f"Saved {len(self.sensors)} discovered sensors")
        except Exception as e:
            logger.error(f"Error saving discovered sensors: {e}")
    def add_or_update(self, mac: str, name: str, rssi: int, 
                     temperature: float, humidity: float, 
                     battery_percent: int, battery_voltage: int) -> bool:
        """
        Add or update a discovered sensor.
        Args:
            mac: MAC address
            name: Advertised device name
            rssi: Signal strength
            temperature: Temperature reading
            humidity: Humidity reading
            battery_percent: Battery percentage
            battery_voltage: Battery voltage in mV
        Returns:
            True if this is a newly discovered sensor, False if updated existing
        """
        mac = mac.upper()
        now = datetime.now().isoformat()
        sample_reading = {
            "temperature": temperature,
            "humidity": humidity,
            "battery_percent": battery_percent,
            "battery_voltage": battery_voltage
        }
        if mac in self.sensors:
            # Update existing sensor
            sensor = self.sensors[mac]
            sensor.last_seen = now
            sensor.rssi = rssi
            sensor.sample_reading = sample_reading
            self.save()
            return False
        else:
            # New sensor discovered
            sensor = DiscoveredSensor(
                mac=mac,
                name=name,
                rssi=rssi,
                first_seen=now,
                last_seen=now,
                sample_reading=sample_reading,
                status="pending"
            )
            self.sensors[mac] = sensor
            self.save()
            logger.info(f"New sensor discovered: {mac} ({name})")
            return True
    def is_known(self, mac: str) -> bool:
        """
        Check if a sensor has been discovered before.
        Args:
            mac: MAC address
        Returns:
            True if sensor is in discovered list
        """
        return mac.upper() in self.sensors
    def get_status(self, mac: str) -> Optional[str]:
        """
        Get status of a discovered sensor.
        Args:
            mac: MAC address
        Returns:
            Status string or None if not found
        """
        sensor = self.sensors.get(mac.upper())
        return sensor.status if sensor else None
    def approve(self, mac: str):
        """
        Mark a sensor as approved.
        Args:
            mac: MAC address
        """
        mac = mac.upper()
        if mac in self.sensors:
            self.sensors[mac].status = "approved"
            self.save()
            logger.info(f"Sensor approved: {mac}")
    def ignore(self, mac: str, reason: Optional[str] = None):
        """
        Mark a sensor as ignored.
        Args:
            mac: MAC address
            reason: Optional reason for ignoring
        """
        mac = mac.upper()
        if mac in self.sensors:
            self.sensors[mac].status = "ignored"
            self.sensors[mac].ignored_at = datetime.now().isoformat()
            self.sensors[mac].ignore_reason = reason
            self.save()
            logger.info(f"Sensor ignored: {mac}")
    def get_pending(self) -> List[DiscoveredSensor]:
        """Get list of sensors with status 'pending'."""
        return [s for s in self.sensors.values() if s.status == "pending"]
    def get_new_pending(self) -> List[DiscoveredSensor]:
        """Get list of pending sensors that haven't been reviewed yet."""
        return [s for s in self.sensors.values() if s.status == "pending" and not s.reviewed]
    def get_ignored(self) -> List[DiscoveredSensor]:
        """Get list of sensors with status 'ignored'."""
        return [s for s in self.sensors.values() if s.status == "ignored"]
    def mark_reviewed(self, mac: str):
        """
        Mark a sensor as reviewed (shown in approval CLI).
        Args:
            mac: MAC address
        """
        mac = mac.upper()
        if mac in self.sensors:
            self.sensors[mac].reviewed = True
            self.save()
    def send_ntfy_notification(self, sensor: DiscoveredSensor):
        """
        Send ntfy notification for a newly discovered sensor.
        Args:
            sensor: Discovered sensor to notify about
        """
        if not config.NTFY_ENABLED:
            logger.debug("ntfy notifications disabled")
            return
        if not config.NTFY_TOKEN:
            logger.warning("ntfy enabled but NTFY_TOKEN not set")
            return
        try:
            message = (
                f"🆕 New sensor discovered!\n\n"
                f"MAC: {sensor.mac}\n"
                f"Name: {sensor.name}\n"
                f"Last seen: {sensor.last_seen}\n"
                f"Temp: {sensor.sample_reading.get('temperature', 'N/A')}°C\n"
                f"Humidity: {sensor.sample_reading.get('humidity', 'N/A')}%\n"
                f"Battery: {sensor.sample_reading.get('battery_percent', 'N/A')}%\n\n"
                f"Run 'sensorpajen approve-sensors' to approve or ignore."
            )
            url = f"{config.NTFY_URL}/{config.NTFY_TOPIC}"
            result = subprocess.run(
                ["curl", "-H", f"Authorization: Bearer {config.NTFY_TOKEN}",
                 "-d", message, url],
                capture_output=True,
                timeout=10
            )
            if result.returncode == 0:
                logger.info(f"Sent ntfy notification for {sensor.mac}")
            else:
                logger.warning(f"ntfy notification failed: {result.stderr.decode()}")
        except subprocess.TimeoutExpired:
            logger.warning("ntfy notification timed out")
        except Exception as e:
            logger.error(f"Error sending ntfy notification: {e}")
--- a/src/sensorpajen/main.py
+++ b/src/sensorpajen/main.py
@@ -0,0 +1,226 @@
 #!/usr/bin/env python3
 """
 Sensorpajen - Main entry point
 Bluetooth temperature sensor monitor for Xiaomi Mijia LYWSD03MMC sensors.
 Publishes sensor data to MQTT broker.
 """
 import sys
 import signal
 import logging
 import time
 import threading
 from pathlib import Path
 from . import __version__
 from . import config
 from .mqtt_publisher import MQTTPublisher
 from .sensor_reader import SensorReader, Measurement
 from .discovery_manager import DiscoveryManager
 class Sensorpajen:
    """Main application class."""
    def __init__(self):
        """Initialize the application."""
        self.mqtt_publisher: MQTTPublisher = None
        self.sensor_reader: SensorReader = None
        self.sensor_config: config.SensorConfig = None
        self.discovery_manager: DiscoveryManager = None
        self.running = False
        self.config_reload_timer: threading.Timer = None
        # Setup logging
        self._setup_logging()
        # Setup signal handlers
        signal.signal(signal.SIGTERM, self._signal_handler)
        signal.signal(signal.SIGINT, self._signal_handler)
    def _setup_logging(self):
        """Configure logging to stdout for journald."""
        log_level = getattr(logging, config.LOG_LEVEL, logging.INFO)
        logging.basicConfig(
            level=log_level,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            stream=sys.stdout
        )
        # Set our logger
        self.logger = logging.getLogger(__name__)
    def _signal_handler(self, sig, frame):
        """Handle shutdown signals."""
        signal_name = "SIGTERM" if sig == signal.SIGTERM else "SIGINT"
        self.logger.info(f"Received {signal_name}, shutting down gracefully...")
        self.shutdown()
        sys.exit(0)
    def _on_measurement(self, measurement: Measurement):
        """
        Callback for new sensor measurements.
        Args:
            measurement: Sensor measurement data
        """
        try:
            # Publish to MQTT
            self.mqtt_publisher.publish_measurement(
                sensor_name=measurement.sensor_name,
                temperature=measurement.temperature,
                humidity=measurement.humidity,
                battery_voltage=measurement.voltage,
                battery_level=measurement.battery
            )
        except Exception as e:
            self.logger.error(f"Error handling measurement: {e}")
    def _reload_config(self):
        """Reload sensor configuration periodically."""
        if not self.running:
            return
        try:
            self.logger.info("Reloading sensor configuration...")
            old_sensors = set(self.sensor_config.sensors.keys())
            self.sensor_config.load()
            new_sensors = set(self.sensor_config.sensors.keys())
            added = new_sensors - old_sensors
            removed = old_sensors - new_sensors
            if added:
                self.logger.info(f"Added sensors: {', '.join(added)}")
            if removed:
                self.logger.info(f"Removed sensors: {', '.join(removed)}")
            if not added and not removed:
                self.logger.debug("No sensor configuration changes")
        except Exception as e:
            self.logger.error(f"Error reloading configuration: {e}")
        finally:
            # Schedule next reload
            if self.running:
                self.config_reload_timer = threading.Timer(
                    config.CONFIG_RELOAD_INTERVAL,
                    self._reload_config
                )
                self.config_reload_timer.daemon = True
                self.config_reload_timer.start()
    def start(self):
        """Start the application."""
        try:
            self.logger.info("=" * 50)
            self.logger.info(f"Starting Sensorpajen v{__version__}")
            self.logger.info("=" * 50)
            # Validate and log configuration
            config.validate_config()
            # Load sensor configuration
            self.sensor_config = config.SensorConfig()
            if len(self.sensor_config.sensors) == 0:
                self.logger.error("No sensors configured!")
                self.logger.error("Please configure sensors in config/sensors.json")
                sys.exit(1)
            # Initialize discovery manager
            self.logger.info("Initializing discovery manager...")
            self.discovery_manager = DiscoveryManager()
            # Initialize MQTT publisher
            self.logger.info("Initializing MQTT publisher...")
            self.mqtt_publisher = MQTTPublisher()
            self.mqtt_publisher.connect()
            # Wait a moment for MQTT connection
            time.sleep(1)
            if not self.mqtt_publisher.is_connected():
                self.logger.warning("MQTT connection not established yet, continuing anyway...")
            # Initialize sensor reader
            self.logger.info("Initializing Bluetooth sensor reader...")
            self.sensor_reader = SensorReader(
                sensor_config=self.sensor_config,
                discovery_manager=self.discovery_manager,
                on_measurement=self._on_measurement,
                interface=0  # hci0
            )
            # Start config reload timer
            self.config_reload_timer = threading.Timer(
                config.CONFIG_RELOAD_INTERVAL,
                self._reload_config
            )
            self.config_reload_timer.daemon = True
            self.config_reload_timer.start()
            self.logger.info(f"Config reload scheduled every {config.CONFIG_RELOAD_INTERVAL}s")
            # Start reading sensors (blocking call)
            self.logger.info("=" * 50)
            self.logger.info("Sensorpajen is now running")
            self.logger.info("Monitoring sensors via Bluetooth...")
            self.logger.info("Publishing to MQTT...")
            self.logger.info("Press Ctrl+C to stop")
            self.logger.info("=" * 50)
            self.running = True
            self.sensor_reader.start()
        except FileNotFoundError as e:
            self.logger.error(f"Configuration error: {e}")
            sys.exit(1)
        except RuntimeError as e:
            self.logger.error(f"Configuration error: {e}")
            sys.exit(1)
        except Exception as e:
            self.logger.error(f"Failed to start application: {e}", exc_info=True)
            self.shutdown()
            sys.exit(1)
    def shutdown(self):
        """Shutdown the application gracefully."""
        if not self.running:
            return
        self.running = False
        self.logger.info("Shutting down...")
        # Cancel config reload timer
        if self.config_reload_timer:
            try:
                self.config_reload_timer.cancel()
            except Exception as e:
                self.logger.error(f"Error canceling reload timer: {e}")
        # Stop sensor reader
        if self.sensor_reader:
            try:
                self.sensor_reader.stop()
            except Exception as e:
                self.logger.error(f"Error stopping sensor reader: {e}")
        # Disconnect MQTT
        if self.mqtt_publisher:
            try:
                self.mqtt_publisher.disconnect()
            except Exception as e:
                self.logger.error(f"Error disconnecting MQTT: {e}")
        self.logger.info("Shutdown complete")
 def main():
    """Main entry point."""
    app = Sensorpajen()
    app.start()
 if __name__ == "__main__":
    main()
--- a/src/sensorpajen/mqtt_publisher.py
+++ b/src/sensorpajen/mqtt_publisher.py
@@ -0,0 +1,131 @@
 """
 MQTT Publisher for sensor data.
 Handles connection to MQTT broker and publishing of sensor measurements.
 """
 import logging
 import paho.mqtt.client as mqtt
 from typing import Optional
 from . import config
 logger = logging.getLogger(__name__)
 class MQTTPublisher:
    """Manages MQTT connection and publishing of sensor data."""
    def __init__(self):
        """Initialize MQTT publisher with configuration."""
        self.client: Optional[mqtt.Client] = None
        self.connected = False
        self._setup_client()
    def _setup_client(self):
        """Setup MQTT client with callbacks."""
        # Handle both paho-mqtt v1.x and v2.x
        try:
            # Try v2.x format (with callback_api_version)
            self.client = mqtt.Client(
                callback_api_version=mqtt.CallbackAPIVersion.VERSION1,
                client_id=config.MQTT_CLIENT_ID
            )
        except (TypeError, AttributeError):
            # Fall back to v1.x format
            self.client = mqtt.Client(config.MQTT_CLIENT_ID)
        # Set credentials if provided
        if config.MQTT_USER and config.MQTT_PASSWORD:
            self.client.username_pw_set(config.MQTT_USER, config.MQTT_PASSWORD)
        # Setup callbacks
        self.client.on_connect = self._on_connect
        self.client.on_disconnect = self._on_disconnect
        self.client.on_publish = self._on_publish
        logger.info(f"MQTT client configured for {config.MQTT_HOST}:{config.MQTT_PORT}")
    def _on_connect(self, client, userdata, flags, rc):
        """Callback for when client connects to broker."""
        if rc == 0:
            self.connected = True
            logger.info(f"Connected to MQTT broker at {config.MQTT_HOST}:{config.MQTT_PORT}")
        else:
            self.connected = False
            logger.error(f"Failed to connect to MQTT broker. Return code: {rc}")
    def _on_disconnect(self, client, userdata, rc):
        """Callback for when client disconnects from broker."""
        self.connected = False
        if rc != 0:
            logger.warning(f"Unexpected disconnection from MQTT broker. Return code: {rc}")
        else:
            logger.info("Disconnected from MQTT broker")
    def _on_publish(self, client, userdata, mid):
        """Callback for when message is published."""
        logger.debug(f"Message published: {mid}")
    def connect(self):
        """Connect to MQTT broker."""
        try:
            logger.info(f"Connecting to MQTT broker at {config.MQTT_HOST}:{config.MQTT_PORT}")
            self.client.connect(config.MQTT_HOST, config.MQTT_PORT, keepalive=60)
            self.client.loop_start()  # Start network loop in background thread
        except Exception as e:
            logger.error(f"Failed to connect to MQTT broker: {e}")
            raise
    def disconnect(self):
        """Disconnect from MQTT broker."""
        if self.client:
            self.client.loop_stop()
            self.client.disconnect()
            logger.info("Disconnected from MQTT broker")
    def publish_measurement(self, sensor_name: str, temperature: float, 
                          humidity: int, battery_voltage: float = None, 
                          battery_level: int = None):
        """
        Publish sensor measurement to MQTT.
        Args:
            sensor_name: Name of the sensor
            temperature: Temperature in Celsius
            humidity: Humidity percentage
            battery_voltage: Battery voltage (optional)
            battery_level: Battery level percentage (optional)
        """
        if not self.connected:
            logger.warning("Not connected to MQTT broker, skipping publish")
            return
        topic_prefix = f"{config.MQTT_TOPIC_PREFIX}/{sensor_name}"
        try:
            # Publish temperature
            self.client.publish(f"{topic_prefix}/temp", f"{temperature:.1f}")
            logger.debug(f"{sensor_name}: temp={temperature:.1f}°C")
            # Publish humidity
            self.client.publish(f"{topic_prefix}/humidity", f"{humidity}")
            logger.debug(f"{sensor_name}: humidity={humidity}%")
            # Publish battery info if enabled and available
            if config.ENABLE_BATTERY:
                if battery_voltage is not None:
                    self.client.publish(f"{topic_prefix}/batteryvoltage", f"{battery_voltage:.3f}")
                    logger.debug(f"{sensor_name}: battery_voltage={battery_voltage:.3f}V")
                if battery_level is not None:
                    self.client.publish(f"{topic_prefix}/batterylevel", f"{battery_level}")
                    logger.debug(f"{sensor_name}: battery_level={battery_level}%")
            logger.info(f"Published: {sensor_name} - {temperature:.1f}°C, {humidity}%")
        except Exception as e:
            logger.error(f"Error publishing to MQTT: {e}")
    def is_connected(self) -> bool:
        """Check if connected to MQTT broker."""
        return self.connected
--- a/src/sensorpajen/sensor_reader.py
+++ b/src/sensorpajen/sensor_reader.py
@@ -0,0 +1,292 @@
 """
 Bluetooth sensor reader for Xiaomi Mijia LYWSD03MMC sensors with ATC firmware.
 Reads temperature, humidity, and battery data from BLE advertisements.
 """
 import logging
 import time
 import threading
 import bluetooth._bluetooth as bluez
 from dataclasses import dataclass
 from typing import Optional, Callable, Dict
 from . import config
 from .utils import (enable_le_scan, disable_le_scan, 
                   parse_le_advertising_events, raw_packet_to_str, toggle_device)
 logger = logging.getLogger(__name__)
@dataclass
 class Measurement:
    """Sensor measurement data."""
    temperature: float
    humidity: int
    voltage: float
    battery: int = 0
    rssi: int = 0
    sensor_name: str = ""
    timestamp: int = 0
 class SensorReader:
    """Reads Xiaomi LYWSD03MMC sensors with ATC firmware via BLE."""
    def __init__(self, sensor_config: config.SensorConfig,
                 discovery_manager,
                 on_measurement: Callable[[Measurement], None],
                 interface: int = 0):
        """
        Initialize sensor reader.
        Args:
            sensor_config: Sensor configuration mapping
            discovery_manager: Discovery manager for tracking new sensors
            on_measurement: Callback function for new measurements
            interface: Bluetooth interface number (default 0 for hci0)
        """
        self.sensor_config = sensor_config
        self.discovery_manager = discovery_manager
        self.on_measurement = on_measurement
        self.interface = interface
        self.sock: Optional[int] = None
        self.running = False
        self.last_ble_packet = time.time()
        self.adv_counter: Dict[str, str] = {}  # Track advertisement numbers to avoid duplicates
        self.watchdog_thread: Optional[threading.Thread] = None
    def start(self):
        """Start BLE scanning for sensors."""
        try:
            logger.info(f"Starting BLE scan on hci{self.interface}")
            # Enable bluetooth device
            toggle_device(self.interface, True)
            # Open bluetooth socket
            try:
                self.sock = bluez.hci_open_dev(self.interface)
            except Exception as e:
                logger.error(f"Cannot open bluetooth device hci{self.interface}: {e}")
                raise
            # Enable LE scanning without filtering duplicates
            enable_le_scan(self.sock, filter_duplicates=False)
            # Start watchdog if configured
            if config.WATCHDOG_TIMEOUT > 0:
                self.running = True
                self.watchdog_thread = threading.Thread(target=self._watchdog_loop, daemon=True)
                self.watchdog_thread.start()
                logger.info(f"Watchdog started with {config.WATCHDOG_TIMEOUT}s timeout")
            logger.info("BLE scanning enabled")
            logger.info(f"Monitoring {len(self.sensor_config.sensors)} sensors")
            # Start parsing advertisements (blocking call)
            parse_le_advertising_events(
                self.sock,
                handler=self._handle_ble_packet,
                debug=False
            )
        except KeyboardInterrupt:
            logger.info("Received keyboard interrupt")
            self.stop()
        except Exception as e:
            logger.error(f"Error in sensor reader: {e}")
            self.stop()
            raise
    def stop(self):
        """Stop BLE scanning."""
        self.running = False
        if self.sock:
            try:
                disable_le_scan(self.sock)
                logger.info("BLE scanning disabled")
            except Exception as e:
                logger.error(f"Error disabling BLE scan: {e}")
        if self.watchdog_thread and self.watchdog_thread.is_alive():
            self.watchdog_thread.join(timeout=2)
    def _watchdog_loop(self):
        """Watchdog thread to restart BLE scanning if no packets received."""
        restart_counter = 1
        while self.running:
            time.sleep(1)
            now = time.time()
            elapsed = now - self.last_ble_packet
            if elapsed > config.WATCHDOG_TIMEOUT:
                logger.warning(
                    f"Watchdog: No BLE packet within {int(elapsed)}s. "
                    f"Restarting BLE scan (count: {restart_counter})"
                )
                try:
                    disable_le_scan(self.sock)
                    time.sleep(1)
                    enable_le_scan(self.sock, filter_duplicates=False)
                    restart_counter += 1
                    self.last_ble_packet = now  # Reset timer
                except Exception as e:
                    logger.error(f"Error restarting BLE scan: {e}")
    def _handle_ble_packet(self, mac: str, adv_type: int, data: bytes, rssi: int):
        """
        Handle incoming BLE advertisement packet.
        Args:
            mac: MAC address of the device
            adv_type: Advertisement type
            data: Advertisement data
            rssi: Signal strength
        """
        # Update last packet time for watchdog
        self.last_ble_packet = time.time()
        # Convert data to hex string
        data_str = raw_packet_to_str(data)
        # Check if this is an ATC packet
        # ATC format: [... service UUID 0x181A ... MAC ... data ...]
        atc_identifier = data_str[6:10].upper()
        if atc_identifier != "1A18":
            return  # Not an ATC packet
        # Extract MAC from packet and verify it matches
        packet_mac = data_str[10:22].upper()
        mac_str = mac.replace(":", "").upper()
        if packet_mac != mac_str:
            return  # MAC mismatch
        mac_with_colons = mac.upper()
        # Parse ATC data packet first to get sensor data
        try:
            parsed_data = self._parse_atc_data(data_str)
            if not parsed_data:
                return
            temperature, humidity, battery_percent, battery_voltage, adv_number = parsed_data
            # Check if this is a known sensor
            if mac_with_colons not in self.sensor_config.sensors:
                # Unknown sensor - check if we should discover it
                self._handle_unknown_sensor(
                    mac_with_colons, 
                    rssi, 
                    temperature, 
                    humidity, 
                    battery_percent, 
                    battery_voltage
                )
                return
            # Check advertisement number to avoid duplicates
            if mac_str in self.adv_counter:
                if self.adv_counter[mac_str] == adv_number:
                    return  # Duplicate packet
            self.adv_counter[mac_str] = adv_number
            # Create measurement for known sensor
            sensor_name = self.sensor_config.get_name(mac_with_colons)
            measurement = Measurement(
                temperature=temperature,
                humidity=humidity,
                voltage=battery_voltage / 1000.0,
                battery=battery_percent,
                rssi=rssi,
                sensor_name=sensor_name,
                timestamp=int(time.time())
            )
            # Log the measurement
            logger.info(
                f"{measurement.sensor_name}: {measurement.temperature}°C, "
                f"{measurement.humidity}%, {measurement.voltage}V, "
                f"battery {measurement.battery}%, RSSI {rssi}dBm"
            )
            # Call measurement callback
            if self.on_measurement:
                self.on_measurement(measurement)
        except Exception as e:
            logger.error(f"Error parsing ATC packet from {mac}: {e}")
    def _handle_unknown_sensor(self, mac: str, rssi: int, temperature: float,
                               humidity: int, battery_percent: int, battery_voltage: int):
        """
        Handle discovery of unknown sensor.
        Args:
            mac: MAC address with colons
            rssi: Signal strength
            temperature: Temperature reading
            humidity: Humidity reading
            battery_percent: Battery percentage
            battery_voltage: Battery voltage in mV
        """
        # Get or construct device name from MAC
        # ATC sensors advertise as ATC_XXXXXX where XXXXXX is last 3 bytes
        mac_suffix = mac.replace(":", "")[-6:]
        device_name = f"ATC_{mac_suffix}"
        # Check if already discovered
        if self.discovery_manager.is_known(mac):
            # Just update the discovery record
            self.discovery_manager.add_or_update(
                mac, device_name, rssi, temperature, humidity,
                battery_percent, battery_voltage
            )
            return
        # New sensor - discover and notify
        is_new = self.discovery_manager.add_or_update(
            mac, device_name, rssi, temperature, humidity,
            battery_percent, battery_voltage
        )
        if is_new:
            logger.info(f"New sensor discovered: {mac} ({device_name})")
            sensor = self.discovery_manager.sensors[mac]
            self.discovery_manager.send_ntfy_notification(sensor)
    def _parse_atc_data(self, data_str: str) -> Optional[tuple]:
        """
        Parse ATC advertisement data.
        Returns:
            Tuple of (temperature, humidity, battery_percent, battery_voltage, adv_number) or None
        """
        try:
            # Temperature: bytes 22-26, signed int16, big endian, /10
            temp_hex = data_str[22:26]
            temp_raw = int(temp_hex, 16)
            if temp_raw & 0x8000:  # Check sign bit
                temp_raw = temp_raw - 0x10000
            temperature = temp_raw / 10.0
            # Humidity: bytes 26-28, uint8
            humidity = int(data_str[26:28], 16)
            # Battery: bytes 28-30, uint8
            battery_percent = int(data_str[28:30], 16)
            # Battery voltage: bytes 30-34, uint16, big endian, mV
            battery_voltage = int(data_str[30:34], 16)
            # Advertisement number: last 2 bytes
            adv_number = data_str[-2:]
            return (temperature, humidity, battery_percent, battery_voltage, adv_number)
        except (ValueError, IndexError) as e:
            logger.debug(f"Error parsing ATC data: {e}")
            return None
--- a/src/sensorpajen/utils.py
+++ b/src/sensorpajen/utils.py
@@ -0,0 +1,421 @@
 # -*- coding: utf-8 -*-
 # This file is from https://github.com/colin-guyon/py-bluetooth-utils 
 # published under MIT License
 # MIT License
 # Copyright (c) 2020 Colin GUYON
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 """
 Module containing some bluetooth utility functions (linux only).
 It either uses HCI commands using PyBluez, or does ioctl calls like it's
 done in Bluez tools such as hciconfig.
 Main functions:
  - toggle_device : enable or disable a bluetooth device
  - set_scan : set scan type on a device ("noscan", "iscan", "pscan", "piscan")
  - enable/disable_le_scan : enable BLE scanning
  - parse_le_advertising_events : parse and read BLE advertisements packets
  - start/stop_le_advertising : advertise custom data using BLE
 Bluez : http://www.bluez.org/
 PyBluez : http://karulis.github.io/pybluez/
 The module was in particular inspired from 'iBeacon-Scanner-'
 https://github.com/switchdoclabs/iBeacon-Scanner-/blob/master/blescan.py
 and sometimes directly from the Bluez sources.
 """
 from __future__ import absolute_import
 import sys
 import struct
 import fcntl
 import array
 import socket
 from errno import EALREADY
 # import PyBluez
 import bluetooth._bluetooth as bluez
 __all__ = ('toggle_device', 'set_scan',
           'enable_le_scan', 'disable_le_scan', 'parse_le_advertising_events',
           'start_le_advertising', 'stop_le_advertising',
           'raw_packet_to_str')
 LE_META_EVENT = 0x3E
 LE_PUBLIC_ADDRESS = 0x00
 LE_RANDOM_ADDRESS = 0x01
 OGF_LE_CTL = 0x08
 OCF_LE_SET_SCAN_PARAMETERS = 0x000B
 OCF_LE_SET_SCAN_ENABLE = 0x000C
 OCF_LE_CREATE_CONN = 0x000D
 OCF_LE_SET_ADVERTISING_PARAMETERS = 0x0006
 OCF_LE_SET_ADVERTISE_ENABLE = 0x000A
 OCF_LE_SET_ADVERTISING_DATA = 0x0008
 SCAN_TYPE_PASSIVE = 0x00
 SCAN_FILTER_DUPLICATES = 0x01
 SCAN_DISABLE = 0x00
 SCAN_ENABLE = 0x01
 # sub-events of LE_META_EVENT
 EVT_LE_CONN_COMPLETE = 0x01
 EVT_LE_ADVERTISING_REPORT = 0x02
 EVT_LE_CONN_UPDATE_COMPLETE = 0x03
 EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE = 0x04
 # Advertisement event types
 ADV_IND = 0x00
 ADV_DIRECT_IND = 0x01
 ADV_SCAN_IND = 0x02
 ADV_NONCONN_IND = 0x03
 ADV_SCAN_RSP = 0x04
 # Allow Scan Request from Any, Connect Request from Any
 FILTER_POLICY_NO_WHITELIST = 0x00
 # Allow Scan Request from White List Only, Connect Request from Any
 FILTER_POLICY_SCAN_WHITELIST = 0x01
 # Allow Scan Request from Any, Connect Request from White List Only
 FILTER_POLICY_CONN_WHITELIST = 0x02
 # Allow Scan Request from White List Only, Connect Request from White List Only
 FILTER_POLICY_SCAN_AND_CONN_WHITELIST = 0x03
 def toggle_device(dev_id, enable):
    """
    Power ON or OFF a bluetooth device.
    :param dev_id: Device id.
    :type dev_id: ``int``
    :param enable: Whether to enable of disable the device.
    :type enable: ``bool``
    """
    hci_sock = socket.socket(socket.AF_BLUETOOTH,
                             socket.SOCK_RAW,
                             socket.BTPROTO_HCI)
    print("Power %s bluetooth device %d" % ('ON' if enable else 'OFF', dev_id))
    # di = struct.pack("HbBIBBIIIHHHH10I", dev_id, *((0,) * 22))
    # fcntl.ioctl(hci_sock.fileno(), bluez.HCIGETDEVINFO, di)
    req_str = struct.pack("H", dev_id)
    request = array.array("b", req_str)
    try:
        fcntl.ioctl(hci_sock.fileno(),
                    bluez.HCIDEVUP if enable else bluez.HCIDEVDOWN,
                    request[0])
    except IOError as e:
        if e.errno == EALREADY:
            print("Bluetooth device %d is already %s" % (
                  dev_id, 'enabled' if enable else 'disabled'))
        else:
            raise
    finally:
        hci_sock.close()
 # Types of bluetooth scan
 SCAN_DISABLED = 0x00
 SCAN_INQUIRY = 0x01
 SCAN_PAGE = 0x02
 def set_scan(dev_id, scan_type):
    """
    Set scan type on a given bluetooth device.
    :param dev_id: Device id.
    :type dev_id: ``int``
    :param scan_type: One of
        ``'noscan'``
        ``'iscan'``
        ``'pscan'``
        ``'piscan'``
    :type scan_type: ``str``
    """
    hci_sock = socket.socket(socket.AF_BLUETOOTH,
                             socket.SOCK_RAW,
                             socket.BTPROTO_HCI)
    if scan_type == "noscan":
        dev_opt = SCAN_DISABLED
    elif scan_type == "iscan":
        dev_opt = SCAN_INQUIRY
    elif scan_type == "pscan":
        dev_opt = SCAN_PAGE
    elif scan_type == "piscan":
        dev_opt = SCAN_PAGE | SCAN_INQUIRY
    else:
        raise ValueError("Unknown scan type %r" % scan_type)
    req_str = struct.pack("HI", dev_id, dev_opt)
    print("Set scan type %r to bluetooth device %d" % (scan_type, dev_id))
    try:
        fcntl.ioctl(hci_sock.fileno(), bluez.HCISETSCAN, req_str)
    finally:
        hci_sock.close()
 def raw_packet_to_str(pkt):
    """
    Returns the string representation of a raw HCI packet.
    """
    if sys.version_info > (3, 0):
        return ''.join('%02x' % struct.unpack("B", bytes([x]))[0] for x in pkt)
    else:
        return ''.join('%02x' % struct.unpack("B", x)[0] for x in pkt)
 def enable_le_scan(sock, interval=0x0800, window=0x0800,
                   filter_policy=FILTER_POLICY_NO_WHITELIST,
                   filter_duplicates=True):
    """
    Enable LE passive scan (with filtering of duplicate packets enabled).
    :param sock: A bluetooth HCI socket (retrieved using the
        ``hci_open_dev`` PyBluez function).
    :param interval: Scan interval.
    :param window: Scan window (must be less or equal than given interval).
    :param filter_policy: One of
        ``FILTER_POLICY_NO_WHITELIST`` (default value)
        ``FILTER_POLICY_SCAN_WHITELIST``
        ``FILTER_POLICY_CONN_WHITELIST``
        ``FILTER_POLICY_SCAN_AND_CONN_WHITELIST``
    .. note:: Scan interval and window are to multiply by 0.625 ms to
        get the real time duration.
    """
    print("Enable LE scan")
    own_bdaddr_type = LE_PUBLIC_ADDRESS  # does not work with LE_RANDOM_ADDRESS
    cmd_pkt = struct.pack("<BHHBB", SCAN_TYPE_PASSIVE, interval, window,
                          own_bdaddr_type, filter_policy)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS, cmd_pkt)
    print("scan params: interval=%.3fms window=%.3fms own_bdaddr=%s "
          "whitelist=%s" %
          (interval * 0.625, window * 0.625,
           'public' if own_bdaddr_type == LE_PUBLIC_ADDRESS else 'random',
           'yes' if filter_policy in (FILTER_POLICY_SCAN_WHITELIST,
                                      FILTER_POLICY_SCAN_AND_CONN_WHITELIST)
           else 'no'))
    cmd_pkt = struct.pack("<BB", SCAN_ENABLE, SCAN_FILTER_DUPLICATES if filter_duplicates else 0x00)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, cmd_pkt)
 def disable_le_scan(sock):
    """
    Disable LE scan.
    :param sock: A bluetooth HCI socket (retrieved using the
        ``hci_open_dev`` PyBluez function).
    """
    print("Disable LE scan")
    cmd_pkt = struct.pack("<BB", SCAN_DISABLE, 0x00)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, cmd_pkt)
 def start_le_advertising(sock, min_interval=1000, max_interval=1000,
                         adv_type=ADV_NONCONN_IND, data=()):
    """
    Start LE advertising.
    :param sock: A bluetooth HCI socket (retrieved using the
        ``hci_open_dev`` PyBluez function).
    :param min_interval: Minimum advertising interval.
    :param max_interval: Maximum advertising interval.
    :param adv_type: Advertisement type (``ADV_NONCONN_IND`` by default).
    :param data: The advertisement data (maximum of 31 bytes).
    :type data: iterable
    """
    own_bdaddr_type = 0
    direct_bdaddr_type = 0
    direct_bdaddr = (0,) * 6
    chan_map = 0x07  # All channels: 37, 38, 39
    filter = 0
    struct_params = [min_interval, max_interval, adv_type, own_bdaddr_type,
                     direct_bdaddr_type]
    struct_params.extend(direct_bdaddr)
    struct_params.extend((chan_map, filter))
    cmd_pkt = struct.pack("<HHBBB6BBB", *struct_params)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISING_PARAMETERS,
                       cmd_pkt)
    cmd_pkt = struct.pack("<B", 0x01)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISE_ENABLE, cmd_pkt)
    data_length = len(data)
    if data_length > 31:
        raise ValueError("data is too long (%d but max is 31 bytes)",
                         data_length)
    cmd_pkt = struct.pack("<B%dB" % data_length, data_length, *data)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISING_DATA, cmd_pkt)
    print("Advertising started data_length=%d data=%r" % (data_length, data))
 def stop_le_advertising(sock):
    """
    Stop LE advertising.
    :param sock: A bluetooth HCI socket (retrieved using the
        ``hci_open_dev`` PyBluez function).
    """
    cmd_pkt = struct.pack("<B", 0x00)
    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISE_ENABLE, cmd_pkt)
    print("Advertising stopped")
 def parse_le_advertising_events(sock, mac_addr=None, packet_length=None,
                                handler=None, debug=False):
    """
    Parse and report LE advertisements.
    This is a blocking call, an infinite loop is started and the
    given handler will be called each time a new LE advertisement packet
    is detected and corresponds to the given filters.
    .. note:: The :func:`.start_le_advertising` function must be
        called before calling this function.
    :param sock: A bluetooth HCI socket (retrieved using the
        ``hci_open_dev`` PyBluez function).
    :param mac_addr: list of filtered mac address representations
        (uppercase, with ':' separators).
        If not specified, the LE advertisement of any device will be reported.
        Example: mac_addr=('00:2A:5F:FF:25:11', 'DA:FF:12:33:66:12')
    :type mac_addr: ``list`` of ``string``
    :param packet_length: Filter a specific length of LE advertisement packet.
    :type packet_length: ``int``
    :param handler: Handler that will be called each time a LE advertisement
        packet is available (in accordance with the ``mac_addr``
        and ``packet_length`` filters).
    :type handler: ``callable`` taking 4 parameters:
        mac (``str``), adv_type (``int``), data (``bytes``) and rssi (``int``)
    :param debug: Enable debug prints.
    :type debug: ``bool``
    """
    if not debug and handler is None:
        raise ValueError("You must either enable debug or give a handler !")
    old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
    flt = bluez.hci_filter_new()
    bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
    # bluez.hci_filter_all_events(flt)
    bluez.hci_filter_set_event(flt, LE_META_EVENT)
    sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
    print("socket filter set to ptype=HCI_EVENT_PKT event=LE_META_EVENT")
    print("Listening ...")
    try:
        while True:
            pkt = full_pkt = sock.recv(255)
            ptype, event, plen = struct.unpack("BBB", pkt[:3])
            if event != LE_META_EVENT:
                # Should never occur because we filtered with this type of event
                print("Not a LE_META_EVENT !")
                continue
            sub_event, = struct.unpack("B", pkt[3:4])
            if sub_event != EVT_LE_ADVERTISING_REPORT:
                if debug:
                    print("Not a EVT_LE_ADVERTISING_REPORT !")
                continue
            pkt = pkt[4:]
            adv_type = struct.unpack("b", pkt[1:2])[0]
            mac_addr_str = bluez.ba2str(pkt[3:9])
            if packet_length and plen != packet_length:
                # ignore this packet
                if debug:
                    print("packet with non-matching length: mac=%s adv_type=%02x plen=%s" %
                          (mac_addr_str, adv_type, plen))
                    print(raw_packet_to_str(pkt))
                continue
            data = pkt[9:-1]
            rssi = struct.unpack("b", full_pkt[len(full_pkt)-1:len(full_pkt)])[0]
            if mac_addr and mac_addr_str not in mac_addr:
                if debug:
                    print("packet with non-matching mac %s adv_type=%02x data=%s RSSI=%s" %
                          (mac_addr_str, adv_type, raw_packet_to_str(data), rssi))
                continue
            if debug:
                print("LE advertisement: mac=%s adv_type=%02x data=%s RSSI=%d" %
                      (mac_addr_str, adv_type, raw_packet_to_str(data), rssi))
            if handler is not None:
                try:
                    handler(mac_addr_str, adv_type, data, rssi)
                except Exception as e:
                    print('Exception when calling handler with a BLE advertising event: %r' % (e,))
                    import traceback
                    traceback.print_exc()
    except KeyboardInterrupt:
        print("\nRestore previous socket filter")
        sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
        raise
 """
 def hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
 {
    struct hci_request {
        uint16_t ogf;
        uint16_t ocf;
        int      event;
        void     *cparam;
        int      clen;
        void     *rparam;
        int      rlen;
    };
    struct hci_request rq;
    le_add_device_to_white_list_cp cp;
    uint8_t status;
    memset(&cp, 0, sizeof(cp));
    cp.bdaddr_type = type;
    bacpy(&cp.bdaddr, bdaddr);
    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
    rq.cparam = &cp;
    rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;
    if (hci_send_req(dd, &rq, to) < 0)
            return -1;
    if (status) {
            errno = EIO;
            return -1;
    }
    return 0;
 }"""
--- a/systemd/README.md
+++ b/systemd/README.md
@@ -0,0 +1,273 @@
 # Systemd Service Installation
 ## Installing Sensorpajen as a User Service
 This allows sensorpajen to run automatically on boot as your user (no sudo required for management).
 ### Installation Steps
 #### 1. Install the Service File
 ```bash
 cd ~/sensorpajen
 # Create user systemd directory if it doesn't exist
 mkdir -p ~/.config/systemd/user/
 # Copy service file
 cp systemd/sensorpajen.service ~/.config/systemd/user/
 # Reload systemd to recognize the new service
 systemctl --user daemon-reload
 ```
 #### 2. Enable Lingering (Run Without Login)
 This allows your user services to run even when you're not logged in:
 ```bash
 # Enable lingering for your user
 sudo loginctl enable-linger $USER
 # Verify it's enabled
 loginctl show-user $USER | grep Linger
 # Should show: Linger=yes
 ```
 #### 3. Start and Enable the Service
 ```bash
 # Start the service now
 systemctl --user start sensorpajen
 # Enable it to start on boot
 systemctl --user enable sensorpajen
 # Check status
 systemctl --user status sensorpajen
 ```
 ### Service Management Commands
 ```bash
 # Start the service
 systemctl --user start sensorpajen
 # Stop the service
 systemctl --user stop sensorpajen
 # Restart the service
 systemctl --user restart sensorpajen
 # Check status
 systemctl --user status sensorpajen
 # View logs (all)
 journalctl --user -u sensorpajen
 # View logs (follow/tail)
 journalctl --user -u sensorpajen -f
 # View logs (last 100 lines)
 journalctl --user -u sensorpajen -n 100
 # View logs (since specific time)
 journalctl --user -u sensorpajen --since "1 hour ago"
 journalctl --user -u sensorpajen --since "2025-12-27 10:00"
 # Enable service (start on boot)
 systemctl --user enable sensorpajen
 # Disable service (don't start on boot)
 systemctl --user disable sensorpajen
 ```
 ### Viewing Logs
 The service logs to systemd journal. View them with:
 ```bash
 # Live view (like tail -f)
 journalctl --user -u sensorpajen -f
 # With timestamps
 journalctl --user -u sensorpajen -f -o short-iso
 # Just today's logs
 journalctl --user -u sensorpajen --since today
 ```
 ### Updating the Service
 After making changes to the code:
 ```bash
 # Pull latest changes
 cd ~/sensorpajen
 git pull origin master
 # Restart the service to apply changes
 systemctl --user restart sensorpajen
 # Check it started correctly
 systemctl --user status sensorpajen
 ```
 After editing `sensorpajen.service`:
 ```bash
 # Copy updated service file
 cp systemd/sensorpajen.service ~/.config/systemd/user/
 # Reload systemd configuration
 systemctl --user daemon-reload
 # Restart the service
 systemctl --user restart sensorpajen
 ```
 After editing configuration files:
 ```bash
 # Edit config
 nano ~/sensorpajen/config/sensorpajen.env
 # or
 nano ~/sensorpajen/config/sensors.json
 # Restart service to reload config
 systemctl --user restart sensorpajen
 ```
 ### Troubleshooting
 ### Permission Denied Errors
 If you see `PermissionError: [Errno 1] Operation not permitted` in the logs:
 ```bash
 # Verify Bluetooth capabilities are set on Python binary
 getcap ~/.local/share/virtualenvs/*/bin/python3.*
 # If not set, apply capabilities (adjust path to your venv):
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f ~/sensorpajen/.venv/bin/python3)
 # Verify it was set:
 getcap $(readlink -f ~/sensorpajen/.venv/bin/python3)
 # Should show: cap_net_admin,cap_net_raw+eip
 # Restart the service
 systemctl --user restart sensorpajen
 ```
 **Important**: Capabilities must be set on the **actual Python binary**, not symlinks. Use `readlink -f` to resolve the real path.
 #### Service Won't Start
 ```bash
 # Check detailed status
 systemctl --user status sensorpajen
 # Check logs for errors
 journalctl --user -u sensorpajen -n 50
 # Test the command manually
 cd ~/sensorpajen
 source .venv/bin/activate
 export $(cat config/sensorpajen.env | grep -v '^#' | xargs)
 python -m sensorpajen.main
 ```
 #### Bluetooth Permission Errors
 Make sure capabilities are set on the Python binary:
 ```bash
 getcap $(readlink -f ~/.venv/bin/python3)
 # Should show: cap_net_raw,cap_net_admin+eip
 # If not set:
 sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f ~/sensorpajen/.venv/bin/python3)
 ```
 #### Service Doesn't Start on Boot
 ```bash
 # Check if service is enabled
 systemctl --user is-enabled sensorpajen
 # Should show: enabled
 # Check if lingering is enabled
 loginctl show-user $USER | grep Linger
 # Should show: Linger=yes
 # If not enabled:
 systemctl --user enable sensorpajen
 sudo loginctl enable-linger $USER
 ```
 #### Environment Variables Not Loading
 ```bash
 # Verify environment file exists and is readable
 cat ~/sensorpajen/config/sensorpajen.env
 # Check file permissions
 ls -la ~/sensorpajen/config/sensorpajen.env
 # Test loading manually
 export $(cat ~/sensorpajen/config/sensorpajen.env | grep -v '^#' | xargs)
 env | grep MQTT
 ```
 ### Verifying Everything Works
 After installation:
 ```bash
 # 1. Check service is running
 systemctl --user status sensorpajen
 # 2. Check logs show sensor data
 journalctl --user -u sensorpajen -f
 # 3. Check MQTT messages are being published
 mosquitto_sub -h 192.168.0.114 -u hasse -P casablanca -t "MiTemperature2/#" -v
 # 4. Reboot and verify it starts automatically
 sudo reboot
 # After reboot:
 systemctl --user status sensorpajen
 ```
 ### Uninstalling the Service
 If you need to remove the service:
 ```bash
 # Stop and disable
 systemctl --user stop sensorpajen
 systemctl --user disable sensorpajen
 # Remove service file
 rm ~/.config/systemd/user/sensorpajen.service
 # Reload systemd
 systemctl --user daemon-reload
 # Optionally disable lingering
 sudo loginctl disable-linger $USER
 ```
 ## Notes
 - **User Service**: Runs as your user, not root - more secure and easier to manage
 - **Lingering**: Required for services to run when not logged in
 - **Logs**: All output goes to systemd journal (journalctl)
 - **Auto-restart**: Service restarts automatically on crashes
 - **Environment**: Config loaded from `config/sensorpajen.env`
 - **Working Directory**: Service runs from `~/sensorpajen`
 ## Next Steps
 Once the service is working:
 1. Monitor for a few days to ensure stability
 2. Check logs occasionally: `journalctl --user -u sensorpajen --since yesterday`
 3. Service will survive reboots and automatically restart on failures
--- a/systemd/sensorpajen.service
+++ b/systemd/sensorpajen.service
@@ -0,0 +1,32 @@
 [Unit]
 Description=Sensorpajen - Bluetooth Temperature Sensor Monitor
 Documentation=https://github.com/yourusername/sensorpajen
 After=network.target bluetooth.target
 Wants=bluetooth.target
 [Service]
 Type=simple
 WorkingDirectory=%h/sensorpajen
 EnvironmentFile=%h/sensorpajen/config/sensorpajen.env
 ExecStart=%h/sensorpajen/.venv/bin/python -m sensorpajen.main
 Restart=always
 RestartSec=10
 # Bluetooth capabilities (alternative to setcap)
 # Note: This requires systemd to be run with proper permissions
 # If this doesn't work, use setcap on the Python binary instead
 #AmbientCapabilities=CAP_NET_RAW CAP_NET_ADMIN
 # Logging
 StandardOutput=journal
 StandardError=journal
 SyslogIdentifier=sensorpajen
 # Security
 # Note: NoNewPrivileges=true can prevent file capabilities from working
 # We need capabilities for Bluetooth access, so we can't use it
 #NoNewPrivileges=true
 PrivateTmp=true
 [Install]
 WantedBy=default.target
--- a/temperatur_koksfonstret.py
+++ b/temperatur_koksfonstret.py
@@ -1,45 +0,0 @@
 #!/usr/bin/python3
 # Copyright (c) 2014 Adafruit Industries
 # Author: Tony DiCola
 import sys
 import Adafruit_DHT
 import paho.mqtt.client as mqtt 
 mqttserver = "192.168.0.114"
 client = mqtt.Client("koksfonstret")
 client.connect(mqttserver)
 # Parse command line parameters.
 sensor_args = { '11': Adafruit_DHT.DHT11,
                '22': Adafruit_DHT.DHT22,
                '2302': Adafruit_DHT.AM2302 }
 if len(sys.argv) == 3 and sys.argv[1] in sensor_args:
    sensor = sensor_args[sys.argv[1]]
    pin = sys.argv[2]
 else:
    print('Usage: sudo ./Adafruit_DHT.py [11|22|2302] <GPIO pin number>')
    print('Example: sudo ./Adafruit_DHT.py 2302 4 - Read from an AM2302 connected to GPIO pin #4')
    sys.exit(1)
 # Try to grab a sensor reading.  Use the read_retry method which will retry up
 # to 15 times to get a sensor reading (waiting 2 seconds between each retry).
 humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)
 # Un-comment the line below to convert the temperature to Fahrenheit.
 # temperature = temperature * 9/5.0 + 32
 # Note that sometimes you won't get a reading and
 # the results will be null (because Linux can't
 # guarantee the timing of calls to read the sensor).
 # If this happens try again!
 if humidity is not None and temperature is not None:
    print('Temp={0:0.1f}*  Humidity={1:0.1f}%'.format(temperature, humidity))
    client.publish("casablanca/koksfonstret/temperature", temperature)
    client.publish("casablanca/koksfonstret/humidity", humidity)
 else:
    print('Failed to get reading. Try again!')
    sys.exit(1)
Author	SHA1	Message	Date
Fredrik Wahlberg	5850089de9	Track reviewed status for discovered sensors Changes: - Added 'reviewed' field to DiscoveredSensor dataclass - By default, only show new (unreviewed) pending sensors - Mark sensors as reviewed when shown in approval CLI - Add --all flag to show all pending sensors (including reviewed) - Add --ignored flag to show ignored sensors - Prevent repeatedly asking for approval of same sensor Usage: approve-sensors # Only new sensors approve-sensors --all # All pending sensors approve-sensors --ignored # Ignored sensors approve-sensors --all --ignored # Everything	2025-12-27 20:33:14 +01:00
Fredrik Wahlberg	c8e8afff67	Add standalone approve-sensors script Creates a wrapper that sets minimal env vars so the tool can run without full MQTT configuration.	2025-12-27 20:28:36 +01:00
Fredrik Wahlberg	9b1229a2ee	Implement sensor auto-discovery feature New Features: - Automatic discovery of unknown Bluetooth sensors - Discovery manager tracks pending/approved/ignored sensors - ntfy notifications when new sensors found (optional) - Interactive CLI tool: sensorpajen-approve-sensors - Automatic config reload every 15 minutes (no restart needed) Files Added: - src/sensorpajen/discovery_manager.py: Sensor discovery management - src/sensorpajen/approve_sensors.py: Interactive approval CLI - config/discovered_sensors.json.example: Example discovery file Files Modified: - src/sensorpajen/config.py: Added ntfy and discovery config - src/sensorpajen/main.py: Added discovery manager and config reload - src/sensorpajen/sensor_reader.py: Added discovery on unknown sensors - config/sensorpajen.env.example: Added ntfy and reload settings - pyproject.toml: Added approve-sensors CLI command Configuration: - NTFY_ENABLED, NTFY_URL, NTFY_TOPIC, NTFY_TOKEN - DISCOVERED_SENSORS_FILE, CONFIG_RELOAD_INTERVAL - Pre-filled comments with sensor metadata See TASKS.md for complete feature specification.	2025-12-27 15:03:19 +01:00
Fredrik Wahlberg	9de5f82924	Add implementation details to sensor auto-discovery task Clarifications added: - Storage: config/discovered_sensors.json with extended metadata - ntfy: Optional notifications via curl with token auth - CLI: sensorpajen approve-sensors (interactive only) - Config reload: Every 15 minutes, no service restart needed - Metadata: MAC, name, RSSI, timestamps, sample readings - Ignored sensors: Stored with timestamp and optional reason - Pre-filled comments with metadata for user to edit	2025-12-27 14:54:52 +01:00
Fredrik Wahlberg	e3bec0d16e	Update README with current system architecture - Modernized documentation to reflect systemd service - Added installation and configuration instructions - Kept thermometer flashing instructions - Added troubleshooting section - Added project structure overview - Removed outdated DHT11 and cron references	2025-12-27 14:30:21 +01:00
Fredrik Wahlberg	675c39eab3	Update ROADMAP: Mark Phase 7 complete and fix phase ordering - Phase 7 (Testing & Validation) complete - service running successfully - Fixed phase ordering (Phase 9 was appearing before Phase 8) - Cleaned up corrupted/duplicate content in phases section	2025-12-27 14:22:22 +01:00
Fredrik Wahlberg	c1519b3eb5	Update ROADMAP: Document Phase 6 lessons learned Key discoveries during systemd service implementation: - AmbientCapabilities doesn't work in user services - NoNewPrivileges prevents file capabilities - Must use setcap with readlink -f on actual binary	2025-12-27 14:18:28 +01:00
Fredrik Wahlberg	f36257226f	Fix systemd service: Disable NoNewPrivileges NoNewPrivileges=true prevents file capabilities from working. Since we need CAP_NET_RAW/CAP_NET_ADMIN for Bluetooth, we must disable this security feature.	2025-12-27 14:17:36 +01:00
Fredrik Wahlberg	b740372d88	Fix systemd service: Add Bluetooth permissions troubleshooting The service needs setcap on the Python binary to access Bluetooth. Added verification steps to troubleshooting section.	2025-12-27 14:14:51 +01:00
Fredrik Wahlberg	d0ba2c5a52	Phase 6 Complete: Systemd Service Creation - Created systemd/sensorpajen.service user service unit - Uses %h for portability across systems - Loads environment from EnvironmentFile - Auto-restart with bluetooth capabilities - Comprehensive security settings - Created systemd/README.md - Installation instructions - Service management commands - Troubleshooting guide - Log viewing examples - Updated ROADMAP.md to mark Phase 6 complete	2025-12-27 14:09:29 +01:00
Fredrik Wahlberg	b2f9bff765	Fix paho-mqtt v2.x compatibility Handle both paho-mqtt v1.x and v2.x in MQTTPublisher: - Try v2.x format with callback_api_version first - Fall back to v1.x format if needed - Ensures compatibility across different paho-mqtt versions Fixes: ValueError when using paho-mqtt 2.0+	2025-12-27 13:52:13 +01:00
Fredrik Wahlberg	f54c0a0f35	Add Raspberry Pi setup and testing guide Created SETUP_ON_PI.md with comprehensive instructions for: - Pulling latest changes on the Pi - Installing system dependencies (Bluetooth, Python) - Setting up virtual environment - Configuring Bluetooth permissions - Setting up configuration files - Running test - Troubleshooting common issues - Environment variable reference Enables seamless development workflow between machines.	2025-12-27 13:42:51 +01:00
Fredrik Wahlberg	c9b68dd8e2	Phase 2 Complete: Python Package Structure Core modules created: - config.py: Environment-based configuration management - Loads MQTT settings from environment variables - SensorConfig class for JSON sensor mapping - Relative path resolution (PROJECT_ROOT) - Configuration validation with fail-fast - mqtt_publisher.py: MQTT client wrapper - MQTTPublisher class with connection management - Replaces sendToMQTT.sh shell script - Direct Python MQTT publishing - Automatic reconnection support - Optional battery data publishing - sensor_reader.py: Bluetooth BLE sensor reader - SensorReader class for passive BLE scanning - ATC firmware packet parsing - Duplicate packet filtering via advertisement counter - Watchdog thread for BLE recovery - Measurement dataclass for type safety - utils.py: Bluetooth utilities - Ported from bluetooth_utils.py (MIT, Colin GUYON) - BLE scanning and advertisement parsing functions - Linux HCI socket operations - main.py: Application entry point - Sensorpajen main application class - Signal handling (SIGTERM/SIGINT) for graceful shutdown - Logging to stdout for journald integration - Coordinates all components Architecture: - Direct Python integration (no shell scripts) - Clean separation of concerns - Type hints and dataclasses - Comprehensive logging - Graceful shutdown handling Updated ROADMAP.md to mark Phase 2 as complete. Next: Phase 3 - Configuration Migration (mostly done in Phase 1)	2025-12-27 13:17:26 +01:00
Fredrik Wahlberg	426f1d3813	Phase 1 Complete: Preparation & Cleanup Directory structure: - Created src/sensorpajen/ for new Python package - Created config/ for configuration templates - Created legacy/ for old scripts - Created systemd/ and debian/ for future phases Package setup: - Added pyproject.toml with modern Python packaging - Created package __init__.py - Defined dependencies: bluepy, paho-mqtt Configuration: - Created config/sensors.json.example (converted from INI) - Created config/sensorpajen.env.example for environment variables - All 8 Xiaomi sensors migrated to JSON format Cleanup: - Removed temperatur_koksfonstret.py (DHT11 functionality) - Moved all legacy scripts to legacy/ folder: - LYWSD03MMC.py - bluetooth_utils.py - sendToMQTT.sh - sensorer.sh - startup.sh - sensorer.ini Updated ROADMAP.md to mark Phase 1 as complete. Next: Phase 2 - Python Package Structure	2025-12-27 13:13:51 +01:00
Fredrik Wahlberg	8cc2c41acf	Begin version 2.0.0 development Starting modernization phase: - Transition to systemd service - Modern Python package structure - Relative configuration paths - APT package support See ROADMAP.md for complete implementation plan.	2025-12-27 13:10:40 +01:00