Merge remote-tracking branch 'upstream/main'

Author: rjtokenring

.github/workflows/docker-github-dev-build.yml

@@ -1,4 +1,4 @@
-name: DEV - build & publish Arduino dev containers
+name: DEV - build & publish Arduino dev-latest containers
 
 on:
   workflow_dispatch:

src/arduino/app_bricks/video_objectdetection/brick_compose.yaml

@@ -13,7 +13,7 @@ services:
     volumes:
       - "${CUSTOM_MODEL_PATH:-/home/arduino/.arduino-bricks/ei-models/}:${CUSTOM_MODEL_PATH:-/home/arduino/.arduino-bricks/ei-models/}"
       - "/run/udev:/run/udev"
-    command: ["--model-file", "${EI_OBJ_DETECTION_MODEL:-/models/ootb/ei/yolo-x-nano.eim}", "--dont-print-predictions", "--mode", "streaming", "--force-target", "--preview-original-resolution", "--camera", "${VIDEO_DEVICE:-/dev/video1}"]
+    command: ["--model-file", "${EI_OBJ_DETECTION_MODEL:-/models/ootb/ei/yolo-x-nano.eim}", "--dont-print-predictions", "--mode", "streaming", "--preview-original-resolution", "--camera", "${VIDEO_DEVICE:-/dev/video1}"]
     healthcheck:
       test: [ "CMD-SHELL", "wget -q --spider http://ei-video-obj-detection-runner:4912 || exit 1" ]
       interval: 2s

src/arduino/app_utils/audio.py

@@ -18,6 +18,7 @@ class SineGenerator:
         sample_rate (int): Audio sample rate in Hz.
         attack (float): Attack time for amplitude smoothing in seconds.
         release (float): Release time for amplitude smoothing in seconds.
+        glide (float): Glide time for frequency smoothing in seconds.
     """
 
     def __init__(self, sample_rate: int):
@@ -31,6 +32,7 @@ def __init__(self, sample_rate: int):
         # envelope parameters (attack/release in seconds)
         self.attack = 0.01
         self.release = 0.03
+        self.glide = 0.02
 
         # reusable buffers
         self._buf_N = 0
@@ -88,17 +90,19 @@ def set_state(self, state: dict) -> None:
         if "freq_last" in state:
             self._freq_last = float(state["freq_last"])
 
-    def set_envelope_params(self, attack: float, release: float) -> None:
+    def set_envelope_params(self, attack: float, release: float, glide: float) -> None:
         """Update attack and release envelope parameters.
 
         Args:
             attack (float): Attack time in seconds (time to rise to target
                 amplitude when increasing amplitude).
             release (float): Release time in seconds (time to fall to target
                 amplitude when decreasing amplitude).
+            glide (float): Glide time in seconds (time to reach target frequency).
         """
         self.attack = float(max(0.0, attack))
         self.release = float(max(0.0, release))
+        self.glide = float(max(0.0, glide))
 
     def generate_block(self, freq: float, amp_target: float, block_dur: float, master_volume: float):
         """Generate a block of float32 audio samples.
@@ -149,10 +153,29 @@ def generate_block(self, freq: float, amp_target: float, block_dur: float, maste
                 envelope[:] = np.linspace(amp_current, next_amp, N, dtype=np.float32)
                 amp_current = float(envelope[-1])
 
-        # oscillator
-        phase_incr = 2.0 * math.pi * float(freq) / float(self.sample_rate)
+        # frequency glide (portamento)
+        freq_current = float(self._freq_last)
+        freq_target = float(freq)
+        glide = float(self.glide)
         phase_incs = self._buf_phase_incs[:N]
-        phase_incs.fill(phase_incr)
+
+        if glide > 0.0 and freq_current != freq_target:
+            # Apply glide smoothing over time
+            frac = min(1.0, block_dur / glide)
+            next_freq = freq_current + (freq_target - freq_current) * frac
+
+            # Linear interpolation within block
+            freq_ramp = np.linspace(freq_current, next_freq, N, dtype=np.float32)
+            phase_incs[:] = 2.0 * math.pi * freq_ramp / float(self.sample_rate)
+
+            freq_current = float(next_freq)
+        else:
+            # No glide or already at target
+            phase_incr = 2.0 * math.pi * freq_target / float(self.sample_rate)
+            phase_incs.fill(phase_incr)
+            freq_current = freq_target
+
+        # oscillator (phase accumulation)
         np.cumsum(phase_incs, dtype=np.float32, out=phases)
         phases += self._phase
         self._phase = float(phases[-1] % (2.0 * math.pi))
@@ -168,6 +191,6 @@ def generate_block(self, freq: float, amp_target: float, block_dur: float, maste
 
         # update state
         self._amp_current = amp_current
-        self._freq_last = float(freq)
+        self._freq_last = freq_current
 
         return samples

src/arduino/app_utils/bridge.py

@@ -516,10 +516,10 @@ def _handle_msg(self, msg: list):
         try:
             if msg_type == 0:  # Request: [0, msgid, method, params]
                 if len(msg) != 4:
-                    raise ValueError("Invalid RPC request: expected length 4")
+                    raise ValueError(f"Invalid RPC request: expected length 4, got {len(msg)}")
                 _, msgid, method, params = msg
                 if not isinstance(params, (list, tuple)):
-                    raise ValueError("Invalid RPC request params: expected array/tuple")
+                    raise ValueError("Invalid RPC request params: expected array or tuple")
 
                 method_name = self._decode_method(method)
 
@@ -538,7 +538,7 @@ def _handle_msg(self, msg: list):
 
             elif msg_type == 1:  # Response: [1, msgid, error, result]
                 if len(msg) != 4:
-                    raise ValueError("Invalid RPC response: expected length 4")
+                    raise ValueError(f"Invalid RPC response: expected length 4, got {len(msg)}")
                 _, msgid, error, result = msg
                 if error and (not isinstance(error, list) or len(error) < 2):
                     raise ValueError("Invalid error format in RPC response")
@@ -559,11 +559,11 @@ def _handle_msg(self, msg: list):
                         else:
                             on_result([GENERIC_ERR, "Unknown error occurred."])
                 else:
-                    on_error([GENERIC_ERR, f"Response for unknown msgid {msgid} received."])
+                    logger.warning(f"Response for unknown msgid {msgid} received.")
 
             elif msg_type == 2:  # Notification: [2, method, params]
                 if len(msg) != 3:
-                    raise ValueError("Invalid RPC notification: expected length 3")
+                    raise ValueError(f"Invalid RPC notification: expected length 3, got {len(msg)}")
                 _, method, params = msg
                 if not isinstance(params, (list, tuple)):
                     raise ValueError("Invalid RPC notification params: expected array or tuple")

tests/arduino/app_utils/bridge/test_unit_common.py

@@ -15,7 +15,9 @@ def setUp(self):
 
         # Patch dependencies
         # Mock the logger used by ClientServer
-        patch("arduino.app_utils.bridge.logger", MagicMock()).start()
+        self.mock_logger = MagicMock()
+        self.logger_patcher = patch("arduino.app_utils.bridge.logger", self.mock_logger)
+        self.logger_patcher.start()
 
         # Mock the socket instance that will be created
         self.mock_socket_instance = MagicMock()
@@ -32,5 +34,6 @@ def setUp(self):
 
     def tearDown(self):
         """This method is called after each test and cleans up the patched dependencies."""
+        self.logger_patcher.stop()
         self.socket_patcher.stop()
         self.threading_patcher.stop()

tests/arduino/app_utils/bridge/test_unit_handle_msg.py

@@ -9,6 +9,58 @@
 
 
 class TestHandleMsg(UnitTest):
+    def test_empty_msg(self):
+        """Test handling of an empty message."""
+        client = ClientServer()
+        client._handle_msg([])
+        self.mock_logger.warning.assert_called_once_with("Invalid RPC message received (must be a non-empty list).")
+        self.mock_logger.error.assert_not_called()
+
+    def test_unknown_msg_type(self):
+        """Test handling of an unknown message type."""
+        client = ClientServer()
+        client._handle_msg([99, 1, None, "result"])  # Msg type 99 does not exist
+        self.mock_logger.warning.assert_called_once_with("Invalid RPC message type received: 99")
+        self.mock_logger.error.assert_not_called()
+
+    def test_unknown_msg_id(self):
+        """Test handling of an unknown message id."""
+        client = ClientServer()
+        client._handle_msg([1, 9999, None, "result"])  # Msg id 9999 does not exist
+        self.mock_logger.warning.assert_called_once_with("Response for unknown msgid 9999 received.")
+        self.mock_logger.error.assert_not_called()
+
+    def test_malformed_messages(self):
+        """Test handling of malformed messages."""
+        client = ClientServer()
+
+        client._handle_msg([0, 1, "method", [0, 1], "extra field"])  # Malformed payload
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid RPC request: expected length 4, got 5")
+        self.mock_logger.reset_mock()
+        client._handle_msg([0, 1, "method", 1])  # Malformed params
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid RPC request params: expected array or tuple")
+        self.mock_logger.reset_mock()
+
+        client._handle_msg([1, 1, None, "result", "extra field"])  # Malformed payload
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid RPC response: expected length 4, got 5")
+        self.mock_logger.reset_mock()
+        client._handle_msg([1, 1, 42, "result"])  # Malformed error
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid error format in RPC response")
+        self.mock_logger.reset_mock()
+
+        client._handle_msg([2, 1, [0, 1], "extra field"])  # Malformed payload
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid RPC notification: expected length 3, got 4")
+        self.mock_logger.reset_mock()
+        client._handle_msg([2, 1, 42])  # Malformed params
+        self.mock_logger.warning.assert_not_called()
+        self.mock_logger.error.assert_called_once_with("Message validation error: Invalid RPC notification params: expected array or tuple")
+        self.mock_logger.reset_mock()
+
     def test_handle_msg_request(self):
         """Test handling of an incoming request message."""
         client = ClientServer()
@@ -27,6 +79,22 @@ def test_handle_msg_request(self):
         handler_mock.assert_called_once_with(*params)
         client._send_response.assert_called_once_with(msgid, None, "handled")
 
+    def test_handle_msg_request_handler_fail(self):
+        """Test handling of a request for a method that fails running its handler."""
+        client = ClientServer()
+        client._send_response = MagicMock()
+
+        request_msg = [0, 111, "failing_method", []]
+        client.handlers["failing_method"] = MagicMock(side_effect=ValueError("Handler failed"))
+
+        client._handle_msg(request_msg)
+
+        client._send_response.assert_called_once()
+        args, _ = client._send_response.call_args
+        self.assertEqual(args[0], 111)  # msgid
+        self.assertIsInstance(args[1], ValueError)  # error
+        self.assertIsNone(args[2])  # result
+
     def test_handle_msg_request_method_not_found(self):
         """Test handling of a request for a method that is not found."""
         client = ClientServer()
@@ -79,7 +147,7 @@ def test_handle_msg_response(self):
         on_error_mock.assert_not_called()
         self.assertNotIn(msgid, client.callbacks)  # Callback should be removed
 
-    def test_handle_msg_response_function_not_found(self):
+    def test_handle_msg_generic_error_response(self):
         """Test handling of an incoming error response message."""
         client = ClientServer()
 
@@ -100,7 +168,7 @@ def test_handle_msg_response_function_not_found(self):
         on_error_mock.assert_called_once_with(result_error)
         self.assertNotIn(msgid, client.callbacks)  # Callback should be removed
 
-    def test_handle_msg_response_already_provided_error(self):
+    def test_handle_msg_method_exists_error_response(self):
         """Test handling of an incoming error response message that signals a method is already provided."""
         client = ClientServer()