Implement remote vision system with tracking and training capabilities

- Added Tracking class for tracking the largest detected object and sending servo commands.
- Introduced TrainModel class for training a face recognition model using images from a dataset.
- Created VideoStream class to handle various camera sources including remote streams, GStreamer, and libcamera.
- Developed RemoteVision class to manage video input, face detection, and motion detection modes.
- Integrated pubsub messaging for logging and state management across modules.
- Enhanced error handling and logging throughout the system for better debugging and user feedback.

Author: SentryCoderDev

modules/SerialShareManager.py

@@ -0,0 +1,339 @@
+import threading
+import time
+from pubsub import pub
+import traceback
+import serial  # Serial bağlantı için
+
+# --- MQTT aktifse bu modül devre dışı bırakılır ---
+DISABLE_SERIAL_SHARE_MANAGER = False
+
+class SerialShareManager:
+    """
+    Class to manage ESP32 serial connection sharing between modules
+    """
+    _instance = None
+    _lock = threading.RLock()
+    
+    def __new__(cls):
+        """Singleton pattern to ensure only one instance exists"""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(SerialShareManager, cls).__new__(cls)
+                cls._instance._serial = None
+                cls._instance._initialized = False
+                cls._instance._active_modules = {}
+                cls._instance._verbose_logging = False  # Default olarak detaylı log kapalı
+                cls._instance._setup_pubsub()
+                # Log creation only in verbose mode
+                try:
+                    if cls._instance._verbose_logging:
+                        pub.sendMessage('log', msg=f'[SerialManager] Instance created')
+                except:
+                    pass  # Suppress if pub not ready
+            return cls._instance
+    
+    def _setup_pubsub(self):
+        """Set up pubsub handlers"""
+        try:
+            pub.subscribe(self._handle_serial_ready, 'esp32:serial_ready')
+            pub.subscribe(self._handle_module_connect, 'esp32:module_connect')
+            pub.subscribe(self._handle_module_disconnect, 'esp32:module_disconnect')
+            # Önemli olaylar için yeni abonelikler
+            pub.subscribe(self._handle_priority_animation, 'priority:person_detected')
+        except:
+            # May happen if pubsub not initialized yet
+            pass
+    
+    def _handle_serial_ready(self):
+        """Handle serial ready event from provider module"""
+        if self._verbose_logging:
+            pub.sendMessage('log', msg=f'[SerialManager] Received serial ready notification')
+        # Broadcast our own ready event
+        try:
+            threading.Timer(0.2, lambda: pub.sendMessage('esp32:serial_global_ready')).start()
+        except:
+            pass
+    
+    def _handle_module_connect(self, module_name):
+        """Track module connection to serial"""
+        with self._lock:
+            self._active_modules[module_name] = time.time()
+            if self._verbose_logging:
+                pub.sendMessage('log', msg=f'[SerialManager] Module {module_name} connected to serial')
+    
+    def _handle_module_disconnect(self, module_name):
+        """Track module disconnection from serial"""
+        with self._lock:
+            if module_name in self._active_modules:
+                del self._active_modules[module_name]
+                if self._verbose_logging:
+                    pub.sendMessage('log', msg=f'[SerialManager] Module {module_name} disconnected from serial')
+    
+    def _handle_priority_animation(self, person_name, animation_name="RAINBOW_CYCLE"):
+        """Öncelikli kişi için animasyon tetikleyici"""
+        if self._serial and self._initialized:
+            try:
+                pub.sendMessage('log:info', msg=f'[SerialManager] Priority person detected: {person_name}, ensuring animation runs')
+                # LED animasyonunu doğrudan tetikle
+                animation_cmd = f"ANIMATE {animation_name.upper()} GREEN 3\n"
+                self._serial.write(animation_cmd.encode())
+                
+                # Yedekleme olarak standart LED animasyon kanalını da tetikle
+                threading.Timer(0.5, lambda: pub.sendMessage('led:animate', animation=animation_name, color='GREEN', repeat=3)).start()
+            except Exception as e:
+                pub.sendMessage('log:error', msg=f'[SerialManager] Error sending priority animation: {e}')
+    
+    def register_serial_provider(self, serial, provider_name='neopixel'):
+        """Register the serial connection from a provider module"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return False
+        with self._lock:
+            old_serial = self._serial
+            self._serial = serial
+            self._initialized = True
+            self._active_modules[provider_name] = time.time()
+            
+            # Eski bağlantıyı kapat (varsa)
+            if old_serial and old_serial != serial:
+                try:
+                    old_serial.close()
+                except:
+                    pass
+                    
+            try:
+                if self._verbose_logging:
+                    pub.sendMessage('log', msg=f'[SerialManager] Serial registered by {provider_name}')
+                
+                # Bağlantıyı test et
+                self._verify_connection()
+                
+                # Notify others that serial is ready
+                threading.Timer(0.5, lambda: pub.sendMessage('esp32:serial_global_ready')).start()
+            except Exception as e:
+                pub.sendMessage('log:error', msg=f'[SerialManager] Error in register_serial_provider: {e}')
+                traceback.print_exc()
+    
+    def _verify_connection(self):
+        """Seri port bağlantısını doğrula"""
+        if not self._serial:
+            return False
+            
+        try:
+            # Veri akışını temizle
+            self._serial.reset_input_buffer()
+            self._serial.reset_output_buffer()
+            
+            # PING komutu gönder
+            self._serial.write(b"PING\n")
+            
+            # Yanıtı bekle (2 saniye timeout)
+            start_time = time.time()
+            response = ""
+            
+            while time.time() - start_time < 2.0:
+                if self._serial.in_waiting > 0:
+                    line = self._serial.readline().decode().strip()
+                    if "PONG" in line:
+                        if self._verbose_logging:
+                            pub.sendMessage('log:info', msg=f'[SerialManager] Connection verified (PONG received)')
+                        return True
+            
+            # PONG alınamadı, tekrar dene
+            self._serial.write(b"PING\n")
+            start_time = time.time()
+            
+            while time.time() - start_time < 2.0:
+                if self._serial.in_waiting > 0:
+                    line = self._serial.readline().decode().strip()
+                    if "PONG" in line:
+                        if self._verbose_logging:
+                            pub.sendMessage('log:info', msg=f'[SerialManager] Connection verified on second attempt')
+                        return True
+            
+            pub.sendMessage('log:warn', msg=f'[SerialManager] Connection verification failed (no PONG response)')
+            return False
+            
+        except Exception as e:
+            pub.sendMessage('log:error', msg=f'[SerialManager] Error verifying connection: {e}')
+            return False
+    
+    def get_serial(self, module_name):
+        """Get the shared serial connection for a module"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return None
+        with self._lock:
+            if self._serial is not None and self._initialized:
+                self._active_modules[module_name] = time.time()
+                if self._verbose_logging:
+                    try:
+                        pub.sendMessage('log', msg=f'[SerialManager] Providing serial to {module_name}')
+                    except:
+                        # Suppress errors if pub not ready
+                        pass
+                return self._serial
+            else:
+                if self._verbose_logging:
+                    try:
+                        pub.sendMessage('log', msg=f'[SerialManager] Serial not available for {module_name}')
+                    except:
+                        # Suppress errors if pub not ready
+                        pass
+        return None
+    
+    def send_command(self, command, module_name="unknown"):
+        """Direkt komut gönderme methodu"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return False
+        with self._lock:
+            if self._serial and self._initialized:
+                try:
+                    # Komut bir satır sonu ile bitmiyorsa ekle
+                    if not command.endswith('\n'):
+                        command += '\n'
+                    
+                    # Komutu gönder
+                    self._serial.write(command.encode())
+                    
+                    # İşleme için kısa süre bekle
+                    time.sleep(0.05)
+                    
+                    if self._verbose_logging:
+                        pub.sendMessage('log:debug', msg=f'[SerialManager] Command sent from {module_name}: {command.strip()}')
+                    
+                    return True
+                except Exception as e:
+                    pub.sendMessage('log:error', msg=f'[SerialManager] Error sending command from {module_name}: {e}')
+            else:
+                if self._verbose_logging:
+                    pub.sendMessage('log:warn', msg=f'[SerialManager] Cannot send command: serial not initialized')
+                    
+            return False
+    
+    def connect(self, serial_port, baudrate=115200, provider_name="auto_connect"):
+        """Seri port bağlantısını kur ve paylaş"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return False
+        with self._lock:
+            # Eğer halihazırda bir seri port bağlantısı varsa, kapat
+            if self._serial and self._serial.is_open:
+                try:
+                    self._serial.close()
+                    time.sleep(0.5)  # Kapanma için bekle
+                except:
+                    pass
+            
+            try:
+                # Bağlantı için 3 deneme yap
+                for attempt in range(3):
+                    try:
+                        serial_connection = serial.Serial(
+                            serial_port,
+                            baudrate,
+                            timeout=1,
+                            write_timeout=1
+                        )
+                        
+                        # Veri akışını temizle
+                        serial_connection.reset_input_buffer()
+                        serial_connection.reset_output_buffer()
+                        
+                        # ESP32'nin hazır olması için bekle
+                        time.sleep(1.5)
+                        
+                        # Bağlantıyı test et
+                        serial_connection.write(b"PING\n")
+                        time.sleep(0.5)
+                        
+                        response = ""
+                        start_time = time.time()
+                        while time.time() - start_time < 2.0:
+                            if serial_connection.in_waiting > 0:
+                                line = serial_connection.readline().decode().strip()
+                                if "PONG" in line:
+                                    # Bağlantı başarılı
+                                    self._serial = serial_connection
+                                    self._initialized = True
+                                    self._active_modules[provider_name] = time.time()
+                                    
+                                    pub.sendMessage('log:info', msg=f'[SerialManager] Connected to {serial_port} at {baudrate} baud')
+                                    
+                                    # Haber ver
+                                    threading.Timer(0.5, lambda: pub.sendMessage('esp32:serial_global_ready')).start()
+                                    
+                                    return True
+                        
+                        # PONG alınamadı, birkaç saniye bekleyip tekrar dene
+                        time.sleep(2)
+                        
+                    except Exception as e:
+                        pub.sendMessage('log:warn', msg=f'[SerialManager] Connection attempt {attempt+1} failed: {e}')
+                        time.sleep(1)
+                
+                pub.sendMessage('log:error', msg=f'[SerialManager] Failed to connect after 3 attempts')
+                return False
+                
+            except Exception as e:
+                pub.sendMessage('log:error', msg=f'[SerialManager] Connection error: {e}')
+                return False
+    
+    def get_active_modules(self):
+        """Get a list of active modules using the serial connection"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return []
+        with self._lock:
+            return list(self._active_modules.keys())
+    
+    def set_verbose_logging(self, verbose):
+        """Enable or disable verbose logging"""
+        if DISABLE_SERIAL_SHARE_MANAGER:
+            return
+        self._verbose_logging = verbose
+
+# Create a global instance
+serialManager = SerialShareManager()
+
+def register_serial(serial_connection, provider_name='neopixel'):
+    """Register a serial connection to be shared"""
+    if DISABLE_SERIAL_SHARE_MANAGER:
+        return False
+    try:
+        global serialManager
+        serialManager.register_serial_provider(serial_connection, provider_name)
+        return True
+    except Exception as e:
+        print(f"Error in register_serial: {e}")
+        traceback.print_exc()
+        return False
+
+def get_serial(module_name):
+    """Get the shared serial connection for a module"""
+    if DISABLE_SERIAL_SHARE_MANAGER:
+        return None
+    try:
+        global serialManager
+        return serialManager.get_serial(module_name)
+    except Exception as e:
+        print(f"Error in get_serial: {e}")
+        traceback.print_exc()
+        return None
+
+def send_command(command, module_name="unknown"):
+    """Komut gönderme fonksiyonu"""
+    if DISABLE_SERIAL_SHARE_MANAGER:
+        return False
+    global serialManager
+    return serialManager.send_command(command, module_name)
+
+def connect_serial(serial_port, baudrate=115200):
+    """Seri port bağlantısı kur"""
+    if DISABLE_SERIAL_SHARE_MANAGER:
+        return False
+    global serialManager
+    return serialManager.connect(serial_port, baudrate)
+
+def set_verbose_logging(verbose):
+    """Set verbose logging for SerialShareManager"""
+    if DISABLE_SERIAL_SHARE_MANAGER:
+        return
+    global serialManager
+    serialManager.set_verbose_logging(verbose)