Add log cleanup function (15-day deletion) and archive documentation

- Added cleanup_old_logs() function to app_v3_simplified.py
- Deletes log.txt if older than 15 days at app startup
- Sends notification to monitoring server when cleanup occurs
- Archived all legacy modules and documentation to oldcode/
- Updated device_info.txt with correct IP (192.168.1.104)
- All changes validated and tested
This commit is contained in:
RPI User
2025-12-18 17:18:14 +02:00
parent eedf3a1c69
commit c3a55a89c3
39 changed files with 2666 additions and 66 deletions

View File

@@ -0,0 +1,477 @@
# Testing & Verification Checklist
## Phase 1: Pre-Deployment Checks
### Code Quality
- [x] Single file (app_v3_simplified.py) - 300 lines
- [x] Clear function separation
- [x] Proper error handling
- [x] Logging at all critical points
- [x] Meaningful variable names
### Dependencies Check
```bash
# Verify required packages installed
python3 -c "import rdm6300; print('✓ rdm6300')"
python3 -c "import requests; print('✓ requests')"
python3 -c "from gpiozero import OutputDevice; print('✓ gpiozero')" 2>/dev/null || echo "⚠ gpiozero not installed (optional, LED won't work)"
```
### Hardware Prerequisites
```bash
# Check serial devices
ls /dev/tty*
# Should show at least: /dev/ttyS0 or /dev/ttyAMA0 or /dev/ttyUSB0
# Check GPIO available
gpio readall 2>/dev/null | head -5
# If not available, app will use dummy LED (still works)
# Check permissions
groups | grep dialout
# Should include 'dialout' group
# If not: sudo usermod -a -G dialout $USER (then logout/login)
```
---
## Phase 2: Startup Test
### Step 1: Set Device Name
```bash
# Edit device ID
nano ./data/idmasa.txt
# Change 'noconfig' to actual device name, e.g.:
# mesa_1
# Save and exit
```
### Step 2: Start Application
```bash
cd /home/pi/Desktop/prezenta_work
# Make executable
chmod +x app_v3_simplified.py
# Run it
python3 app_v3_simplified.py
```
### Expected Output
```
============================================================
RFID CARD READER - Simplified v3.0
============================================================
✓ Logging configured: ./data/log.txt
✓ LED initialized on GPIO 23
Device: raspberry (192.168.1.50)
Name ID: mesa_1
Monitoring: http://rpi-ansible:80/logs
API: https://dataswsibiusb01.sibiusb.harting.intra/RO_Quality_PRD/api/record
✓ RFID reader started on /dev/ttyS0
✓ WiFi monitor started
✓ RFID Client operational - waiting for cards...
```
### Verification
- [ ] No error messages
- [ ] All ✓ marks present
- [ ] Device IP correct
- [ ] Device name correct (from idmasa.txt)
- [ ] WiFi monitor started
---
## Phase 3: Card Detection Test
### Test 1: Insert Regular Card
```
Expected Behavior:
1. LED turns ON immediately
2. Console shows: "🔴 CARD INSERTED - ID: [card_number]"
3. Next line: "✓ Card event posted to API: [card_number]"
4. Check log.txt shows: "INFO - 🔴 CARD INSERTED"
```
### Test 2: Remove Card
```
Expected Behavior:
1. LED turns OFF immediately
2. Console shows: "⚪ CARD REMOVED - ID: [card_number]"
3. Next line: "✓ Card event posted to API: [card_number]"
4. Check log.txt shows: "INFO - ⚪ CARD REMOVED"
```
### Test 3: Multiple Rapid Cards
```
Insert 3 cards rapidly, remove them.
Expected:
- Each insert → LED ON, "🔴 CARD INSERTED"
- Each remove → LED OFF, "⚪ CARD REMOVED"
- All POSTs successful
- No crashes or hangs
```
### Verification Checklist
- [ ] LED feedback immediate (no 5-second delay)
- [ ] Console output shows card events
- [ ] log.txt records all events with timestamps
- [ ] No error messages
- [ ] API POSTs show success (✓)
---
## Phase 4: Offline Mode Test
### Setup
```bash
# Stop WiFi to simulate offline
sudo rfkill block wifi
# Wait for connection loss
sleep 10
```
### Test 1: Insert Card While Offline
```
Expected:
1. LED turns ON
2. Console: "🔴 CARD INSERTED - ID: [number]"
3. Console: "✗ Offline: Saving card [number] to backup"
4. Check tag.txt: Should contain the API URL
5. Check log.txt: Shows "WARNING - ✗ Offline: Saving card"
```
### Test 2: Remove Card While Offline
```
Expected:
1. LED turns OFF
2. Console: "⚪ CARD REMOVED - ID: [number]"
3. Console: "✗ Offline: Saving card [number] to backup"
4. Check tag.txt: Should have 2 lines now (insert + remove)
```
### Test 3: Restore WiFi
```bash
# Re-enable WiFi
sudo rfkill unblock wifi
# Wait for reconnection
sleep 10
```
### Expected After WiFi Restored
```
Console should show:
✓ Connection OK - checking for backed-up data
INFO - Posted backed-up data: https://....../[card_id]/1/...
INFO - Posted backed-up data: https://....../[card_id]/0/...
Check tag.txt: Should be EMPTY now
```
### Verification Checklist
- [ ] tag.txt created with card URLs when offline
- [ ] Console shows "✗ Offline: Saving" messages
- [ ] After WiFi restored, shows "Posted backed-up data"
- [ ] tag.txt cleared after posting
- [ ] log.txt records all events
---
## Phase 5: WiFi Recovery Test
### Monitor WiFi Checks
```bash
# Terminal 1: Watch logs
tail -f ./data/log.txt | grep -E "(Connection|WiFi|offline)"
```
### Test WiFi Loss & Recovery
```bash
# Terminal 2: Wait for next WiFi check (happens every 40 min)
# Or force a check by restarting the app
# Simulate connection loss
sudo rfkill block wifi
# Monitor terminal 1
# Should see: "Connection lost - disabling WiFi for recovery"
# Wait 20 minutes
# Should see: "WiFi re-enabled"
# Re-enable WiFi
sudo rfkill unblock wifi
```
### Expected Log Output
```
INFO - ✓ Connection OK - checking for backed-up data
WARNING - ✗ Connection lost - disabling WiFi for recovery
INFO - WiFi disabled, waiting 1200s for recovery...
INFO - WiFi re-enabled
INFO - ✓ Connection OK - checking for backed-up data
```
### Verification Checklist
- [ ] WiFi check happens every 40 minutes
- [ ] WiFi recovery initiates on connection loss
- [ ] WiFi disabled for 20 minutes
- [ ] WiFi re-enabled automatically
- [ ] Monitoring server receives WiFi event logs
- [ ] backed-up data posted after WiFi restored
---
## Phase 6: Server Communication Test
### Monitoring Server Check
```bash
# On monitoring server (rpi-ansible):
# Check if logs are being received
tail -f /path/to/monitoring/app/logs
# Should show entries like:
# hostname: raspberry
# device_ip: 192.168.1.50
# nume_masa: mesa_1
# log_message: Card 12345678 inserted
```
### Harting API Check
```bash
# Test with curl
curl -X POST "https://dataswsibiusb01.sibiusb.harting.intra/RO_Quality_PRD/api/record/mesa_1/12345678/1/2025-12-18&14:23:45" \
--insecure \
-v
```
### Verification Checklist
- [ ] Monitoring server receives card event logs
- [ ] Harting API logs card insertions/removals
- [ ] All events timestamped correctly
- [ ] Device name matches idmasa.txt
---
## Phase 7: Error Handling Test
### Test 1: Serial Port Error
```bash
# Disconnect RFID reader (physically)
# Or block the device:
sudo chmod 000 /dev/ttyS0
```
### Expected
```
✗ RFID reader failed - application cannot continue
ERROR: RFID reader initialization failed - exiting
```
### Fix
```bash
# Restore permissions
sudo chmod 644 /dev/ttyS0
# Restart app
python3 app_v3_simplified.py
```
### Test 2: Network Error (Firewall)
```bash
# Block outbound HTTPS
sudo ufw deny out 443 # (if ufw enabled)
# Insert card
# Expected: "✗ Offline: Saving card to backup"
```
### Test 3: Server Down
```bash
# Stop monitoring server
# Insert card
# Expected: "WARNING - Failed to send log to server"
# But card still posts to Harting API and LED works
```
### Verification Checklist
- [ ] App handles serial port errors gracefully
- [ ] App handles network timeouts
- [ ] App falls back to backup when server down
- [ ] No crashes, proper error messages
- [ ] Recovery when service restored
---
## Phase 8: Performance Checks
### Memory Usage
```bash
# In another terminal while app is running:
ps aux | grep app_v3_simplified
# Check RSS column (resident memory)
# Should be ~30-50 MB, not 80+ MB
```
### CPU Usage
```bash
# Should be <1% idle, <5% when processing cards
top
```
### Response Time
```bash
# Insert card, measure time to LED response
# Should be <100ms (instant visual feedback)
# Should post within <1 second
```
### Verification Checklist
- [ ] Memory usage <50 MB
- [ ] CPU usage <5% during operation
- [ ] LED feedback <100ms
- [ ] API post <1 second
- [ ] Startup time <2 seconds
---
## Phase 9: Stability Test
### 24-Hour Test
```bash
# Run overnight
python3 app_v3_simplified.py > app.log 2>&1 &
# Next day check:
wc -l ./data/log.txt # Should grow steadily
ps aux | grep app_v3 # Still running?
free -m # Memory stable?
```
### Expected
- [ ] App still running
- [ ] No zombie processes
- [ ] Memory stable (not growing)
- [ ] WiFi monitor checks happened
- [ ] Any card events logged properly
### 7-Day Test
- [ ] No crashes
- [ ] WiFi recovery worked multiple times
- [ ] Monitored card events working
- [ ] System still responsive
---
## Phase 10: Production Readiness
### Final Checklist
- [ ] All tests passed
- [ ] Old app.py backed up
- [ ] New app.py ready for production
- [ ] idmasa.txt configured correctly
- [ ] Monitoring server receiving logs
- [ ] Harting API receiving card events
- [ ] WiFi recovery tested
- [ ] Offline backup working
- [ ] LED feedback working
- [ ] Documentation updated
### Deployment Steps
```bash
# 1. Stop old app (if running)
# 2. Start new app
python3 app_v3_simplified.py
# 3. (Optional) Create systemd service for auto-start
sudo nano /etc/systemd/system/rfid-reader.service
# Content:
[Unit]
Description=RFID Card Reader
After=network.target
[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/Desktop/prezenta_work
ExecStart=/usr/bin/python3 /home/pi/Desktop/prezenta_work/app_v3_simplified.py
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.target
# Then:
sudo systemctl enable rfid-reader
sudo systemctl start rfid-reader
sudo systemctl status rfid-reader
```
---
## Troubleshooting During Tests
### App crashes immediately
```bash
# Check logs
tail -50 ./data/log.txt
# Common issues:
# 1. rdm6300 not installed: pip3 install rdm6300
# 2. Serial device not found: ls /dev/tty*
# 3. Permission denied: sudo usermod -a -G dialout $USER
```
### Card inserted but no LED/log
```bash
# 1. Check RFID reader connected: cat /dev/ttyS0 (present card, should see data)
# 2. Check LED wired to GPIO 23
# 3. Check device permissions: ls -la /dev/ttyS0
# 4. Restart app
```
### Server not receiving logs
```bash
# 1. Check network: ping 10.76.140.17
# 2. Check server running: ps aux | grep monitoring
# 3. Check firewall: sudo ufw status
# 4. Check log for errors: grep ERROR ./data/log.txt
```
### WiFi recovery not working
```bash
# 1. Check WiFi can be blocked: sudo rfkill block wifi
# 2. Check it was unblocked: sudo rfkill unblock wifi
# 3. Check sudo permissions: sudo -l | grep rfkill
# 4. Test manual: sudo rfkill block wifi && sleep 5 && sudo rfkill unblock wifi
```
---
## Sign-Off
Once all tests pass, app is ready for production:
```
Date Tested: _________________
Tester: _____________________
Status: [ ] PASS [ ] FAIL
Notes: _______________________
```
---
**Need Help?** Check:
1. Console output for immediate errors
2. `./data/log.txt` for detailed logs
3. `./data/tag.txt` for offline backup status
4. Monitoring server logs for received events