Refactor ArduinoSerial and RobustSerial modules to remove MOTOR handling, improve connection logic, and enhance logging. Update Sensor class to support ESP32 protocol with improved retry logic and motion monitoring. Modify AudioLLM to utilize the ollama library for LLM interactions. Enhance Personality module for better state management and behavior handling, including improved logging and error handling.

Author: SentryCoderDev

modules/actuators/piservo.py

@@ -2,44 +2,198 @@
 from modules.config import Config
 from time import sleep
 from pubsub import pub
+import serial
+from modules.neopixel.neopx import get_shared_esp32_serial
+import threading
+import sys
+import os
+
+# Add path to SerialShareManager
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
+from modules.SerialShareManager import get_serial
+
+# No longer need a global ESP32 connection - using the shared one
 
 class PiServo:
 
     def __init__(self, **kwargs):
         """
         PiServo class
-        :param kwargs: pin, range, start
+        :param kwargs: pin, range, start, protocol, id, name
         :param pin: GPIO pin number
         :param range: [min, max] angle range
         :param start: initial angle
+        :param protocol: 'GPIO' (default) or 'ESP32'
+        :param id: Servo ID for identification
+        :param name: Servo name for logging and subscription
         
         Install: pip install gpiozero
         
-        Subscribes to 'piservo:move' to move servo
+        Subscribes to 'piservo:move' to move any servo
+        - Argument: angle (int) - angle to move servo
+        
+        Subscribes to 'piservo:move:{name}' to move specific servo
         - Argument: angle (int) - angle to move servo
         
         Example:
-        pub.sendMessage('piservo:move', angle=90)        
+        pub.sendMessage('piservo:move', angle=90)
+        pub.sendMessage('piservo:move:ear', angle=45)
         """
-        
         self.pin = kwargs.get('pin')
         self.range = kwargs.get('range')
         self.start = kwargs.get('start', 0)
+        self.id = kwargs.get('id', 0)
+        self.name = kwargs.get('name', f'servo_{self.id}')
         self.servo = None
+        self.serial = None  # Will be set if ESP32 protocol is used
+        self.verbose_logging = kwargs.get('verbose_logging', False)  # Add logging control
+        
+        # Protokol desteği ekleme
+        accepted_protocols = ['GPIO', 'ESP32']
+        self.protocol = kwargs.get('protocol', 'GPIO')
+        if self.protocol not in accepted_protocols:
+            raise ValueError("Invalid protocol specified. Choose one of: " + ", ".join(accepted_protocols))
+        
+        # ESP32 protocol handling with improved retry logic
+        if self.protocol == 'ESP32':
+            # Subscribe to both events - the original and the new global event
+            pub.subscribe(self.on_serial_ready, 'esp32:serial_ready')
+            pub.subscribe(self.on_serial_ready, 'esp32:serial_global_ready')
+            
+            # Try to get the shared serial connection now - it might already be available
+            self.serial = get_serial(f'servo_{self.name}')
+            if not self.serial:
+                # Try the old way too as fallback
+                self.serial = get_shared_esp32_serial()
+            
+            # Start retry timer with increased initial delay
+            retry_timer = threading.Timer(5.0, self.retry_get_serial)
+            retry_timer.daemon = True
+            retry_timer.start()
+        
+        # Main movement subscription
         pub.subscribe(self.move, 'piservo:move')
-        # print(self.range)
-        # self.move(0)
-        # sleep(2)
-        # self.move(self.range[0])
-        # sleep(2)
-        # self.move(self.range[1])
-        # sleep(2)
-        self.move(self.start)
 
+        # Servo-specific subscription
+        specific_topic = f'piservo:move:{self.name}'
+        pub.subscribe(self.move, specific_topic)
+        
+        # Initialize to starting position with increased delay
+        timer = threading.Timer(2.0, lambda: self.move(self.start))
+        timer.daemon = True
+        timer.start()
+
+    def retry_get_serial(self):
+        """Retry getting the serial connection with progressive delay"""
+        if self.serial is None:
+            # First try new method
+            self.serial = get_serial(f'servo_{self.name}')
+            if not self.serial:
+                # Fall back to old method
+                self.serial = get_shared_esp32_serial()
+                
+            if self.serial:
+                if self.verbose_logging:
+                    pub.sendMessage('log', msg=f'[SERVO] {self.name} connected to shared ESP32 serial on retry')
+                self.move(self.start)
+            else:
+                # Progressive backoff - increase delay each time
+                delay = min(10.0, 2.0 + len(self.name) % 3)  # Vary delay slightly per instance
+                retry_timer = threading.Timer(delay, self.retry_get_serial)
+                retry_timer.daemon = True
+                retry_timer.start()
 
+    def on_serial_ready(self):
+        """Called when the shared serial connection becomes available"""
+        # Get the serial connection and log
+        self.serial = get_shared_esp32_serial()
+        if self.serial:
+            if self.verbose_logging:
+                pub.sendMessage('log', msg=f'[SERVO] {self.name} connected to shared ESP32 serial')
+            # Move to start position once serial is available
+            self.move(self.start)
+        
     def move(self, angle):
+        """
+        Move servo to specified angle
+        :param angle: Angle to move servo to
+        """
+        # Açı değerini izin verilen aralıkta tut
+        if self.range:
+            if angle < self.range[0]:
+                angle = self.range[0]
+                if self.verbose_logging:
+                    pub.sendMessage('log', msg=f'[SERVO] {self.name}: Angle limited to minimum {self.range[0]}')
+            elif angle > self.range[1]:
+                angle = self.range[1]
+                if self.verbose_logging:
+                    pub.sendMessage('log', msg=f'[SERVO] {self.name}: Angle limited to maximum {self.range[1]}')
+        
+        # ESP32 protokolü kullanıyorsa
+        if self.protocol == 'ESP32':
+            self.send_servo_command(angle)
+            return
+        
+        # GPIO protokolü için orijinal kod
         if self.servo is None:
             self.servo = AngularServo(self.pin, min_angle=self.range[0], max_angle=self.range[1], initial_angle=self.start)
         self.servo.angle = angle                # Changes the angle (to move the servo)
         sleep(1)                                # @TODO: Remove this sleep
-        self.servo.detach()                     # Detaches the servo (to stop jitter)
+        self.servo.detach()                     # Detaches the servo (to stop jitter)
+
+    def send_servo_command(self, angle):
+        """
+        Send servo command to ESP32
+        :param angle: Angle to move servo to
+        """
+        if self.protocol != 'ESP32':
+            return
+        
+        if self.serial is None:
+            if self.verbose_logging:
+                pub.sendMessage('log', msg=f'[SERVO] {self.name}: Cannot send command - no serial connection')
+            # Try to reconnect to serial
+            self.serial = get_shared_esp32_serial()
+            if self.serial is None:
+                return
+        
+        # Constrain angle to valid range
+        if self.range:
+            if angle < self.range[0]:
+                angle = self.range[0]
+            elif angle > self.range[1]:
+                angle = self.range[1]
+        
+        # Create and send command
+        cmd = f"SERVO {self.pin} {angle}\n"
+        # Only log actual movement commands when verbose is enabled
+        if self.verbose_logging:
+            pub.sendMessage('log', msg=f'[SERVO] {self.name}: Sending command: {cmd.strip()}')
+        
+        try:
+            self.serial.write(cmd.encode())
+            sleep(0.1)  # Brief pause for command processing
+        except Exception as e:
+            pub.sendMessage('log', msg=f'[SERVO] ERROR: Failed to send command to ESP32: {e}')
+            self.serial = None  # Reset the serial connection to trigger a reconnect
+    
+    def detach(self):
+        """
+        Detach the servo to prevent jitter
+        """
+        if self.protocol == 'ESP32' and self.serial is not None:
+            cmd = f"SERVO_DETACH {self.pin}\n"
+            if self.verbose_logging:
+                pub.sendMessage('log', msg=f'[SERVO] {self.name}: Detaching servo on pin {self.pin}')
+            try:
+                self.serial.write(cmd.encode())
+            except Exception as e:
+                pub.sendMessage('log', msg=f'[SERVO] ERROR: Failed to send detach command: {e}')
+        elif self.servo:
+            self.servo.detach()
+    
+    def __del__(self):
+        """
+        Clean up resources when object is destroyed
+        """
+        self.detach()

modules/actuators/servo.py

@@ -56,6 +56,8 @@ def __init__(self, **kwargs):
 
         pub.subscribe(self.move, 'servo:' + self.identifier + ':mvabs')
         pub.subscribe(self.move_relative, 'servo:' + self.identifier + ':mv')
+        # Genel animasyon komutlarını dinle
+        pub.subscribe(self.handle_servo_animation, 'servo:move')
 
     def __del__(self):
         pass #self.reset()
@@ -186,3 +188,25 @@ def translate(self, value):
 
         # Convert the 0-1 range into a value in the right range.
         return self.range[0] + (valueScaled * rightSpan)
+
+    def handle_servo_animation(self, data):
+        """
+        DeskGUI veya CommandReceiver'dan gelen genel animasyon komutlarını işler.
+        :param data: {'animation': animasyon_adı, 'repeat': tekrar_sayısı}
+        """
+        animation = data.get('animation', '').upper()
+        repeat = data.get('repeat', 1)
+        # Sadece bu servo ilgili animasyonda rol oynuyorsa hareket etsin
+        # Örnek: pan servosu HEAD_LEFT animasyonunda hareket eder
+        if animation == 'HEAD_LEFT' and self.identifier == 'pan':
+            for _ in range(repeat):
+                self.move(0)  # Sola bak (örnek değer)
+                sleep(0.5)
+                self.move(50) # Ortaya dön
+        elif animation == 'HEAD_RIGHT' and self.identifier == 'pan':
+            for _ in range(repeat):
+                self.move(100)  # Sağa bak (örnek değer)
+                sleep(0.5)
+                self.move(50) # Ortaya dön
+        # Diğer animasyonlar için benzer şekilde ekleyebilirsiniz
+        # İlgili servo ve animasyon eşleşmiyorsa hiçbir şey yapmaz

modules/animate.py

@@ -37,7 +37,17 @@ def animate(self, action):
             cmd = list(step.keys())[0]
             args = list(step.values())
             if 'servo:' in cmd:
-                pub.sendMessage(cmd, percentage=args[0])
+                # Hatalı veya eksik veri varsa atla ve logla
+                try:
+                    val = args[0]
+                    if val is None or (isinstance(val, str) and not val.strip()):
+                        pub.sendMessage('log:error', msg=f"[Animate] Invalid servo value in animation '{action}': {cmd} -> {val}")
+                        continue
+                    val = float(val)
+                except Exception as e:
+                    pub.sendMessage('log:error', msg=f"[Animate] Exception parsing servo value in animation '{action}': {cmd} -> {args[0]} | {e}")
+                    continue
+                pub.sendMessage(cmd, percentage=val)
             elif 'sleep' == cmd:
                 sleep(args[0])
             elif 'animate' == cmd: