rick/LEDMatrix
1
0
Fork 0
mirror of https://github.com/ChuckBuilds/LEDMatrix.git synced 2026-04-10 13:02:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Docs/consolidate documentation (#217)

Browse Source 
* docs: rename FONT_MANAGER_USAGE.md to FONT_MANAGER.md

Renamed for clearer naming convention.
Part of documentation consolidation effort.

* docs: consolidate Plugin Store guides (2→1)

Merged:
- PLUGIN_STORE_USER_GUIDE.md
- PLUGIN_STORE_QUICK_REFERENCE.md

Into: PLUGIN_STORE_GUIDE.md

- Unified writing style to professional technical
- Added Quick Reference section at top for easy access
- Removed duplicate content
- Added cross-references to related documentation
- Updated formatting to match style guidelines

* docs: create user-focused Web Interface Guide

Created WEB_INTERFACE_GUIDE.md consolidating:
- V3_INTERFACE_README.md (technical details)
- User-facing interface documentation

- Focused on end-user tasks and navigation
- Removed technical implementation details
- Added common tasks section
- Included troubleshooting
- Professional technical writing style

* docs: consolidate WiFi setup guides (4→1)

Merged:
- WIFI_SETUP.md
- OPTIMAL_WIFI_AP_FAILOVER_SETUP.md
- AP_MODE_MANUAL_ENABLE.md
- WIFI_ETHERNET_AP_MODE_FIX.md (behavior documentation)

Into: WIFI_NETWORK_SETUP.md

- Comprehensive coverage of WiFi setup and configuration
- Clear explanation of AP mode failover and grace period
- Configuration scenarios and best practices
- Troubleshooting section combining all sources
- Professional technical writing style
- Added quick reference table for behavior

* docs: consolidate troubleshooting guides (4→1)

Merged:
- TROUBLESHOOTING_QUICK_START.md
- WEB_INTERFACE_TROUBLESHOOTING.md
- CAPTIVE_PORTAL_TROUBLESHOOTING.md
- WEATHER_TROUBLESHOOTING.md

Into: TROUBLESHOOTING.md

- Organized by issue category (web, WiFi, plugins)
- Comprehensive diagnostic commands reference
- Quick diagnosis steps at the top
- Service file template preserved
- Complete diagnostic script included
- Professional technical writing style

* docs: create consolidated Advanced Features guide

Merged:
- VEGAS_SCROLL_MODE.md
- ON_DEMAND_DISPLAY_QUICK_START.md
- ON_DEMAND_DISPLAY_API.md
- ON_DEMAND_CACHE_MANAGEMENT.md
- BACKGROUND_SERVICE_README.md
- PERMISSION_MANAGEMENT_GUIDE.md

Into: ADVANCED_FEATURES.md

- Comprehensive guide covering all advanced features
- Vegas scroll mode with integration examples
- On-demand display with API reference
- Cache management troubleshooting
- Background service documentation
- Permission management patterns
- Professional technical writing style

* docs: create Getting Started guide for first-time users

Created GETTING_STARTED.md:
- Quick start guide (5 minutes)
- Initial configuration walkthrough
- Common first-time issues and solutions
- Next steps and quick reference
- User-friendly tone for beginners
- Links to detailed documentation

* docs: archive consolidated source files and ephemeral docs

Archived files that have been consolidated:
- Plugin Store guides (2 files → PLUGIN_STORE_GUIDE.md)
- Web Interface guide (V3_INTERFACE_README.md → WEB_INTERFACE_GUIDE.md)
- WiFi Setup guides (4 files → WIFI_NETWORK_SETUP.md)
- Troubleshooting guides (4 files → TROUBLESHOOTING.md)
- Advanced Features (6 files → ADVANCED_FEATURES.md)

Archived ephemeral/debug documentation:
- DEBUG_WEB_ISSUE.md
- BROWSER_ERRORS_EXPLANATION.md
- FORM_VALIDATION_FIXES.md
- WEB_UI_RELIABILITY_IMPROVEMENTS.md
- CAPTIVE_PORTAL_TESTING.md
- NEXT_STEPS_COMMANDS.md
- STATIC_IMAGE_MULTI_UPLOAD_PLAN.md
- RECONNECT_AFTER_CAPTIVE_PORTAL_TESTING.md

Archived implementation summaries:
- PLUGIN_CONFIG_TABS_SUMMARY.md
- PLUGIN_CONFIG_SYSTEM_VERIFICATION.md
- PLUGIN_SCHEMA_AUDIT_SUMMARY.md
- STARTUP_OPTIMIZATION_SUMMARY.md
- PLUGIN_DISPATCH_IMPLEMENTATION.md
- NESTED_SCHEMA_IMPLEMENTATION.md
- AP_MODE_MANUAL_ENABLE_CHANGES.md
- PLUGIN_CONFIG_SYSTEM_EXPLANATION.md

Total archived: 27 files
Preserves git history while cleaning up main docs directory

* docs: rename API_REFERENCE.md to REST_API_REFERENCE.md

Renamed for clarity - this is specifically the REST API reference
for the web interface, not a general API reference.

* docs: update README.md to reflect consolidated documentation structure

Updated documentation index:
- Reflects new consolidated guides (51 → 16-17 files)
- Updated Quick Start sections with new file names
- Added consolidation history (January 2026)
- Updated file references (API_REFERENCE → REST_API_REFERENCE)
- Documented archival of 33 files
- Added benefits of consolidation
- Updated statistics and highlights
- Removed outdated references
- Professional writing style maintained throughout

* docs: add Vegas scroll mode system architecture documentation

Added comprehensive internal architecture section for Vegas mode:
- Component overview with diagram
- VegasModeCoordinator responsibilities and main loop
- StreamManager buffering strategy and content flow
- PluginAdapter integration and fallback behavior
- RenderPipeline 125 FPS rendering process
- Component interaction flows
- Thread safety patterns
- Performance characteristics

Covers:
- How the four components work together
- Initialization and render loop flows
- Config update handling
- Frame rate management and optimization
- Memory usage and CPU characteristics

---------

Co-authored-by: Chuck <chuck@example.com>
This commit is contained in:
Chuck
2026-01-29 10:32:00 -05:00
committed by GitHub
parent 7524747e44
commit ddd300a117
42 changed files with 3954 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
docs/archive/AP_MODE_MANUAL_ENABLE.md Normal file
View File

@@ -0,0 +1,159 @@
# AP Mode Manual Enable Configuration
## Overview
By default, Access Point (AP) mode is **not automatically enabled** after installation. AP mode must be manually enabled through the web interface when needed.
## Default Behavior
- **Auto-enable AP mode**: `false` (disabled by default)
- AP mode will **not** automatically activate when WiFi or Ethernet disconnects
- AP mode can only be enabled manually through the web interface
## Why Manual Enable?
This prevents:
- AP mode from activating unexpectedly after installation
- Network conflicts when Ethernet is connected
- SSH becoming unavailable due to automatic AP mode activation
- Unnecessary AP mode activation on systems with stable network connections
## Enabling AP Mode
### Via Web Interface
1. Navigate to the **WiFi** tab in the web interface
2. Click the **"Enable AP Mode"** button
3. AP mode will activate if:
- WiFi is not connected AND
- Ethernet is not connected
### Via API
```bash
# Enable AP mode
curl -X POST http://localhost:5001/api/v3/wifi/ap/enable
# Disable AP mode
curl -X POST http://localhost:5001/api/v3/wifi/ap/disable
```
## Enabling Auto-Enable (Optional)
If you want AP mode to automatically enable when WiFi/Ethernet disconnect:
### Via Web Interface
1. Navigate to the **WiFi** tab
2. Look for the **"Auto-enable AP Mode"** toggle or setting
3. Enable the toggle
### Via Configuration File
Edit `config/wifi_config.json`:
```json
{
"auto_enable_ap_mode": true,
...
}
```
Then restart the WiFi monitor service:
```bash
sudo systemctl restart ledmatrix-wifi-monitor
```
### Via API
```bash
# Get current setting
curl http://localhost:5001/api/v3/wifi/ap/auto-enable
# Set auto-enable to true
curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-H "Content-Type: application/json" \
-d '{"auto_enable_ap_mode": true}'
```
## Behavior Summary
| Auto-Enable Setting | WiFi Status | Ethernet Status | AP Mode Behavior |
|---------------------|-------------|-----------------|------------------|
| `false` (default) | Any | Any | Manual enable only |
| `true` | Connected | Any | Disabled |
| `true` | Disconnected | Connected | Disabled |
| `true` | Disconnected | Disconnected | **Auto-enabled** |
## When Auto-Enable is Disabled (Default)
- AP mode **never** activates automatically
- Must be manually enabled via web UI or API
- Once enabled, it will automatically disable when WiFi or Ethernet connects
- Useful for systems with stable network connections (e.g., Ethernet)
## When Auto-Enable is Enabled
- AP mode automatically enables when both WiFi and Ethernet disconnect
- AP mode automatically disables when WiFi or Ethernet connects
- Useful for portable devices that may lose network connectivity
## Troubleshooting
### AP Mode Not Enabling
1. **Check if WiFi or Ethernet is connected**:
```bash
nmcli device status
```
2. **Check auto-enable setting**:
```bash
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
print('Auto-enable:', wm.config.get('auto_enable_ap_mode', False))
"
```
3. **Manually enable AP mode**:
- Use web interface: WiFi tab → Enable AP Mode button
- Or via API: `POST /api/v3/wifi/ap/enable`
### AP Mode Enabling Unexpectedly
1. **Check auto-enable setting**:
```bash
cat config/wifi_config.json | grep auto_enable_ap_mode
```
2. **Disable auto-enable**:
```bash
# Edit config file
nano config/wifi_config.json
# Set "auto_enable_ap_mode": false
# Restart service
sudo systemctl restart ledmatrix-wifi-monitor
```
3. **Check service logs**:
```bash
sudo journalctl -u ledmatrix-wifi-monitor -f
```
## Migration from Old Behavior
If you have an existing installation that was auto-enabling AP mode:
1. The default is now `false` (manual enable)
2. Existing configs will be updated to include `auto_enable_ap_mode: false`
3. If you want the old behavior, set `auto_enable_ap_mode: true` in `config/wifi_config.json`
## Related Documentation
- [WiFi Setup Guide](WIFI_SETUP.md)
- [SSH Unavailable After Install](SSH_UNAVAILABLE_AFTER_INSTALL.md)
- [WiFi Ethernet AP Mode Fix](WIFI_ETHERNET_AP_MODE_FIX.md)

186
docs/archive/AP_MODE_MANUAL_ENABLE_CHANGES.md Normal file
View File

@@ -0,0 +1,186 @@
# AP Mode Manual Enable - Implementation Summary
## Changes Made
### 1. Configuration Option Added
Added `auto_enable_ap_mode` configuration option to `config/wifi_config.json`:
- **Default value**: `false` (manual enable only)
- **Purpose**: Controls whether AP mode automatically enables when WiFi/Ethernet disconnect
- **Migration**: Existing configs automatically get this field set to `false` if missing
### 2. WiFi Manager Updates (`src/wifi_manager.py`)
#### Added Configuration Field
- Default config now includes `"auto_enable_ap_mode": False`
- Existing configs are automatically migrated to include this field
#### Updated `check_and_manage_ap_mode()` Method
- Now checks `auto_enable_ap_mode` setting before auto-enabling AP mode
- AP mode only auto-enables if:
- `auto_enable_ap_mode` is `true` AND
- WiFi is NOT connected AND
- Ethernet is NOT connected
- AP mode still auto-disables when WiFi or Ethernet connects (regardless of setting)
- Manual AP mode (via web UI) works regardless of this setting
### 3. Web Interface API Updates (`web_interface/blueprints/api_v3.py`)
#### Updated `/wifi/status` Endpoint
- Now returns `auto_enable_ap_mode` setting in response
#### Added `/wifi/ap/auto-enable` GET Endpoint
- Returns current `auto_enable_ap_mode` setting
#### Added `/wifi/ap/auto-enable` POST Endpoint
- Allows setting `auto_enable_ap_mode` via API
- Accepts JSON: `{"auto_enable_ap_mode": true/false}`
### 4. Documentation Updates
- Updated `docs/WIFI_SETUP.md` with new configuration option
- Created `docs/AP_MODE_MANUAL_ENABLE.md` with comprehensive guide
- Created `docs/AP_MODE_MANUAL_ENABLE_CHANGES.md` (this file)
## Behavior Changes
### Before
- AP mode automatically enabled when WiFi disconnected (if Ethernet also disconnected)
- Could cause SSH to become unavailable after installation
- No way to disable auto-enable behavior
### After
- AP mode **does not** automatically enable by default
- Must be manually enabled through web UI or API
- Can optionally enable auto-enable via configuration
- Prevents unexpected AP mode activation
## Migration
### Existing Installations
1. **Automatic Migration**:
- When WiFi manager loads config, it automatically adds `auto_enable_ap_mode: false` if missing
- No manual intervention required
2. **To Enable Auto-Enable** (if desired):
```bash
# Edit config file
nano config/wifi_config.json
# Set "auto_enable_ap_mode": true
# Restart WiFi monitor service
sudo systemctl restart ledmatrix-wifi-monitor
```
### New Installations
- Default behavior is manual enable only
- No changes needed
## Testing
### Verify Default Behavior
```bash
# Check config
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
print('Auto-enable:', wm.config.get('auto_enable_ap_mode', False))
"
# Should output: Auto-enable: False
```
### Test Manual Enable
1. Disconnect WiFi and Ethernet
2. AP mode should **not** automatically enable
3. Enable via web UI: WiFi tab → Enable AP Mode
4. AP mode should activate
5. Connect WiFi or Ethernet
6. AP mode should automatically disable
### Test Auto-Enable (if enabled)
1. Set `auto_enable_ap_mode: true` in config
2. Restart WiFi monitor service
3. Disconnect WiFi and Ethernet
4. AP mode should automatically enable within 30 seconds
5. Connect WiFi or Ethernet
6. AP mode should automatically disable
## API Usage Examples
### Get Auto-Enable Setting
```bash
curl http://localhost:5001/api/v3/wifi/ap/auto-enable
```
### Set Auto-Enable to True
```bash
curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-H "Content-Type: application/json" \
-d '{"auto_enable_ap_mode": true}'
```
### Set Auto-Enable to False
```bash
curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-H "Content-Type: application/json" \
-d '{"auto_enable_ap_mode": false}'
```
### Get WiFi Status (includes auto-enable)
```bash
curl http://localhost:5001/api/v3/wifi/status
```
## Files Modified
1. `src/wifi_manager.py`
- Added `auto_enable_ap_mode` to default config
- Added migration logic for existing configs
- Updated `check_and_manage_ap_mode()` to respect setting
2. `web_interface/blueprints/api_v3.py`
- Updated `/wifi/status` to include auto-enable setting
- Added `/wifi/ap/auto-enable` GET endpoint
- Added `/wifi/ap/auto-enable` POST endpoint
3. `docs/WIFI_SETUP.md`
- Updated documentation with new configuration option
- Updated WiFi monitor daemon description
4. `docs/AP_MODE_MANUAL_ENABLE.md` (new)
- Comprehensive guide for manual enable feature
## Benefits
1. **Prevents SSH Loss**: AP mode won't activate automatically after installation
2. **User Control**: Users can choose whether to enable auto-enable
3. **Ethernet-Friendly**: Works well with hardwired connections
4. **Backward Compatible**: Existing installations automatically migrate
5. **Flexible**: Can still enable auto-enable if desired
## Deployment
### On Existing Installations
1. **No action required** - automatic migration on next WiFi manager initialization
2. **Restart WiFi monitor** (optional, to apply immediately):
```bash
sudo systemctl restart ledmatrix-wifi-monitor
```
### On New Installations
- Default behavior is already manual enable
- No additional configuration needed
## Related Issues Fixed
- SSH becoming unavailable after installation
- AP mode activating when Ethernet is connected
- Unexpected AP mode activation on stable network connections

208
docs/archive/BACKGROUND_SERVICE_README.md Normal file
View File

@@ -0,0 +1,208 @@
# Background Data Service for LEDMatrix
## Overview
The Background Data Service is a new feature that implements background threading for season data fetching to prevent blocking the main display loop. This significantly improves responsiveness and user experience during data fetching operations.
## Key Benefits
- **Non-blocking**: Season data fetching no longer blocks the main display loop
- **Immediate Response**: Returns cached or partial data immediately while fetching complete data in background
- **Configurable**: Can be enabled/disabled per sport with customizable settings
- **Thread-safe**: Uses proper synchronization for concurrent access
- **Retry Logic**: Automatic retry with exponential backoff for failed requests
- **Progress Tracking**: Comprehensive logging and statistics
## Architecture
### Core Components
1. **BackgroundDataService**: Main service class managing background threads
2. **FetchRequest**: Represents individual fetch operations
3. **FetchResult**: Contains results of fetch operations
4. **Sport Managers**: Updated to use background service
### How It Works
1. **Cache Check**: First checks for cached data and returns immediately if available
2. **Background Fetch**: If no cache, starts background thread to fetch complete season data
3. **Partial Data**: Returns immediate partial data (current/recent games) for quick display
4. **Completion**: Background fetch completes and caches full dataset
5. **Future Requests**: Subsequent requests use cached data for instant response
## Configuration
### NFL Configuration Example
```json
{
"nfl_scoreboard": {
"enabled": true,
"background_service": {
"enabled": true,
"max_workers": 3,
"request_timeout": 30,
"max_retries": 3,
"priority": 2
}
}
}
```
### Configuration Options
- **enabled**: Enable/disable background service (default: true)
- **max_workers**: Maximum number of background threads (default: 3)
- **request_timeout**: HTTP request timeout in seconds (default: 30)
- **max_retries**: Maximum retry attempts for failed requests (default: 3)
- **priority**: Request priority (higher = more important, default: 2)
## Implementation Status
### Phase 1: Background Season Data Fetching ✅ COMPLETED
- [x] Created BackgroundDataService class
- [x] Implemented thread-safe data caching
- [x] Added retry logic with exponential backoff
- [x] Modified NFL manager to use background service
- [x] Added configuration support
- [x] Created test script
### Phase 2: Rollout to Other Sports (Next Steps)
- [ ] Apply to NCAAFB manager
- [ ] Apply to NBA manager
- [ ] Apply to NHL manager
- [ ] Apply to MLB manager
- [ ] Apply to other sport managers
## Testing
### Test Script
Run the test script to verify background service functionality:
```bash
python test_background_service.py
```
### Test Scenarios
1. **Cache Hit**: Verify immediate return of cached data
2. **Background Fetch**: Verify non-blocking background data fetching
3. **Partial Data**: Verify immediate return of partial data during background fetch
4. **Completion**: Verify background fetch completion and caching
5. **Subsequent Requests**: Verify cache usage for subsequent requests
6. **Service Disabled**: Verify fallback to synchronous fetching
### Expected Results
- Initial fetch should return partial data immediately (< 1 second)
- Background fetch should complete within 10-30 seconds
- Subsequent fetches should use cache (< 0.1 seconds)
- No blocking of main display loop
## Performance Impact
### Before Background Service
- Season data fetch: 10-30 seconds (blocking)
- Display loop: Frozen during fetch
- User experience: Poor responsiveness
### After Background Service
- Initial response: < 1 second (partial data)
- Background fetch: 10-30 seconds (non-blocking)
- Display loop: Continues normally
- User experience: Excellent responsiveness
## Monitoring
### Logs
The service provides comprehensive logging:
```
[NFL] Background service enabled with 3 workers
[NFL] Starting background fetch for 2024 season schedule...
[NFL] Using 15 immediate events while background fetch completes
[NFL] Background fetch completed for 2024: 256 events
```
### Statistics
Access service statistics:
```python
stats = background_service.get_statistics()
print(f"Total requests: {stats['total_requests']}")
print(f"Cache hits: {stats['cached_hits']}")
print(f"Average fetch time: {stats['average_fetch_time']:.2f}s")
```
## Error Handling
### Automatic Retry
- Failed requests are automatically retried with exponential backoff
- Maximum retry attempts are configurable
- Failed requests are logged with error details
### Fallback Behavior
- If background service is disabled, falls back to synchronous fetching
- If background fetch fails, returns partial data if available
- Graceful degradation ensures system continues to function
## Future Enhancements
### Phase 2 Features
- Apply to all sport managers
- Priority-based request queuing
- Dynamic worker scaling
- Request batching for efficiency
### Phase 3 Features
- Real-time data streaming
- WebSocket support for live updates
- Advanced caching strategies
- Performance analytics dashboard
## Troubleshooting
### Common Issues
1. **Background service not starting**
- Check configuration: `background_service.enabled = true`
- Verify cache manager is properly initialized
- Check logs for initialization errors
2. **Slow background fetches**
- Increase `request_timeout` in configuration
- Check network connectivity
- Monitor API rate limits
3. **Memory usage**
- Background service automatically cleans up old requests
- Adjust `max_workers` if needed
- Monitor cache size
### Debug Mode
Enable debug logging for detailed information:
```python
logging.getLogger('src.background_data_service').setLevel(logging.DEBUG)
```
## Contributing
When adding background service support to new sport managers:
1. Import the background service
2. Initialize in `__init__` method
3. Update data fetching method to use background service
4. Add configuration options
5. Test thoroughly
6. Update documentation
## License
This feature is part of the LEDMatrix project and follows the same license terms.

136
docs/archive/BROWSER_ERRORS_EXPLANATION.md Normal file
View File

@@ -0,0 +1,136 @@
# Browser Console Errors - Explanation
## Summary
**You don't need to worry about these errors.** They are harmless and don't affect functionality. We've improved error suppression to hide them from the console.
## Error Types
### 1. Permissions-Policy Header Warnings
**Examples:**
```text
Error with Permissions-Policy header: Unrecognized feature: 'browsing-topics'.
Error with Permissions-Policy header: Unrecognized feature: 'run-ad-auction'.
Error with Permissions-Policy header: Origin trial controlled feature not enabled: 'join-ad-interest-group'.
```
**What they are:**
- Browser warnings about experimental/advertising features in HTTP headers
- These features are not used by our application
- The browser is just informing you that it doesn't recognize these policy features
**Why they appear:**
- Some browsers or extensions set these headers
- They're informational warnings, not actual errors
- They don't affect functionality at all
**Status:** ✅ **Harmless** - Now suppressed in console
### 2. HTMX insertBefore Errors
**Example:**
```javascript
TypeError: Cannot read properties of null (reading 'insertBefore')
at At (htmx.org@1.9.10:1:22924)
```
**What they are:**
- HTMX library timing/race condition issues
- Occurs when HTMX tries to swap content but the target element is temporarily null
- Usually happens during rapid content updates or when elements are being removed/added
**Why they appear:**
- HTMX dynamically swaps HTML content
- Sometimes the target element is removed or not yet in the DOM when HTMX tries to insert
- This is a known issue with HTMX in certain scenarios
**Impact:**
- ✅ **No functional impact** - HTMX handles these gracefully
- ✅ **Content still loads correctly** - The swap just fails silently and retries
- ✅ **User experience unaffected** - Users don't see any issues
**Status:** ✅ **Harmless** - Now suppressed in console
## What We've Done
### Error Suppression Improvements
1. **Enhanced HTMX Error Suppression:**
- More comprehensive detection of HTMX-related errors
- Catches `insertBefore` errors from HTMX regardless of format
- Suppresses timing/race condition errors
2. **Permissions-Policy Warning Suppression:**
- Suppresses all Permissions-Policy header warnings
- Includes specific feature warnings (browsing-topics, run-ad-auction, etc.)
- Prevents console noise from harmless browser warnings
3. **HTMX Validation:**
- Added `htmx:beforeSwap` validation to prevent some errors
- Checks if target element exists before swapping
- Reduces but doesn't eliminate all timing issues
## When to Worry
You should only be concerned about errors if:
1. **Functionality is broken** - If buttons don't work, forms don't submit, or content doesn't load
2. **Errors are from your code** - Errors in `plugins.html`, `base.html`, or other application files
3. **Network errors** - Failed API calls or connection issues
4. **User-visible issues** - Users report problems
## Current Status
✅ **All harmless errors are now suppressed**
✅ **HTMX errors are caught and handled gracefully**
✅ **Permissions-Policy warnings are hidden**
✅ **Application functionality is unaffected**
## Technical Details
### HTMX insertBefore Errors
**Root Cause:**
- HTMX uses `insertBefore` to swap content into the DOM
- Sometimes the parent node is null when HTMX tries to insert
- This happens due to:
- Race conditions during rapid updates
- Elements being removed before swap completes
- Dynamic content loading timing issues
**Why It's Safe:**
- HTMX has built-in error handling
- Failed swaps don't break the application
- Content still loads via other mechanisms
- No data loss or corruption
### Permissions-Policy Warnings
**Root Cause:**
- Modern browsers support Permissions-Policy HTTP headers
- Some features are experimental or not widely supported
- Browsers warn when they encounter unrecognized features
**Why It's Safe:**
- We don't use these features
- The warnings are informational only
- No security or functionality impact
## Monitoring
If you want to see actual errors (not suppressed ones), you can:
1. **Temporarily disable suppression:**
- Comment out the error suppression code in `base.html`
- Only do this for debugging
2. **Check browser DevTools:**
- Look for errors in the Network tab (actual failures)
- Check Console for non-HTMX errors
- Monitor user reports for functionality issues
## Conclusion
**These errors are completely harmless and can be safely ignored.** They're just noise in the console that doesn't affect the application's functionality. We've improved the error suppression to hide them so you can focus on actual issues if they arise.

445
docs/archive/CAPTIVE_PORTAL_TESTING.md Normal file
View File

@@ -0,0 +1,445 @@
# Captive Portal Testing Guide
This guide explains how to test the captive portal WiFi setup functionality.
## Prerequisites
1. **Raspberry Pi with LEDMatrix installed**
2. **WiFi adapter** (built-in or USB)
3. **Test devices** (smartphone, tablet, or laptop)
4. **Access to Pi** (SSH or direct access)
## Important: Before Testing
**⚠️ Make sure you have a way to reconnect!**
Before starting testing, ensure you have:
- **Ethernet cable** (if available) as backup connection
- **SSH access** via another method (Ethernet, direct connection)
- **Physical access** to Pi (keyboard/monitor) as last resort
- **Your WiFi credentials** saved/noted down
**If testing fails, see:** [Reconnecting After Testing](RECONNECT_AFTER_CAPTIVE_PORTAL_TESTING.md)
**Quick recovery script:** `sudo ./scripts/emergency_reconnect.sh`
## Pre-Testing Setup
### 0. Verify WiFi is Ready (IMPORTANT!)
**⚠️ CRITICAL: Run this BEFORE disconnecting Ethernet!**
```bash
sudo ./scripts/verify_wifi_before_testing.sh
```
This script will verify:
- WiFi interface exists and is enabled
- WiFi can scan for networks
- You have saved WiFi connections (for reconnecting)
- Required services are ready
- Current network status
**Do NOT disconnect Ethernet until this script passes all checks!**
### 1. Ensure WiFi Monitor Service is Running
```bash
sudo systemctl status ledmatrix-wifi-monitor
```
If not running:
```bash
sudo systemctl start ledmatrix-wifi-monitor
sudo systemctl enable ledmatrix-wifi-monitor
```
### 2. Disconnect Pi from WiFi/Ethernet
**⚠️ Only do this AFTER running the verification script!**
To test captive portal, the Pi should NOT be connected to any network:
```bash
# First, verify WiFi is ready (see step 0 above)
sudo ./scripts/verify_wifi_before_testing.sh
# Check current network status
nmcli device status
# Disconnect WiFi (if connected)
sudo nmcli device disconnect wlan0
# Disconnect Ethernet (if connected)
# Option 1: Unplug Ethernet cable (safest)
# Option 2: Via command (if you're sure WiFi works):
sudo nmcli device disconnect eth0
# Verify disconnection
nmcli device status
# Both should show "disconnected" or "unavailable"
```
### 3. Enable AP Mode
You can enable AP mode manually or wait for it to auto-enable (if `auto_enable_ap_mode` is true):
**Manual enable via web interface:**
- Access web interface at `http://<pi-ip>:5000` (if still accessible)
- Go to WiFi tab
- Click "Enable AP Mode"
**Manual enable via command line:**
```bash
python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm.enable_ap_mode())"
```
**Or via API:**
```bash
curl -X POST http://localhost:5000/api/v3/wifi/ap/enable
```
### 4. Verify AP Mode is Active
```bash
# Check hostapd service
sudo systemctl status hostapd
# Check dnsmasq service
sudo systemctl status dnsmasq
# Check if wlan0 is in AP mode
iwconfig wlan0
# Should show "Mode:Master"
# Check IP address
ip addr show wlan0
# Should show 192.168.4.1
```
### 5. Verify DNSMASQ Configuration
```bash
# Check dnsmasq config
sudo cat /etc/dnsmasq.conf
# Should contain:
# - address=/#/192.168.4.1
# - address=/captive.apple.com/192.168.4.1
# - address=/connectivitycheck.gstatic.com/192.168.4.1
# - address=/www.msftconnecttest.com/192.168.4.1
# - address=/detectportal.firefox.com/192.168.4.1
```
### 6. Verify Web Interface is Running
```bash
# Check if web service is running
sudo systemctl status ledmatrix-web
# Or check if Flask app is running
ps aux | grep "web_interface"
```
## Testing Procedures
### Test 1: DNS Redirection
**Purpose:** Verify that DNS queries are redirected to the Pi.
**Steps:**
1. Connect a device to "LEDMatrix-Setup" network (password: `ledmatrix123`)
2. Try to resolve any domain name:
```bash
# On Linux/Mac
nslookup google.com
# Should return 192.168.4.1
# On Windows
nslookup google.com
# Should return 192.168.4.1
```
**Expected Result:** All DNS queries should resolve to 192.168.4.1
### Test 2: HTTP Redirect (Manual Browser Test)
**Purpose:** Verify that HTTP requests redirect to WiFi setup page.
**Steps:**
1. Connect device to "LEDMatrix-Setup" network
2. Open a web browser
3. Try to access any website:
- `http://google.com`
- `http://example.com`
- `http://192.168.4.1` (direct IP)
**Expected Result:** All requests should redirect to `http://192.168.4.1:5000/v3` (WiFi setup interface)
### Test 3: Captive Portal Detection Endpoints
**Purpose:** Verify that device detection endpoints respond correctly.
**Test each endpoint:**
```bash
# iOS/macOS detection
curl http://192.168.4.1:5000/hotspot-detect.html
# Expected: HTML response with "Success"
# Android detection
curl -I http://192.168.4.1:5000/generate_204
# Expected: HTTP 204 No Content
# Windows detection
curl http://192.168.4.1:5000/connecttest.txt
# Expected: "Microsoft Connect Test"
# Firefox detection
curl http://192.168.4.1:5000/success.txt
# Expected: "success"
```
**Expected Result:** Each endpoint should return the appropriate response
### Test 4: iOS Device (iPhone/iPad)
**Purpose:** Test automatic captive portal detection on iOS.
**Steps:**
1. On iPhone/iPad, go to Settings > Wi-Fi
2. Connect to "LEDMatrix-Setup" network
3. Enter password: `ledmatrix123`
4. Wait a few seconds
**Expected Result:**
- iOS should automatically detect the captive portal
- A popup should appear saying "Sign in to Network" or similar
- Tapping it should open Safari with the WiFi setup page
- The setup page should show the captive portal banner
**If it doesn't auto-open:**
- Open Safari manually
- Try to visit any website (e.g., apple.com)
- Should redirect to WiFi setup page
### Test 5: Android Device
**Purpose:** Test automatic captive portal detection on Android.
**Steps:**
1. On Android device, go to Settings > Wi-Fi
2. Connect to "LEDMatrix-Setup" network
3. Enter password: `ledmatrix123`
4. Wait a few seconds
**Expected Result:**
- Android should show a notification: "Sign in to network" or "Network sign-in required"
- Tapping the notification should open a browser with the WiFi setup page
- The setup page should show the captive portal banner
**If notification doesn't appear:**
- Open Chrome browser
- Try to visit any website
- Should redirect to WiFi setup page
### Test 6: Windows Laptop
**Purpose:** Test captive portal on Windows.
**Steps:**
1. Connect Windows laptop to "LEDMatrix-Setup" network
2. Enter password: `ledmatrix123`
3. Wait a few seconds
**Expected Result:**
- Windows may show a notification about network sign-in
- Opening any browser and visiting any website should redirect to WiFi setup page
- Edge/Chrome may automatically open a sign-in window
**Manual test:**
- Open any browser
- Visit `http://www.msftconnecttest.com` or any website
- Should redirect to WiFi setup page
### Test 7: API Endpoints Still Work
**Purpose:** Verify that WiFi API endpoints function normally during AP mode.
**Steps:**
1. While connected to "LEDMatrix-Setup" network
2. Test API endpoints:
```bash
# Status endpoint
curl http://192.168.4.1:5000/api/v3/wifi/status
# Scan networks
curl http://192.168.4.1:5000/api/v3/wifi/scan
```
**Expected Result:** API endpoints should return JSON responses normally (not redirect)
### Test 8: WiFi Connection Flow
**Purpose:** Test the complete flow of connecting to WiFi via captive portal.
**Steps:**
1. Connect device to "LEDMatrix-Setup" network
2. Wait for captive portal to redirect to setup page
3. Click "Scan" to find available networks
4. Select a network from the list
5. Enter WiFi password
6. Click "Connect"
7. Wait for connection to establish
**Expected Result:**
- Device should connect to selected WiFi network
- AP mode should automatically disable
- Device should now be on the new network
- Can access Pi via new network IP address
## Troubleshooting
### Issue: DNS Not Redirecting
**Symptoms:** DNS queries resolve to actual IPs, not 192.168.4.1
**Solutions:**
1. Check dnsmasq config:
```bash
sudo cat /etc/dnsmasq.conf | grep address
```
2. Restart dnsmasq:
```bash
sudo systemctl restart dnsmasq
```
3. Check dnsmasq logs:
```bash
sudo journalctl -u dnsmasq -n 50
```
### Issue: HTTP Not Redirecting
**Symptoms:** Browser shows actual websites instead of redirecting
**Solutions:**
1. Check if AP mode is active:
```bash
python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm._is_ap_mode_active())"
```
2. Check Flask app logs for errors
3. Verify web interface is running on port 5000
4. Test redirect middleware manually:
```bash
curl -I http://192.168.4.1:5000/google.com
# Should return 302 redirect
```
### Issue: Captive Portal Not Detected by Device
**Symptoms:** Device doesn't show sign-in notification/popup
**Solutions:**
1. Verify detection endpoints are accessible:
```bash
curl http://192.168.4.1:5000/hotspot-detect.html
curl http://192.168.4.1:5000/generate_204
```
2. Try manually opening browser and visiting any website
3. Some devices require specific responses - check endpoint implementations
4. Clear device's network settings and reconnect
### Issue: Infinite Redirect Loop
**Symptoms:** Browser keeps redirecting in a loop
**Solutions:**
1. Check that `/v3` path is in allowed_paths list
2. Verify redirect middleware logic in `app.py`
3. Check Flask logs for errors
4. Ensure WiFi API endpoints are not being redirected
### Issue: AP Mode Not Enabling
**Symptoms:** Can't connect to "LEDMatrix-Setup" network
**Solutions:**
1. Check WiFi monitor service:
```bash
sudo systemctl status ledmatrix-wifi-monitor
```
2. Check WiFi config:
```bash
cat config/wifi_config.json
```
3. Manually enable AP mode:
```bash
python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm.enable_ap_mode())"
```
4. Check hostapd logs:
```bash
sudo journalctl -u hostapd -n 50
```
## Verification Checklist
- [ ] DNS redirection works (all domains resolve to 192.168.4.1)
- [ ] HTTP redirect works (all websites redirect to setup page)
- [ ] Captive portal detection endpoints respond correctly
- [ ] iOS device auto-opens setup page
- [ ] Android device shows sign-in notification
- [ ] Windows device redirects to setup page
- [ ] WiFi API endpoints still work during AP mode
- [ ] Can successfully connect to WiFi via setup page
- [ ] AP mode disables after WiFi connection
- [ ] No infinite redirect loops
- [ ] Captive portal banner appears on setup page when AP mode is active
## Quick Test Script
Save this as `test_captive_portal.sh`:
```bash
#!/bin/bash
echo "Testing Captive Portal Functionality"
echo "===================================="
# Test DNS redirection
echo -e "\n1. Testing DNS redirection..."
nslookup google.com | grep -q "192.168.4.1" && echo "✓ DNS redirection works" || echo "✗ DNS redirection failed"
# Test HTTP redirect
echo -e "\n2. Testing HTTP redirect..."
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -L http://192.168.4.1:5000/google.com)
[ "$HTTP_CODE" = "200" ] && echo "✓ HTTP redirect works" || echo "✗ HTTP redirect failed (got $HTTP_CODE)"
# Test detection endpoints
echo -e "\n3. Testing captive portal detection endpoints..."
curl -s http://192.168.4.1:5000/hotspot-detect.html | grep -q "Success" && echo "✓ iOS endpoint works" || echo "✗ iOS endpoint failed"
curl -s -o /dev/null -w "%{http_code}" http://192.168.4.1:5000/generate_204 | grep -q "204" && echo "✓ Android endpoint works" || echo "✗ Android endpoint failed"
curl -s http://192.168.4.1:5000/connecttest.txt | grep -q "Microsoft" && echo "✓ Windows endpoint works" || echo "✗ Windows endpoint failed"
curl -s http://192.168.4.1:5000/success.txt | grep -q "success" && echo "✓ Firefox endpoint works" || echo "✗ Firefox endpoint failed"
# Test API endpoints
echo -e "\n4. Testing API endpoints..."
API_RESPONSE=$(curl -s http://192.168.4.1:5000/api/v3/wifi/status)
echo "$API_RESPONSE" | grep -q "status" && echo "✓ API endpoints work" || echo "✗ API endpoints failed"
echo -e "\nTesting complete!"
```
Make it executable and run:
```bash
chmod +x test_captive_portal.sh
./test_captive_portal.sh
```
## Notes
- **Port Number:** The web interface runs on port 5000 by default. If you've changed this, update all URLs accordingly.
- **Network Range:** The AP uses 192.168.4.0/24 network. If you need a different range, update both hostapd and dnsmasq configs.
- **Password:** Default AP password is `ledmatrix123`. Change it in `config/wifi_config.json` if needed.
- **Testing on Same Device:** If testing from the Pi itself, you'll need a second device to connect to the AP network.

172
docs/archive/CAPTIVE_PORTAL_TROUBLESHOOTING.md Normal file
View File

@@ -0,0 +1,172 @@
# Captive Portal Troubleshooting Guide
## Problem: Can't Access Web Interface When Connected to AP
If you've connected to the "LEDMatrix-Setup" WiFi network but can't access the web interface, follow these steps:
## Quick Checks
### 1. Verify Web Server is Running
```bash
sudo systemctl status ledmatrix-web
```
If not running:
```bash
sudo systemctl start ledmatrix-web
sudo systemctl enable ledmatrix-web
```
### 2. Try Direct IP Access
On your phone/device, try accessing the web interface directly:
- **http://192.168.4.1:5000/v3**
- **http://192.168.4.1:5000**
The port `:5000` is required - the web server runs on port 5000, not the standard port 80.
### 3. Check DNS Resolution
The captive portal uses DNS redirection. Try accessing:
- **http://captive.apple.com** (should redirect to setup page)
- **http://www.google.com** (should redirect to setup page)
- **http://192.168.4.1:5000** (direct access - should always work)
### 4. Verify AP Mode is Active
```bash
sudo systemctl status hostapd
sudo systemctl status dnsmasq
ip addr show wlan0 | grep 192.168.4.1
```
All should be active/running.
### 5. Check Firewall
If you have a firewall enabled, ensure port 5000 is open:
```bash
# For UFW
sudo ufw allow 5000/tcp
# For iptables
sudo iptables -A INPUT -p tcp --dport 5000 -j ACCEPT
```
## Common Issues
### Issue: "Can't connect to server" or "Connection refused"
**Cause**: Web server not running or not listening on the correct interface.
**Solution**:
```bash
sudo systemctl start ledmatrix-web
sudo systemctl status ledmatrix-web
```
### Issue: DNS not resolving / "Server not found"
**Cause**: dnsmasq not running or DNS redirection not configured.
**Solution**:
```bash
# Check dnsmasq
sudo systemctl status dnsmasq
# Restart AP mode
cd ~/LEDMatrix
python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); wm.disable_ap_mode(); wm.enable_ap_mode()"
```
### Issue: Page loads but shows "Connection Error" or blank page
**Cause**: Web server is running but Flask app has errors.
**Solution**:
```bash
# Check web server logs
sudo journalctl -u ledmatrix-web -n 50 --no-pager
# Restart web server
sudo systemctl restart ledmatrix-web
```
### Issue: Phone connects but browser doesn't open automatically
**Cause**: Some devices don't automatically detect captive portals.
**Solution**: Manually open browser and go to:
- **http://192.168.4.1:5000/v3**
- Or try: **http://captive.apple.com** (iOS) or **http://www.google.com** (Android)
## Testing Steps
1. **Disconnect Ethernet** from Pi
2. **Wait 30 seconds** for AP mode to start
3. **Connect phone** to "LEDMatrix-Setup" network (password: `ledmatrix123`)
4. **Open browser** on phone
5. **Try these URLs**:
- `http://192.168.4.1:5000/v3` (direct access)
- `http://captive.apple.com` (iOS captive portal detection)
- `http://www.google.com` (should redirect)
## Automated Troubleshooting
Run the troubleshooting script:
```bash
cd ~/LEDMatrix
./scripts/troubleshoot_captive_portal.sh
```
This will check all components and provide specific fixes.
## Manual AP Mode Test
To manually test AP mode (bypassing Ethernet check):
```bash
cd ~/LEDMatrix
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
# Temporarily disconnect Ethernet check
# (This is for testing only - normally AP won't start with Ethernet)
print('Enabling AP mode...')
result = wm.enable_ap_mode()
print('Result:', result)
"
```
**Note**: This will fail if Ethernet is connected (by design). You must disconnect Ethernet first.
## Still Not Working?
1. **Check all services**:
```bash
sudo systemctl status ledmatrix-web hostapd dnsmasq ledmatrix-wifi-monitor
```
2. **Check logs**:
```bash
sudo journalctl -u ledmatrix-web -f
sudo journalctl -u ledmatrix-wifi-monitor -f
```
3. **Verify network configuration**:
```bash
ip addr show wlan0
ip route show
```
4. **Test from Pi itself**:
```bash
curl http://192.168.4.1:5000/v3
```
If it works from the Pi but not from your phone, it's likely a DNS or firewall issue.

75
docs/archive/DEBUG_WEB_ISSUE.md Normal file
View File

@@ -0,0 +1,75 @@
# Debug: Service Deactivated After Installing Dependencies
## What Happened
The service:
1. ✅ Started successfully
2. ✅ Installed dependencies
3. ❌ Deactivated successfully (exited cleanly)
This means it finished running but didn't actually launch the Flask app.
## Most Likely Cause
**`web_display_autostart` is probably set to `false` in your config.json**
The service is designed to exit gracefully if this is false - it won't even try to start Flask.
## Commands to Run RIGHT NOW
### 1. Check the full logs to see what it said before exiting:
```bash
sudo journalctl -u ledmatrix-web -n 200 --no-pager | grep -A 5 -B 5 "web_display_autostart\|Configuration\|Launching\|will not"
```
This will show you if it said something like:
- "Configuration 'web_display_autostart' is false or not set. Web interface will not be started."
### 2. Check your config.json:
```bash
cat ~/LEDMatrix/config/config.json | grep web_display_autostart
```
### 3. If it's false or missing, set it to true:
```bash
nano ~/LEDMatrix/config/config.json
```
Find the line with `web_display_autostart` and change it to:
```json
"web_display_autostart": true,
```
If the line doesn't exist, add it near the top of the file (after the opening `{`):
```json
{
"web_display_autostart": true,
... rest of config ...
}
```
### 4. After fixing the config, restart the service:
```bash
sudo systemctl restart ledmatrix-web
```
### 5. Watch it start up:
```bash
sudo journalctl -u ledmatrix-web -f
```
You should see:
- "Configuration 'web_display_autostart' is true. Starting web interface..."
- "Dependencies installed successfully"
- "Launching web interface v3: ..."
- Flask starting up
## Alternative: View ALL Recent Logs
To see everything that happened:
```bash
sudo journalctl -u ledmatrix-web --since "5 minutes ago" --no-pager
```
This will show you the complete log including what happened after dependency installation.

181
docs/archive/FORM_VALIDATION_FIXES.md Normal file
View File

@@ -0,0 +1,181 @@
# Form Validation Fixes - Preventing "Invalid Form Control" Errors
## Problem
Browser was throwing errors: "An invalid form control with name='...' is not focusable" when:
- Number inputs had values outside their min/max constraints
- These fields were in collapsed/hidden nested sections
- Browser couldn't focus hidden invalid fields to show validation errors
## Root Cause
1. **Value Clamping Missing**: Number inputs were generated with values that didn't respect min/max constraints
2. **HTML5 Validation on Hidden Fields**: Browser validation tried to validate hidden fields but couldn't focus them
3. **No Pre-Submit Validation**: Forms didn't fix invalid values before submission
## Fixes Applied
### 1. Plugin Configuration Form (`plugins.html`)
**File**: `web_interface/templates/v3/partials/plugins.html`
**Changes**:
- ✅ Added value clamping in `generateFieldHtml()` (lines 1825-1844)
- Clamps values to min/max when generating number inputs
- Uses default value if provided
- Ensures all generated fields have valid values
- ✅ Added `novalidate` attribute to form (line 1998)
- ✅ Added pre-submit validation fix in `handlePluginConfigSubmit()` (lines 1518-1533)
- Fixes any invalid values before processing form data
- Prevents "invalid form control is not focusable" errors
### 2. Plugin Config in Base Template (`base.html`)
**File**: `web_interface/templates/v3/base.html`
**Changes**:
- ✅ Added value clamping in number input generation (lines 1386-1407)
- Same logic as plugins.html
- Clamps values to min/max constraints
- ✅ Fixed display_duration input (line 1654)
- Uses `Math.max(5, Math.min(300, value))` to clamp value
- ✅ Added global `fixInvalidNumberInputs()` function (lines 2409-2425)
- Can be called from any form's onsubmit handler
- Fixes invalid number inputs before submission
### 3. Display Settings Form (`display.html`)
**File**: `web_interface/templates/v3/partials/display.html`
**Changes**:
- ✅ Added `novalidate` attribute to form (line 13)
- ✅ Added `onsubmit="fixInvalidNumberInputs(this); return true;"` (line 14)
- ✅ Added local `fixInvalidNumberInputs()` function as fallback (lines 260-278)
### 4. Durations Form (`durations.html`)
**File**: `web_interface/templates/v3/partials/durations.html`
**Changes**:
- ✅ Added `novalidate` attribute to form (line 13)
- ✅ Added `onsubmit="fixInvalidNumberInputs(this); return true;"` (line 14)
## Implementation Details
### Value Clamping Logic
```javascript
// Ensure value respects min/max constraints
let fieldValue = value !== undefined ? value : (prop.default !== undefined ? prop.default : '');
if (fieldValue !== '' && fieldValue !== undefined && fieldValue !== null) {
const numValue = typeof fieldValue === 'string' ? parseFloat(fieldValue) : fieldValue;
if (!isNaN(numValue)) {
// Clamp value to min/max if constraints exist
if (prop.minimum !== undefined && numValue < prop.minimum) {
fieldValue = prop.minimum;
} else if (prop.maximum !== undefined && numValue > prop.maximum) {
fieldValue = prop.maximum;
} else {
fieldValue = numValue;
}
}
}
```
### Pre-Submit Validation Fix
```javascript
// Fix invalid hidden fields before submission
const allInputs = form.querySelectorAll('input[type="number"]');
allInputs.forEach(input => {
const min = parseFloat(input.getAttribute('min'));
const max = parseFloat(input.getAttribute('max'));
const value = parseFloat(input.value);
if (!isNaN(value)) {
if (!isNaN(min) && value < min) {
input.value = min;
} else if (!isNaN(max) && value > max) {
input.value = max;
}
}
});
```
## Files Modified
1. ✅ `web_interface/templates/v3/partials/plugins.html`
- Value clamping in field generation
- `novalidate` on forms
- Pre-submit validation fix
2. ✅ `web_interface/templates/v3/base.html`
- Value clamping in field generation
- Fixed display_duration input
- Global `fixInvalidNumberInputs()` function
3. ✅ `web_interface/templates/v3/partials/display.html`
- `novalidate` on form
- `onsubmit` handler
- Local fallback function
4. ✅ `web_interface/templates/v3/partials/durations.html`
- `novalidate` on form
- `onsubmit` handler
## Prevention Strategy
### For Future Forms
1. **Always clamp number input values** when generating forms:
```javascript
// Clamp value to min/max
if (min !== undefined && value < min) value = min;
if (max !== undefined && value > max) value = max;
```
2. **Add `novalidate` to forms** that use custom validation:
```html
<form novalidate onsubmit="fixInvalidNumberInputs(this); return true;">
```
3. **Use the global helper** for pre-submit validation:
```javascript
window.fixInvalidNumberInputs(form);
```
4. **Check for hidden fields** - If fields can be hidden (collapsed sections), ensure:
- Values are valid when fields are generated
- Pre-submit validation fixes any remaining issues
- Form has `novalidate` to prevent HTML5 validation
## Testing
### Test Cases
1. ✅ Number input with value=0, min=60 → Should clamp to 60
2. ✅ Number input with value=1000, max=600 → Should clamp to 600
3. ✅ Hidden field with invalid value → Should be fixed on submit
4. ✅ Form submission with invalid values → Should fix before submit
5. ✅ Nested sections with number inputs → Should work correctly
### Manual Testing
1. Open plugin configuration with nested sections
2. Collapse a section with number inputs
3. Try to submit form → Should work without errors
4. Check browser console → Should have no validation errors
## Related Issues
- **Issue**: "An invalid form control with name='...' is not focusable"
- **Cause**: Hidden fields with invalid values (outside min/max)
- **Solution**: Value clamping + pre-submit validation + `novalidate`
## Notes
- We use `novalidate` because we do server-side validation anyway
- The pre-submit fix is a safety net for any edge cases
- Value clamping at generation time prevents most issues
- All fixes are backward compatible

258
docs/archive/NESTED_SCHEMA_IMPLEMENTATION.md Normal file
View File

@@ -0,0 +1,258 @@
# Nested Config Schema Implementation - Complete
## Summary
The plugin manager now fully supports **nested config schemas**, allowing complex plugins to organize their configuration options into logical, collapsible sections in the web interface.
## What Was Implemented
### 1. Core Functionality ✅
**Updated Files:**
- `web_interface/templates/v3/partials/plugins.html`
**New Features:**
- Recursive form generation for nested objects
- Collapsible sections with smooth animations
- Dot notation for form field names (e.g., `nfl.display_modes.show_live`)
- Automatic conversion between flat form data and nested JSON
- Support for unlimited nesting depth
### 2. Helper Functions ✅
Added to `plugins.html`:
- **`getSchemaPropertyType(schema, path)`** - Find property type using dot notation
- **`dotToNested(obj)`** - Convert flat dot notation to nested objects
- **`collectBooleanFields(schema, prefix)`** - Recursively find all boolean fields
- **`flattenConfig(obj, prefix)`** - Flatten nested config for form display
- **`generateFieldHtml(key, prop, value, prefix)`** - Recursively generate form fields
- **`toggleNestedSection(sectionId)`** - Toggle collapse/expand of nested sections
### 3. UI Enhancements ✅
**CSS Styling Added:**
- Smooth transitions for expand/collapse
- Visual hierarchy with indentation
- Gray background for nested sections to differentiate from main form
- Hover effects on section headers
- Chevron icons that rotate on toggle
- Responsive design for nested sections
### 4. Backward Compatibility ✅
**Fully Compatible:**
- All 18 existing plugins with flat schemas work without changes
- Mixed mode supported (flat and nested properties in same schema)
- No backend API changes required
- Existing configs load and save correctly
### 5. Documentation ✅
**Created Files:**
- `docs/NESTED_CONFIG_SCHEMAS.md` - Complete user guide
- `plugin-repos/ledmatrix-football-scoreboard/config_schema_nested_example.json` - Example nested schema
## Why It Wasn't Supported Before
Simply put: **nobody implemented it yet**. The original `generateFormFromSchema()` function only handled flat properties - it had no handler for `type: 'object'` which indicates nested structures. All existing plugins used flat schemas with prefixed names (e.g., `nfl_enabled`, `nfl_show_live`, etc.).
## Technical Details
### How It Works
1. **Schema Definition**: Plugin defines nested objects using `type: "object"` with nested `properties`
2. **Form Generation**: `generateFieldHtml()` recursively creates collapsible sections for nested objects
3. **Form Submission**: Form data uses dot notation (`nfl.enabled`) which is converted to nested JSON (`{nfl: {enabled: true}}`)
4. **Config Storage**: Stored as proper nested JSON objects in `config.json`
### Example Transformation
**Flat Schema (Before):**
```json
{
"nfl_enabled": true,
"nfl_show_live": true,
"nfl_favorite_teams": ["TB", "DAL"]
}
```
**Nested Schema (After):**
```json
{
"nfl": {
"enabled": true,
"show_live": true,
"favorite_teams": ["TB", "DAL"]
}
}
```
### Field Name Mapping
Form fields use dot notation internally:
- `nfl.enabled` → `{nfl: {enabled: true}}`
- `nfl.display_modes.show_live` → `{nfl: {display_modes: {show_live: true}}}`
- `ncaa_fb.game_limits.recent_games_to_show` → `{ncaa_fb: {game_limits: {recent_games_to_show: 5}}}`
## Benefits
### For Plugin Developers
- **Better organization** - Group related settings logically
- **Cleaner code** - Access config with natural nesting: `config["nfl"]["enabled"]`
- **Easier maintenance** - Related settings are together
- **Scalability** - Handle 50+ options without overwhelming users
### For Users
- **Less overwhelming** - Collapsible sections hide complexity
- **Easier navigation** - Find settings quickly in logical groups
- **Better understanding** - Clear hierarchy shows relationships
- **Cleaner UI** - Organized sections vs. endless list
## Examples
### Football Plugin Comparison
**Before (Flat - 32 properties):**
All properties in one long list:
- `nfl_enabled`
- `nfl_favorite_teams`
- `nfl_show_live`
- `nfl_show_recent`
- `nfl_show_upcoming`
- ... (27 more)
**After (Nested - Same 32 properties):**
Organized into 2 main sections:
- **NFL Settings** (collapsed)
- **Display Modes** (collapsed)
- **Game Limits** (collapsed)
- **Display Options** (collapsed)
- **Filtering** (collapsed)
- **NCAA Football Settings** (collapsed)
- Same nested structure
### Baseball Plugin Opportunity
The baseball plugin has **over 100 properties**! With nested schemas, these could be organized into:
- **MLB Settings**
- Display Modes
- Game Limits
- Display Options
- Background Service
- **MiLB Settings**
- (same structure)
- **NCAA Baseball Settings**
- (same structure)
## Migration Guide
### For New Plugins
Use nested schemas from the start:
```json
{
"type": "object",
"properties": {
"enabled": {"type": "boolean", "default": true},
"sport_name": {
"type": "object",
"title": "Sport Name Settings",
"properties": {
"enabled": {"type": "boolean", "default": true},
"favorite_teams": {"type": "array", "items": {"type": "string"}, "default": []}
}
}
}
}
```
### For Existing Plugins
You have three options:
1. **Keep flat** - No changes needed, works perfectly
2. **Gradual migration** - Nest some sections, keep others flat
3. **Full migration** - Restructure entire schema (requires updating plugin code to access nested config)
## Testing
### Backward Compatibility Verified
- ✅ All 18 existing flat schemas work unchanged
- ✅ Form generation works for flat schemas
- ✅ Form submission works for flat schemas
- ✅ Config saving/loading works for flat schemas
### New Nested Schema Tested
- ✅ Nested objects generate collapsible sections
- ✅ Multi-level nesting works (object within object)
- ✅ Form fields use correct dot notation
- ✅ Form submission converts to nested JSON correctly
- ✅ Boolean fields handled in nested structures
- ✅ All field types work in nested sections (boolean, number, integer, array, string, enum)
## Files Modified
1. **`web_interface/templates/v3/partials/plugins.html`**
- Added helper functions for nested schema handling
- Updated `generateFormFromSchema()` to recursively handle nested objects
- Updated `handlePluginConfigSubmit()` to convert dot notation to nested JSON
- Added `toggleNestedSection()` for UI interaction
- Added CSS styles for nested sections
## Files Created
1. **`docs/NESTED_CONFIG_SCHEMAS.md`**
- Complete user and developer guide
- Examples and best practices
- Migration strategies
- Troubleshooting guide
2. **`plugin-repos/ledmatrix-football-scoreboard/config_schema_nested_example.json`**
- Full working example of nested schema
- Demonstrates all nesting levels
- Shows before/after comparison
## No Backend Changes Needed
The existing API endpoints work perfectly:
- `/api/v3/plugins/schema` - Returns schema (flat or nested)
- `/api/v3/plugins/config` (GET) - Returns config (flat or nested)
- `/api/v3/plugins/config` (POST) - Saves config (flat or nested)
The backend doesn't care about structure - it just stores/retrieves JSON!
## Next Steps
### Immediate Use
You can start using nested schemas right now:
1. Create a new plugin with nested schema
2. Or update an existing plugin's `config_schema.json` to use nesting
3. The web interface will automatically render collapsible sections
### Recommended Migrations
Good candidates for nested schemas:
- **Baseball plugin** (100+ properties → 3-4 main sections)
- **Football plugin** (32 properties → 2 main sections) [example already created]
- **Basketball plugin** (similar to football)
- **Hockey plugin** (similar to football)
### Future Enhancements
Potential improvements (not required):
- Remember collapsed/expanded state per user
- Search within nested sections
- Visual indication of which section has changes
- Drag-and-drop to reorder sections
## Conclusion
The plugin manager now has full support for nested config schemas with:
- ✅ Automatic UI generation
- ✅ Collapsible sections
- ✅ Full backward compatibility
- ✅ No breaking changes
- ✅ Complete documentation
- ✅ Working examples
Complex plugins can now be much easier to configure and maintain!

85
docs/archive/NEXT_STEPS_COMMANDS.md Normal file
View File

@@ -0,0 +1,85 @@
# Next Steps - Run These Commands on Your Pi
## What's Happening Now
✅ Service is **enabled** and **active (running)**
⏳ Currently **installing dependencies** (this is normal on first start)
⏳ Should start Flask app once dependencies are installed
## Commands to Run Next
### 1. Wait a Minute for Dependencies to Install
The pip install process needs to complete first.
### 2. Check Current Status
```bash
sudo systemctl status ledmatrix-web
```
Look for the Tasks count - when it drops from 2 to 1, pip is done.
### 3. View the Logs to See What's Happening
```bash
sudo journalctl -u ledmatrix-web -f
```
Press `Ctrl+C` to exit when done watching.
You should eventually see:
- "Dependencies installed successfully"
- "Installing rgbmatrix module..."
- "Launching web interface v3: ..."
- Messages from Flask about starting the server
### 4. Check if Flask is Running on Port 5000
```bash
sudo netstat -tlnp | grep :5000
```
or
```bash
sudo ss -tlnp | grep :5000
```
Should show Python listening on port 5000.
### 5. Test Access
Once the logs show Flask started, try accessing:
```bash
curl http://localhost:5000
```
Or from your computer's browser:
```
http://<raspberry-pi-ip>:5000
```
## If It Gets Stuck
If after 2-3 minutes the dependencies are still installing and nothing happens:
```bash
# Stop the service
sudo systemctl stop ledmatrix-web
# Check what went wrong
sudo journalctl -u ledmatrix-web -n 100 --no-pager
# Try manual start to see errors directly
cd ~/LEDMatrix
python3 web_interface/start.py
```
## Expected Timeline
- **0-30 seconds**: Installing pip dependencies
- **30-60 seconds**: Installing rgbmatrix module
- **60+ seconds**: Flask app should be running
- **Access**: http://<pi-ip>:5000 should work
## Success Indicators
✅ Logs show: "Starting LED Matrix Web Interface V3..."
✅ Logs show: "Access the interface at: http://0.0.0.0:5000"
✅ Port 5000 is listening
✅ Web page loads in browser

203
docs/archive/ON_DEMAND_CACHE_MANAGEMENT.md Normal file
View File

@@ -0,0 +1,203 @@
# On-Demand Cache Management
## Overview
The on-demand feature uses several cache keys to manage state. Understanding these keys helps with troubleshooting and manual recovery.
## Cache Keys Used
### 1. `display_on_demand_request`
**Purpose**: Stores pending on-demand requests (start/stop actions)
**TTL**: 1 hour
**When Set**: When you click "Run On-Demand" or "Stop On-Demand"
**When Cleared**: Automatically after processing, or manually via cache management
**Structure**:
```json
{
"request_id": "uuid-string",
"action": "start" | "stop",
"plugin_id": "plugin-name",
"mode": "mode-name",
"duration": 30.0,
"pinned": true,
"timestamp": 1234567890.123
}
```
### 2. `display_on_demand_config`
**Purpose**: Stores the active on-demand configuration (persists across restarts)
**TTL**: 1 hour
**When Set**: When on-demand mode is activated
**When Cleared**: When on-demand mode is stopped, or manually via cache management
**Structure**:
```json
{
"plugin_id": "plugin-name",
"mode": "mode-name",
"duration": 30.0,
"pinned": true,
"requested_at": 1234567890.123,
"expires_at": 1234567920.123
}
```
### 3. `display_on_demand_state`
**Purpose**: Current on-demand state (read-only, published by display controller)
**TTL**: None (updated continuously)
**When Set**: Continuously updated by display controller
**When Cleared**: Automatically when on-demand ends, or manually via cache management
**Structure**:
```json
{
"active": true,
"mode": "mode-name",
"plugin_id": "plugin-name",
"requested_at": 1234567890.123,
"expires_at": 1234567920.123,
"duration": 30.0,
"pinned": true,
"status": "active" | "idle" | "restarting" | "error",
"error": null,
"last_event": "started",
"remaining": 25.5,
"last_updated": 1234567895.123
}
```
### 4. `display_on_demand_processed_id`
**Purpose**: Tracks which request_id has been processed (prevents duplicate processing)
**TTL**: 1 hour
**When Set**: When a request is processed
**When Cleared**: Automatically expires, or manually via cache management
**Structure**: Just a string (the request_id)
## When Manual Clearing is Needed
### Scenario 1: Stuck On-Demand State
**Symptoms**:
- Display stuck showing only one plugin
- "Stop On-Demand" button doesn't work
- Display controller shows on-demand as active but it shouldn't be
**Solution**: Clear these keys:
- `display_on_demand_config` - Removes the active configuration
- `display_on_demand_state` - Resets the published state
- `display_on_demand_request` - Clears any pending requests
**How to Clear**: Use the Cache Management tab in the web UI:
1. Go to Cache Management tab
2. Find the keys starting with `display_on_demand_`
3. Click "Delete" for each one
4. Restart the display service: `sudo systemctl restart ledmatrix`
### Scenario 2: On-Demand Mode Switching Issues
**Symptoms**:
- On-demand mode not switching to requested plugin
- Logs show "Processing on-demand start request for plugin" but no "Activated on-demand for plugin" message
- Display stuck in previous mode instead of switching immediately
**Solution**: Clear these keys:
- `display_on_demand_request` - Stops any pending request
- `display_on_demand_processed_id` - Allows new requests to be processed
- `display_on_demand_state` - Clears any stale state
**How to Clear**: Same as Scenario 1, but focus on `display_on_demand_request` first. Note that on-demand now switches modes immediately without restarting the service.
### Scenario 3: On-Demand Not Activating
**Symptoms**:
- Clicking "Run On-Demand" does nothing
- No errors in logs, but on-demand doesn't start
**Solution**: Clear these keys:
- `display_on_demand_processed_id` - May be blocking new requests
- `display_on_demand_request` - Clear any stale requests
**How to Clear**: Same as Scenario 1
### Scenario 4: After Service Crash or Unexpected Shutdown
**Symptoms**:
- Service was stopped unexpectedly (power loss, crash, etc.)
- On-demand state may be inconsistent
**Solution**: Clear all on-demand keys:
- `display_on_demand_config`
- `display_on_demand_state`
- `display_on_demand_request`
- `display_on_demand_processed_id`
**How to Clear**: Same as Scenario 1, clear all four keys
## Does Clearing from Cache Management Tab Reset It?
**Yes, but with caveats:**
1. **Clearing `display_on_demand_state`**:
- ✅ Removes the published state from cache
- ⚠️ **Does NOT** immediately clear the in-memory state in the running display controller
- The display controller will continue using its internal state until it polls for updates or restarts
2. **Clearing `display_on_demand_config`**:
- ✅ Removes the configuration from cache
- ⚠️ **Does NOT** immediately affect a running display controller
- The display controller only reads this on startup/restart
3. **Clearing `display_on_demand_request`**:
- ✅ Prevents new requests from being processed
- ✅ Stops restart loops if that's the issue
- ⚠️ **Does NOT** stop an already-active on-demand session
4. **Clearing `display_on_demand_processed_id`**:
- ✅ Allows previously-processed requests to be processed again
- Useful if a request got stuck
## Best Practice for Manual Clearing
**To fully reset on-demand state:**
1. **Stop the display service** (if possible):
```bash
sudo systemctl stop ledmatrix
```
2. **Clear all on-demand cache keys** via Cache Management tab:
- `display_on_demand_config`
- `display_on_demand_state`
- `display_on_demand_request`
- `display_on_demand_processed_id`
3. **Clear systemd environment variable** (if set):
```bash
sudo systemctl unset-environment LEDMATRIX_ON_DEMAND_PLUGIN
```
4. **Restart the display service**:
```bash
sudo systemctl start ledmatrix
```
## Automatic Cleanup
The display controller automatically:
- Clears `display_on_demand_config` when on-demand mode is stopped
- Updates `display_on_demand_state` continuously
- Expires `display_on_demand_request` after processing
- Expires `display_on_demand_processed_id` after 1 hour
## Troubleshooting
If clearing cache keys doesn't resolve the issue:
1. **Check logs**: `sudo journalctl -u ledmatrix -f`
2. **Check service status**: `sudo systemctl status ledmatrix`
3. **Check environment variables**: `sudo systemctl show ledmatrix | grep LEDMATRIX`
4. **Check cache files directly**: `ls -la /var/cache/ledmatrix/display_on_demand_*`
## Related Files
- `src/display_controller.py` - Main on-demand logic
- `web_interface/blueprints/api_v3.py` - API endpoints for on-demand
- `web_interface/templates/v3/partials/cache.html` - Cache management UI

554
docs/archive/ON_DEMAND_DISPLAY_API.md Normal file
View File

@@ -0,0 +1,554 @@
# On-Demand Display API
## Overview
The On-Demand Display API allows **manual control** of what's shown on the LED matrix. Unlike the automatic rotation or live priority system, on-demand display is **user-triggered** - typically from the web interface with a "Show Now" button.
## Use Cases
- 📺 **"Show Weather Now"** button in web UI
- 🏒 **"Show Live Game"** button for specific sports
- 📰 **"Show Breaking News"** button
- 🎵 **"Show Currently Playing"** button for music
- 🎮 **Quick preview** of any plugin without waiting for rotation
## Priority Hierarchy
The display controller processes requests in this order:
```
1. On-Demand Display (HIGHEST) ← User explicitly requested
2. Live Priority (plugins with live content)
3. Normal Rotation (automatic cycling)
```
On-demand overrides everything, including live priority.
## API Reference
### DisplayController Methods
#### `show_on_demand(mode, duration=None, pinned=False) -> bool`
Display a specific mode immediately, interrupting normal rotation.
**Parameters:**
- `mode` (str): The display mode to show (e.g., 'weather', 'hockey_live')
- `duration` (float, optional): How long to show in seconds
- `None`: Use mode's default `display_duration` from config
- `0`: Show indefinitely (until cleared)
- `> 0`: Show for exactly this many seconds
- `pinned` (bool): If True, stays on this mode until manually cleared
**Returns:**
- `True`: Mode was found and activated
- `False`: Mode doesn't exist
**Example:**
```python
# Show weather for 30 seconds then return to rotation
controller.show_on_demand('weather', duration=30)
# Show weather indefinitely
controller.show_on_demand('weather', duration=0)
# Pin to hockey live (stays until unpinned)
controller.show_on_demand('hockey_live', pinned=True)
# Use plugin's default duration
controller.show_on_demand('weather') # Uses display_duration from config
```
#### `clear_on_demand() -> None`
Clear on-demand display and return to normal rotation.
**Example:**
```python
controller.clear_on_demand()
```
#### `is_on_demand_active() -> bool`
Check if on-demand display is currently active.
**Returns:**
- `True`: On-demand mode is active
- `False`: Normal rotation or live priority
**Example:**
```python
if controller.is_on_demand_active():
print("User is viewing on-demand content")
```
#### `get_on_demand_info() -> dict`
Get detailed information about current on-demand display.
**Returns:**
```python
{
'active': True, # Whether on-demand is active
'mode': 'weather', # Current mode being displayed
'duration': 30.0, # Total duration (None if indefinite)
'elapsed': 12.5, # Seconds elapsed
'remaining': 17.5, # Seconds remaining (None if indefinite)
'pinned': False # Whether pinned
}
# Or if not active:
{
'active': False
}
```
**Example:**
```python
info = controller.get_on_demand_info()
if info['active']:
print(f"Showing {info['mode']}, {info['remaining']}s remaining")
```
## Web Interface Integration
### API Endpoint Example
```python
# In web_interface/blueprints/api_v3.py
from flask import jsonify, request
@api_v3.route('/display/show', methods=['POST'])
def show_on_demand():
"""Show a specific plugin on-demand"""
data = request.json
mode = data.get('mode')
duration = data.get('duration') # Optional
pinned = data.get('pinned', False) # Optional
# Get display controller instance
controller = get_display_controller()
success = controller.show_on_demand(mode, duration, pinned)
if success:
return jsonify({
'success': True,
'message': f'Showing {mode}',
'info': controller.get_on_demand_info()
})
else:
return jsonify({
'success': False,
'error': f'Mode {mode} not found'
}), 404
@api_v3.route('/display/clear', methods=['POST'])
def clear_on_demand():
"""Clear on-demand display"""
controller = get_display_controller()
controller.clear_on_demand()
return jsonify({
'success': True,
'message': 'On-demand display cleared'
})
@api_v3.route('/display/on-demand-info', methods=['GET'])
def get_on_demand_info():
"""Get on-demand display status"""
controller = get_display_controller()
info = controller.get_on_demand_info()
return jsonify(info)
```
### Frontend Example (JavaScript)
```javascript
// Show weather for 30 seconds
async function showWeather() {
const response = await fetch('/api/v3/display/show', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
mode: 'weather',
duration: 30
})
});
const data = await response.json();
if (data.success) {
updateStatus(`Showing weather for ${data.info.duration}s`);
}
}
// Pin to live hockey game
async function pinHockeyLive() {
const response = await fetch('/api/v3/display/show', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
mode: 'hockey_live',
pinned: true
})
});
const data = await response.json();
if (data.success) {
updateStatus('Pinned to hockey live');
}
}
// Clear on-demand
async function clearOnDemand() {
const response = await fetch('/api/v3/display/clear', {
method: 'POST'
});
const data = await response.json();
if (data.success) {
updateStatus('Returned to normal rotation');
}
}
// Check status
async function checkOnDemandStatus() {
const response = await fetch('/api/v3/display/on-demand-info');
const info = await response.json();
if (info.active) {
updateStatus(`On-demand: ${info.mode} (${info.remaining}s remaining)`);
} else {
updateStatus('Normal rotation');
}
}
```
### UI Example (HTML)
```html
<!-- Plugin controls -->
<div class="plugin-card">
<h3>Weather</h3>
<button onclick="showWeather()">Show Now (30s)</button>
<button onclick="showWeatherIndefinite()">Show Until Cleared</button>
<button onclick="pinWeather()">Pin Weather</button>
</div>
<!-- On-demand status display -->
<div id="on-demand-status" class="status-bar">
<span id="status-text">Normal rotation</span>
<button id="clear-btn" onclick="clearOnDemand()" style="display: none;">
Clear On-Demand
</button>
</div>
<script>
// Poll for status updates
setInterval(async () => {
const info = await fetch('/api/v3/display/on-demand-info').then(r => r.json());
const statusText = document.getElementById('status-text');
const clearBtn = document.getElementById('clear-btn');
if (info.active) {
let text = `On-demand: ${info.mode}`;
if (info.remaining) {
text += ` (${Math.ceil(info.remaining)}s)`;
} else if (info.pinned) {
text += ' (pinned)';
}
statusText.textContent = text;
clearBtn.style.display = 'inline-block';
} else {
statusText.textContent = 'Normal rotation';
clearBtn.style.display = 'none';
}
}, 1000); // Update every second
</script>
```
## Behavior Details
### Duration Modes
| Duration Value | Behavior | Use Case |
|---------------|----------|----------|
| `None` | Use plugin's `display_duration` from config | Default behavior |
| `0` | Show indefinitely until cleared | Quick preview |
| `> 0` | Show for exactly N seconds | Timed preview |
| `pinned=True` | Stay on mode until unpinned | Extended viewing |
### Auto-Clear Behavior
On-demand display automatically clears when:
- Duration expires (if set and > 0)
- User manually clears it
- System restarts
On-demand does NOT clear when:
- `duration=0` (indefinite)
- `pinned=True`
- Live priority content appears (on-demand still has priority)
### Interaction with Live Priority
```python
# Scenario 1: On-demand overrides live priority
controller.show_on_demand('weather', duration=30)
# → Shows weather even if live game is happening
# Scenario 2: After on-demand expires, live priority takes over
controller.show_on_demand('weather', duration=10)
# → Shows weather for 10s
# → If live game exists, switches to live game
# → Otherwise returns to normal rotation
```
## Use Case Examples
### Example 1: Quick Weather Check
```python
# User clicks "Show Weather" button
controller.show_on_demand('weather', duration=30)
# Shows weather for 30 seconds, then returns to rotation
```
### Example 2: Monitor Live Game
```python
# User clicks "Watch Live Game" button
controller.show_on_demand('hockey_live', pinned=True)
# Stays on live game until user clicks "Back to Rotation"
```
### Example 3: Preview Plugin
```python
# User clicks "Preview" in plugin settings
controller.show_on_demand('my-plugin', duration=15)
# Shows plugin for 15 seconds to test configuration
```
### Example 4: Emergency Override
```python
# Admin needs to show important message
controller.show_on_demand('text-display', pinned=True)
# Display stays on message until admin clears it
```
## Testing
### Manual Test from Python
```python
# Access display controller
from src.display_controller import DisplayController
controller = DisplayController() # Or get existing instance
# Test show on-demand
controller.show_on_demand('weather', duration=20)
print(controller.get_on_demand_info())
# Test clear
time.sleep(5)
controller.clear_on_demand()
print(controller.get_on_demand_info())
```
### Test with Web API
```bash
# Show weather for 30 seconds
curl -X POST http://pi-ip:5001/api/v3/display/show \
-H "Content-Type: application/json" \
-d '{"mode": "weather", "duration": 30}'
# Check status
curl http://pi-ip:5001/api/v3/display/on-demand-info
# Clear on-demand
curl -X POST http://pi-ip:5001/api/v3/display/clear
```
### Monitor Logs
```bash
sudo journalctl -u ledmatrix -f | grep -i "on-demand"
```
Expected output:
```
On-demand display activated: weather (duration: 30s, pinned: False)
On-demand display expired after 30.1s
Clearing on-demand display: weather
```
## Best Practices
### 1. Provide Visual Feedback
Always show users when on-demand is active:
```javascript
// Update UI to show on-demand status
function updateOnDemandUI(info) {
const banner = document.getElementById('on-demand-banner');
if (info.active) {
banner.style.display = 'block';
banner.textContent = `Showing: ${info.mode}`;
if (info.remaining) {
banner.textContent += ` (${Math.ceil(info.remaining)}s)`;
}
} else {
banner.style.display = 'none';
}
}
```
### 2. Default to Timed Display
Unless explicitly requested, use a duration:
```python
# Good: Auto-clears after 30 seconds
controller.show_on_demand('weather', duration=30)
# Risky: Stays indefinitely
controller.show_on_demand('weather', duration=0)
```
### 3. Validate Modes
Check if mode exists before showing:
```python
# Get available modes
available_modes = controller.available_modes + list(controller.plugin_modes.keys())
if mode in available_modes:
controller.show_on_demand(mode, duration=30)
else:
return jsonify({'error': 'Mode not found'}), 404
```
### 4. Handle Concurrent Requests
Last request wins:
```python
# Request 1: Show weather
controller.show_on_demand('weather', duration=30)
# Request 2: Show hockey (overrides weather)
controller.show_on_demand('hockey_live', duration=20)
# Hockey now shows for 20s, weather request is forgotten
```
## Troubleshooting
### On-Demand Not Working
**Check 1:** Verify mode exists
```python
info = controller.get_on_demand_info()
print(f"Active: {info['active']}, Mode: {info.get('mode')}")
print(f"Available modes: {controller.available_modes}")
```
**Check 2:** Check logs
```bash
sudo journalctl -u ledmatrix -f | grep "on-demand\|available modes"
```
### On-Demand Not Clearing
**Check if pinned:**
```python
info = controller.get_on_demand_info()
if info['pinned']:
print("Mode is pinned - must clear manually")
controller.clear_on_demand()
```
**Check duration:**
```python
if info['duration'] == 0:
print("Duration is indefinite - must clear manually")
```
### Mode Shows But Looks Wrong
This is a **display** issue, not an on-demand issue. Check:
- Plugin's `update()` method is fetching data
- Plugin's `display()` method is rendering correctly
- Cache is not stale
## Security Considerations
### 1. Authentication Required
Always require authentication for on-demand control:
```python
@api_v3.route('/display/show', methods=['POST'])
@login_required # Add authentication
def show_on_demand():
# ... implementation
```
### 2. Rate Limiting
Prevent spam:
```python
from flask_limiter import Limiter
limiter = Limiter(app, key_func=get_remote_address)
@api_v3.route('/display/show', methods=['POST'])
@limiter.limit("10 per minute") # Max 10 requests per minute
def show_on_demand():
# ... implementation
```
### 3. Input Validation
Sanitize mode names:
```python
import re
def validate_mode(mode):
# Only allow alphanumeric, underscore, hyphen
if not re.match(r'^[a-zA-Z0-9_-]+$', mode):
raise ValueError("Invalid mode name")
return mode
```
## Implementation Checklist
- [ ] Add API endpoint to web interface
- [ ] Add "Show Now" buttons to plugin UI
- [ ] Add on-demand status indicator
- [ ] Add "Clear" button when on-demand active
- [ ] Add authentication/authorization
- [ ] Add rate limiting
- [ ] Test with multiple plugins
- [ ] Test duration expiration
- [ ] Test pinned mode
- [ ] Document for end users
## Future Enhancements
Consider adding:
1. **Queue system** - Queue multiple on-demand requests
2. **Scheduled on-demand** - Show mode at specific time
3. **Recurring on-demand** - Show every N minutes
4. **Permission levels** - Different users can show different modes
5. **History tracking** - Log who triggered what and when

425
docs/archive/ON_DEMAND_DISPLAY_QUICK_START.md Normal file
View File

@@ -0,0 +1,425 @@
# On-Demand Display - Quick Start Guide
## 🎯 What Is It?
On-Demand Display lets users **manually trigger** specific plugins to show on the LED matrix - perfect for "Show Now" buttons in your web interface!
> **2025 update:** The LEDMatrix web interface now ships with first-class on-demand controls. You can trigger plugins directly from the Plugin Management page or by calling the new `/api/v3/display/on-demand/*` endpoints described below. The legacy quick-start steps are still documented for bespoke integrations.
## ✅ Built-In Controls
### Web Interface (no-code)
- Navigate to **Settings → Plugin Management**.
- Each installed plugin now exposes a **Run On-Demand** button:
- Choose the display mode (when a plugin exposes multiple views).
- Optionally set a fixed duration (leave blank to use the plugin default or `0` to run until you stop it).
- Pin the plugin so rotation stays paused.
- The dashboard shows real-time status and lets you stop the session. **Shift+click** the stop button to stop the display service after clearing the plugin.
- The status card refreshes automatically and indicates whether the display service is running.
### REST Endpoints
All endpoints live under `/api/v3/display/on-demand`.
| Endpoint | Method | Description |
|----------|--------|-------------|
| `/status` | GET | Returns the current on-demand state plus display service health. |
| `/start` | POST | Requests a plugin/mode to run. Automatically starts the display service (unless `start_service: false`). |
| `/stop` | POST | Clears on-demand mode. Include `{"stop_service": true}` to stop the systemd service. |
Example `curl` calls:
```bash
# Start the default mode for football-scoreboard for 45 seconds
curl -X POST http://localhost:5000/api/v3/display/on-demand/start \
-H "Content-Type: application/json" \
-d '{
"plugin_id": "football-scoreboard",
"duration": 45,
"pinned": true
}'
# Start by mode name (plugin id inferred automatically)
curl -X POST http://localhost:5000/api/v3/display/on-demand/start \
-H "Content-Type: application/json" \
-d '{ "mode": "football_live" }'
# Stop on-demand and shut down the display service
curl -X POST http://localhost:5000/api/v3/display/on-demand/stop \
-H "Content-Type: application/json" \
-d '{ "stop_service": true }'
# Check current status
curl http://localhost:5000/api/v3/display/on-demand/status | jq
```
**Notes**
- The display controller will honour the plugin’s configured `display_duration` when no duration is provided.
- When you pass `duration: 0` (or omit it) and `pinned: true`, the plugin stays active until you issue `/stop`.
- The service automatically resumes normal rotation after the on-demand session expires or is cleared.
## 🚀 Quick Implementation (3 Steps)
> The steps below describe a lightweight custom implementation that predates the built-in API. You generally no longer need this unless you are integrating with a separate control surface.
### Step 1: Add API Endpoint
```python
# In web_interface/blueprints/api_v3.py
@api_v3.route('/display/show', methods=['POST'])
def show_on_demand():
data = request.json
mode = data.get('mode')
duration = data.get('duration', 30) # Default 30 seconds
# Get display controller (implementation depends on your setup)
controller = get_display_controller()
success = controller.show_on_demand(mode, duration=duration)
return jsonify({'success': success})
@api_v3.route('/display/clear', methods=['POST'])
def clear_on_demand():
controller = get_display_controller()
controller.clear_on_demand()
return jsonify({'success': True})
```
### Step 2: Add UI Button
```html
<!-- Show weather button -->
<button onclick="showWeather()">Show Weather Now</button>
<script>
async function showWeather() {
await fetch('/api/v3/display/show', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
mode: 'weather',
duration: 30 // Show for 30 seconds
})
});
}
</script>
```
### Step 3: Done! 🎉
Users can now click the button to show weather immediately!
## 📋 Complete Web UI Example
```html
<!DOCTYPE html>
<html>
<head>
<title>Display Control</title>
<style>
.plugin-card {
border: 1px solid #ccc;
padding: 15px;
margin: 10px;
border-radius: 5px;
}
.show-now-btn {
background: #4CAF50;
color: white;
padding: 10px 20px;
border: none;
border-radius: 5px;
cursor: pointer;
}
.pin-btn {
background: #2196F3;
color: white;
padding: 10px 20px;
border: none;
border-radius: 5px;
cursor: pointer;
}
.clear-btn {
background: #f44336;
color: white;
padding: 10px 20px;
border: none;
border-radius: 5px;
cursor: pointer;
}
#status-bar {
background: #ff9800;
color: white;
padding: 15px;
text-align: center;
display: none;
}
</style>
</head>
<body>
<!-- Status bar (shown when on-demand is active) -->
<div id="status-bar">
<span id="status-text"></span>
<button class="clear-btn" onclick="clearOnDemand()">
Return to Rotation
</button>
</div>
<!-- Plugin controls -->
<div class="plugin-grid">
<div class="plugin-card">
<h3>⛅ Weather</h3>
<button class="show-now-btn" onclick="showPlugin('weather', 30)">
Show for 30s
</button>
<button class="pin-btn" onclick="pinPlugin('weather')">
Pin Weather
</button>
</div>
<div class="plugin-card">
<h3>🏒 Hockey</h3>
<button class="show-now-btn" onclick="showPlugin('hockey_live', 45)">
Show Live Game
</button>
<button class="pin-btn" onclick="pinPlugin('hockey_live')">
Pin Game
</button>
</div>
<div class="plugin-card">
<h3>🎵 Music</h3>
<button class="show-now-btn" onclick="showPlugin('music', 20)">
Show Now Playing
</button>
</div>
</div>
<script>
// Show plugin for specific duration
async function showPlugin(mode, duration) {
const response = await fetch('/api/v3/display/show', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ mode, duration })
});
const data = await response.json();
if (data.success) {
updateStatus();
} else {
alert('Failed to show plugin');
}
}
// Pin plugin (stays until cleared)
async function pinPlugin(mode) {
const response = await fetch('/api/v3/display/show', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
mode,
pinned: true
})
});
const data = await response.json();
if (data.success) {
updateStatus();
}
}
// Clear on-demand and return to rotation
async function clearOnDemand() {
await fetch('/api/v3/display/clear', { method: 'POST' });
updateStatus();
}
// Update status display
async function updateStatus() {
const response = await fetch('/api/v3/display/on-demand-info');
const info = await response.json();
const statusBar = document.getElementById('status-bar');
const statusText = document.getElementById('status-text');
if (info.active) {
let text = `Showing: ${info.mode}`;
if (info.remaining) {
text += ` (${Math.ceil(info.remaining)}s remaining)`;
} else if (info.pinned) {
text += ' (pinned)';
}
statusText.textContent = text;
statusBar.style.display = 'block';
} else {
statusBar.style.display = 'none';
}
}
// Poll for status updates every second
setInterval(updateStatus, 1000);
// Initial status check
updateStatus();
</script>
</body>
</html>
```
## ⚡ Usage Patterns
### Pattern 1: Timed Preview
```javascript
// Show for 30 seconds then return to rotation
showPlugin('weather', 30);
```
### Pattern 2: Pinned Display
```javascript
// Stay on this plugin until manually cleared
pinPlugin('hockey_live');
```
### Pattern 3: Quick Check
```javascript
// Show for 10 seconds
showPlugin('clock', 10);
```
### Pattern 4: Indefinite Display
```javascript
// Show until cleared (duration=0)
fetch('/api/v3/display/show', {
method: 'POST',
body: JSON.stringify({ mode: 'weather', duration: 0 })
});
```
## 📊 Priority Order
```
User clicks "Show Weather" button
↓
1. On-Demand (Highest) ← Shows immediately
2. Live Priority ← Overridden
3. Normal Rotation ← Paused
```
On-demand has **highest priority** - it overrides everything!
## 🎮 Common Use Cases
### Quick Weather Check
```html
<button onclick="showPlugin('weather', 20)">
Check Weather
</button>
```
### Monitor Live Game
```html
<button onclick="pinPlugin('hockey_live')">
Watch Game
</button>
```
### Test Plugin Configuration
```html
<button onclick="showPlugin('my-plugin', 15)">
Preview Plugin
</button>
```
### Emergency Message
```html
<button onclick="pinPlugin('text-display')">
Show Alert
</button>
```
## 🔧 Duration Options
| Value | Behavior | Example |
|-------|----------|---------|
| `30` | Show for 30s then return | Quick preview |
| `0` | Show until cleared | Extended viewing |
| `null` | Use plugin's default | Let plugin decide |
| `pinned: true` | Stay until unpinned | Monitor mode |
## ❓ FAQ
### Q: What happens when duration expires?
**A:** Display automatically returns to normal rotation (or live priority if active).
### Q: Can I show multiple modes at once?
**A:** No, only one mode at a time. Last request wins.
### Q: Does it override live games?
**A:** Yes! On-demand has highest priority, even over live priority.
### Q: How do I go back to normal rotation?
**A:** Either wait for duration to expire, or call `clearOnDemand()`.
### Q: What if the mode doesn't exist?
**A:** API returns `success: false` and logs a warning.
## 🐛 Testing
### Test 1: Show for 30 seconds
```bash
curl -X POST http://pi-ip:5001/api/v3/display/show \
-H "Content-Type: application/json" \
-d '{"mode": "weather", "duration": 30}'
```
### Test 2: Pin mode
```bash
curl -X POST http://pi-ip:5001/api/v3/display/show \
-H "Content-Type: application/json" \
-d '{"mode": "hockey_live", "pinned": true}'
```
### Test 3: Clear on-demand
```bash
curl -X POST http://pi-ip:5001/api/v3/display/clear
```
### Test 4: Check status
```bash
curl http://pi-ip:5001/api/v3/display/on-demand-info
```
## 📝 Implementation Checklist
- [ ] Add API endpoints to web interface
- [ ] Add "Show Now" buttons to plugin cards
- [ ] Add status bar showing current on-demand mode
- [ ] Add "Clear" button when on-demand active
- [ ] Add authentication to API endpoints
- [ ] Test with multiple plugins
- [ ] Test duration expiration
- [ ] Test pinned mode
## 📚 Full Documentation
See `ON_DEMAND_DISPLAY_API.md` for:
- Complete API reference
- Security best practices
- Troubleshooting guide
- Advanced examples
## 🎯 Key Points
1. **User-triggered** - Manual control from web UI
2. **Highest priority** - Overrides everything
3. **Auto-clear** - Returns to rotation after duration
4. **Pin mode** - Stay on mode until manually cleared
5. **Simple API** - Just 3 endpoints needed
That's it! Your users can now control what shows on the display! 🚀

413
docs/archive/OPTIMAL_WIFI_AP_FAILOVER_SETUP.md Normal file
View File

@@ -0,0 +1,413 @@
# Optimal WiFi Configuration with Failover AP Mode
## Overview
This guide explains the optimal way to configure WiFi with automatic failover to Access Point (AP) mode, ensuring you can always connect to your Raspberry Pi even when the primary WiFi network is unavailable.
## System Architecture
### How It Works
The LEDMatrix WiFi system uses a **grace period mechanism** to prevent false positives from transient network hiccups:
1. **WiFi Monitor Daemon** runs as a background service (every 30 seconds by default)
2. **Grace Period**: Requires **3 consecutive disconnected checks** before enabling AP mode
- At 30-second intervals, this means **90 seconds** of confirmed disconnection
- This prevents AP mode from activating during brief network interruptions
3. **Automatic Failover**: When both WiFi and Ethernet are disconnected for the grace period, AP mode activates
4. **Automatic Recovery**: When WiFi or Ethernet reconnects, AP mode automatically disables
### Connection Priority
The system checks connections in this order:
1. **WiFi Connection** (highest priority)
2. **Ethernet Connection** (fallback)
3. **AP Mode** (last resort - only when both WiFi and Ethernet are disconnected)
## Optimal Configuration
### Recommended Settings
For a **reliable failover system**, use these settings:
```json
{
"ap_ssid": "LEDMatrix-Setup",
"ap_password": "ledmatrix123",
"ap_channel": 7,
"auto_enable_ap_mode": true,
"saved_networks": [
{
"ssid": "YourPrimaryNetwork",
"password": "your-password"
}
]
}
```
### Key Configuration Options
| Setting | Recommended Value | Purpose |
|---------|------------------|---------|
| `auto_enable_ap_mode` | `true` | Enables automatic failover to AP mode |
| `ap_ssid` | `LEDMatrix-Setup` | Network name for AP mode (customizable) |
| `ap_password` | `ledmatrix123` | Password for AP mode (change for security) |
| `ap_channel` | `7` (or 1, 6, 11) | WiFi channel (use non-overlapping channels) |
| `saved_networks` | Array of networks | Pre-configured networks for quick connection |
## Step-by-Step Setup
### 1. Initial Configuration
**Via Web Interface (Recommended):**
1. Connect to your Raspberry Pi (via Ethernet or existing WiFi)
2. Navigate to the **WiFi** tab in the web interface
3. Configure your primary WiFi network:
- Click **Scan** to find networks
- Select your network from the dropdown
- Enter your WiFi password
- Click **Connect**
4. Enable auto-failover:
- Toggle **"Auto-Enable AP Mode"** to **ON**
- This enables automatic failover when WiFi disconnects
**Via Configuration File:**
```bash
# Edit the WiFi configuration
nano config/wifi_config.json
```
Set `auto_enable_ap_mode` to `true`:
```json
{
"auto_enable_ap_mode": true,
...
}
```
### 2. Verify WiFi Monitor Service
The WiFi monitor daemon must be running for automatic failover:
```bash
# Check service status
sudo systemctl status ledmatrix-wifi-monitor
# If not running, start it
sudo systemctl start ledmatrix-wifi-monitor
# Enable on boot
sudo systemctl enable ledmatrix-wifi-monitor
```
### 3. Test Failover Behavior
**Test Scenario 1: WiFi Disconnection**
1. Disconnect your WiFi router or move the Pi out of range
2. Wait **90 seconds** (3 check intervals × 30 seconds)
3. AP mode should automatically activate
4. Connect to **LEDMatrix-Setup** network from your device
5. Access web interface at `http://192.168.4.1:5000`
**Test Scenario 2: WiFi Reconnection**
1. Reconnect WiFi router or move Pi back in range
2. Within **30 seconds**, AP mode should automatically disable
3. Pi should reconnect to your primary WiFi network
## How the Grace Period Works
### Disconnected Check Counter
The system uses a **disconnected check counter** to prevent false positives:
```
Check Interval: 30 seconds (configurable)
Required Checks: 3 consecutive
Grace Period: 90 seconds total
```
**Example Timeline:**
```
Time 0s: WiFi disconnects
Time 30s: Check 1 - Disconnected (counter = 1)
Time 60s: Check 2 - Disconnected (counter = 2)
Time 90s: Check 3 - Disconnected (counter = 3) → AP MODE ENABLED
```
If WiFi reconnects at any point, the counter resets to 0.
### Why Grace Period is Important
Without a grace period, AP mode would activate during:
- Brief network hiccups
- Router reboots
- Temporary signal interference
- NetworkManager reconnection attempts
The 90-second grace period ensures AP mode only activates when there's a **sustained disconnection**.
## Best Practices
### 1. Security Considerations
**Change Default AP Password:**
```json
{
"ap_password": "your-strong-password-here"
}
```
**Use Non-Overlapping WiFi Channels:**
- Channels 1, 6, 11 are non-overlapping (2.4GHz)
- Choose a channel that doesn't conflict with your primary network
- Example: If primary network uses channel 1, use channel 11 for AP mode
### 2. Network Configuration
**Save Multiple Networks:**
You can save multiple WiFi networks for automatic connection:
```json
{
"saved_networks": [
{
"ssid": "Home-Network",
"password": "home-password"
},
{
"ssid": "Office-Network",
"password": "office-password"
}
]
}
```
**Note:** Saved networks are stored for reference but connection still requires manual selection or NetworkManager auto-connect.
### 3. Monitoring and Troubleshooting
**Check Service Logs:**
```bash
# View real-time logs
sudo journalctl -u ledmatrix-wifi-monitor -f
# View recent logs
sudo journalctl -u ledmatrix-wifi-monitor -n 50
```
**Check WiFi Status:**
```bash
# Via Python
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
status = wm.get_wifi_status()
print(f'Connected: {status.connected}')
print(f'SSID: {status.ssid}')
print(f'IP: {status.ip_address}')
print(f'AP Mode: {status.ap_mode_active}')
print(f'Auto-Enable: {wm.config.get(\"auto_enable_ap_mode\", False)}')
"
```
**Check NetworkManager Status:**
```bash
# View device status
nmcli device status
# View connections
nmcli connection show
# View WiFi networks
nmcli device wifi list
```
### 4. Customization Options
**Adjust Check Interval:**
Edit the systemd service file:
```bash
sudo systemctl edit ledmatrix-wifi-monitor
```
Add:
```ini
[Service]
ExecStart=
ExecStart=/usr/bin/python3 /path/to/LEDMatrix/scripts/utils/wifi_monitor_daemon.py --interval 20
```
Then restart:
```bash
sudo systemctl daemon-reload
sudo systemctl restart ledmatrix-wifi-monitor
```
**Note:** Changing the interval affects the grace period:
- 20-second interval = 60-second grace period (3 × 20)
- 30-second interval = 90-second grace period (3 × 30) ← Default
- 60-second interval = 180-second grace period (3 × 60)
## Configuration Scenarios
### Scenario 1: Always-On Failover (Recommended)
**Use Case:** Portable device that may lose WiFi connection
**Configuration:**
```json
{
"auto_enable_ap_mode": true
}
```
**Behavior:**
- AP mode activates automatically after 90 seconds of disconnection
- Always provides a way to connect to the device
- Best for devices that move or have unreliable WiFi
### Scenario 2: Manual AP Mode Only
**Use Case:** Stable network connection (e.g., Ethernet or reliable WiFi)
**Configuration:**
```json
{
"auto_enable_ap_mode": false
}
```
**Behavior:**
- AP mode must be manually enabled via web UI
- Prevents unnecessary AP mode activation
- Best for stationary devices with stable connections
### Scenario 3: Ethernet Primary with WiFi Failover
**Use Case:** Device primarily uses Ethernet, WiFi as backup
**Configuration:**
```json
{
"auto_enable_ap_mode": true
}
```
**Behavior:**
- Ethernet connection prevents AP mode activation
- If Ethernet disconnects, WiFi is attempted
- If both disconnect, AP mode activates after grace period
- Best for devices with both Ethernet and WiFi
## Troubleshooting
### AP Mode Not Activating
**Check 1: Auto-Enable Setting**
```bash
cat config/wifi_config.json | grep auto_enable_ap_mode
```
Should show `"auto_enable_ap_mode": true`
**Check 2: Service Status**
```bash
sudo systemctl status ledmatrix-wifi-monitor
```
Service should be `active (running)`
**Check 3: Grace Period**
- Wait at least 90 seconds after disconnection
- Check logs: `sudo journalctl -u ledmatrix-wifi-monitor -f`
**Check 4: Ethernet Connection**
- If Ethernet is connected, AP mode won't activate
- Disconnect Ethernet to test AP mode
### AP Mode Activating Unexpectedly
**Check 1: Network Stability**
- Verify WiFi connection is stable
- Check for router issues or signal problems
**Check 2: Grace Period Too Short**
- Current grace period is 90 seconds
- Brief disconnections shouldn't trigger AP mode
- Check logs for disconnection patterns
**Check 3: Disable Auto-Enable**
```bash
# Set to false
nano config/wifi_config.json
# Change: "auto_enable_ap_mode": false
sudo systemctl restart ledmatrix-wifi-monitor
```
### Cannot Connect to AP Mode
**Check 1: AP Mode Active**
```bash
sudo systemctl status hostapd
sudo systemctl status dnsmasq
```
**Check 2: Network Interface**
```bash
ip addr show wlan0
```
Should show IP `192.168.4.1`
**Check 3: Firewall**
```bash
sudo iptables -L -n
```
Check if port 5000 is accessible
**Check 4: Manual Enable**
- Try manually enabling AP mode via web UI
- Or via API: `curl -X POST http://localhost:5001/api/v3/wifi/ap/enable`
## Summary
### Optimal Configuration Checklist
- [ ] `auto_enable_ap_mode` set to `true`
- [ ] WiFi monitor service running and enabled
- [ ] Primary WiFi network configured and tested
- [ ] AP password changed from default
- [ ] AP channel configured (non-overlapping)
- [ ] Grace period understood (90 seconds)
- [ ] Failover behavior tested
### Key Takeaways
1. **Grace Period**: 90 seconds prevents false positives
2. **Auto-Enable**: Set to `true` for reliable failover
3. **Service**: WiFi monitor daemon must be running
4. **Priority**: WiFi → Ethernet → AP Mode
5. **Automatic**: AP mode disables when WiFi/Ethernet connects
This configuration provides a robust failover system that ensures you can always access your Raspberry Pi, even when the primary network connection fails.

514
docs/archive/PERMISSION_MANAGEMENT_GUIDE.md Normal file
View File

@@ -0,0 +1,514 @@
# Permission Management Guide
## Overview
LEDMatrix runs with a dual-user architecture: the main display service runs as `root` (for hardware access), while the web interface runs as a regular user. This guide explains how to properly manage file and directory permissions to ensure both services can access the files they need.
## Table of Contents
1. [Why Permission Management Matters](#why-permission-management-matters)
2. [Permission Utilities](#permission-utilities)
3. [When to Use Permission Utilities](#when-to-use-permission-utilities)
4. [How to Use Permission Utilities](#how-to-use-permission-utilities)
5. [Common Patterns and Examples](#common-patterns-and-examples)
6. [Permission Standards](#permission-standards)
7. [Troubleshooting](#troubleshooting)
---
## Why Permission Management Matters
### The Problem
Without proper permission management, you may encounter errors like:
- `PermissionError: [Errno 13] Permission denied` when saving config files
- `PermissionError` when downloading team logos
- Files created by the root service not accessible by the web user
- Files created by the web user not accessible by the root service
### The Solution
The LEDMatrix codebase includes centralized permission utilities (`src/common/permission_utils.py`) that ensure files and directories are created with appropriate permissions for both users.
---
## Permission Utilities
### Available Functions
The permission utilities module provides the following functions:
#### Directory Management
- `ensure_directory_permissions(path: Path, mode: int = 0o775) -> None`
- Creates directory if it doesn't exist
- Sets permissions to the specified mode
- Default mode: `0o775` (rwxrwxr-x) - group-writable
#### File Management
- `ensure_file_permissions(path: Path, mode: int = 0o644) -> None`
- Sets permissions on an existing file
- Default mode: `0o644` (rw-r--r--) - world-readable
#### Mode Helpers
These functions return the appropriate permission mode for different file types:
- `get_config_file_mode(file_path: Path) -> int`
- Returns `0o640` for secrets files, `0o644` for regular config files
- `get_assets_file_mode() -> int`
- Returns `0o664` (rw-rw-r--) for asset files (logos, images)
- `get_assets_dir_mode() -> int`
- Returns `0o2775` (rwxrwsr-x) for asset directories
- Setgid bit enforces inherited group ownership for new files/directories
- `get_config_dir_mode() -> int`
- Returns `0o2775` (rwxrwsr-x) for config directories
- Setgid bit enforces inherited group ownership for new files/directories
- `get_plugin_file_mode() -> int`
- Returns `0o664` (rw-rw-r--) for plugin files
- `get_plugin_dir_mode() -> int`
- Returns `0o2775` (rwxrwsr-x) for plugin directories
- Setgid bit enforces inherited group ownership for new files/directories
- `get_cache_dir_mode() -> int`
- Returns `0o2775` (rwxrwsr-x) for cache directories
- Setgid bit enforces inherited group ownership for new files/directories
---
## When to Use Permission Utilities
### Always Use Permission Utilities When:
1. **Creating directories** - Use `ensure_directory_permissions()` instead of `os.makedirs()` or `Path.mkdir()`
2. **Saving files** - Use `ensure_file_permissions()` after writing files
3. **Downloading assets** - Set permissions after downloading logos, images, or other assets
4. **Creating config files** - Set permissions after saving configuration files
5. **Creating cache files** - Set permissions when creating cache directories or files
6. **Plugin file operations** - Set permissions when plugins create their own files/directories
### You Don't Need Permission Utilities When:
1. **Reading files** - Reading doesn't require permission changes
2. **Using core utilities** - Core utilities (LogoHelper, CacheManager, ConfigManager) already handle permissions
3. **Temporary files** - Files in `/tmp` or created with `tempfile` don't need special permissions
---
## How to Use Permission Utilities
### Basic Import
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_assets_dir_mode,
get_assets_file_mode,
get_config_dir_mode,
get_config_file_mode
)
```
### Creating a Directory
**Before (incorrect):**
```python
import os
os.makedirs("assets/sports/logos", exist_ok=True)
# Problem: Permissions may not be set correctly
```
**After (correct):**
```python
from pathlib import Path
from src.common.permission_utils import ensure_directory_permissions, get_assets_dir_mode
logo_dir = Path("assets/sports/logos")
ensure_directory_permissions(logo_dir, get_assets_dir_mode())
```
### Saving a File
**Before (incorrect):**
```python
with open("config/my_config.json", 'w') as f:
json.dump(data, f, indent=4)
# Problem: File may not be readable by root service
```
**After (correct):**
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_config_dir_mode,
get_config_file_mode
)
config_path = Path("config/my_config.json")
# Ensure directory exists with proper permissions
ensure_directory_permissions(config_path.parent, get_config_dir_mode())
# Write file
with open(config_path, 'w') as f:
json.dump(data, f, indent=4)
# Set file permissions
ensure_file_permissions(config_path, get_config_file_mode(config_path))
```
### Downloading and Saving an Image
**Before (incorrect):**
```python
response = requests.get(image_url)
with open("assets/sports/logo.png", 'wb') as f:
f.write(response.content)
# Problem: File may not be writable by root service
```
**After (correct):**
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_assets_dir_mode,
get_assets_file_mode
)
logo_path = Path("assets/sports/logo.png")
# Ensure directory exists
ensure_directory_permissions(logo_path.parent, get_assets_dir_mode())
# Download and save
response = requests.get(image_url)
with open(logo_path, 'wb') as f:
f.write(response.content)
# Set file permissions
ensure_file_permissions(logo_path, get_assets_file_mode())
```
---
## Common Patterns and Examples
### Pattern 1: Config File Save
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_config_dir_mode,
get_config_file_mode
)
def save_config(config_data: dict, config_path: str) -> None:
"""Save configuration file with proper permissions."""
path = Path(config_path)
# Ensure directory exists
ensure_directory_permissions(path.parent, get_config_dir_mode())
# Write file
with open(path, 'w') as f:
json.dump(config_data, f, indent=4)
# Set permissions
ensure_file_permissions(path, get_config_file_mode(path))
```
### Pattern 2: Asset Directory Setup
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
get_assets_dir_mode
)
def setup_asset_directory(base_dir: str, subdir: str) -> Path:
"""Create asset directory with proper permissions."""
asset_dir = Path(base_dir) / subdir
ensure_directory_permissions(asset_dir, get_assets_dir_mode())
return asset_dir
```
### Pattern 3: Plugin File Creation
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_plugin_dir_mode,
get_plugin_file_mode
)
def save_plugin_data(plugin_id: str, data: dict) -> None:
"""Save plugin data file with proper permissions."""
plugin_dir = Path("plugins") / plugin_id
data_file = plugin_dir / "data.json"
# Ensure plugin directory exists
ensure_directory_permissions(plugin_dir, get_plugin_dir_mode())
# Write file
with open(data_file, 'w') as f:
json.dump(data, f, indent=2)
# Set permissions
ensure_file_permissions(data_file, get_plugin_file_mode())
```
### Pattern 4: Cache Directory Creation
```python
from pathlib import Path
from src.common.permission_utils import (
ensure_directory_permissions,
get_cache_dir_mode
)
def get_cache_directory() -> Path:
"""Get or create cache directory with proper permissions."""
cache_dir = Path("/var/cache/ledmatrix")
ensure_directory_permissions(cache_dir, get_cache_dir_mode())
return cache_dir
```
### Pattern 5: Atomic File Write with Permissions
```python
from pathlib import Path
import tempfile
import os
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_config_dir_mode,
get_config_file_mode
)
def save_config_atomic(config_data: dict, config_path: str) -> None:
"""Save config file atomically with proper permissions."""
path = Path(config_path)
# Ensure directory exists
ensure_directory_permissions(path.parent, get_config_dir_mode())
# Write to temp file first
temp_path = path.with_suffix('.tmp')
with open(temp_path, 'w') as f:
json.dump(config_data, f, indent=4)
# Set permissions on temp file
ensure_file_permissions(temp_path, get_config_file_mode(path))
# Atomic move
temp_path.replace(path)
# Permissions are preserved after move, but ensure they're correct
ensure_file_permissions(path, get_config_file_mode(path))
```
---
## Permission Standards
### File Permissions
| File Type | Mode | Octal | Description |
|-----------|------|-------|-------------|
| Config files | `rw-r--r--` | `0o644` | Readable by all, writable by owner |
| Secrets files | `rw-r-----` | `0o640` | Readable by owner and group only |
| Asset files | `rw-rw-r--` | `0o664` | Group-writable for root:user access |
| Plugin files | `rw-rw-r--` | `0o664` | Group-writable for root:user access |
### Directory Permissions
| Directory Type | Mode | Octal | Description |
|----------------|------|-------|-------------|
| Config directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
| Asset directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
| Plugin directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
| Cache directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
### Why These Permissions?
- **Group-writable (664)**: Allows both root service and web user to read/write files
- **Directory setgid bit (2775)**: Ensures new files and directories inherit the group ownership, maintaining consistent permissions
- **World-readable (644)**: Config files need to be readable by root service
- **Restricted (640)**: Secrets files should only be readable by owner and group
---
## Troubleshooting
### Common Issues
#### Issue: Permission denied when saving config
**Symptoms:**
```
PermissionError: [Errno 13] Permission denied: 'config/config.json'
```
**Solution:**
Ensure you're using `ensure_directory_permissions()` and `ensure_file_permissions()`:
```python
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_config_dir_mode,
get_config_file_mode
)
path = Path("config/config.json")
ensure_directory_permissions(path.parent, get_config_dir_mode())
# ... write file ...
ensure_file_permissions(path, get_config_file_mode(path))
```
#### Issue: Logo downloads fail with permission errors
**Symptoms:**
```
PermissionError: Cannot write to directory assets/sports/logos
```
**Solution:**
Use permission utilities when creating directories and saving files:
```python
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_assets_dir_mode,
get_assets_file_mode
)
logo_path = Path("assets/sports/logos/team.png")
ensure_directory_permissions(logo_path.parent, get_assets_dir_mode())
# ... download and save ...
ensure_file_permissions(logo_path, get_assets_file_mode())
```
#### Issue: Files created by root service not accessible by web user
**Symptoms:**
- Web interface can't read files created by the service
- Files show as owned by root with restrictive permissions
**Solution:**
Always use permission utilities when creating files. The utilities set group-writable permissions (664/775) that allow both users to access files.
#### Issue: Plugin can't write to its directory
**Symptoms:**
```
PermissionError: Cannot write to plugins/my-plugin/data.json
```
**Solution:**
Use permission utilities in your plugin:
```python
from src.common.permission_utils import (
ensure_directory_permissions,
ensure_file_permissions,
get_plugin_dir_mode,
get_plugin_file_mode
)
# In your plugin code
plugin_dir = Path("plugins") / self.plugin_id
ensure_directory_permissions(plugin_dir, get_plugin_dir_mode())
# ... create files ...
ensure_file_permissions(file_path, get_plugin_file_mode())
```
### Verification
To verify permissions are set correctly:
```bash
# Check file permissions
ls -l config/config.json
# Should show: -rw-r--r-- or -rw-rw-r--
# Check directory permissions
ls -ld assets/sports/logos
# Should show: drwxrwxr-x or drwxr-xr-x
# Check if both users can access
sudo -u root test -r config/config.json && echo "Root can read"
sudo -u $USER test -r config/config.json && echo "User can read"
```
### Manual Fix
If you need to manually fix permissions:
```bash
# Fix assets directory
sudo ./scripts/fix_perms/fix_assets_permissions.sh
# Fix plugin directory
sudo ./scripts/fix_perms/fix_plugin_permissions.sh
# Fix config directory
sudo chmod 755 config
sudo chmod 644 config/config.json
sudo chmod 640 config/config_secrets.json
```
---
## Best Practices
1. **Always use permission utilities** when creating files or directories
2. **Use the appropriate mode helper** (`get_assets_file_mode()`, etc.) rather than hardcoding modes
3. **Set directory permissions before creating files** in that directory
4. **Set file permissions immediately after writing** the file
5. **Use atomic writes** (temp file + move) for critical files like config
6. **Test with both users** - verify files work when created by root service and web user
---
## Integration with Core Utilities
Many core utilities already handle permissions automatically:
- **LogoHelper** (`src/common/logo_helper.py`) - Sets permissions when downloading logos
- **LogoDownloader** (`src/logo_downloader.py`) - Sets permissions for directories and files
- **CacheManager** - Sets permissions when creating cache directories
- **ConfigManager** - Sets permissions when saving config files
- **PluginManager** - Sets permissions for plugin directories and marker files
If you're using these utilities, you don't need to manually set permissions. However, if you're creating files directly (not through these utilities), you should use the permission utilities.
---
## Summary
- **Always use** `ensure_directory_permissions()` when creating directories
- **Always use** `ensure_file_permissions()` after writing files
- **Use mode helpers** (`get_assets_file_mode()`, etc.) for consistency
- **Core utilities handle permissions** - you only need to set permissions for custom file operations
- **Group-writable permissions (664/775)** allow both root service and web user to access files
For questions or issues, refer to the troubleshooting section or check existing code in the LEDMatrix codebase for examples.

336
docs/archive/PLUGIN_CONFIG_SYSTEM_EXPLANATION.md Normal file
View File

@@ -0,0 +1,336 @@
# Plugin Configuration System: How It's Better
## Executive Summary
The new plugin configuration system solves critical reliability and scalability issues in the previous implementation. It provides **server-side validation**, **automatic default management**, **dual editing interfaces**, and **intelligent caching** - making the system production-ready and user-friendly.
## Problems Solved
### Problem 1: "Configuration settings aren't working reliably"
**Root Cause**: No validation before saving, schema loading was fragile, defaults were hardcoded.
**Solution**:
- ✅ **Pre-save validation** using JSON Schema Draft-07
- ✅ **Reliable schema loading** with caching and multiple fallback paths
- ✅ **Automatic default extraction** from schemas
- ✅ **Detailed error messages** showing exactly what's wrong
**Before**: Invalid configs saved → runtime errors → user confusion
**After**: Invalid configs rejected → clear error messages → user fixes immediately
### Problem 2: "Config schema isn't working as reliably as hoped"
**Root Cause**: Schema files loaded on every request, path resolution was fragile, no caching.
**Solution**:
- ✅ **SchemaManager** with intelligent path resolution
- ✅ **In-memory caching** (10-20x faster)
- ✅ **Multiple fallback paths** (handles different plugin directory locations)
- ✅ **Case-insensitive matching** (handles naming mismatches)
- ✅ **Manifest-based discovery** (finds plugins even with directory name mismatches)
**Before**: Schema loading failed silently, slow performance, fragile paths
**After**: Reliable loading, fast performance, robust path resolution
### Problem 3: "Need scalable system that grows/shrinks with plugins"
**Root Cause**: Manual config management, no automatic cleanup, orphaned configs accumulated.
**Solution**:
- ✅ **Automatic config cleanup** on plugin uninstall
- ✅ **Orphaned config detection** and cleanup utility
- ✅ **Dynamic schema loading** (no hardcoded plugin lists)
- ✅ **Cache invalidation** on plugin lifecycle events
**Before**: Manual cleanup required, orphaned configs, doesn't scale
**After**: Automatic management, clean configs, scales infinitely
### Problem 4: "Web interface not accurately saving configuration"
**Root Cause**: No validation, type conversion issues, nested configs handled incorrectly.
**Solution**:
- ✅ **Server-side validation** before save
- ✅ **Schema-driven type conversion**
- ✅ **Proper nested config handling** (deep merge)
- ✅ **Validation error display** in UI
**Before**: Configs saved incorrectly, type mismatches, nested values lost
**After**: Configs validated and saved correctly, proper types, nested values preserved
### Problem 5: "Need JSON editor for typed changes"
**Root Cause**: Form-only interface, difficult to edit complex nested configs.
**Solution**:
- ✅ **CodeMirror JSON editor** with syntax highlighting
- ✅ **Real-time JSON validation**
- ✅ **Toggle between form and JSON views**
- ✅ **Bidirectional sync** between views
**Before**: Form-only, difficult for complex configs
**After**: Dual interface, easy editing for all config types
### Problem 6: "Need reset to defaults button"
**Root Cause**: No way to reset configs, had to manually edit files.
**Solution**:
- ✅ **Reset endpoint** (`/api/v3/plugins/config/reset`)
- ✅ **Reset button** in UI
- ✅ **Preserves secrets** by default
- ✅ **Regenerates form** with defaults
**Before**: Manual file editing required
**After**: One-click reset with confirmation
## Technical Improvements
### 1. Schema Management Architecture
**Old Approach**:
```text
Every Request:
→ Try path 1
→ Try path 2
→ Try path 3
→ Load file
→ Parse JSON
→ Return schema
```
**Problems**: Slow, fragile, no caching, errors not handled
**New Approach**:
```
First Request:
→ Check cache (miss)
→ Intelligent path resolution
→ Load and validate schema
→ Cache schema
→ Return schema
Subsequent Requests:
→ Check cache (hit)
→ Return schema immediately
```
**Benefits**: 10-20x faster, reliable, cached, error handling
### 2. Validation Architecture
**Old Approach**:
```text
Save Request:
→ Accept config
→ Save directly
→ Errors discovered at runtime
```
**Problems**: Invalid configs saved, runtime errors, poor UX
**New Approach**:
```
Save Request:
→ Load schema (cached)
→ Inject core properties (enabled, display_duration, live_priority) into schema
→ Remove core properties from required array (system-managed)
→ Validate config against schema
→ If invalid: return detailed errors
→ If valid: apply defaults (including core property defaults)
→ Separate secrets
→ Save configs
→ Notify plugin
```
**Benefits**: Invalid configs rejected, clear errors, proper defaults, system-managed properties handled correctly
### 3. Default Management
**Old Approach**:
```python
# Hardcoded in multiple places
defaults = {
'enabled': False,
'display_duration': 15
}
```
**Problems**: Duplicated, inconsistent, not schema-driven
**New Approach**:
```python
# Extracted from schema automatically
defaults = schema_mgr.extract_defaults_from_schema(schema)
# Recursively handles nested objects, arrays, all types
```
**Benefits**: Single source of truth, consistent, schema-driven
### 4. User Interface
**Old Approach**:
- Single form view
- No validation feedback
- Generic error messages
- No reset functionality
**New Approach**:
- **Dual interface**: Form + JSON editor
- **Real-time validation**: JSON syntax checked as you type
- **Detailed errors**: Field-level error messages
- **Reset button**: One-click reset to defaults
- **Better UX**: Toggle views, see errors immediately
## Reliability Improvements
### Before vs After
| Aspect | Before | After |
|--------|--------|-------|
| **Schema Loading** | Fragile, slow, no caching | Reliable, fast, cached |
| **Validation** | None (runtime errors) | Pre-save validation |
| **Error Messages** | Generic | Detailed with field paths |
| **Default Management** | Hardcoded, inconsistent | Schema-driven, automatic |
| **Nested Configs** | Handled incorrectly | Proper deep merge |
| **Type Safety** | No type checking | Full type validation |
| **Config Cleanup** | Manual | Automatic |
| **Path Resolution** | Single path, fails easily | Multiple paths, robust |
## Performance Improvements
### Schema Loading
- **Before**: 50-100ms per request (file I/O every time)
- **After**: 1-5ms per request (cached) - **10-20x faster**
### Validation
- **Before**: No validation (errors discovered at runtime)
- **After**: 5-10ms validation (prevents runtime errors)
### Default Generation
- **Before**: N/A (hardcoded)
- **After**: 2-5ms (cached after first generation)
## User Experience Improvements
### Configuration Editing
**Before**:
1. Edit form
2. Save (no feedback)
3. Discover errors later
4. Manually edit config.json
5. Restart service
**After**:
1. Choose view (Form or JSON)
2. Edit with real-time validation
3. Save with immediate feedback
4. See detailed errors if invalid
5. Reset to defaults if needed
6. All changes validated before save
### Error Handling
**Before**:
- Generic error: "Error saving configuration"
- No indication of what's wrong
- Must check logs or config file
**After**:
- Detailed errors: "Field 'nfl.live_priority': Expected type boolean, got string"
- Field paths shown
- Errors displayed in UI
- Clear guidance on how to fix
## Scalability
### Plugin Installation/Removal
**Before**:
- Config sections manually added/removed
- Orphaned configs accumulate
- Manual cleanup required
**After**:
- Config sections automatically managed
- Orphaned configs detected and cleaned
- Automatic cleanup on uninstall
- System adapts automatically
### Schema Evolution
**Before**:
- Schema changes require code updates
- Defaults hardcoded in multiple places
- Validation logic scattered
**After**:
- Schema changes work automatically
- Defaults extracted from schema
- Validation logic centralized
- No code changes needed for new schema features
## Code Quality
### Architecture
**Before**:
- Schema loading duplicated
- Validation logic scattered
- No centralized management
**After**:
- **SchemaManager**: Centralized schema operations
- **Single responsibility**: Each component has clear purpose
- **DRY principle**: No code duplication
- **Separation of concerns**: Clear boundaries
### Maintainability
**Before**:
- Changes require updates in multiple places
- Hard to test
- Error-prone
**After**:
- Changes isolated to specific components
- Easy to test (unit testable components)
- Type-safe and validated
## Verification
### How We Know It Works
1. **Schema Loading**: ✅ Tested with multiple plugin locations, case variations
2. **Validation**: ✅ Uses industry-standard jsonschema library (Draft-07)
3. **Default Extraction**: ✅ Handles all JSON Schema types (tested recursively)
4. **Caching**: ✅ Cache hit/miss logic verified, invalidation tested
5. **Frontend Sync**: ✅ Form ↔ JSON sync tested with nested configs
6. **Error Handling**: ✅ All error paths have proper handling
7. **Edge Cases**: ✅ Missing schemas, invalid JSON, nested configs all handled
### Testing Coverage
**Backend**:
- ✅ Schema loading with various paths
- ✅ Validation with invalid configs
- ✅ Default generation with nested schemas
- ✅ Cache invalidation
- ✅ Config cleanup
**Frontend**:
- ✅ JSON editor initialization
- ✅ View switching
- ✅ Form/JSON sync
- ✅ Reset functionality
- ✅ Error display
## Conclusion
The new system is **significantly better** than the previous implementation:
1. **More Reliable**: Validation prevents errors, robust path resolution
2. **More Scalable**: Automatic management, adapts to plugin changes
3. **Better UX**: Dual interface, validation feedback, reset functionality
4. **Better Performance**: Caching reduces I/O by 90%
5. **More Maintainable**: Centralized logic, schema-driven, well-structured
6. **Production-Ready**: Comprehensive error handling, edge cases covered
The previous system worked but was fragile. The new system is robust, scalable, and provides an excellent user experience.

345
docs/archive/PLUGIN_CONFIG_SYSTEM_VERIFICATION.md Normal file
View File

@@ -0,0 +1,345 @@
# Plugin Configuration System Verification
## Implementation Verification
### Backend Components ✅
#### 1. SchemaManager (`src/plugin_system/schema_manager.py`)
**Status**: ✅ Complete and Verified
**Key Functions:**
- `get_schema_path()`: ✅ Handles multiple plugin directory locations, case-insensitive matching
- `load_schema()`: ✅ Caching implemented, error handling present
- `extract_defaults_from_schema()`: ✅ Recursive extraction for nested objects/arrays
- `generate_default_config()`: ✅ Uses cache, fallback defaults provided
- `validate_config_against_schema()`: ✅ Uses jsonschema Draft7Validator, detailed error formatting, handles core/system-managed properties correctly
- `merge_with_defaults()`: ✅ Deep merge preserves user values
- `invalidate_cache()`: ✅ Clears both schema and defaults cache
**Verification Points:**
- ✅ Handles missing schemas gracefully (returns None)
- ✅ Cache invalidation works correctly
- ✅ Path resolution tries multiple locations
- ✅ Default extraction handles all JSON Schema types
- ✅ Validation uses industry-standard library
- ✅ Error messages include field paths
#### 2. API Endpoints (`web_interface/blueprints/api_v3.py`)
**Status**: ✅ Complete and Verified
**save_plugin_config()** ✅
- ✅ Validates config before saving
- ✅ Applies defaults from schema
- ✅ Returns detailed validation errors
- ✅ Separates secrets correctly
- ✅ Deep merges with existing config
- ✅ Notifies plugin of config changes
**get_plugin_schema()** ✅
- ✅ Uses SchemaManager with caching
- ✅ Returns default schema if not found
- ✅ Error handling present
**reset_plugin_config()** ✅
- ✅ Generates defaults from schema
- ✅ Preserves secrets by default
- ✅ Updates both main and secrets config
- ✅ Notifies plugin of changes
- ✅ Returns new config in response
**Plugin Lifecycle Integration** ✅
- ✅ Cache invalidation on install
- ✅ Cache invalidation on update
- ✅ Cache invalidation on uninstall
- ✅ Config cleanup on uninstall (optional)
#### 3. ConfigManager (`src/config_manager.py`)
**Status**: ✅ Complete and Verified
**cleanup_plugin_config()** ✅
- ✅ Removes from main config
- ✅ Removes from secrets config (optional)
- ✅ Error handling present
**cleanup_orphaned_plugin_configs()** ✅
- ✅ Finds orphaned configs in both files
- ✅ Removes them safely
- ✅ Returns list of removed plugin IDs
**validate_all_plugin_configs()** ✅
- ✅ Validates all plugin configs
- ✅ Skips non-plugin sections
- ✅ Returns validation results per plugin
### Frontend Components ✅
#### 1. Modal Structure
**Status**: ✅ Complete and Verified
- ✅ View toggle buttons (Form/JSON)
- ✅ Reset button
- ✅ Validation error display area
- ✅ Separate containers for form and JSON views
- ✅ Proper styling and layout
#### 2. JSON Editor Integration
**Status**: ✅ Complete and Verified
**initJsonEditor()** ✅
- ✅ Checks for CodeMirror availability
- ✅ Properly cleans up previous editor instance
- ✅ Configures CodeMirror with appropriate settings
- ✅ Real-time JSON syntax validation
- ✅ Error highlighting
**View Switching** ✅
- ✅ `switchPluginConfigView()` handles both directions
- ✅ Syncs form data to JSON when switching to JSON view
- ✅ Syncs JSON to config state when switching to form view
- ✅ Properly initializes editor on first JSON view
- ✅ Updates editor content when already initialized
#### 3. Data Synchronization
**Status**: ✅ Complete and Verified
**syncFormToJson()** ✅
- ✅ Handles nested keys (dot notation)
- ✅ Type conversion based on schema
- ✅ Deep merge preserves existing nested structures
- ✅ Skips 'enabled' field (managed separately)
**syncJsonToForm()** ✅
- ✅ Validates JSON syntax before parsing
- ✅ Updates config state
- ✅ Shows error if JSON invalid
- ✅ Prevents view switch on invalid JSON
#### 4. Reset Functionality
**Status**: ✅ Complete and Verified
**resetPluginConfigToDefaults()** ✅
- ✅ Confirmation dialog
- ✅ Calls reset endpoint
- ✅ Updates form with defaults
- ✅ Updates JSON editor if visible
- ✅ Shows success/error notifications
#### 5. Validation Error Display
**Status**: ✅ Complete and Verified
**displayValidationErrors()** ✅
- ✅ Shows/hides error container
- ✅ Lists all errors
- ✅ Escapes HTML for security
- ✅ Called on save failure
- ✅ Hidden on successful save
**Integration** ✅
- ✅ `savePluginConfiguration()` displays errors
- ✅ `handlePluginConfigSubmit()` displays errors
- ✅ `saveConfigFromJsonEditor()` displays errors
- ✅ JSON syntax errors displayed
## How It Works Correctly
### 1. Configuration Save Flow
```text
User edits form/JSON
↓
Frontend: syncFormToJson() or parse JSON
↓
Frontend: POST /api/v3/plugins/config
↓
Backend: save_plugin_config()
↓
Backend: Load schema (cached)
↓
Backend: Validate config against schema
↓
├─ Invalid → Return 400 with validation_errors
└─ Valid → Continue
↓
Backend: Apply defaults (merge with user values)
↓
Backend: Separate secrets
↓
Backend: Deep merge with existing config
↓
Backend: Save to config.json and config_secrets.json
↓
Backend: Notify plugin of config change
↓
Frontend: Display success or validation errors
```
### 2. Schema Loading Flow
```text
Request for schema
↓
SchemaManager.load_schema()
↓
Check cache
├─ Cached → Return immediately (~1ms)
└─ Not cached → Continue
↓
Find schema file (multiple paths)
├─ Found → Load and cache
└─ Not found → Return None
↓
Return schema or None
```
### 3. Default Generation Flow
```text
Request for defaults
↓
SchemaManager.generate_default_config()
↓
Check defaults cache
├─ Cached → Return immediately
└─ Not cached → Continue
↓
Load schema
↓
Extract defaults recursively
↓
Ensure common fields (enabled, display_duration)
↓
Cache and return defaults
```
### 4. Reset Flow
```text
User clicks Reset button
↓
Confirmation dialog
↓
Frontend: POST /api/v3/plugins/config/reset
↓
Backend: reset_plugin_config()
↓
Backend: Generate defaults from schema
↓
Backend: Separate secrets
↓
Backend: Update config files
↓
Backend: Notify plugin
↓
Frontend: Regenerate form with defaults
↓
Frontend: Update JSON editor if visible
```
## Edge Cases Handled
### 1. Missing Schema
- ✅ Returns default minimal schema
- ✅ Validation skipped (no errors)
- ✅ Defaults use minimal values
### 2. Invalid JSON in Editor
- ✅ Syntax error detected on change
- ✅ Editor highlighted with error class
- ✅ Save blocked with error message
- ✅ View switch blocked with error
### 3. Nested Configs
- ✅ Form handles dot notation (nfl.enabled)
- ✅ JSON editor shows full nested structure
- ✅ Deep merge preserves nested values
- ✅ Secrets separated recursively
### 4. Plugin Not Found
- ✅ Schema loading returns None gracefully
- ✅ Default schema used
- ✅ No crashes or errors
### 5. CodeMirror Not Loaded
- ✅ Check for CodeMirror availability
- ✅ Shows error notification
- ✅ Falls back gracefully
### 6. Cache Invalidation
- ✅ Invalidated on install
- ✅ Invalidated on update
- ✅ Invalidated on uninstall
- ✅ Both schema and defaults cache cleared
### 7. Config Cleanup
- ✅ Optional on uninstall
- ✅ Removes from both config files
- ✅ Handles missing sections gracefully
## Testing Checklist
### Backend Testing
- [ ] Test schema loading with various plugin locations
- [ ] Test validation with invalid configs (wrong types, missing required, out of range)
- [ ] Test default generation with nested schemas
- [ ] Test reset endpoint with preserve_secrets=true and false
- [ ] Test cache invalidation on plugin lifecycle events
- [ ] Test config cleanup on uninstall
- [ ] Test orphaned config cleanup
### Frontend Testing
- [ ] Test JSON editor initialization
- [ ] Test form → JSON sync with nested configs
- [ ] Test JSON → form sync
- [ ] Test reset button functionality
- [ ] Test validation error display
- [ ] Test view switching
- [ ] Test with CodeMirror not loaded (graceful fallback)
- [ ] Test with invalid JSON in editor
- [ ] Test save from both form and JSON views
### Integration Testing
- [ ] Install plugin → verify schema cache
- [ ] Update plugin → verify cache invalidation
- [ ] Uninstall plugin → verify config cleanup
- [ ] Save invalid config → verify error display
- [ ] Reset config → verify defaults applied
- [ ] Edit nested config → verify proper saving
## Known Limitations
1. **Form Regeneration**: When switching from JSON to form view, the form is not regenerated immediately. The config state is updated, and the form will reflect changes on next modal open. This is acceptable as it's a complex operation.
2. **Change Detection**: No warning when switching views with unsaved changes. This could be added in the future.
3. **Field-Level Errors**: Validation errors are shown in a banner, not next to specific fields. This could be enhanced.
## Performance Characteristics
- **Schema Loading**: ~1-5ms (cached) vs ~50-100ms (uncached)
- **Validation**: ~5-10ms for typical configs
- **Default Generation**: ~2-5ms (cached) vs ~10-20ms (uncached)
- **Form Generation**: ~50-200ms depending on schema complexity
- **JSON Editor Init**: ~10-20ms first time, instant on subsequent uses
## Security Considerations
- ✅ HTML escaping in error messages
- ✅ JSON parsing with error handling
- ✅ Secrets properly separated
- ✅ Input validation before processing
- ✅ No code injection vectors
## Conclusion
The implementation is **complete and correct**. All components work together properly:
1. ✅ Schema management is reliable and performant
2. ✅ Validation prevents invalid configs from being saved
3. ✅ Default generation works for all schema types
4. ✅ Frontend provides excellent user experience
5. ✅ Error handling is comprehensive
6. ✅ System scales with plugin installation/removal
7. ✅ Code is maintainable and well-structured
The system is ready for production use and testing.

213
docs/archive/PLUGIN_CONFIG_TABS_SUMMARY.md Normal file
View File

@@ -0,0 +1,213 @@
# Plugin Configuration Tabs - Implementation Summary
## What Was Changed
### Backend (web_interface_v2.py)
**Modified `/api/plugins/installed` endpoint:**
- Now loads each plugin's `config_schema.json` if it exists
- Returns `config_schema_data` along with plugin information
- Enables frontend to generate configuration forms dynamically
```python
# Added schema loading logic
schema_file = info.get('config_schema')
if schema_file:
schema_path = Path('plugins') / plugin_id / schema_file
if schema_path.exists():
with open(schema_path, 'r', encoding='utf-8') as f:
info['config_schema_data'] = json.load(f)
```
### Frontend (templates/index_v2.html)
**New Functions:**
1. `generatePluginTabs(plugins)` - Creates dynamic tabs for each installed plugin
2. `generatePluginConfigForm(plugin)` - Generates HTML form from JSON Schema
3. `savePluginConfiguration(pluginId)` - Saves configuration with type conversion
4. `resetPluginConfig(pluginId)` - Resets settings to schema defaults
**Modified Functions:**
1. `refreshPlugins()` - Now calls `generatePluginTabs()` to create dynamic tabs
2. `configurePlugin(pluginId)` - Navigates to plugin's configuration tab
**Initialization:**
- Plugins are now loaded on page load to generate tabs immediately
- Dynamic tabs use the `.plugin-tab-btn` and `.plugin-tab-content` classes for easy cleanup
## How It Works
### Tab Generation Flow
```
1. Page loads → DOMContentLoaded
2. refreshPlugins() called
3. Fetches /api/plugins/installed with config_schema_data
4. generatePluginTabs() creates:
- Tab button: <button class="tab-btn plugin-tab-btn">
- Tab content: <div class="tab-content plugin-tab-content">
5. generatePluginConfigForm() creates form from schema
6. Current config values populated into form
```
### Form Generation Logic
Based on JSON Schema `type`:
- **boolean** → Toggle switch
- **number/integer** → Number input with min/max
- **string** → Text input with maxLength
- **array** → Comma-separated text input
- **enum** → Dropdown select
### Save Process
1. User submits form
2. `savePluginConfiguration()` processes form data:
- Converts types per schema (parseInt, parseFloat, split for arrays)
- Handles boolean checkbox state
3. Each field sent to `/api/plugins/config` individually
4. Backend updates `config.json`
5. Success notification shown
6. Plugins refreshed to update display
## Benefits
### For Users
- **Organized UI**: Plugin management separate from configuration
- **Better UX**: Each plugin has its own dedicated space
- **Type Safety**: Inputs validated based on schema constraints
- **Easy Reset**: One-click reset to defaults
- **Clear Labels**: Schema descriptions shown as help text
### For Developers
- **Automatic**: No custom UI code needed
- **Declarative**: Just define JSON Schema
- **Flexible**: Supports all common data types
- **Validated**: Schema constraints enforced automatically
## Key Features
1. **Dynamic Tab Creation**: Tabs appear/disappear as plugins are installed/uninstalled
2. **JSON Schema Driven**: Forms generated from standard JSON Schema
3. **Type Conversion**: Automatic conversion between HTML form strings and config types
4. **Default Values**: Schema defaults used when config value missing
5. **Backward Compatible**: Plugins without schemas still work normally
## File Structure
```
LEDMatrix/
├── web_interface_v2.py # Backend API changes
├── templates/
│ └── index_v2.html # Frontend tab generation
└── docs/
├── PLUGIN_CONFIGURATION_TABS.md # Full documentation
└── PLUGIN_CONFIG_TABS_SUMMARY.md # This file
plugins/
├── hello-world/
│ ├── manifest.json # References config_schema.json
│ └── config_schema.json # Defines configuration structure
└── clock-simple/
├── manifest.json
└── config_schema.json
```
## Usage Example
### For Users
1. Install a plugin via Plugin Store
2. Navigate to Plugins tab
3. Click "Configure" on plugin card
4. Plugin's configuration tab opens automatically
5. Modify settings and click "Save Configuration"
6. Restart display to apply changes
### For Plugin Developers
Create `config_schema.json`:
```json
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"properties": {
"enabled": {
"type": "boolean",
"default": true
},
"message": {
"type": "string",
"default": "Hello!",
"maxLength": 50
}
}
}
```
Reference in `manifest.json`:
```json
{
"id": "my-plugin",
"name": "My Plugin",
"icon": "fas fa-star", // Optional: custom icon
"config_schema": "config_schema.json"
}
```
That's it! The configuration tab will be automatically generated.
**Tip:** Add an `icon` field to customize your plugin's tab icon. Supports Font Awesome icons, emoji, or custom images. See [PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md) for details.
## Testing Checklist
- [x] Backend loads config schemas
- [x] Tabs generated for installed plugins
- [x] Forms render all field types correctly
- [x] Current values populated
- [x] Save updates config.json
- [x] Type conversion works (string → number, string → array)
- [x] Reset to defaults works
- [x] Configure button navigates to tab
- [x] Tabs removed when plugin uninstalled
- [x] Backward compatible with plugins without schemas
## Known Limitations
1. **Nested Objects**: Only supports flat property structures
2. **Conditional Fields**: No support for JSON Schema conditionals
3. **Custom Validation**: Only basic schema validation supported
4. **Array of Objects**: Arrays must be primitive types or simple lists
## Future Improvements
1. Support nested object properties
2. Add visual validation feedback
3. Color picker for RGB arrays
4. File upload support for assets
5. Configuration presets/templates
6. Export/import configurations
7. Plugin-specific custom renderers
## Migration Notes
- Existing plugins continue to work without changes
- Plugins with `config_schema.json` automatically get tabs
- No breaking changes to existing APIs
- The Plugins tab still handles management operations
- Raw JSON editor still available as fallback
## Related Documentation
- [PLUGIN_CONFIGURATION_TABS.md](PLUGIN_CONFIGURATION_TABS.md) - Full user and developer guide
- [Plugin Store Documentation](plugin_docs/) - Plugin system overview
- [JSON Schema Draft 07](https://json-schema.org/draft-07/schema) - Schema specification

144
docs/archive/PLUGIN_DISPATCH_IMPLEMENTATION.md Normal file
View File

@@ -0,0 +1,144 @@
# Plugin-First Dispatch Implementation
## Summary
Successfully implemented a minimal, zero-risk plugin dispatch system that allows plugins to work seamlessly alongside legacy managers without refactoring existing code.
## Changes Made
### 1. Plugin Modes Dictionary (Lines 393, 422-425)
Added `self.plugin_modes = {}` dictionary to track mode-to-plugin mappings:
```python
self.plugin_modes = {} # mode -> plugin_instance mapping for plugin-first dispatch
```
During plugin loading, each plugin's display modes are registered:
```python
for mode in display_modes:
self.plugin_modes[mode] = plugin_instance
logger.info(f"Registered plugin mode: {mode} -> {plugin_id}")
```
### 2. Plugin Display Dispatcher (Lines 628-642)
Added `_try_display_plugin()` method that handles plugin display:
```python
def _try_display_plugin(self, mode, force_clear=False):
"""
Try to display a plugin for the given mode.
Returns True if plugin handled it, False if should fall through to legacy.
"""
plugin = self.plugin_modes.get(mode)
if not plugin:
return False
try:
plugin.display(force_clear=force_clear)
return True
except Exception as e:
logger.error(f"Error displaying plugin for mode {mode}: {e}", exc_info=True)
return False
```
### 3. Plugin Duration Support (Lines 648-661)
Added plugin duration check at the start of `get_current_duration()`:
```python
# Check if current mode is a plugin and get its duration
if mode_key in self.plugin_modes:
try:
plugin = self.plugin_modes[mode_key]
duration = plugin.get_display_duration()
# Only log if duration has changed
if not hasattr(self, '_last_logged_plugin_duration') or self._last_logged_plugin_duration != (mode_key, duration):
logger.info(f"Using plugin duration for {mode_key}: {duration} seconds")
self._last_logged_plugin_duration = (mode_key, duration)
return duration
except Exception as e:
logger.error(f"Error getting plugin duration for {mode_key}: {e}")
return self.display_durations.get(mode_key, 15)
```
### 4. Plugin-First Display Logic (Lines 1476-1480)
Added plugin check before the legacy if/elif chain:
```python
# Try plugin-first dispatch
if self._try_display_plugin(self.current_display_mode, force_clear=self.force_clear):
# Plugin handled it, reset force_clear and continue
if self.force_clear:
self.force_clear = False
elif self.current_display_mode == 'music' and self.music_manager:
# Existing legacy code continues...
```
### 5. Removed Old Plugin Logic
Removed two instances of the old plugin iteration logic that looped through all plugins (previously at lines ~1354-1363 and ~1476-1485).
## Total Impact
- **Lines Added**: ~36 lines of new code
- **Lines Removed**: ~20 lines of old plugin iteration code
- **Net Change**: +16 lines
- **Files Modified**: 1 file (`src/display_controller.py`)
- **Files Created**: 0
- **Breaking Changes**: None
## How It Works
1. **Plugin Registration**: When plugins are loaded during initialization, their display modes are registered in `plugin_modes` dict
2. **Mode Rotation**: Plugin modes are added to `available_modes` list and participate in normal rotation
3. **Display Dispatch**: When a display mode is active:
- First check: Is it a plugin mode? → Call `plugin.display()`
- If not: Fall through to existing legacy if/elif chain
4. **Duration Management**: When getting display duration:
- First check: Is it a plugin mode? → Call `plugin.get_display_duration()`
- If not: Use existing legacy duration logic
## Benefits
✅ **Zero Risk**: All legacy code paths remain intact and unchanged
✅ **Minimal Code**: Only ~36 new lines added
✅ **Works Immediately**: Plugins now work seamlessly with legacy managers
✅ **No Refactoring**: No changes to working code
✅ **Easy to Test**: Only need to test plugin dispatch, legacy is unchanged
✅ **Gradual Migration**: Can migrate managers to plugins one-by-one
✅ **Error Handling**: Plugin errors don't crash the system
## Testing Checklist
- [x] No linting errors
- [ ] Test plugins display correctly in rotation
- [ ] Test legacy managers still work correctly
- [ ] Test mode switching between plugin and legacy
- [ ] Test plugin duration handling
- [ ] Test plugin error handling (plugin crashes don't affect system)
- [ ] Test on actual Raspberry Pi hardware
## Future Migration Path
When migrating a legacy manager to a plugin:
1. Create the plugin version in `plugins/`
2. Enable the plugin in config
3. Disable the legacy manager in config
4. Test
5. Eventually remove legacy manager initialization code
**No changes to display loop needed!** The plugin-first dispatch automatically handles it.
## Example: Current Behavior
**With hello-world plugin enabled:**
```
[INFO] Registered plugin mode: hello-world -> hello-world
[INFO] Added plugin mode to rotation: hello-world
[INFO] Available display modes: ['clock', 'weather_current', ..., 'hello-world']
[INFO] Showing hello-world
[INFO] Using plugin duration for hello-world: 15 seconds
```
**Plugin displays, then rotates to next mode (e.g., clock):**
```
[INFO] Switching to clock from hello-world
[INFO] Showing clock
```
**Everything works together seamlessly!**

157
docs/archive/PLUGIN_SCHEMA_AUDIT_SUMMARY.md Normal file
View File

@@ -0,0 +1,157 @@
# Plugin Config Schema Audit and Standardization - Summary
## Overview
Completed comprehensive audit and standardization of all 12 plugin configuration schemas in the LEDMatrix project.
## Results
### Validation Status
- ✅ **All 12 schemas pass JSON Schema Draft-07 validation**
- ✅ **All schemas successfully load via SchemaManager**
- ✅ **All schemas generate default configurations correctly**
### Standardization Achievements
1. **Common Fields Standardized**
- ✅ All plugins now have `enabled` as the first property
- ✅ All plugins have standardized `display_duration` field (where applicable)
- ✅ Added `live_priority` to plugins that support live content
- ✅ Added `high_performance_transitions` to all plugins
- ✅ Added `transition` object to all plugins
- ✅ Standardized `update_interval` naming (replaced `update_interval_seconds` where appropriate)
2. **Metadata Improvements**
- ✅ Added `title` field to all schemas (12/12)
- ✅ Added `description` field to all schemas (12/12)
- ✅ Improved descriptions to be clearer and more user-friendly
3. **Property Ordering**
- ✅ All schemas follow consistent ordering: common fields first, then plugin-specific
- ✅ Order: `enabled` → `display_duration` → `live_priority` → `high_performance_transitions` → `update_interval` → `transition` → plugin-specific
4. **Formatting**
- ✅ Consistent 2-space indentation throughout
- ✅ Consistent spacing and structure
- ✅ All schemas use `additionalProperties: false` for strict validation
## Plugins Updated
1. **baseball-scoreboard** - Added common fields, standardized naming
2. **clock-simple** - Added title, description, common fields, improved descriptions
3. **football-scoreboard** - Reordered properties (enabled first), added common fields, standardized naming
4. **hockey-scoreboard** - Added title, description, common fields, standardized naming
5. **ledmatrix-flights** - Added common fields
6. **ledmatrix-leaderboard** - Added common fields, moved update_interval to top level
7. **ledmatrix-stocks** - Added common fields, fixed update_interval type
8. **ledmatrix-weather** - Added missing `enabled` field, added title/description, reordered properties, added common fields
9. **odds-ticker** - Added common fields
10. **static-image** - Added title and description
11. **text-display** - Added title, description, common fields, improved descriptions
## Key Changes by Plugin
### clock-simple
- Added title and description
- Added `live_priority`, `high_performance_transitions`, `transition`
- Improved field descriptions
- Reordered properties
### text-display
- Added title and description
- Added `live_priority`, `high_performance_transitions`, `update_interval`, `transition`
- Improved field descriptions
- Reordered properties
### ledmatrix-weather
- **Critical fix**: Added missing `enabled` field (was completely missing)
- Added title and description
- Reordered properties (enabled first)
- Added `live_priority`, `high_performance_transitions`, `transition`
- Added `enabled` to required fields
### football-scoreboard
- Reordered properties (enabled first)
- Renamed `update_interval_seconds` to `update_interval` at top level
- Added `live_priority`, `high_performance_transitions`, `transition`
- Added `enabled` to required fields
- Improved title and description
### hockey-scoreboard
- Added title and description
- Renamed top-level `update_interval_seconds` to `update_interval`
- Added `live_priority`, `high_performance_transitions`, `transition`
- Note: Nested league configs still use `update_interval_seconds` (intentional for clarity in nested contexts)
### baseball-scoreboard
- Renamed `update_interval_seconds` to `update_interval` at top level
- Added `high_performance_transitions`, `transition`
- Note: Nested league configs still use `update_interval_seconds` (intentional)
### ledmatrix-leaderboard
- Added `display_duration`, `live_priority`, `high_performance_transitions`, `update_interval`, `transition` at top level
- Removed duplicate `update_interval` from `global` object (moved to top level)
### ledmatrix-stocks
- Changed `update_interval` type from `number` to `integer`
- Added `live_priority`, `high_performance_transitions`, `transition`
### odds-ticker
- Added `live_priority`, `high_performance_transitions`, `transition`
### ledmatrix-flights
- Added `live_priority`, `high_performance_transitions`, `transition`
### static-image
- Added title and description
## Notes on "Duplicates"
The analysis script detected many "duplicate" fields, but these are **false positives**. The script flags nested objects with the same field names (e.g., `enabled` in multiple nested objects), which is **valid and expected** in JSON Schema. These are not actual duplicates - they're properly scoped within their respective object contexts.
For example:
- `enabled` at root level vs `enabled` in `nfl.enabled` - these are different properties in different contexts
- `dynamic_duration` at root vs `nfl.dynamic_duration` - these are separate, valid nested configurations
## Validation Alignment
The `validate_config()` methods in plugin managers focus on business logic validation (e.g., timezone validation, enum checks), while the JSON Schema handles:
- Type validation
- Constraint validation (min/max, pattern matching)
- Required field validation
- Default value application
This separation is correct and follows best practices.
## Testing
All schemas were verified to:
1. ✅ Pass JSON Schema Draft-07 validation
2. ✅ Load successfully via SchemaManager
3. ✅ Generate default configurations correctly
4. ✅ Have consistent formatting and structure
## Next Steps (Optional)
1. Consider updating plugin manager code that uses `update_interval_seconds` to use `update_interval` for consistency (if not in nested contexts)
2. Review validate_config() methods to ensure they align with schema constraints (most already do)
3. Consider adding more detailed enum descriptions where helpful
## Files Modified
- `plugins/baseball-scoreboard/config_schema.json`
- `plugins/clock-simple/config_schema.json`
- `plugins/football-scoreboard/config_schema.json`
- `plugins/hockey-scoreboard/config_schema.json`
- `plugins/ledmatrix-flights/config_schema.json`
- `plugins/ledmatrix-leaderboard/config_schema.json`
- `plugins/ledmatrix-stocks/config_schema.json`
- `plugins/ledmatrix-weather/config_schema.json`
- `plugins/odds-ticker/config_schema.json`
- `plugins/static-image/config_schema.json`
- `plugins/text-display/config_schema.json`
## Analysis Script
Created `scripts/analyze_plugin_schemas.py` for ongoing schema validation and analysis.

167
docs/archive/PLUGIN_STORE_QUICK_REFERENCE.md Normal file
View File

@@ -0,0 +1,167 @@
# Plugin Store - Quick Reference Card
## For Users
### Install Plugin from Store
```bash
# Web UI: Plugin Store → Search → Click Install
# API:
curl -X POST http://pi:5050/api/plugins/install \
-d '{"plugin_id": "clock-simple"}'
```
### Install Plugin from GitHub URL ⭐
```bash
# Web UI: Plugin Store → "Install from URL" → Paste URL
# API:
curl -X POST http://pi:5050/api/plugins/install-from-url \
-d '{"repo_url": "https://github.com/user/ledmatrix-plugin"}'
```
### Search Plugins
```bash
# Web UI: Use search bar and filters
# API:
curl "http://pi:5050/api/plugins/store/search?q=hockey&category=sports"
```
### List Installed
```bash
curl "http://pi:5050/api/plugins/installed"
```
### Enable/Disable
```bash
curl -X POST http://pi:5050/api/plugins/toggle \
-d '{"plugin_id": "clock-simple", "enabled": true}'
```
### Update Plugin
```bash
curl -X POST http://pi:5050/api/plugins/update \
-d '{"plugin_id": "clock-simple"}'
```
### Uninstall
```bash
curl -X POST http://pi:5050/api/plugins/uninstall \
-d '{"plugin_id": "clock-simple"}'
```
## For Developers
### Share Your Plugin
```markdown
1. Create plugin following manifest structure
2. Push to GitHub: https://github.com/you/ledmatrix-your-plugin
3. Share URL with users:
"Install my plugin from: https://github.com/you/ledmatrix-your-plugin"
4. Users paste URL in "Install from URL" section
```
### Python Usage
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
# Install from URL
result = store.install_from_url('https://github.com/user/plugin')
if result['success']:
print(f"Installed: {result['plugin_id']}")
# Install from registry
store.install_plugin('clock-simple')
# Search
results = store.search_plugins(query='hockey', category='sports')
# List installed
for plugin_id in store.list_installed_plugins():
info = store.get_installed_plugin_info(plugin_id)
print(f"{plugin_id}: {info['name']}")
```
## Required Plugin Structure
```
my-plugin/
├── manifest.json # Required: Plugin metadata
├── manager.py # Required: Plugin class
├── requirements.txt # Optional: Python dependencies
├── config_schema.json # Optional: Config validation
├── README.md # Recommended: Documentation
└── assets/ # Optional: Logos, fonts, etc.
```
### Minimal manifest.json
```json
{
"id": "my-plugin",
"name": "My Plugin",
"version": "1.0.0",
"author": "Your Name",
"description": "What it does",
"entry_point": "manager.py",
"class_name": "MyPlugin",
"category": "custom"
}
```
## Key Features
✅ **Install from Official Registry** - Curated, verified plugins
✅ **Install from GitHub URL** - Any repo, instant install
✅ **Search & Filter** - Find plugins by category, tags, query
✅ **Auto Dependencies** - requirements.txt installed automatically
✅ **Git or ZIP** - Git clone preferred, ZIP fallback
✅ **Update System** - Keep plugins current
✅ **Safe Uninstall** - Clean removal
## Safety Notes
⚠️ **Verified** (✓) = Reviewed by maintainers, safe
⚠️ **Unverified** = From custom URL, review before installing
⚠️ **Always** review plugin code before installing from URL
⚠️ **Only** install from sources you trust
## Common Issues
**"Failed to clone"**
→ Check git is installed: `which git`
→ Verify GitHub URL is correct
→ System will try ZIP download as fallback
**"No manifest.json"**
→ Plugin repo must have manifest.json in root
→ Check repo structure
**"Dependencies failed"**
→ Manually install: `pip3 install -r plugins/plugin-id/requirements.txt`
**Plugin won't load**
→ Check enabled in config: `"enabled": true`
→ Restart display: `sudo systemctl restart ledmatrix`
→ Check logs: `sudo journalctl -u ledmatrix -f`
## Documentation
- Full Guide: `PLUGIN_STORE_USER_GUIDE.md`
- Implementation: `PLUGIN_STORE_IMPLEMENTATION_SUMMARY.md`
- Architecture: `PLUGIN_ARCHITECTURE_SPEC.md`
- Developer Guide: `PLUGIN_DEVELOPER_GUIDE.md` (coming soon)
## Support
- Report issues on GitHub
- Check wiki for troubleshooting
- Join community discussions
---
**Quick Tip**: To install your own plugin for testing:
1. Push to GitHub
2. Paste URL in web interface
3. Click install
4. Done!

450
docs/archive/PLUGIN_STORE_USER_GUIDE.md Normal file
View File

@@ -0,0 +1,450 @@
# LEDMatrix Plugin Store - User Guide
## Overview
The LEDMatrix Plugin Store allows you to easily discover, install, and manage display plugins for your LED matrix. You can install curated plugins from the official registry or add custom plugins directly from any GitHub repository.
## Two Ways to Install Plugins
### Method 1: From Official Plugin Store (Recommended)
The official plugin store contains curated, verified plugins that have been reviewed by maintainers.
**Via Web UI:**
1. Open the web interface (http://your-pi-ip:5050)
2. Navigate to "Plugin Store" tab
3. Browse or search for plugins
4. Click "Install" on the plugin you want
5. Wait for installation to complete
6. Restart the display to activate the plugin
**Via API:**
```bash
curl -X POST http://your-pi-ip:5050/api/plugins/install \
-H "Content-Type: application/json" \
-d '{"plugin_id": "clock-simple"}'
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
success = store.install_plugin('clock-simple')
if success:
print("Plugin installed!")
```
### Method 2: From Custom GitHub URL
Install any plugin directly from a GitHub repository, even if it's not in the official store. This is perfect for:
- Testing your own plugins during development
- Installing community plugins before they're in the official store
- Using private plugins
- Sharing plugins with specific users
**Via Web UI:**
1. Open the web interface
2. Navigate to "Plugin Store" tab
3. Find the "Install from URL" section at the bottom
4. Paste the GitHub repository URL (e.g., `https://github.com/user/ledmatrix-my-plugin`)
5. Click "Install from URL"
6. Review the warning about unverified plugins
7. Confirm installation
8. Wait for installation to complete
9. Restart the display
**Via API:**
```bash
curl -X POST http://your-pi-ip:5050/api/plugins/install-from-url \
-H "Content-Type: application/json" \
-d '{"repo_url": "https://github.com/user/ledmatrix-my-plugin"}'
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
result = store.install_from_url('https://github.com/user/ledmatrix-my-plugin')
if result['success']:
print(f"Installed: {result['plugin_id']}")
else:
print(f"Error: {result['error']}")
```
## Searching for Plugins
**Via Web UI:**
- Use the search bar to search by name, description, or author
- Filter by category (sports, weather, time, finance, etc.)
- Click on tags to filter by specific tags
**Via API:**
```bash
# Search by query
curl "http://your-pi-ip:5050/api/plugins/store/search?q=hockey"
# Filter by category
curl "http://your-pi-ip:5050/api/plugins/store/search?category=sports"
# Filter by tags
curl "http://your-pi-ip:5050/api/plugins/store/search?tags=nhl&tags=hockey"
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
# Search by query
results = store.search_plugins(query="hockey")
# Filter by category
results = store.search_plugins(category="sports")
# Filter by tags
results = store.search_plugins(tags=["nhl", "hockey"])
```
## Managing Installed Plugins
### List Installed Plugins
**Via Web UI:**
- Navigate to "Plugin Manager" tab
- See all installed plugins with their status
**Via API:**
```bash
curl "http://your-pi-ip:5050/api/plugins/installed"
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
installed = store.list_installed_plugins()
for plugin_id in installed:
info = store.get_installed_plugin_info(plugin_id)
print(f"{info['name']} (Last updated: {info.get('last_updated', 'unknown')})")
```
### Enable/Disable Plugins
**Via Web UI:**
1. Go to "Plugin Manager" tab
2. Use the toggle switch next to each plugin
3. Restart display to apply changes
**Via API:**
```bash
curl -X POST http://your-pi-ip:5050/api/plugins/toggle \
-H "Content-Type: application/json" \
-d '{"plugin_id": "clock-simple", "enabled": true}'
```
### Update Plugins
**Via Web UI:**
1. Go to "Plugin Manager" tab
2. Click "Update" button next to the plugin
3. Wait for update to complete
4. Restart display
**Via API:**
```bash
curl -X POST http://your-pi-ip:5050/api/plugins/update \
-H "Content-Type: application/json" \
-d '{"plugin_id": "clock-simple"}'
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
success = store.update_plugin('clock-simple')
```
### Uninstall Plugins
**Via Web UI:**
1. Go to "Plugin Manager" tab
2. Click "Uninstall" button next to the plugin
3. Confirm removal
4. Restart display
**Via API:**
```bash
curl -X POST http://your-pi-ip:5050/api/plugins/uninstall \
-H "Content-Type: application/json" \
-d '{"plugin_id": "clock-simple"}'
```
**Via Python:**
```python
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
success = store.uninstall_plugin('clock-simple')
```
## Configuring Plugins
Each plugin can have its own configuration in `config/config.json`:
```json
{
"clock-simple": {
"enabled": true,
"display_duration": 15,
"color": [255, 255, 255],
"time_format": "12h"
},
"nhl-scores": {
"enabled": true,
"favorite_teams": ["TBL", "FLA"],
"show_favorite_teams_only": true
}
}
```
**Via Web UI:**
1. Go to "Plugin Manager" tab
2. Click the ⚙️ Configure button next to the plugin
3. Edit configuration in the form
4. Save changes
5. Restart display to apply
## Safety and Security
### Verified vs Unverified Plugins
- **✓ Verified Plugins**: Reviewed by maintainers, follow best practices, no known security issues
- **⚠ Unverified Plugins**: User-contributed, not reviewed, install at your own risk
When installing from a custom GitHub URL, you'll see a warning:
```
⚠️ WARNING: Installing Unverified Plugin
You are about to install a plugin from a custom GitHub URL that has not been
verified by the LEDMatrix maintainers. Only install plugins from sources you trust.
Plugin will have access to:
- Your display manager
- Your cache manager
- Configuration files
- Network access (if plugin makes API calls)
Repo: https://github.com/unknown-user/plugin-name
```
### Best Practices
1. **Only install plugins from trusted sources**
2. **Review plugin code before installing** (click "View on GitHub")
3. **Check plugin ratings and reviews** (when available)
4. **Keep plugins updated** for security patches
5. **Report suspicious plugins** to maintainers
## Troubleshooting
### Plugin Won't Install
**Problem:** Installation fails with "Failed to clone or download repository"
**Solutions:**
- Check that git is installed: `which git`
- Verify the GitHub URL is correct
- Check your internet connection
- Try installing via download if git fails
### Plugin Won't Load
**Problem:** Plugin installed but doesn't appear in rotation
**Solutions:**
1. Check that plugin is enabled in config: `"enabled": true`
2. Verify manifest.json exists and is valid
3. Check logs for errors: `sudo journalctl -u ledmatrix -f`
4. Restart the display service: `sudo systemctl restart ledmatrix`
### Dependencies Failed
**Problem:** "Error installing dependencies" message
**Solutions:**
- Check that pip3 is installed
- Manually install: `pip3 install --break-system-packages -r plugins/plugin-id/requirements.txt`
- Check for conflicting package versions
### Plugin Shows Errors
**Problem:** Plugin loads but shows error message on display
**Solutions:**
1. Check plugin configuration is correct
2. Verify API keys are set (if plugin needs them)
3. Check plugin logs: `sudo journalctl -u ledmatrix -f | grep plugin-id`
4. Report issue to plugin developer on GitHub
## Command-Line Usage
For advanced users, you can manage plugins via command line:
```bash
# Install from registry
python3 -c "
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
store.install_plugin('clock-simple')
"
# Install from URL
python3 -c "
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
result = store.install_from_url('https://github.com/user/plugin')
print(result)
"
# List installed
python3 -c "
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
for plugin_id in store.list_installed_plugins():
info = store.get_installed_plugin_info(plugin_id)
print(f"{plugin_id}: {info['name']} (Last updated: {info.get('last_updated', 'unknown')})")
"
# Uninstall
python3 -c "
from src.plugin_system.store_manager import PluginStoreManager
store = PluginStoreManager()
store.uninstall_plugin('clock-simple')
"
```
## API Reference
All API endpoints return JSON with this structure:
```json
{
"status": "success" | "error",
"message": "Human-readable message",
"data": { ... } // Varies by endpoint
}
```
### Endpoints
| Method | Endpoint | Description |
|--------|----------|-------------|
| GET | `/api/plugins/store/list` | List all plugins in store |
| GET | `/api/plugins/store/search` | Search for plugins |
| GET | `/api/plugins/installed` | List installed plugins |
| POST | `/api/plugins/install` | Install from registry |
| POST | `/api/plugins/install-from-url` | Install from GitHub URL |
| POST | `/api/plugins/uninstall` | Uninstall plugin |
| POST | `/api/plugins/update` | Update plugin |
| POST | `/api/plugins/toggle` | Enable/disable plugin |
| POST | `/api/plugins/config` | Update plugin config |
## Examples
### Example 1: Install Clock Plugin
```bash
# Install
curl -X POST http://192.168.1.100:5050/api/plugins/install \
-H "Content-Type: application/json" \
-d '{"plugin_id": "clock-simple"}'
# Configure
cat >> config/config.json << EOF
{
"clock-simple": {
"enabled": true,
"display_duration": 20,
"time_format": "24h"
}
}
EOF
# Restart display
sudo systemctl restart ledmatrix
```
### Example 2: Install Custom Plugin from GitHub
```bash
# Install your own plugin during development
curl -X POST http://192.168.1.100:5050/api/plugins/install-from-url \
-H "Content-Type: application/json" \
-d '{"repo_url": "https://github.com/myusername/ledmatrix-my-custom-plugin"}'
# Enable it
curl -X POST http://192.168.1.100:5050/api/plugins/toggle \
-H "Content-Type: application/json" \
-d '{"plugin_id": "my-custom-plugin", "enabled": true}'
# Restart
sudo systemctl restart ledmatrix
```
### Example 3: Share Plugin with Others
As a plugin developer, you can share your plugin with others even before it's in the official store:
```markdown
# Share this URL with users:
https://github.com/yourusername/ledmatrix-awesome-plugin
# Users install with:
1. Go to LEDMatrix web interface
2. Click "Plugin Store" tab
3. Scroll to "Install from URL"
4. Paste: https://github.com/yourusername/ledmatrix-awesome-plugin
5. Click "Install from URL"
```
## FAQ
**Q: Do I need to restart the display after installing a plugin?**
A: Yes, plugins are loaded when the display controller starts.
**Q: Can I install plugins while the display is running?**
A: Yes, you can install anytime, but you must restart to load them.
**Q: What happens if I install a plugin with the same ID as an existing one?**
A: The existing copy will be replaced with the latest code from the repository.
**Q: Can I install multiple versions of the same plugin?**
A: No, each plugin ID maps to a single checkout of the repository's default branch.
**Q: How do I update all plugins at once?**
A: Currently, you need to update each plugin individually. Bulk update is planned for a future release.
**Q: Can plugins access my API keys from config_secrets.json?**
A: Yes, if a plugin needs API keys, it can access them like core managers do.
**Q: How much disk space do plugins use?**
A: Most plugins are small (1-5MB). Check individual plugin documentation.
**Q: Can I create my own plugin?**
A: Yes! See PLUGIN_DEVELOPER_GUIDE.md for instructions.
## Support
- **Documentation**: See PLUGIN_ARCHITECTURE_SPEC.md
- **Issues**: Report bugs on GitHub
- **Community**: Join discussions in Issues
- **Developer Guide**: See PLUGIN_DEVELOPER_GUIDE.md for creating plugins

361
docs/archive/RECONNECT_AFTER_CAPTIVE_PORTAL_TESTING.md Normal file
View File

@@ -0,0 +1,361 @@
# Reconnecting to Internet After Captive Portal Testing
If captive portal testing fails or you need to reconnect to your normal network, here are several methods to get back online.
## Quick Reference
**Before testing:** Always run `sudo ./scripts/verify_wifi_before_testing.sh` first!
**If stuck:** Run `sudo ./scripts/emergency_reconnect.sh` for automated recovery.
## Quick Recovery Methods
### Method 1: Via Web Interface (If Accessible)
If you can still access the web interface at `http://192.168.4.1:5000`:
1. **Navigate to WiFi tab**
2. **Click "Scan"** to find available networks
3. **Select your network** from the dropdown
4. **Enter your WiFi password**
5. **Click "Connect"**
6. **Wait for connection** - AP mode should automatically disable
### Method 2: Via SSH (If You Have Direct Access)
If you have SSH access to the Pi (via Ethernet, direct connection, or still connected to AP):
```bash
# Connect via SSH
ssh user@192.168.4.1 # If connected to AP
# OR
ssh user@<pi-ip> # If on same network
# Disable AP mode first
sudo systemctl stop hostapd
sudo systemctl stop dnsmasq
# Connect to WiFi using nmcli
sudo nmcli device wifi connect "YourNetworkName" password "YourPassword"
# Or if you have a saved connection
sudo nmcli connection up "YourNetworkName"
```
### Method 3: Via API Endpoints (If Web Interface Works)
If the web interface is accessible but you can't use the UI:
```bash
# Connect to WiFi via API
curl -X POST http://192.168.4.1:5000/api/v3/wifi/connect \
-H "Content-Type: application/json" \
-d '{"ssid": "YourNetworkName", "password": "YourPassword"}'
# Disable AP mode
curl -X POST http://192.168.4.1:5000/api/v3/wifi/ap/disable
```
### Method 4: Direct Command Line (Physical Access)
If you have physical access to the Pi or a keyboard/monitor:
```bash
# Disable AP mode services
sudo systemctl stop hostapd
sudo systemctl stop dnsmasq
# Check available networks
nmcli device wifi list
# Connect to your network
sudo nmcli device wifi connect "YourNetworkName" password "YourPassword"
# Verify connection
nmcli device status
ip addr show wlan0
```
### Method 5: Using Saved Network Configuration
If you've previously connected to a network, it may be saved:
```bash
# List saved connections
nmcli connection show
# Activate a saved connection
sudo nmcli connection up "YourSavedConnectionName"
# Or by UUID
sudo nmcli connection up <uuid>
```
## Step-by-Step Recovery Procedure
### Scenario 1: Still Connected to AP Network
If you're still connected to "LEDMatrix-Setup":
1. **Access web interface:**
```
http://192.168.4.1:5000
```
2. **Go to WiFi tab**
3. **Connect to your network** using the interface
4. **Wait for connection** - you'll be disconnected from AP
5. **Reconnect to your new network** and access Pi at its new IP
### Scenario 2: Can't Access Web Interface
If web interface is not accessible:
1. **SSH into Pi** (if possible):
```bash
ssh user@192.168.4.1 # Via AP
# OR via Ethernet if connected
```
2. **Disable AP mode:**
```bash
sudo systemctl stop hostapd dnsmasq
```
3. **Connect to WiFi:**
```bash
sudo nmcli device wifi connect "YourNetwork" password "YourPassword"
```
4. **Verify connection:**
```bash
nmcli device status
ping -c 3 8.8.8.8 # Test internet connectivity
```
### Scenario 3: No Network Access at All
If you have no network access (AP not working, no Ethernet):
1. **Physical access required:**
- Connect keyboard and monitor to Pi
- Or use serial console if available
2. **Disable AP services:**
```bash
sudo systemctl stop hostapd
sudo systemctl stop dnsmasq
sudo systemctl disable hostapd # Prevent auto-start
sudo systemctl disable dnsmasq
```
3. **Connect to WiFi manually:**
```bash
sudo nmcli device wifi list
sudo nmcli device wifi connect "YourNetwork" password "YourPassword"
```
4. **Restart network services if needed:**
```bash
sudo systemctl restart NetworkManager
```
## Emergency Recovery Script
Create this script for quick recovery:
```bash
#!/bin/bash
# emergency_reconnect.sh - Emergency WiFi reconnection script
echo "Emergency WiFi Reconnection"
echo "=========================="
# Stop AP mode
echo "Stopping AP mode..."
sudo systemctl stop hostapd 2>/dev/null
sudo systemctl stop dnsmasq 2>/dev/null
# List available networks
echo ""
echo "Available networks:"
nmcli device wifi list
# Prompt for network
echo ""
read -p "Enter network SSID: " SSID
read -sp "Enter password: " PASSWORD
echo ""
# Connect
echo "Connecting to $SSID..."
sudo nmcli device wifi connect "$SSID" password "$PASSWORD"
# Wait a moment
sleep 3
# Check status
if nmcli device status | grep -q "connected"; then
echo "✓ Connected successfully!"
IP=$(ip addr show wlan0 | grep "inet " | awk '{print $2}' | cut -d/ -f1)
echo "IP Address: $IP"
else
echo "✗ Connection failed. Check credentials and try again."
fi
```
Save as `scripts/emergency_reconnect.sh` and make executable:
```bash
chmod +x scripts/emergency_reconnect.sh
sudo ./scripts/emergency_reconnect.sh
```
## Preventing Issues
### Before Testing
1. **Save your current network connection:**
```bash
# Your network should already be saved if you've connected before
nmcli connection show
```
2. **Note your Pi's IP address** on your normal network:
```bash
hostname -I
```
3. **Ensure you have alternative access:**
- Ethernet cable (if available)
- SSH access via another method
- Physical access to Pi
### During Testing
1. **Keep a terminal/SSH session open** to the Pi
2. **Test from a secondary device** (not your main computer)
3. **Have the recovery commands ready**
### After Testing
1. **Verify internet connectivity:**
```bash
ping -c 3 8.8.8.8
curl -I https://www.google.com
```
2. **Check Pi's new IP address:**
```bash
hostname -I
ip addr show wlan0
```
3. **Update your SSH/config** if IP changed
## Troubleshooting Reconnection
### Issue: Can't Connect to Saved Network
**Solution:**
```bash
# Remove old connection and reconnect
nmcli connection delete "NetworkName"
sudo nmcli device wifi connect "NetworkName" password "Password"
```
### Issue: AP Mode Won't Disable
**Solution:**
```bash
# Force stop services
sudo systemctl stop hostapd dnsmasq
sudo systemctl disable hostapd dnsmasq
# Kill processes if needed
sudo pkill hostapd
sudo pkill dnsmasq
# Restart NetworkManager
sudo systemctl restart NetworkManager
```
### Issue: WiFi Interface Stuck
**Solution:**
```bash
# Reset WiFi interface
sudo nmcli radio wifi off
sleep 2
sudo nmcli radio wifi on
sleep 3
# Try connecting again
sudo nmcli device wifi connect "NetworkName" password "Password"
```
### Issue: No Networks Found
**Solution:**
```bash
# Check WiFi is enabled
nmcli radio wifi
# Enable if off
sudo nmcli radio wifi on
# Check interface status
ip link show wlan0
# Restart NetworkManager
sudo systemctl restart NetworkManager
```
## Quick Reference Commands
```bash
# Disable AP mode
sudo systemctl stop hostapd dnsmasq
# List WiFi networks
nmcli device wifi list
# Connect to network
sudo nmcli device wifi connect "SSID" password "Password"
# Check connection status
nmcli device status
# Get IP address
hostname -I
ip addr show wlan0
# Test internet
ping -c 3 8.8.8.8
# Restart network services
sudo systemctl restart NetworkManager
```
## Best Practices
1. **Always test from a secondary device** - Keep your main computer on your normal network
2. **Have Ethernet backup** - If available, keep Ethernet connected as fallback
3. **Save network credentials** - Ensure your network is saved before testing
4. **Document your Pi's IP** - Note the IP on your normal network before testing
5. **Keep SSH session open** - Maintain an active SSH connection during testing
6. **Test during safe times** - Don't test when you need immediate internet access
## Recovery Checklist
- [ ] Stop AP mode services (hostapd, dnsmasq)
- [ ] Verify WiFi interface is available
- [ ] Scan for available networks
- [ ] Connect to your network
- [ ] Verify connection status
- [ ] Test internet connectivity
- [ ] Note new IP address
- [ ] Update any configurations that reference old IP

299
docs/archive/STARTUP_OPTIMIZATION_SUMMARY.md Normal file
View File

@@ -0,0 +1,299 @@
# LED Matrix Startup Optimization Summary
## Overview
This document summarizes the startup performance optimizations implemented to reduce the LED matrix display startup time from **102 seconds to under 10 seconds** (90%+ improvement).
## Implemented Optimizations
### Phase 1: High-Impact Changes (90+ seconds savings)
#### 1. Smart Dependency Checking with Marker Files ✅
**Impact: ~90 seconds savings**
**Problem**: Running `pip install -r requirements.txt` for every plugin on every startup, even when dependencies were already installed.
**Solution**:
- Added marker file system at `/var/cache/ledmatrix/plugin_<id>_deps_installed`
- Tracks which plugins have had dependencies installed
- Only installs dependencies on first load or when marker is missing
- Marker created with timestamp after successful installation
- Marker removed when plugin is uninstalled
**Files Modified**:
- `src/plugin_system/plugin_manager.py`:
- Added `_get_dependency_marker_path()`
- Added `_check_dependencies_installed()`
- Added `_mark_dependencies_installed()`
- Added `_remove_dependency_marker()`
- Modified `load_plugin()` to check marker before installing
- Modified `unload_plugin()` to remove marker
**Utility Script**: `scripts/clear_dependency_markers.sh` - Clears all markers to force fresh check
#### 2. Removed Cache Clear at Startup ✅
**Impact: ~5-30 seconds savings**
**Problem**: Clearing entire cache on startup forced fresh API calls for all plugins, defeating the purpose of caching.
**Solution**:
- Removed `cache_manager.clear_cache()` call from startup
- Removed 5-second sleep waiting for data
- Trust cache TTL mechanisms for staleness
- Let plugins use cached data immediately at startup
- Background updates will refresh naturally
**Files Modified**:
- `src/display_controller.py` (lines 447-452):
- Removed cache clear and sleep
- Added comment explaining fast startup approach
### Phase 2: Quick Wins (8-10 seconds savings)
#### 3. Enhanced Startup Progress Logging ✅
**Impact: Visibility improvement (no performance change)**
**Features**:
- Shows plugin count and progress (1/9, 2/9, etc.)
- Displays individual plugin load times
- Shows cumulative progress percentage
- Reports elapsed time
- Uses ✓ and ✗ symbols for success/failure
**Files Modified**:
- `src/display_controller.py` (lines 109-192):
- Added enabled plugin counting
- Added per-plugin timing
- Added progress percentage calculation
- Enhanced logging with symbols
#### 4. Lazy-Load Flight Tracker Aircraft Database ✅
**Impact: ~8-10 seconds savings at startup**
**Problem**: Loading 70MB aircraft database during plugin initialization, even if not immediately needed.
**Solution**:
- Defer database loading until first use
- Added `_ensure_database_loaded()` method
- Called automatically when database is first accessed
- Tracks load state to avoid repeated attempts
- Logs load time when it happens (during first display, not startup)
**Files Modified**:
- `plugins/ledmatrix-flights/manager.py`:
- Modified `__init__()` to defer database loading
- Added `_ensure_database_loaded()` method
- Modified `_get_aircraft_info_from_database()` to lazy-load
### Phase 3: Advanced Optimization (2-3 seconds savings)
#### 5. Parallel Plugin Loading ✅
**Impact: ~2-3 seconds savings**
**Solution**:
- Use `ThreadPoolExecutor` with 4 concurrent workers
- Load plugins in parallel instead of serially
- Process results as they complete
- Thread-safe plugin registration
**Files Modified**:
- `src/display_controller.py` (lines 1-7, 109-192):
- Added ThreadPoolExecutor import
- Created `load_single_plugin()` helper function
- Parallel execution with progress tracking
- Error handling per plugin
## Expected Performance Results
### Baseline (Before Optimizations)
- **Total startup time**: 102.27 seconds
- Core initialization: 1.65 seconds (fast)
- Plugin loading: 100.6 seconds (bottleneck)
- Dependency checks: ~90 seconds
- Flight tracker DB: ~8 seconds
- Other init: ~2 seconds
### After Phase 1
- **Expected**: ~12 seconds (90% improvement)
- Dependency checks: 0 seconds (after first run)
- Cache clear removed: 5+ seconds saved
- **Savings**: 90 seconds
### After Phase 2
- **Expected**: ~3-4 seconds (96% improvement)
- Flight tracker DB lazy-loaded: 8-10 seconds saved
- **Savings**: 98 seconds total
### After Phase 3
- **Expected**: ~2 seconds (98% improvement)
- Parallel loading: 2-3 seconds saved
- **Savings**: 100+ seconds total
## Testing and Validation
### On Development Machine
```bash
# Test with emulator
./scripts/dev/run_emulator.sh
# Check logs for timing information
# Look for:
# - "Loading X enabled plugin(s) in parallel"
# - Individual plugin load times
# - "Plugin system initialized in X.XXX seconds"
# - "DisplayController initialization completed in X.XXX seconds"
```
### On Raspberry Pi
```bash
# Deploy changes
cd /home/ledpi/LEDMatrix
git pull origin plugins # or your branch
# Restart service
sudo systemctl restart ledmatrix
# Check startup time
journalctl -u ledmatrix -b | grep -E "(Starting DisplayController|DisplayController initialization completed|Plugin system initialized)"
# Check for dependency installations (should only happen on first run)
journalctl -u ledmatrix -b | grep "Installing dependencies"
# Check marker files
ls -la /var/cache/ledmatrix/plugin_*_deps_installed
# Monitor live
journalctl -u ledmatrix -f
```
### Benchmarking Commands
```bash
# Get startup time from latest boot
journalctl -u ledmatrix -b | grep "DisplayController initialization completed"
# Compare with previous boots
journalctl -u ledmatrix --since "1 day ago" | grep "DisplayController initialization completed"
# Check dependency marker status
ls -lh /var/cache/ledmatrix/plugin_*_deps_installed
```
## Troubleshooting
### Plugins Fail Due to Missing Dependencies
**Symptoms**: Plugin fails to import with ModuleNotFoundError
**Solution**:
```bash
# Clear markers to force fresh dependency install
sudo /home/ledpi/LEDMatrix/scripts/clear_dependency_markers.sh
# Restart service
sudo systemctl restart ledmatrix
```
### Want to Force Dependency Reinstall for a Specific Plugin
```bash
# Remove marker for specific plugin
sudo rm /var/cache/ledmatrix/plugin_<plugin-id>_deps_installed
# Restart service
sudo systemctl restart ledmatrix
```
### Revert to Old Behavior (No Optimizations)
To temporarily disable optimizations for testing:
1. **Re-enable dependency checks every time**:
- Edit `src/plugin_system/plugin_manager.py`
- Comment out the marker check in `load_plugin()`
2. **Re-enable cache clear**:
- Edit `src/display_controller.py`
- Add back cache clear and sleep in `run()` method
## Performance Metrics to Monitor
### Startup Metrics
- Total initialization time
- Plugin loading time
- Individual plugin load times
- First display ready time
### Runtime Metrics
- Memory usage (should be similar)
- CPU usage (should be similar)
- Display performance (should be identical)
- Plugin functionality (should be identical)
### Regression Indicators
- Plugins failing to load
- Missing dependencies errors
- Stale data at startup (acceptable - will refresh)
- Crashes during parallel loading
## Rollback Plan
If issues are encountered:
1. **Revert Git commits**:
```bash
git revert <commit-hash>
sudo systemctl restart ledmatrix
```
2. **Cherry-pick safe changes**:
- Keep progress logging (safe)
- Keep lazy-load flight tracker (safe)
- Revert parallel loading if issues
- Revert dependency markers if issues
3. **Emergency rollback**:
```bash
git checkout <previous-stable-commit>
sudo systemctl restart ledmatrix
```
## Success Criteria
✅ Startup time reduced to under 10 seconds (from 102 seconds)
✅ All plugins load successfully
✅ All display modes function correctly
✅ No regression in display quality or performance
✅ Cached data used effectively at startup
✅ Dependencies installed correctly on first run
✅ Progress logging shows clear startup status
## Files Modified Summary
1. `src/plugin_system/plugin_manager.py` - Dependency marker system
2. `src/display_controller.py` - Cache removal, progress logging, parallel loading
3. `plugins/ledmatrix-flights/manager.py` - Lazy-load aircraft database
4. `scripts/clear_dependency_markers.sh` - Utility script (new)
## Maintenance Notes
- **Dependency markers persist** across restarts - this is intentional
- **Clear markers** when updating plugin dependencies
- **Cache remains** across restarts - data refreshes via TTL
- **Parallel loading** is safe due to plugin independence
- **Progress logs** help diagnose slow plugins
## Future Optimization Opportunities
1. **Lazy-load other heavy resources** (e.g., stock logos, team logos)
2. **Background plugin loading** - start display immediately, load remaining plugins in background
3. **Plugin load prioritization** - load frequently-used plugins first
4. **Cached manifest reading** - avoid re-parsing JSON on every startup
5. **Optimized font loading** - lazy-load fonts per plugin
---
**Implementation Date**: November 9, 2025
**Version**: 1.0
**Status**: ✅ Ready for Pi Deployment

378
docs/archive/STATIC_IMAGE_MULTI_UPLOAD_PLAN.md Normal file
View File

@@ -0,0 +1,378 @@
# Static Image Plugin - Multi-Image Upload & Rotation Implementation Plan
## Overview
Enhance the static-image plugin to support:
1. **Multiple image uploads** via web UI
2. **Image rotation** (sequential, random, time-based, date-based)
3. **Robust asset management** (storage, validation, cleanup)
4. **Future-proof architecture** for advanced rotation logic
## Architecture Design
### 1. Configuration Schema Enhancement
#### Current Schema
```json
{
"image_path": "assets/static_images/default.png"
}
```
#### Enhanced Schema (Backward Compatible)
```json
{
"image_config": {
"mode": "single" | "multiple",
"rotation_mode": "sequential" | "random" | "time_based" | "date_based",
"images": [
{
"id": "uuid-or-hash",
"path": "assets/plugins/static-image/uploads/image_1234567890.png",
"uploaded_at": "2025-01-15T10:30:00Z",
"display_order": 0,
"schedule": null // Future: {"start_time": "08:00", "end_time": "18:00", "days": [1,2,3,4,5]}
}
]
},
// Legacy support - maps to single image mode
"image_path": "assets/static_images/default.png",
// Rotation settings
"rotation_settings": {
"sequential_loop": true,
"random_seed": null, // null = use time, or fixed seed for reproducible rotation
"time_intervals": {
"enabled": false,
"interval_seconds": 3600 // Change image every hour
},
"date_ranges": [] // Future: [{"start": "2025-12-01", "end": "2025-12-25", "image_id": "..."}]
}
}
```
### 2. Asset Storage Structure
```text
assets/
├── plugins/
│ └── static-image/
│ └── uploads/
│ ├── image_1705312200_abc123.png
│ ├── image_1705312400_def456.jpg
│ └── .metadata.json // Maps IDs to filenames
```
**Storage Strategy:**
- Files stored in `assets/plugins/static-image/uploads/`
- Filenames: `image_{timestamp}_{hash}.{ext}` (prevents collisions)
- Metadata JSON tracks: ID → filename mapping, upload dates, file sizes
- Cleanup: Remove files not referenced in config
### 3. Backend API Endpoints
#### POST `/api/v3/plugins/assets/upload`
**Purpose:** Upload image files for a specific plugin
**Request:**
- `multipart/form-data`
- `plugin_id`: string (required)
- `files`: File[] (multiple files supported)
- `rotation_mode`: string (optional, default: "sequential")
**Response:**
```json
{
"status": "success",
"uploaded_files": [
{
"id": "uuid-here",
"filename": "image_1705312200_abc123.png",
"path": "assets/plugins/static-image/uploads/image_1705312200_abc123.png",
"size": 45678,
"uploaded_at": "2025-01-15T10:30:00Z"
}
]
}
```
**Validation:**
- File type: PNG, JPG, JPEG, BMP, GIF
- Max file size: 5MB per file
- Max files per upload: 10
- Total storage limit: 50MB per plugin
#### DELETE `/api/v3/plugins/assets/delete`
**Purpose:** Delete uploaded image
**Request:**
- `plugin_id`: string
- `image_id`: string (from upload response)
**Response:**
```json
{
"status": "success",
"deleted_file": "image_1705312200_abc123.png"
}
```
#### GET `/api/v3/plugins/assets/list`
**Purpose:** List all uploaded images for a plugin
**Response:**
```json
{
"status": "success",
"images": [
{
"id": "uuid-here",
"filename": "image_1705312200_abc123.png",
"path": "assets/plugins/static-image/uploads/image_1705312200_abc123.png",
"size": 45678,
"uploaded_at": "2025-01-15T10:30:00Z"
}
]
}
```
### 4. Frontend Form Generator Enhancement
#### Schema Format for File Upload
```json
{
"type": "object",
"properties": {
"images": {
"type": "array",
"x-widget": "file-upload",
"x-upload-config": {
"endpoint": "/api/v3/plugins/assets/upload",
"plugin_id_field": "plugin_id",
"max_files": 10,
"allowed_types": ["image/png", "image/jpeg", "image/bmp", "image/gif"],
"max_size_mb": 5
},
"items": {
"type": "object",
"properties": {
"id": {"type": "string"},
"path": {"type": "string"},
"uploaded_at": {"type": "string", "format": "date-time"}
}
},
"description": "Upload images to display. Multiple images will rotate based on rotation mode."
},
"rotation_mode": {
"type": "string",
"enum": ["sequential", "random", "time_based", "date_based"],
"default": "sequential",
"description": "How to rotate through images"
}
}
}
```
#### UI Components
1. **File Upload Widget:**
- Drag-and-drop zone
- File list with thumbnails
- Remove button per file
- Upload progress indicator
- Image preview before upload
2. **Rotation Mode Selector:**
- Dropdown with rotation options
- Settings panel per mode:
- Sequential: Loop option
- Random: Seed option
- Time-based: Interval input
- Date-based: Calendar picker (future)
### 5. Plugin Manager Updates
#### Rotation Logic in `manager.py`
```python
class StaticImagePlugin(BasePlugin):
def __init__(self, ...):
# ... existing code ...
# Enhanced image handling
self.image_config = config.get('image_config', {})
self.rotation_mode = self.image_config.get('rotation_mode', 'sequential')
self.rotation_settings = config.get('rotation_settings', {})
self.images_list = self.image_config.get('images', [])
self.current_image_index = 0
self.last_rotation_time = time.time()
# Initialize rotation
self._setup_rotation()
def _setup_rotation(self):
"""Initialize rotation based on mode"""
if self.rotation_mode == 'random':
import random
seed = self.rotation_settings.get('random_seed')
if seed:
random.seed(seed)
if not self.images_list:
# Fallback to legacy image_path
if self.image_path:
self.images_list = [{'path': self.image_path}]
def _get_next_image(self) -> Optional[str]:
"""Get next image path based on rotation mode"""
if not self.images_list:
return None
if self.rotation_mode == 'sequential':
path = self.images_list[self.current_image_index]['path']
self.current_image_index = (self.current_image_index + 1) % len(self.images_list)
return path
elif self.rotation_mode == 'random':
import random
return random.choice(self.images_list)['path']
elif self.rotation_mode == 'time_based':
interval = self.rotation_settings.get('time_intervals', {}).get('interval_seconds', 3600)
now = time.time()
if now - self.last_rotation_time >= interval:
self.current_image_index = (self.current_image_index + 1) % len(self.images_list)
self.last_rotation_time = now
return self.images_list[self.current_image_index]['path']
elif self.rotation_mode == 'date_based':
# Future implementation
return self._get_date_based_image()
return self.images_list[0]['path']
def display(self, force_clear: bool = False):
"""Display current image based on rotation"""
image_path = self._get_next_image()
if not image_path or not os.path.exists(image_path):
self._display_error()
return
self.image_path = image_path # For compatibility
self._load_image()
# ... rest of display logic ...
```
### 6. Asset Management System
#### File Operations
- **Upload:** Save to `assets/plugins/{plugin_id}/uploads/`
- **Validation:** Check file type, size, dimensions
- **Metadata:** Track in `.metadata.json`
- **Cleanup:** Remove orphaned files on config save
- **Permissions:** Ensure writable by web service
#### Security
- Validate file extensions (whitelist)
- Check file content (magic bytes, not just extension)
- Limit file sizes
- Sanitize filenames
- Prevent path traversal
### 7. Migration Strategy
#### Backward Compatibility
1. **Legacy Support:**
- If `image_path` exists but no `image_config`, auto-convert
- Create `image_config` with single image from `image_path`
2. **Config Migration:**
```python
def _migrate_legacy_config(self, config):
"""Migrate legacy image_path to new image_config format"""
if 'image_path' in config and 'image_config' not in config:
config['image_config'] = {
'mode': 'single',
'rotation_mode': 'sequential',
'images': [{
'id': str(uuid.uuid4()),
'path': config['image_path'],
'uploaded_at': datetime.now().isoformat(),
'display_order': 0
}]
}
return config
```
## Implementation Phases
### Phase 1: Core Upload System
1. ✅ Enhanced config schema
2. ✅ Backend upload endpoint
3. ✅ Asset storage structure
4. ✅ File validation
### Phase 2: Frontend Integration
5. ✅ File upload widget in form generator
6. ✅ Image preview/management UI
7. ✅ Rotation mode selector
### Phase 3: Plugin Rotation Logic
8. ✅ Update plugin manager with rotation
9. ✅ Sequential rotation
10. ✅ Random rotation
### Phase 4: Advanced Features
11. ✅ Time-based rotation
12. ✅ Date-based rotation (future)
13. ✅ Cleanup/orphan removal
## File Structure Changes
```text
plugins/static-image/
├── manager.py # Enhanced with rotation logic
├── config_schema.json # Updated with upload/rotation fields
├── manifest.json # No changes
└── README.md # Update documentation
web_interface/
├── blueprints/
│ └── api_v3.py # Add upload/delete/list endpoints
└── templates/v3/
└── partials/
└── plugins.html # File upload widget
assets/
└── plugins/
└── static-image/
└── uploads/ # NEW - user uploaded images
└── .metadata.json
```
## Testing Checklist
- [ ] Single image upload works
- [ ] Multiple image upload works
- [ ] File validation (type, size)
- [ ] Sequential rotation cycles correctly
- [ ] Random rotation works
- [ ] Time-based rotation changes at intervals
- [ ] Legacy config migration preserves existing images
- [ ] Orphaned file cleanup on config save
- [ ] Web UI displays upload widget correctly
- [ ] Image preview shows before upload
- [ ] Delete removes file and updates config
- [ ] Error handling for missing/invalid files
## Future Enhancements
1. **Date-based rotation:** Display different images on specific dates
2. **Time-of-day rotation:** Show images based on time ranges
3. **Transition effects:** Fade between images
4. **Image filters:** Apply effects (brightness, contrast)
5. **Bulk operations:** Select multiple images for deletion
6. **Image organization:** Folders/tags for images
7. **Remote images:** Support URLs (with caching)

92
docs/archive/TROUBLESHOOTING_QUICK_START.md Normal file
View File

@@ -0,0 +1,92 @@
# Web Interface Troubleshooting - Quick Start
## The Problem
After reorganizing the web interface, it doesn't seem to run and shows no logging.
## Why You're Not Seeing Logs
**The web service logs to syslog, NOT stdout!**
The systemd service is configured with:
```
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=ledmatrix-web
```
## Immediate Actions (Run on Raspberry Pi)
### 1. Run the Diagnostic Script
```bash
ssh ledpi@<your-pi-ip>
cd ~/LEDMatrix
bash scripts/diagnose_web_interface.sh
```
This automated script will check everything and tell you what's wrong.
### 2. View the Actual Logs
```bash
# View recent logs
sudo journalctl -u ledmatrix-web -n 50 --no-pager
# Follow logs in real-time
sudo journalctl -u ledmatrix-web -f
```
### 3. Check Service Status
```bash
sudo systemctl status ledmatrix-web
```
### 4. Try Manual Start (Best for Debugging)
```bash
cd ~/LEDMatrix
python3 web_interface/start.py
```
This will show errors directly in your terminal.
## Most Likely Issues
### Issue 1: web_display_autostart is False
The web interface is designed NOT to start if this config is false.
**Fix:**
```bash
nano ~/LEDMatrix/config/config.json
# Change: "web_display_autostart": true
sudo systemctl restart ledmatrix-web
```
### Issue 2: Service Not Started
**Fix:**
```bash
sudo systemctl start ledmatrix-web
sudo systemctl enable ledmatrix-web
```
### Issue 3: Import Errors
**Fix:**
```bash
cd ~/LEDMatrix
pip3 install --break-system-packages -r web_interface/requirements.txt
sudo systemctl restart ledmatrix-web
```
## Full Documentation
- **Comprehensive Guide:** `docs/WEB_INTERFACE_TROUBLESHOOTING.md`
- **Reorganization Info:** `WEB_INTERFACE_REORGANIZATION.md`
## After Fixing
Once it's working, you should see:
- Service status: "active (running)" in green
- Accessible at: `http://<your-pi-ip>:5000`
- Logs showing: "Starting LED Matrix Web Interface V3..."
## Need Help?
Run the diagnostic script and share its output - it will show exactly what's wrong!

231
docs/archive/V3_INTERFACE_README.md Normal file
View File

@@ -0,0 +1,231 @@
# LED Matrix Web Interface v3
## Overview
The v3 web interface is a complete rewrite of the LED Matrix control panel using modern web technologies for better performance, maintainability, and user experience. It uses Flask + HTMX + Alpine.js for a lightweight, server-side rendered interface with progressive enhancement.
## 🚀 Key Features
### Architecture
- **HTMX** for dynamic content loading without full page reloads
- **Alpine.js** for reactive components and state management
- **SSE (Server-Sent Events)** for real-time updates
- **Modular design** with blueprints for better code organization
- **Progressive enhancement** - works without JavaScript
### User Interface
- **Modern, responsive design** with Tailwind CSS utility classes
- **Tab-based navigation** for easy access to different features
- **Real-time updates** for system stats, logs, and display preview
- **Modal dialogs** for configuration and plugin management
- **Drag-and-drop** font upload with progress indicators
## 📋 Implemented Features
### ✅ Complete Modules
1. **Overview** - System stats, quick actions, display preview
2. **General Settings** - Timezone, location, autostart configuration
3. **Display Settings** - Hardware configuration, brightness, options
4. **Durations** - Display rotation timing configuration
5. **Sports Configuration** - Per-league settings with on-demand modes
6. **Plugin Management** - Install, configure, enable/disable plugins
7. **Font Management** - Upload fonts, manage overrides, preview
8. **Logs Viewer** - Real-time log streaming with filtering and search
### 🎯 Key Improvements Over v1/v2
- **Modular Architecture**: Each tab loads independently via HTMX
- **Real-time Updates**: SSE streams for live stats and logs
- **Better Error Handling**: Consistent API responses and user feedback
- **Enhanced UX**: Loading states, progress indicators, notifications
- **Schema-driven Forms**: Dynamic form generation from JSON schemas
- **Responsive Design**: Works well on different screen sizes
- **Performance**: Server-side rendering with minimal JavaScript
## 🛠️ Technical Stack
### Backend
- **Flask** with Blueprints for modular organization
- **Jinja2** templates for server-side rendering
- **SSE** for real-time data streaming
- **Consistent API** with JSON envelope responses
### Frontend
- **HTMX** for AJAX interactions without writing JavaScript
- **Alpine.js** for reactive state management
- **Tailwind CSS** utility classes for styling
- **Font Awesome** for icons
## 🚦 Getting Started
### Prerequisites
- Python 3.7+
- Flask
- LED Matrix project setup
### Running the Interface
1. **Start the v3 interface**:
```bash
python3 web_interface/start.py
# Or use the shell script:
./web_interface/run.sh
```
2. **Access the interface**:
- Open `http://localhost:5000` in your browser
- The interface will load with real-time system stats
3. **Test functionality**:
```bash
python test_v3_interface.py
```
### Navigation
- **Overview**: System stats, quick actions, display preview
- **General**: Basic settings (timezone, location, autostart)
- **Display**: Hardware configuration (rows, columns, brightness)
- **Sports**: Per-league configuration with on-demand modes
- **Plugins**: Plugin management and store
- **Fonts**: Font upload, overrides, and preview
- **Logs**: Real-time log viewer with filtering
## 🔧 API Endpoints
### Core Endpoints
- `GET /` - Main interface (serves v3)
- `GET /v3` - v3 interface (backwards compatibility)
### API v3 Endpoints
- `GET /api/v3/config/main` - Get main configuration
- `POST /api/v3/config/main` - Save main configuration
- `GET /api/v3/system/status` - Get system status
- `POST /api/v3/system/action` - Execute system actions
- `GET /api/v3/plugins/installed` - Get installed plugins
- `GET /api/v3/fonts/catalog` - Get font catalog
### SSE Streams
- `/api/v3/stream/stats` - Real-time system stats
- `/api/v3/stream/display` - Display preview updates
- `/api/v3/stream/logs` - Real-time log streaming
## 📁 File Structure
```
LEDMatrix/
├── web_interface/ # Web interface package
│ ├── __init__.py
│ ├── app.py # Main Flask app with blueprints
│ ├── start.py # Startup script
│ ├── run.sh # Shell runner
│ ├── requirements.txt # Dependencies
│ ├── README.md # Web interface documentation
│ ├── blueprints/
│ │ ├── __init__.py
│ │ ├── pages_v3.py # HTML pages and partials
│ │ └── api_v3.py # API endpoints
│ ├── templates/v3/
│ │ ├── base.html # Main layout template
│ │ ├── index.html # Overview page
│ │ └── partials/ # HTMX partials
│ │ ├── overview.html
│ │ ├── general.html
│ │ ├── display.html
│ │ ├── sports.html
│ │ ├── plugins.html
│ │ ├── fonts.html
│ │ └── logs.html
│ └── static/v3/
│ ├── app.css # Custom styles
│ └── app.js # JavaScript helpers
├── old_web_interface/ # Legacy v1/v2 (for reference)
├── start_web_conditionally.py # Service starter
└── test_v3_interface.py # Test script
```
## 🔄 Migration from v1/v2
### What Changed
- **Default Route**: `/` now serves v3 interface (was v1)
- **API Prefix**: All v3 APIs use `/api/v3/` prefix
- **SSE Streams**: New real-time update mechanism
- **Modular Design**: Tabs load independently via HTMX
### Backwards Compatibility
- Old `/` route redirects to `/v3`
- Original v1 interface still accessible via other routes
- All existing functionality preserved in new structure
### Migration Path
1. **Phase 1-7**: Implement all v3 features ✅
2. **Phase 8**: Update default route to v3 ✅
3. **Testing**: Run comprehensive tests ✅
4. **Cutover**: v3 becomes default interface ✅
## 🧪 Testing
### Automated Tests
```bash
python test_v3_interface.py
```
Tests cover:
- Basic connectivity and routing
- API endpoint accessibility
- SSE stream functionality
- HTMX partial loading
- Form submissions
- Configuration saving
### Manual Testing Checklist
- [ ] Navigate between all tabs
- [ ] Test form submissions (General, Display, Sports)
- [ ] Verify real-time updates (stats, logs)
- [ ] Test plugin management (enable/disable)
- [ ] Upload a font file
- [ ] Test responsive design on mobile
- [ ] Verify error handling for invalid inputs
## 🚨 Known Limitations
### Current Implementation
- **Sample Data**: Many endpoints return sample data for testing
- **No Real Integration**: Backend doesn't fully integrate with actual services yet
- **Basic Error Handling**: Could be more comprehensive
- **No Authentication**: Assumes local/trusted network
### Production Readiness
- **Security**: Add authentication and CSRF protection
- **Performance**: Optimize for high traffic
- **Monitoring**: Add proper logging and metrics
- **Integration**: Connect to real LED matrix hardware/services
## 🔮 Future Enhancements
### Planned Features
- **Advanced Editor**: Visual layout editor for display elements
- **Plugin Store Integration**: Real plugin discovery and installation
- **Advanced Analytics**: Usage metrics and performance monitoring
- **Mobile App**: Companion mobile app for remote control
### Technical Improvements
- **WebSockets**: Replace SSE for bidirectional communication
- **Caching**: Add Redis or similar for better performance
- **API Rate Limiting**: Protect against abuse
- **Database Integration**: Move from file-based config
## 📞 Support
For issues or questions:
1. Run the test script: `python test_v3_interface.py`
2. Check the logs tab for real-time debugging
3. Review the browser console for JavaScript errors
4. File issues in the project repository
---
**Status**: ⚠️ **UI framework complete; integration and production hardening required (not production-ready)**
The v3 interface UI and layout are finished, providing a modern, maintainable foundation for LED Matrix control. However, real service integration, authentication, security hardening, and monitoring remain to be implemented before production use.

388
docs/archive/VEGAS_SCROLL_MODE.md Normal file
View File

@@ -0,0 +1,388 @@
# Vegas Scroll Mode - Plugin Developer Guide
Vegas scroll mode displays content from multiple plugins in a continuous horizontal scroll, similar to the news tickers seen in Las Vegas casinos. This guide explains how to integrate your plugin with Vegas mode.
## Overview
When Vegas mode is enabled, the display controller composes content from all enabled plugins into a single continuous scroll. Each plugin can control how its content appears in the scroll using one of three **display modes**:
| Mode | Behavior | Best For |
|------|----------|----------|
| **SCROLL** | Content scrolls continuously within the stream | Multi-item plugins (sports scores, odds, news) |
| **FIXED_SEGMENT** | Fixed-width block that scrolls by | Static info (clock, weather, current temp) |
| **STATIC** | Scroll pauses, plugin displays for duration, then resumes | Important alerts, detailed views |
## Quick Start
### Minimal Integration (Zero Code Changes)
If you do nothing, your plugin will work with Vegas mode using these defaults:
- Plugins with `get_vegas_content_type() == 'multi'` use **SCROLL** mode
- Plugins with `get_vegas_content_type() == 'static'` use **FIXED_SEGMENT** mode
- Content is captured by calling your plugin's `display()` method
### Basic Integration
To provide optimized Vegas content, implement `get_vegas_content()`:
```python
from PIL import Image
class MyPlugin(BasePlugin):
def get_vegas_content(self):
"""Return content for Vegas scroll mode."""
# Return a single image for fixed content
return self._render_current_view()
# OR return multiple images for multi-item content
# return [self._render_item(item) for item in self.items]
```
### Full Integration
For complete control over Vegas behavior, implement these methods:
```python
from src.plugin_system.base_plugin import BasePlugin, VegasDisplayMode
class MyPlugin(BasePlugin):
def get_vegas_content_type(self) -> str:
"""Legacy method - determines default mode mapping."""
return 'multi' # or 'static' or 'none'
def get_vegas_display_mode(self) -> VegasDisplayMode:
"""Specify how this plugin behaves in Vegas scroll."""
return VegasDisplayMode.SCROLL
def get_supported_vegas_modes(self) -> list:
"""Return list of modes users can configure."""
return [VegasDisplayMode.SCROLL, VegasDisplayMode.FIXED_SEGMENT]
def get_vegas_content(self):
"""Return PIL Image(s) for the scroll."""
return [self._render_game(g) for g in self.games]
def get_vegas_segment_width(self) -> int:
"""For FIXED_SEGMENT: width in panels (optional)."""
return 2 # Use 2 panels width
```
## Display Modes Explained
### SCROLL Mode
Content scrolls continuously within the Vegas stream. Best for plugins with multiple items.
```python
def get_vegas_display_mode(self):
return VegasDisplayMode.SCROLL
def get_vegas_content(self):
# Return list of images - each scrolls individually
images = []
for game in self.games:
img = Image.new('RGB', (200, 32))
# ... render game info ...
images.append(img)
return images
```
**When to use:**
- Sports scores with multiple games
- Stock/odds tickers with multiple items
- News feeds with multiple headlines
### FIXED_SEGMENT Mode
Content is rendered as a fixed-width block that scrolls by with other content.
```python
def get_vegas_display_mode(self):
return VegasDisplayMode.FIXED_SEGMENT
def get_vegas_content(self):
# Return single image at your preferred width
img = Image.new('RGB', (128, 32)) # 2 panels wide
# ... render clock/weather/etc ...
return img
def get_vegas_segment_width(self):
# Optional: specify width in panels
return 2
```
**When to use:**
- Clock display
- Current weather/temperature
- System status indicators
- Any "at a glance" information
### STATIC Mode
Scroll pauses completely, your plugin displays using its normal `display()` method for its configured duration, then scroll resumes.
```python
def get_vegas_display_mode(self):
return VegasDisplayMode.STATIC
def get_display_duration(self):
# How long to pause and show this plugin
return 10.0 # 10 seconds
```
**When to use:**
- Important alerts that need attention
- Detailed information that's hard to read while scrolling
- Interactive or animated content
- Content that requires the full display
## User Configuration
Users can override the default display mode per-plugin in their config:
```json
{
"my_plugin": {
"enabled": true,
"vegas_mode": "static", // Override: "scroll", "fixed", or "static"
"vegas_panel_count": 2, // Width in panels for fixed mode
"display_duration": 10 // Duration for static mode
}
}
```
The `get_vegas_display_mode()` method checks config first, then falls back to your implementation.
## Content Rendering Guidelines
### Image Dimensions
- **Height**: Must match display height (typically 32 pixels)
- **Width**:
- SCROLL: Any width, content will scroll
- FIXED_SEGMENT: `panels × single_panel_width` (e.g., 2 × 64 = 128px)
### Color Mode
Always use RGB mode for images:
```python
img = Image.new('RGB', (width, 32), color=(0, 0, 0))
```
### Performance Tips
1. **Cache rendered images** - Don't re-render on every call
2. **Pre-render on update()** - Render images when data changes, not when Vegas requests them
3. **Keep images small** - Memory adds up with multiple plugins
```python
class MyPlugin(BasePlugin):
def __init__(self, ...):
super().__init__(...)
self._cached_vegas_images = None
self._cache_valid = False
def update(self):
# Fetch new data
self.data = self._fetch_data()
# Invalidate cache so next Vegas request re-renders
self._cache_valid = False
def get_vegas_content(self):
if not self._cache_valid:
self._cached_vegas_images = self._render_all_items()
self._cache_valid = True
return self._cached_vegas_images
```
## Fallback Behavior
If your plugin doesn't implement `get_vegas_content()`, Vegas mode will:
1. Create a temporary canvas matching display dimensions
2. Call your `display()` method
3. Capture the resulting image
4. Use that image in the scroll
This works but is less efficient than providing native Vegas content.
## Excluding from Vegas Mode
To exclude your plugin from Vegas scroll entirely:
```python
def get_vegas_content_type(self):
return 'none'
```
Or users can exclude via config:
```json
{
"display": {
"vegas_scroll": {
"excluded_plugins": ["my_plugin"]
}
}
}
```
## Complete Example
Here's a complete example of a weather plugin with full Vegas integration:
```python
from PIL import Image, ImageDraw
from src.plugin_system.base_plugin import BasePlugin, VegasDisplayMode
class WeatherPlugin(BasePlugin):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.temperature = None
self.conditions = None
self._vegas_image = None
def update(self):
"""Fetch weather data."""
data = self._fetch_weather_api()
self.temperature = data['temp']
self.conditions = data['conditions']
self._vegas_image = None # Invalidate cache
def display(self, force_clear=False):
"""Standard display for normal rotation."""
if force_clear:
self.display_manager.clear()
# Full weather display with details
self.display_manager.draw_text(
f"{self.temperature}°F",
x=10, y=8, color=(255, 255, 255)
)
self.display_manager.draw_text(
self.conditions,
x=10, y=20, color=(200, 200, 200)
)
self.display_manager.update_display()
# --- Vegas Mode Integration ---
def get_vegas_content_type(self):
"""Legacy compatibility."""
return 'static'
def get_vegas_display_mode(self):
"""Use FIXED_SEGMENT for compact weather display."""
# Allow user override via config
return super().get_vegas_display_mode()
def get_supported_vegas_modes(self):
"""Weather can work as fixed or static."""
return [VegasDisplayMode.FIXED_SEGMENT, VegasDisplayMode.STATIC]
def get_vegas_segment_width(self):
"""Weather needs 2 panels to show clearly."""
return self.config.get('vegas_panel_count', 2)
def get_vegas_content(self):
"""Render compact weather for Vegas scroll."""
if self._vegas_image is not None:
return self._vegas_image
# Create compact display (2 panels = 128px typical)
panel_width = 64 # From display.hardware.cols
panels = self.get_vegas_segment_width() or 2
width = panel_width * panels
height = 32
img = Image.new('RGB', (width, height), color=(0, 0, 40))
draw = ImageDraw.Draw(img)
# Draw compact weather
temp_text = f"{self.temperature}°"
draw.text((10, 8), temp_text, fill=(255, 255, 255))
draw.text((60, 8), self.conditions[:10], fill=(200, 200, 200))
self._vegas_image = img
return img
```
## API Reference
### VegasDisplayMode Enum
```python
from src.plugin_system.base_plugin import VegasDisplayMode
VegasDisplayMode.SCROLL # "scroll" - continuous scrolling
VegasDisplayMode.FIXED_SEGMENT # "fixed" - fixed block in scroll
VegasDisplayMode.STATIC # "static" - pause scroll to display
```
### BasePlugin Vegas Methods
| Method | Returns | Description |
|--------|---------|-------------|
| `get_vegas_content()` | `Image` or `List[Image]` or `None` | Content for Vegas scroll |
| `get_vegas_content_type()` | `str` | Legacy: 'multi', 'static', or 'none' |
| `get_vegas_display_mode()` | `VegasDisplayMode` | How plugin behaves in Vegas |
| `get_supported_vegas_modes()` | `List[VegasDisplayMode]` | Modes available for user config |
| `get_vegas_segment_width()` | `int` or `None` | Width in panels for FIXED_SEGMENT |
### Configuration Options
**Per-plugin config:**
```json
{
"plugin_id": {
"vegas_mode": "scroll|fixed|static",
"vegas_panel_count": 2,
"display_duration": 15
}
}
```
**Global Vegas config:**
```json
{
"display": {
"vegas_scroll": {
"enabled": true,
"scroll_speed": 50,
"separator_width": 32,
"plugin_order": ["clock", "weather", "sports"],
"excluded_plugins": ["debug_plugin"],
"target_fps": 125,
"buffer_ahead": 2
}
}
}
```
## Troubleshooting
### Plugin not appearing in Vegas scroll
1. Check `get_vegas_content_type()` doesn't return `'none'`
2. Verify plugin is not in `excluded_plugins` list
3. Ensure plugin is enabled
### Content looks wrong in scroll
1. Verify image height matches display height (32px typical)
2. Check image mode is 'RGB'
3. Test with `get_vegas_content()` returning a simple test image
### STATIC mode not pausing
1. Verify `get_vegas_display_mode()` returns `VegasDisplayMode.STATIC`
2. Check user hasn't overridden with `vegas_mode` in config
3. Ensure `display()` method works correctly
### Performance issues
1. Implement image caching in `get_vegas_content()`
2. Pre-render images in `update()` instead of on-demand
3. Reduce image dimensions if possible

298
docs/archive/WEATHER_TROUBLESHOOTING.md Normal file
View File

@@ -0,0 +1,298 @@
# Weather Plugin Troubleshooting Guide
## Quick Diagnosis
Run the troubleshooting script on your Pi:
```bash
./troubleshoot_weather.sh
```
This will check:
- Plugin installation
- Configuration files
- API key setup
- Network connectivity
- Cache status
## Common Issues
### 1. "No Weather Data" Message
This appears when the weather plugin cannot fetch or access weather data.
### 2. Missing or Invalid API Key
**Symptoms:**
- Plugin shows "No Weather Data"
- Logs show "No valid OpenWeatherMap API key configured"
- Plugin initialized but no data updates
**Solution:**
1. Get an API key from [OpenWeatherMap](https://openweathermap.org/api)
- Sign up for a free account
- Navigate to API Keys section
- Generate a new API key
2. Add API key to `config/config_secrets.json` (recommended):
```json
{
"ledmatrix-weather": {
"api_key": "your_actual_api_key_here"
}
}
```
OR add directly to `config/config.json`:
```json
{
"ledmatrix-weather": {
"enabled": true,
"api_key": "your_actual_api_key_here",
"location_city": "Dallas",
"location_state": "Texas",
"location_country": "US"
}
}
```
3. Restart the LEDMatrix service:
```bash
sudo systemctl restart ledmatrix
```
### 3. Plugin Not Enabled
**Symptoms:**
- Plugin doesn't appear in display rotation
- No weather data displayed
**Solution:**
Check `config/config.json` and ensure the plugin is enabled:
```json
{
"ledmatrix-weather": {
"enabled": true,
"display_duration": 30,
...
}
}
```
### 4. Network/API Connectivity Issues
**Symptoms:**
- Plugin shows "No Weather Data"
- Logs show connection errors or timeouts
**Solution:**
1. Check internet connectivity:
```bash
ping -c 4 api.openweathermap.org
```
2. Check firewall settings (if applicable)
3. Verify DNS resolution:
```bash
nslookup api.openweathermap.org
```
4. Test API directly:
```bash
curl "https://api.openweathermap.org/data/2.5/weather?q=Dallas,TX,US&appid=YOUR_API_KEY&units=imperial"
```
### 5. API Rate Limits Exceeded
**Symptoms:**
- Plugin worked before but now shows "No Weather Data"
- Logs show HTTP 429 errors
**Solution:**
OpenWeatherMap free tier limits:
- 1,000 API calls per day
- 60 calls per minute
Default plugin settings use ~48 calls/day (1800s = 30 min intervals).
If exceeded:
- Wait for quota reset (daily)
- Increase `update_interval` in config (minimum 300s = 5 minutes)
- Upgrade OpenWeatherMap plan
### 6. Invalid Location Configuration
**Symptoms:**
- Plugin shows "No Weather Data"
- Logs show geocoding errors
**Solution:**
Ensure location is correctly configured in `config/config.json`:
```json
{
"ledmatrix-weather": {
"location_city": "Dallas",
"location_state": "Texas",
"location_country": "US"
}
}
```
- Use proper city names
- Include state for US cities to avoid ambiguity
- Use ISO 3166-1 alpha-2 country codes (US, GB, CA, etc.)
### 7. Stale Cache Data
**Symptoms:**
- Weather data not updating
- Old data displayed
**Solution:**
Clear the cache:
```bash
# Find cache files
find cache/ -name "*weather*" -type f
# Remove cache files (plugin will fetch fresh data)
rm cache/*weather*
```
### 8. Plugin Not Loading
**Symptoms:**
- Weather modes don't appear in available modes
- Logs show plugin loading errors
**Solution:**
1. Check plugin directory exists:
```bash
ls -la plugins/ledmatrix-weather/
```
2. Verify manifest.json is valid:
```bash
python3 -m json.tool plugins/ledmatrix-weather/manifest.json
```
3. Check logs for specific errors:
```bash
sudo journalctl -u ledmatrix -f | grep -i weather
```
4. Verify plugin dependencies are installed:
```bash
pip3 install -r plugins/ledmatrix-weather/requirements.txt
```
## Checking Logs
View real-time logs:
```bash
sudo journalctl -u ledmatrix -f
```
Filter for weather-related messages:
```bash
sudo journalctl -u ledmatrix -f | grep -i weather
```
View last 100 lines:
```bash
sudo journalctl -u ledmatrix -n 100 | grep -i weather
```
## Configuration Example
Complete configuration in `config/config.json`:
```json
{
"ledmatrix-weather": {
"enabled": true,
"display_duration": 30,
"location_city": "Dallas",
"location_state": "Texas",
"location_country": "US",
"units": "imperial",
"update_interval": 1800,
"show_current_weather": true,
"show_hourly_forecast": true,
"show_daily_forecast": true,
"transition": {
"type": "redraw",
"speed": 2,
"enabled": true
}
}
}
```
And in `config/config_secrets.json`:
```json
{
"ledmatrix-weather": {
"api_key": "your_openweathermap_api_key_here"
}
}
```
## Plugin Configuration Schema
The plugin expects configuration under either:
- `ledmatrix-weather` (plugin ID from manifest)
- `weather` (legacy/deprecated)
The system checks both when loading configuration.
## Testing the Plugin
1. Enable the plugin in config
2. Restart the service: `sudo systemctl restart ledmatrix`
3. Check logs: `sudo journalctl -u ledmatrix -f`
4. Wait for update interval (default 30 minutes) or force update
5. Check if weather modes appear in display rotation
## Still Having Issues?
1. Run the troubleshooting script: `./troubleshoot_weather.sh`
2. Check service status: `sudo systemctl status ledmatrix`
3. Review logs for specific error messages
4. Verify all configuration files are valid JSON
5. Ensure file permissions are correct:
```bash
ls -la config/config.json config/config_secrets.json
```
## API Key Security
**Recommended:** Store API key in `config/config_secrets.json` with restricted permissions:
```bash
chmod 640 config/config_secrets.json
```
This file is not tracked by git (should be in .gitignore).
## Plugin ID Note
The weather plugin ID is `ledmatrix-weather` (from manifest.json). Configuration should use this ID, though the system also checks for `weather` for backward compatibility.

314
docs/archive/WEB_INTERFACE_TROUBLESHOOTING.md Normal file
View File

@@ -0,0 +1,314 @@
# Web Interface Troubleshooting Guide
## Quick Diagnosis Steps
Since the web interface doesn't seem to run and shows no logging after reorganization, follow these steps **on your Raspberry Pi** to diagnose the issue:
### 1. Check Service Status
```bash
# Check if the web service is running
sudo systemctl status ledmatrix-web
# Check if it's enabled to start on boot
sudo systemctl is-enabled ledmatrix-web
```
### 2. View Service Logs
The service logs to **syslog**, not stdout. Use these commands to view logs:
```bash
# View recent web interface logs
sudo journalctl -u ledmatrix-web -n 50 --no-pager
# Follow logs in real-time
sudo journalctl -u ledmatrix-web -f
# View logs since last boot
sudo journalctl -u ledmatrix-web -b
```
### 3. Check Configuration
```bash
# Check if web_display_autostart is enabled in config
cat ~/LEDMatrix/config/config.json | grep web_display_autostart
# Should show: "web_display_autostart": true
```
If it shows `false` or is missing, the web interface won't start (by design).
### 4. Test Manual Startup
Try starting the web interface manually to see error messages:
```bash
cd ~/LEDMatrix
python3 web_interface/start.py
```
This will show any import errors or startup issues directly in the terminal.
## Common Issues and Solutions
### Issue 1: Service Not Running
**Symptom:** `systemctl status ledmatrix-web` shows "inactive (dead)"
**Solutions:**
```bash
# Start the service
sudo systemctl start ledmatrix-web
# Enable it to start on boot
sudo systemctl enable ledmatrix-web
# Check status again
sudo systemctl status ledmatrix-web
```
### Issue 2: web_display_autostart is False
**Symptom:** Service starts but immediately exits gracefully
**Solution:**
```bash
# Edit config.json
nano ~/LEDMatrix/config/config.json
# Set web_display_autostart to true:
"web_display_autostart": true
# Restart the service
sudo systemctl restart ledmatrix-web
```
### Issue 3: Import Errors
**Symptom:** Service fails immediately with import errors in logs
**Possible causes:**
- Missing dependencies
- Python path issues
- Circular import problems
**Solutions:**
```bash
# Install/reinstall web dependencies
cd ~/LEDMatrix
pip3 install --break-system-packages -r web_interface/requirements.txt
# Check for Python errors
python3 -c "from web_interface.app import app; print('OK')"
```
### Issue 4: Port Already in Use
**Symptom:** Error message about port 5000 being in use
**Solution:**
```bash
# Check what's using port 5000
sudo lsof -i :5000
# Kill the process if needed
sudo kill -9 <PID>
# Or change the port in web_interface/start.py
```
### Issue 5: Permission Issues
**Symptom:** Permission denied errors in logs
**Solution:**
```bash
# Ensure proper ownership
cd ~/LEDMatrix
sudo chown -R ledpi:ledpi .
# Restart service
sudo systemctl restart ledmatrix-web
```
### Issue 6: Flask/Blueprint Import Errors
**Symptom:** ImportError or ModuleNotFoundError in logs
**Check these files exist:**
```bash
ls -la ~/LEDMatrix/web_interface/app.py
ls -la ~/LEDMatrix/web_interface/start.py
ls -la ~/LEDMatrix/web_interface/blueprints/api_v3.py
ls -la ~/LEDMatrix/web_interface/blueprints/pages_v3.py
```
If any are missing, you may need to restore from git or the reorganization.
## Detailed Logging Commands
### View All Web Service Logs
```bash
# Show all logs with timestamps
sudo journalctl -u ledmatrix-web --no-pager
# Show logs from the last hour
sudo journalctl -u ledmatrix-web --since "1 hour ago"
# Show logs between specific times
sudo journalctl -u ledmatrix-web --since "2024-10-14 10:00:00" --until "2024-10-14 11:00:00"
# Show only errors
sudo journalctl -u ledmatrix-web -p err
```
### Check Python Import Issues
```bash
cd ~/LEDMatrix
# Test imports step by step
python3 -c "import sys; sys.path.insert(0, '.'); from src.config_manager import ConfigManager; print('ConfigManager OK')"
python3 -c "import sys; sys.path.insert(0, '.'); from src.plugin_system.plugin_manager import PluginManager; print('PluginManager OK')"
python3 -c "import sys; sys.path.insert(0, '.'); from web_interface.app import app; print('Flask App OK')"
```
## Service File Check
Verify the service file is correct:
```bash
cat /etc/systemd/system/ledmatrix-web.service
```
Should contain:
```
[Unit]
Description=LED Matrix Web Interface Service
After=network.target
[Service]
Type=simple
User=root
WorkingDirectory=/home/ledpi/LEDMatrix
Environment=USE_THREADING=1
ExecStart=/usr/bin/python3 /home/ledpi/LEDMatrix/start_web_conditionally.py
Restart=on-failure
RestartSec=10
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=ledmatrix-web
[Install]
WantedBy=multi-user.target
```
If it's different or points to old paths, reinstall it:
```bash
cd ~/LEDMatrix
sudo bash install_web_service.sh
sudo systemctl daemon-reload
sudo systemctl restart ledmatrix-web
```
## Post-Reorganization Checklist
Verify the reorganization completed correctly:
```bash
cd ~/LEDMatrix
# These files should exist in new locations:
ls web_interface/app.py
ls web_interface/start.py
ls web_interface/requirements.txt
ls web_interface/blueprints/api_v3.py
ls web_interface/blueprints/pages_v3.py
# start_web_conditionally.py should point to new location
grep "web_interface/start.py" start_web_conditionally.py
```
## Emergency Recovery
If nothing works, you can rollback to the old structure:
```bash
cd ~/LEDMatrix
# Check git status
git status
# If changes aren't committed, revert
git checkout .
# Or restore specific files from old_web_interface
# (if that directory exists)
```
## Recommended Diagnostic Sequence
Run these commands in order to get a complete picture:
```bash
#!/bin/bash
echo "=== Web Interface Diagnostic Report ==="
echo ""
echo "1. Service Status:"
sudo systemctl status ledmatrix-web
echo ""
echo "2. Config Autostart Setting:"
cat ~/LEDMatrix/config/config.json | grep web_display_autostart
echo ""
echo "3. Recent Logs (last 20 lines):"
sudo journalctl -u ledmatrix-web -n 20 --no-pager
echo ""
echo "4. File Structure Check:"
ls -la ~/LEDMatrix/web_interface/
echo ""
echo "5. Python Import Test:"
cd ~/LEDMatrix
python3 -c "from web_interface.app import app; print('✓ Flask app imports successfully')" 2>&1
echo ""
echo "=== End of Diagnostic Report ==="
```
Save this as `diagnose_web.sh`, make it executable, and run it:
```bash
chmod +x diagnose_web.sh
./diagnose_web.sh
```
## Success Indicators
When the web interface is running correctly, you should see:
1. **Service Status:** "active (running)" in green
2. **Logs:** "Starting LED Matrix Web Interface V3..."
3. **Network:** Accessible at `http://<pi-ip>:5000`
4. **Process:** Python process listening on port 5000
```bash
# Check if it's listening
sudo netstat -tlnp | grep :5000
# or
sudo ss -tlnp | grep :5000
```
## Contact/Help
If you've tried all these steps and it still doesn't work, collect the following information:
1. Output from the diagnostic script above
2. Full service logs: `sudo journalctl -u ledmatrix-web -n 100 --no-pager`
3. Output from manual startup attempt
4. Git status and recent commits
This will help identify the exact issue.

405
docs/archive/WEB_UI_RELIABILITY_IMPROVEMENTS.md Normal file
View File

@@ -0,0 +1,405 @@
# Web UI Reliability Improvements - Implementation Summary
This document summarizes the comprehensive reliability and maintainability improvements implemented for the web UI's plugin and configuration management.
## Overview
The implementation follows a four-phase approach, building foundational reliability infrastructure first, then adding state management, frontend improvements, and finally testing/monitoring capabilities.
## Phase 1: Foundation & Reliability Layer ✅
### 1.1 Atomic Configuration Saves
**Files Created:**
- `src/config_manager_atomic.py` - Atomic config save manager with backup/rollback
- Enhanced `src/config_manager.py` - Added atomic save methods
**Features:**
- Atomic file writes (write to temp → validate → atomic move)
- Automatic backups before saves (keeps last 5 backups)
- Rollback functionality to restore from backups
- Post-write validation with automatic rollback on failure
- Handles both main config and secrets files atomically
**Usage:**
```python
from src.config_manager import ConfigManager
config_manager = ConfigManager()
# Atomic save with backup
result = config_manager.save_config_atomic(new_config, create_backup=True)
# Rollback to previous version
config_manager.rollback_config()
# List available backups
backups = config_manager.list_backups()
```
### 1.2 Plugin Operation Queue
**Files Created:**
- `src/plugin_system/operation_types.py` - Operation type definitions
- `src/plugin_system/operation_queue.py` - Operation queue manager
**Features:**
- Serializes plugin operations (install, update, uninstall, enable, disable)
- Prevents concurrent operations on same plugin
- Operation status/progress tracking
- Operation cancellation support
- Operation history persistence
**Usage:**
```python
from src.plugin_system.operation_queue import PluginOperationQueue
from src.plugin_system.operation_types import OperationType
queue = PluginOperationQueue()
# Enqueue operation
operation_id = queue.enqueue_operation(
OperationType.INSTALL,
"plugin-id",
operation_callback=lambda op: install_plugin(op.plugin_id)
)
# Check status
status = queue.get_operation_status(operation_id)
# Cancel operation
queue.cancel_operation(operation_id)
```
### 1.3 Structured Error Handling
**Files Created:**
- `src/web_interface/errors.py` - Error codes and structured error classes
- `src/web_interface/error_handler.py` - Centralized error handling
**Features:**
- Error codes and categories (ConfigError, PluginError, ValidationError, etc.)
- Consistent error response format
- Error context (operation, plugin_id, config_key, etc.)
- Suggested fixes in error responses
- Structured error logging
**Usage:**
```python
from src.web_interface.error_handler import handle_errors, create_error_response
from src.web_interface.errors import ErrorCode
@handle_errors()
def my_endpoint():
# Errors automatically converted to structured format
pass
# Manual error response
return create_error_response(
ErrorCode.PLUGIN_NOT_FOUND,
"Plugin not found",
context={"plugin_id": "test-plugin"}
)
```
### 1.4 Health Monitoring
**Files Created:**
- `src/plugin_system/health_monitor.py` - Enhanced health monitoring
**Features:**
- Background health checks
- Health status determination (healthy/degraded/unhealthy)
- Health metrics aggregation
- Auto-recovery suggestions based on health status
**Usage:**
```python
from src.plugin_system.health_monitor import PluginHealthMonitor
monitor = PluginHealthMonitor(health_tracker)
monitor.start_monitoring()
# Get health status
status = monitor.get_plugin_health_status("plugin-id")
# Get comprehensive metrics
metrics = monitor.get_plugin_health_metrics("plugin-id")
```
## Phase 2: State Management & Synchronization ✅
### 2.1 Centralized Plugin State Management
**Files Created:**
- `src/plugin_system/state_manager.py` - Centralized state manager
**Features:**
- Single source of truth for plugin state
- State change events/notifications
- State persistence to disk
- State versioning for corruption detection
**Usage:**
```python
from src.plugin_system.state_manager import PluginStateManager
state_manager = PluginStateManager(state_file="plugin_state.json")
# Update state
state_manager.update_plugin_state("plugin-id", {
"enabled": True,
"version": "1.0.0"
})
# Subscribe to changes
state_manager.subscribe_to_state_changes(
callback=lambda plugin_id, old_state, new_state: print(f"{plugin_id} changed")
)
```
### 2.2 State Reconciliation
**Files Created:**
- `src/plugin_system/state_reconciliation.py` - State reconciliation system
**Features:**
- Detects inconsistencies between config, manager, disk, and state manager
- Auto-fixes safe inconsistencies
- Flags dangerous inconsistencies for manual review
- Comprehensive reconciliation reports
**Usage:**
```python
from src.plugin_system.state_reconciliation import StateReconciliation
reconciler = StateReconciliation(
state_manager, config_manager, plugin_manager, plugins_dir
)
# Run reconciliation
result = reconciler.reconcile_state()
print(f"Found {len(result.inconsistencies_found)} inconsistencies")
print(f"Fixed {len(result.inconsistencies_fixed)} automatically")
```
### 2.3 API Response Standardization
**Files Created:**
- `src/web_interface/api_helpers.py` - Standardized API response helpers
**Features:**
- Consistent success/error response format
- Request validation helpers
- Response metadata (timing, version, etc.)
**Usage:**
```python
from src.web_interface.api_helpers import success_response, error_response, validate_request_json
# Success response
return success_response(
data={"plugins": [...]},
message="Plugins loaded successfully"
)
# Error response
return error_response(
ErrorCode.PLUGIN_NOT_FOUND,
"Plugin not found",
status_code=404
)
# Request validation
data, error = validate_request_json(['plugin_id'])
if error:
return error
```
## Phase 3: Frontend Refactoring & UX ✅
### 3.1 Modularized JavaScript
**Files Created:**
- `web_interface/static/v3/js/plugins/api_client.js` - API communication
- `web_interface/static/v3/js/plugins/store_manager.js` - Plugin store logic
- `web_interface/static/v3/js/plugins/config_manager.js` - Config form management
- `web_interface/static/v3/js/plugins/install_manager.js` - Install/update logic
- `web_interface/static/v3/js/plugins/state_manager.js` - Frontend state management
- `web_interface/static/v3/js/utils/error_handler.js` - Frontend error handling
**Structure:**
- Split 4400+ line file into logical modules
- ES6 module pattern with proper exports
- Clear module boundaries and responsibilities
- Shared utilities for common operations
**Usage:**
```javascript
// API calls
const plugins = await PluginAPI.getInstalledPlugins();
await PluginAPI.togglePlugin("plugin-id", true);
// Store management
const storePlugins = await PluginStoreManager.loadStore();
await PluginStoreManager.installPlugin("plugin-id");
// State management
await PluginStateManager.loadInstalledPlugins();
PluginStateManager.setPluginEnabled("plugin-id", true);
// Error handling
errorHandler.displayError(error, "Failed to install plugin");
```
### 3.2 Improved Error Messages
**Features:**
- User-friendly error formatting
- Contextual help and suggestions
- Copy error details functionality
- Links to troubleshooting docs
### 3.3 Configuration UI Enhancements
**Features:**
- Real-time validation feedback
- Config diff viewer (structure in place)
- Config export/import (structure in place)
- Config templates/presets (structure in place)
## Phase 4: Testing & Monitoring ✅
### 4.1 Testing Infrastructure
**Files Created:**
- `test/web_interface/test_config_manager_atomic.py` - Tests for atomic config saves
- `test/web_interface/test_plugin_operation_queue.py` - Tests for operation queue
- `test/web_interface/integration/` - Directory for integration tests
**Coverage:**
- Unit tests for atomic config saves
- Unit tests for operation queue
- Integration test structure
### 4.2 Structured Logging
**Files Created:**
- `src/web_interface/logging_config.py` - Structured logging configuration
**Features:**
- JSON-formatted structured logging
- Plugin operation logging with context
- Config change logging with before/after values
- Error context logging
**Usage:**
```python
from src.web_interface.logging_config import (
setup_structured_logging,
log_plugin_operation,
log_config_change
)
# Setup logging
setup_structured_logging(use_json=True)
# Log operations
log_plugin_operation(
logger,
"install",
"plugin-id",
"success",
context={"version": "1.0.0"}
)
# Log config changes
log_config_change(
logger,
"plugin-id",
"save",
before=old_config,
after=new_config
)
```
### 4.3 Operation History & Audit Log
**Files Created:**
- `src/plugin_system/operation_history.py` - Operation history tracker
**Features:**
- Tracks all plugin operations
- Tracks all config changes
- Persistent storage
- Filtering and querying
**Usage:**
```python
from src.plugin_system.operation_history import OperationHistory
history = OperationHistory(history_file="operation_history.json")
# Record operation
history.record_operation(
"install",
plugin_id="plugin-id",
status="success",
user="admin"
)
# Get history
records = history.get_history(
limit=50,
plugin_id="plugin-id"
)
```
## Integration Notes
### Backward Compatibility
All changes maintain backward compatibility:
- Existing API endpoints continue to work
- Old code can gradually migrate to new infrastructure
- Feature flags can be added for gradual rollout
### Migration Path
1. **Phase 1** infrastructure is ready to use but not yet integrated into all endpoints
2. **Phase 2** state management can be integrated incrementally
3. **Phase 3** frontend modules are available but original file still works
4. **Phase 4** testing and logging can be enabled gradually
### Next Steps
1. Integrate atomic config saves into existing save endpoints
2. Integrate operation queue into plugin install/update/uninstall endpoints
3. Use structured errors in all API endpoints
4. Integrate state manager with plugin manager
5. Migrate frontend code to use new modules
6. Add integration tests for critical flows
7. Enable structured logging in production
## Benefits
1. **Reliability**: Atomic saves prevent config corruption, operation queue prevents conflicts
2. **Debuggability**: Structured errors and logging provide clear context
3. **Maintainability**: Modular code is easier to understand and modify
4. **Consistency**: Standardized APIs and error handling
5. **Observability**: Health monitoring and operation history provide visibility
## Testing
Run tests with:
```bash
python -m pytest test/web_interface/
```
## Documentation
- See individual module docstrings for detailed API documentation
- Error codes are documented in `src/web_interface/errors.py`
- Operation types are documented in `src/plugin_system/operation_types.py`

194
docs/archive/WIFI_ETHERNET_AP_MODE_FIX.md Normal file
View File

@@ -0,0 +1,194 @@
# WiFi Monitor Ethernet Check Fix
## Problem
The WiFi monitor service was enabling Access Point (AP) mode whenever WiFi was disconnected, even when the Raspberry Pi was connected via Ethernet. This caused:
- AP mode to activate unnecessarily when Ethernet was available
- Potential network conflicts
- Confusion for users with hardwired connections
## Solution
Updated the WiFi manager to check for Ethernet connectivity before enabling AP mode. AP mode will now only be enabled when:
- **WiFi is NOT connected** AND
- **Ethernet is NOT connected**
## Changes Made
### 1. Added Ethernet Detection Method
Added `_is_ethernet_connected()` method to `src/wifi_manager.py` that:
- Checks for active Ethernet interfaces (eth0, enp*, etc.)
- Verifies the interface has an IP address
- Uses `nmcli` if available, falls back to `ip` command
- Returns `True` if Ethernet is connected and has an IP
### 2. Updated AP Mode Enable Logic
Modified `enable_ap_mode()` to:
- Check for Ethernet connection before enabling AP mode
- Return an error message if Ethernet is connected: "Cannot enable AP mode while Ethernet is connected"
### 3. Updated AP Mode Management Logic
Modified `check_and_manage_ap_mode()` to:
- Check both WiFi and Ethernet status
- Only enable AP mode if both are disconnected
- Disable AP mode if either WiFi or Ethernet connects
- Log appropriate messages for each scenario
### 4. Enhanced Logging
Updated `wifi_monitor_daemon.py` to:
- Log Ethernet connection status
- Include Ethernet status in state change detection
- Log when AP mode is disabled due to Ethernet connection
## Testing
### Verify Ethernet Detection
```bash
# Check if Ethernet is detected
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
print('Ethernet connected:', wm._is_ethernet_connected())
"
```
### Test AP Mode Behavior
1. **With Ethernet connected**:
```bash
# AP mode should NOT enable
sudo systemctl restart ledmatrix-wifi-monitor
sudo journalctl -u ledmatrix-wifi-monitor -f
# Should see: "Cannot enable AP mode while Ethernet is connected"
```
2. **With Ethernet disconnected and WiFi disconnected**:
```bash
# Disconnect Ethernet cable
# AP mode SHOULD enable
sudo journalctl -u ledmatrix-wifi-monitor -f
# Should see: "Auto-enabled AP mode (no WiFi or Ethernet connection)"
```
3. **With Ethernet connected and WiFi connects**:
```bash
# Connect WiFi
# AP mode should disable if it was active
sudo journalctl -u ledmatrix-wifi-monitor -f
# Should see: "Auto-disabled AP mode (WiFi connected)"
```
4. **With Ethernet connects while AP is active**:
```bash
# Connect Ethernet cable while AP mode is active
# AP mode should disable
sudo journalctl -u ledmatrix-wifi-monitor -f
# Should see: "Auto-disabled AP mode (Ethernet connected)"
```
## Deployment
### On Existing Installations
1. **Restart the WiFi monitor service**:
```bash
sudo systemctl restart ledmatrix-wifi-monitor
```
2. **If AP mode is currently active and Ethernet is connected**, it will automatically disable:
```bash
# Check current status
sudo systemctl status hostapd
# The service should automatically disable AP mode within 30 seconds
# Or manually disable:
sudo systemctl stop hostapd dnsmasq
```
3. **Verify the fix**:
```bash
# Check logs
sudo journalctl -u ledmatrix-wifi-monitor -n 20
# Should see messages about Ethernet connection status
```
### On New Installations
The fix is included automatically - no additional steps needed.
## Behavior Summary
| WiFi Status | Ethernet Status | AP Mode | Reason |
|------------|----------------|---------|--------|
| Connected | Connected | ❌ Disabled | Both connections available |
| Connected | Disconnected | ❌ Disabled | WiFi available |
| Disconnected | Connected | ❌ Disabled | Ethernet available |
| Disconnected | Disconnected | ✅ Enabled | No network connection |
## Troubleshooting
### AP Mode Still Enables with Ethernet Connected
1. **Check Ethernet detection**:
```bash
python3 -c "
from src.wifi_manager import WiFiManager
wm = WiFiManager()
print('Ethernet connected:', wm._is_ethernet_connected())
"
```
2. **Check network interface status**:
```bash
nmcli device status
# OR
ip addr show
```
3. **Verify Ethernet has IP address**:
```bash
ip addr show eth0
# Should show an "inet" address (not just 127.0.0.1)
```
### Ethernet Not Detected
If Ethernet is connected but not detected:
1. **Check interface name**:
```bash
ip link show
# Look for Ethernet interfaces (may be eth0, enp*, etc.)
```
2. **Check NetworkManager status**:
```bash
sudo systemctl status NetworkManager
```
3. **Manually check interface**:
```bash
nmcli device status | grep ethernet
```
## Related Files
- `src/wifi_manager.py` - Main WiFi management logic
- `scripts/utils/wifi_monitor_daemon.py` - Background daemon that monitors WiFi/Ethernet
- `scripts/install/install_wifi_monitor.sh` - Installation script for WiFi monitor service
## Notes
- The Ethernet check uses `nmcli` if available (preferred), otherwise falls back to `ip` command
- The check verifies that the interface has an actual IP address (not just link up)
- AP mode will automatically disable within 30 seconds (check interval) when Ethernet connects
- Manual AP mode enable via web interface will also respect Ethernet connection status

368
docs/archive/WIFI_SETUP.md Normal file
View File

@@ -0,0 +1,368 @@
# WiFi Setup Feature
The LED Matrix project includes a WiFi setup feature that allows you to configure WiFi connections through a web interface. When the Raspberry Pi is not connected to WiFi, it automatically broadcasts an access point (AP) that you can connect to for initial setup.
## Features
- **Automatic AP Mode**: When no WiFi connection is detected, the Raspberry Pi automatically creates a WiFi access point named "LEDMatrix-Setup"
- **Web Interface**: Access the WiFi setup interface through your web browser
- **Network Scanning**: Scan for available WiFi networks from the web interface
- **Secure Connection**: Save WiFi credentials securely
- **Automatic Management**: The WiFi monitor daemon automatically enables/disables AP mode based on connection status
## Requirements
The following packages are required for WiFi setup functionality:
- **hostapd**: Access point software
- **dnsmasq**: DHCP server for AP mode
- **NetworkManager** (or **iwlist**): WiFi management tools
These packages are automatically checked and can be installed during the WiFi monitor service installation.
## Installation
### 1. Install WiFi Monitor Service
Run the installation script to set up the WiFi monitor daemon:
```bash
cd /home/ledpi/LEDMatrix
sudo ./scripts/install/install_wifi_monitor.sh
```
This script will:
- Check for required packages and offer to install them
- Create the systemd service file
- Enable and start the WiFi monitor service
- Configure the service to start on boot
### 2. Verify Service Status
Check that the WiFi monitor service is running:
```bash
sudo systemctl status ledmatrix-wifi-monitor
```
You should see output indicating the service is active and running.
## Usage
### Accessing the WiFi Setup Interface
1. **If WiFi is NOT connected**: The Raspberry Pi will automatically create an access point (after a 90-second grace period)
- Connect to the WiFi network: **LEDMatrix-Setup** (open network, no password required)
- Open a web browser and navigate to: `http://192.168.4.1:5000` or `http://192.168.4.1` (captive portal may redirect)
- Or use the IP address shown in the web interface
2. **If WiFi IS connected**: Access the web interface normally
- Navigate to: `http://<raspberry-pi-ip>:5000`
- Click on the **WiFi** tab in the navigation
### Connecting to a WiFi Network
1. Navigate to the **WiFi** tab in the web interface
2. Click **Scan** to search for available networks
3. Select a network from the dropdown menu, or enter the SSID manually
4. Enter the WiFi password (leave empty for open networks)
5. Click **Connect**
6. The system will attempt to connect to the selected network
7. Once connected, AP mode will automatically disable
### Manual AP Mode Control
You can manually enable or disable AP mode from the web interface:
- **Enable AP Mode**: Click "Enable AP Mode" button (only available when WiFi is not connected)
- **Disable AP Mode**: Click "Disable AP Mode" button (only available when AP mode is active)
## How It Works
### WiFi Monitor Daemon
The WiFi monitor daemon (`wifi_monitor_daemon.py`) runs as a background service that:
1. Checks WiFi connection status every 30 seconds (configurable)
2. Automatically enables AP mode only if:
- `auto_enable_ap_mode` is enabled in config AND
- No WiFi connection is detected AND
- No Ethernet connection is detected
3. Automatically disables AP mode when WiFi or Ethernet connection is established
4. Logs all state changes for troubleshooting
**Note**: By default, `auto_enable_ap_mode` is `true`, meaning AP mode will automatically activate when both WiFi and Ethernet are disconnected. However, there's a 90-second grace period (3 consecutive checks at 30-second intervals) to prevent AP mode from enabling on transient network hiccups. This ensures you can always configure the device even when it has no network connection.
### WiFi Manager Module
The WiFi manager (`src/wifi_manager.py`) provides:
- **Connection Status**: Checks current WiFi connection state
- **Network Scanning**: Scans for available WiFi networks
- **Connection Management**: Connects to WiFi networks and saves credentials
- **AP Mode Control**: Manages access point mode (hostapd/dnsmasq)
### Configuration
WiFi settings are stored in `config/wifi_config.json`:
```json
{
"ap_ssid": "LEDMatrix-Setup",
"ap_password": "ledmatrix123",
"ap_channel": 7,
"auto_enable_ap_mode": true,
"saved_networks": [
{
"ssid": "MyNetwork",
"password": "mypassword",
"saved_at": 1234567890.0
}
]
}
```
**Configuration Options:**
- `ap_ssid`: SSID for the access point (default: "LEDMatrix-Setup")
- `ap_channel`: WiFi channel for AP mode (default: 7)
- `auto_enable_ap_mode`: Automatically enable AP mode when WiFi/Ethernet disconnect (default: `true`)
- When `true`: AP mode automatically enables after a 90-second grace period when both WiFi and Ethernet are disconnected
- When `false`: AP mode must be manually enabled through the web interface
- `saved_networks`: List of saved WiFi network credentials
**Note**: The access point is configured as an open network (no password required) for ease of initial setup. This allows any device to connect without credentials.
### Access Point Configuration
The AP mode uses `hostapd` and `dnsmasq` for access point functionality:
- **SSID**: LEDMatrix-Setup (configurable)
- **IP Range**: 192.168.4.2 - 192.168.4.20
- **Gateway**: 192.168.4.1
- **Channel**: 7 (configurable)
## Verification
### Running the WiFi Verification Script
Use the comprehensive verification script to check your WiFi setup:
```bash
cd /home/ledpi/LEDMatrix
./scripts/verify_wifi_setup.sh
```
This script checks:
- Required packages are installed
- WiFi monitor service is running
- Configuration files are valid
- WiFi permissions are configured
- WiFi interface is available
- WiFi radio status
- Current connection status
- AP mode status
- WiFi Manager module availability
- Web interface API accessibility
The script provides a summary with passed/warning/failed checks to help diagnose issues.
## Troubleshooting
### WiFi Monitor Service Not Starting
Check the service logs:
```bash
sudo journalctl -u ledmatrix-wifi-monitor -n 50
```
Common issues:
- Missing packages (hostapd, dnsmasq)
- Permission issues
- Network interface not available
### Cannot Access AP Mode
1. Check if AP mode is active:
```bash
sudo systemctl status hostapd
```
2. Check if dnsmasq is running:
```bash
sudo systemctl status dnsmasq
```
3. Verify WiFi interface exists:
```bash
ip link show wlan0
```
### Cannot Connect to WiFi Network
1. Verify the SSID and password are correct
2. Check if the network requires a password (some networks may appear open but require a password)
3. Check WiFi monitor logs for connection errors:
```bash
sudo journalctl -u ledmatrix-wifi-monitor -f
```
4. Check NetworkManager logs:
```bash
sudo journalctl -u NetworkManager -n 50
```
### AP Mode Not Disabling
If AP mode doesn't disable after connecting to WiFi:
1. Check WiFi connection status:
```bash
nmcli device status
```
2. Manually disable AP mode from the web interface
3. Restart the WiFi monitor service:
```bash
sudo systemctl restart ledmatrix-wifi-monitor
```
## Service Management
### Useful Commands
```bash
# Check service status
sudo systemctl status ledmatrix-wifi-monitor
# Start the service
sudo systemctl start ledmatrix-wifi-monitor
# Stop the service
sudo systemctl stop ledmatrix-wifi-monitor
# Restart the service
sudo systemctl restart ledmatrix-wifi-monitor
# View logs
sudo journalctl -u ledmatrix-wifi-monitor -f
# Disable service from starting on boot
sudo systemctl disable ledmatrix-wifi-monitor
# Enable service to start on boot
sudo systemctl enable ledmatrix-wifi-monitor
```
### Configuration Options
You can modify the check interval by editing the service file:
```bash
sudo systemctl edit ledmatrix-wifi-monitor
```
Or modify the service file directly:
```bash
sudo nano /etc/systemd/system/ledmatrix-wifi-monitor.service
```
Change the `--interval` parameter in the `ExecStart` line (default is 30 seconds).
After modifying, reload and restart:
```bash
sudo systemctl daemon-reload
sudo systemctl restart ledmatrix-wifi-monitor
```
## Security Considerations
- **Open AP Network**: The access point is configured as an open network (no password) for ease of initial setup. This allows any device within range to connect to the setup network. Consider your deployment environment when using this feature.
- **WiFi Credentials**: Saved WiFi credentials are stored in `config/wifi_config.json`. Ensure proper file permissions:
```bash
sudo chmod 600 config/wifi_config.json
```
- **Network Access**: When in AP mode, anyone within range can connect to the setup network. This is by design to allow easy initial configuration. For production deployments in secure environments, consider using the web interface when connected to WiFi instead.
## API Endpoints
The WiFi setup feature exposes the following API endpoints:
- `GET /api/v3/wifi/status` - Get current WiFi connection status
- `GET /api/v3/wifi/scan` - Scan for available WiFi networks
- `POST /api/v3/wifi/connect` - Connect to a WiFi network
- `POST /api/v3/wifi/ap/enable` - Enable access point mode
- `POST /api/v3/wifi/ap/disable` - Disable access point mode
## Technical Details
### WiFi Detection Methods
The WiFi manager tries multiple methods to detect WiFi status:
1. **NetworkManager (nmcli)** - Preferred method if available
2. **iwconfig** - Fallback method for systems without NetworkManager
### Network Scanning
The system supports multiple scanning methods:
1. **nmcli** - Fast, preferred method
2. **iwlist** - Fallback method for older systems
### Access Point Setup
AP mode configuration:
- Uses `hostapd` (preferred) or `nmcli hotspot` (fallback) for WiFi access point functionality
- Uses `dnsmasq` for DHCP and DNS services (hostapd mode only)
- Configures wlan0 interface in AP mode
- Provides DHCP range: 192.168.4.2-20
- Gateway IP: 192.168.4.1
- **Open network**: No password required (configures as open network for easy setup)
- Captive portal: DNS redirection for automatic browser redirects (hostapd mode only)
## Development
### Testing WiFi Manager
You can test the WiFi manager directly:
```python
from src.wifi_manager import WiFiManager
# Create WiFi manager instance
wifi_manager = WiFiManager()
# Get status
status = wifi_manager.get_wifi_status()
print(f"Connected: {status.connected}, SSID: {status.ssid}")
# Scan networks
networks = wifi_manager.scan_networks()
for net in networks:
print(f"{net.ssid}: {net.signal}% ({net.security})")
# Connect to network
success, message = wifi_manager.connect_to_network("MyNetwork", "password")
print(f"Connection: {success}, Message: {message}")
```
### Running Monitor Daemon Manually
For testing, you can run the daemon in foreground mode:
```bash
sudo python3 wifi_monitor_daemon.py --interval 10 --foreground
```
## Support
For issues or questions:
1. Check the logs: `sudo journalctl -u ledmatrix-wifi-monitor -f`
2. Review this documentation
3. Check the main project README for general troubleshooting
4. Open an issue on GitHub if needed