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

oldcode/wifi_recovery_module.py

@@ -0,0 +1,270 @@
+"""
+WiFi recovery module for handling server disconnection
+Monitors server connectivity and auto-restarts WiFi if connection is lost
+"""
+
+import subprocess
+import time
+import threading
+import logging
+from datetime import datetime
+from logger_module import log_with_server
+
+
+class WiFiRecoveryManager:
+    """
+    Manages WiFi recovery when server connection is lost
+    Restarts WiFi after 20 minutes of consecutive connection failures
+    """
+    
+    def __init__(self, hostname, device_ip, check_interval=60, failure_threshold=5):
+        """
+        Initialize WiFi recovery manager
+        
+        Args:
+            hostname: Device hostname
+            device_ip: Device IP
+            check_interval: Seconds between connectivity checks
+            failure_threshold: Number of consecutive failures before WiFi restart
+        """
+        self.hostname = hostname
+        self.device_ip = device_ip
+        self.check_interval = check_interval
+        self.failure_threshold = failure_threshold
+        self.consecutive_failures = 0
+        self.is_wifi_down = False
+        self.monitor_thread = None
+        self.is_running = False
+        self.wifi_down_time = 1200  # 20 minutes in seconds
+        
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+    
+    
+    def get_wifi_interface(self):
+        """Detect WiFi interface (wlan0 or wlan1)"""
+        try:
+            result = subprocess.run(
+                ['ip', 'link', 'show'],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            if 'wlan0' in result.stdout:
+                return 'wlan0'
+            elif 'wlan1' in result.stdout:
+                return 'wlan1'
+            else:
+                self.logger.error("No WiFi interface found")
+                return None
+                
+        except Exception as e:
+            self.logger.error(f"Error detecting WiFi interface: {e}")
+            return None
+    
+    
+    def stop_wifi(self, interface):
+        """Stop WiFi interface"""
+        try:
+            self.logger.info(f"Stopping WiFi interface: {interface}")
+            log_with_server(f"Stopping WiFi interface {interface}", self.hostname, self.device_ip)
+            
+            subprocess.run(
+                ['sudo', 'ip', 'link', 'set', interface, 'down'],
+                check=True,
+                timeout=10
+            )
+            self.is_wifi_down = True
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to stop WiFi: {e}")
+            log_with_server(f"ERROR: Failed to stop WiFi: {str(e)}", self.hostname, self.device_ip)
+            return False
+    
+    
+    def start_wifi(self, interface):
+        """Start WiFi interface"""
+        try:
+            self.logger.info(f"Starting WiFi interface: {interface}")
+            log_with_server(f"Starting WiFi interface {interface}", self.hostname, self.device_ip)
+            
+            subprocess.run(
+                ['sudo', 'ip', 'link', 'set', interface, 'up'],
+                check=True,
+                timeout=10
+            )
+            self.is_wifi_down = False
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start WiFi: {e}")
+            log_with_server(f"ERROR: Failed to start WiFi: {str(e)}", self.hostname, self.device_ip)
+            return False
+    
+    
+    def reconnect_wifi(self, interface, wifi_down_time=1200):
+        """
+        Perform WiFi disconnect and reconnect cycle
+        
+        Args:
+            interface: WiFi interface to reset
+            wifi_down_time: Time to keep WiFi disabled (seconds)
+        """
+        self.logger.info(f"WiFi recovery: Stopping for {wifi_down_time} seconds...")
+        log_with_server(
+            f"WiFi recovery initiated: WiFi down for {wifi_down_time} seconds",
+            self.hostname,
+            self.device_ip
+        )
+        
+        # Stop WiFi
+        if not self.stop_wifi(interface):
+            return False
+        
+        # Keep WiFi down for specified time
+        wait_time = wifi_down_time
+        while wait_time > 0:
+            minutes = wait_time // 60
+            seconds = wait_time % 60
+            self.logger.info(f"WiFi will restart in {minutes}m {seconds}s")
+            
+            time.sleep(60)  # Check every minute
+            wait_time -= 60
+        
+        # Restart WiFi
+        if not self.start_wifi(interface):
+            return False
+        
+        self.logger.info("WiFi has been restarted")
+        log_with_server("WiFi successfully restarted", self.hostname, self.device_ip)
+        
+        # Reset failure counter
+        self.consecutive_failures = 0
+        return True
+    
+    
+    def check_server_connection(self, server_host):
+        """
+        Check if server is reachable via ping
+        
+        Args:
+            server_host: Server hostname or IP to ping
+            
+        Returns:
+            bool: True if server is reachable, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                ['ping', '-c', '1', '-W', '5', server_host],
+                capture_output=True,
+                timeout=10
+            )
+            return result.returncode == 0
+            
+        except Exception as e:
+            self.logger.error(f"Ping check failed: {e}")
+            return False
+    
+    
+    def monitor_connection(self, server_host="10.76.140.17"):
+        """
+        Continuously monitor server connection and manage WiFi
+        
+        Args:
+            server_host: Server hostname/IP to monitor
+        """
+        self.is_running = True
+        wifi_interface = self.get_wifi_interface()
+        
+        if not wifi_interface:
+            self.logger.error("Cannot monitor without WiFi interface")
+            return
+        
+        self.logger.info(f"Starting connection monitor for {server_host} on {wifi_interface}")
+        log_with_server(
+            f"Connection monitor started for {server_host}",
+            self.hostname,
+            self.device_ip
+        )
+        
+        while self.is_running:
+            try:
+                # Check if server is reachable
+                if self.check_server_connection(server_host):
+                    if self.consecutive_failures > 0:
+                        self.consecutive_failures = 0
+                        self.logger.info("Server connection restored")
+                        log_with_server("Server connection restored", self.hostname, self.device_ip)
+                else:
+                    self.consecutive_failures += 1
+                    self.logger.warning(
+                        f"Connection lost: {self.consecutive_failures}/{self.failure_threshold} failures"
+                    )
+                    
+                    # If threshold reached, do WiFi recovery
+                    if self.consecutive_failures >= self.failure_threshold:
+                        self.logger.error(
+                            f"Server unreachable for {self.failure_threshold} pings - initiating WiFi recovery"
+                        )
+                        
+                        # Perform WiFi recovery
+                        if self.reconnect_wifi(wifi_interface, self.wifi_down_time):
+                            self.logger.info("WiFi recovery completed successfully")
+                        else:
+                            self.logger.error("WiFi recovery failed")
+                
+                time.sleep(self.check_interval)
+                
+            except Exception as e:
+                self.logger.error(f"Error in connection monitor: {e}")
+                time.sleep(self.check_interval)
+    
+    
+    def start_monitoring(self, server_host="10.76.140.17"):
+        """
+        Start background monitoring thread
+        
+        Args:
+            server_host: Server to monitor
+        """
+        self.monitor_thread = threading.Thread(
+            target=self.monitor_connection,
+            args=(server_host,),
+            daemon=True
+        )
+        self.monitor_thread.start()
+        self.logger.info("WiFi recovery monitor thread started")
+    
+    
+    def stop_monitoring(self):
+        """Stop the monitoring thread"""
+        self.is_running = False
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=5)
+        self.logger.info("WiFi recovery monitor stopped")
+
+
+# Global WiFi recovery manager instance
+wifi_recovery_manager = None
+
+
+def initialize_wifi_recovery(hostname, device_ip, server_host="10.76.140.17"):
+    """Initialize and start WiFi recovery monitoring"""
+    global wifi_recovery_manager
+    
+    try:
+        wifi_recovery_manager = WiFiRecoveryManager(
+            hostname=hostname,
+            device_ip=device_ip,
+            check_interval=60,
+            failure_threshold=5
+        )
+        wifi_recovery_manager.start_monitoring(server_host)
+        logging.info("WiFi recovery initialized")
+        return wifi_recovery_manager
+        
+    except Exception as e:
+        logging.error(f"Failed to initialize WiFi recovery: {e}")
+        return None