change peripheral function inputs

Author: gabrielburnworth

README.md

@@ -238,8 +238,8 @@ sidecar-starter-pack/
 | `control_servo()` | Set servo angle between 0-100 degrees. |
 | `control_peripheral()` | Set peripheral value (digital ON/OFF or analog value from 0-255). |
 | `toggle_peripheral()` | Toggles the state of a specific peripheral between 'ON' (100%) and 'OFF' (0%). |
-| `on()` | Turns specified peripheral 'ON' (100%). |
-| `off()` | Turns specified peripheral 'OFF' (0%). |
+| `on()` | Turns specified pin number 'ON' (100%). |
+| `off()` | Turns specified pin number 'OFF' (0%). |
 
 ### resources.py
 

functions/peripherals.py

@@ -41,18 +41,34 @@ def control_servo(self, pin, angle):
         self.state.print_status(description=f"Set servo angle to {angle}.")
         return
 
-    def control_peripheral(self, peripheral_id, value, mode=None):
+    def get_peripheral(self, peripheral_name):
+        """Find a peripheral by name."""
+        peripherals = self.info.api_get("peripherals")
+        peripheral_names = [peripheral["label"] for peripheral in peripherals]
+        if peripheral_name not in peripheral_names:
+            error = f"ERROR: '{peripheral_name}' peripheral not in {peripheral_names}."
+            self.state.print_status(description=error, update_only=True)
+            self.state.error = error
+            return
+
+        peripheral = [p for p in peripherals if p["label"] == peripheral_name][0]
+        return peripheral
+
+    def control_peripheral(self, peripheral_name, value, mode=None):
         """Set peripheral value and mode."""
+        self.state.print_status(description=f"Setting {peripheral_name} to {value}.")
 
-        if mode is None:
-            peripheral = self.info.api_get("peripherals", peripheral_id)
-            mode = peripheral["mode"]
+        peripheral = self.get_peripheral(peripheral_name)
+        if peripheral is None:
+            return
+        peripheral_id = peripheral["id"]
+        pin_mode = peripheral["mode"] if mode is None else mode
 
         control_peripheral_message = {
             "kind": "write_pin",
             "args": {
                 "pin_value": value, # Controls ON/OFF or slider value from 0-255
-                "pin_mode": mode, # Controls digital (0) or analog (1) mode
+                "pin_mode": pin_mode, # Controls digital (0) or analog (1) mode
                 "pin_number": {
                     "kind": "named_pin",
                     "args": {
@@ -65,11 +81,13 @@ def control_peripheral(self, peripheral_id, value, mode=None):
 
         self.broker.publish(control_peripheral_message)
 
-        self.state.print_status(description=f"Set peripheral {peripheral_id} to {value} with mode={mode}.")
-
-    def toggle_peripheral(self, peripheral_id):
+    def toggle_peripheral(self, peripheral_name):
         """Toggles the state of a specific peripheral between `on` and `off`."""
-
+        self.state.print_status(description=f"Toggling {peripheral_name}.")
+        peripheral = self.get_peripheral(peripheral_name)
+        if peripheral is None:
+            return
+        peripheral_id = peripheral["id"]
         toggle_peripheral_message = {
             "kind": "toggle_pin",
             "args": {
@@ -85,26 +103,32 @@ def toggle_peripheral(self, peripheral_id):
 
         self.broker.publish(toggle_peripheral_message)
 
-        self.state.print_status(description=f"Triggered toggle peripheral {peripheral_id}.")
-
-    def on(self, peripheral_id):
-        """Turns specified peripheral `on` (100%)."""
-        self.state.print_status(description=f"Turning ON peripheral {peripheral_id}.")
-
-        peripheral = self.info.api_get("peripherals", peripheral_id)
-        mode = peripheral["mode"]
+    def on(self, pin_number):
+        """Turns specified pin number `on` (100%)."""
+        self.state.print_status(description=f"Turning ON pin number {pin_number}.")
 
-        if mode == 1:
-            self.control_peripheral(peripheral_id, 255, mode)
-        elif mode == 0:
-            self.control_peripheral(peripheral_id, 1, mode)
+        on_message = {
+            "kind": "write_pin",
+            "args": {
+                "pin_value": 1,
+                "pin_mode": 0,
+                "pin_number": pin_number,
+            }
+        }
 
-        return
+        self.broker.publish(on_message)
 
-    def off(self, peripheral_id):
-        """Turns specified peripheral `off` (0%)."""
-        self.state.print_status(description=f"Turning OFF peripheral {peripheral_id}.")
+    def off(self, pin_number):
+        """Turns specified pin number `off` (0%)."""
+        self.state.print_status(description=f"Turning OFF pin number {pin_number}.")
 
-        self.control_peripheral(peripheral_id, 0)
+        off_message = {
+            "kind": "write_pin",
+            "args": {
+                "pin_value": 0,
+                "pin_mode": 0,
+                "pin_number": pin_number,
+            }
+        }
 
-        return
+        self.broker.publish(off_message)

main.py

@@ -199,21 +199,21 @@ def control_servo(self, pin, angle):
         """Set servo angle between 0-100 degrees."""
         return self.peripherals.control_servo(pin, angle)
 
-    def control_peripheral(self, peripheral_id, value, mode=None):
+    def control_peripheral(self, peripheral_name, value, mode=None):
         """Set peripheral value and mode."""
-        return self.peripherals.control_peripheral(peripheral_id, value, mode)
+        return self.peripherals.control_peripheral(peripheral_name, value, mode)
 
-    def toggle_peripheral(self, peripheral_id):
+    def toggle_peripheral(self, peripheral_name):
         """Toggles the state of a specific peripheral between `on` and `off`."""
-        return self.peripherals.toggle_peripheral(peripheral_id)
+        return self.peripherals.toggle_peripheral(peripheral_name)
 
-    def on(self, peripheral_id):
-        """Turns specified peripheral `on` (100%)."""
-        return self.peripherals.on(peripheral_id)
+    def on(self, pin_number):
+        """Turns specified pin number `on` (100%)."""
+        return self.peripherals.on(pin_number)
 
-    def off(self, peripheral_id):
-        """Turns specified peripheral `off` (0%)."""
-        return self.peripherals.off(peripheral_id)
+    def off(self, pin_number):
+        """Turns specified pin number `off` (0%)."""
+        return self.peripherals.off(pin_number)
 
     # resources.py
 

tests/tests_main.py

@@ -822,7 +822,7 @@ def exec_command():
     def test_toggle_peripheral(self):
         '''Test toggle_peripheral command'''
         def exec_command():
-            self.fb.toggle_peripheral(123)
+            self.fb.toggle_peripheral('New Peripheral')
         self.send_command_test_helper(
             exec_command,
             expected_command={
@@ -835,67 +835,51 @@ def exec_command():
                 },
             },
             extra_rpc_args={},
-            mock_api_response={})
+            mock_api_response=[{'label': 'New Peripheral', 'id': 123}])
 
-    def test_on_digital(self):
-        '''Test on command: digital'''
+    def test_toggle_peripheral_not_found(self):
+        '''Test toggle_peripheral command: peripheral not found'''
         def exec_command():
-            self.fb.on(123)
+            self.fb.toggle_peripheral('New Peripheral')
         self.send_command_test_helper(
             exec_command,
-            expected_command={
-                'kind': 'write_pin',
-                'args': {
-                    'pin_value': 1,
-                    'pin_mode': 0,
-                    'pin_number': {
-                        'kind': 'named_pin',
-                        'args': {'pin_type': 'Peripheral', 'pin_id': 123},
-                    },
-                },
-            },
+            expected_command=None,
             extra_rpc_args={},
-            mock_api_response={'mode': 0})
+            mock_api_response=[])
 
-    def test_on_analog(self):
-        '''Test on command: analog'''
+    def test_on_digital(self):
+        '''Test on command: digital'''
         def exec_command():
-            self.fb.on(123)
+            self.fb.on(13)
         self.send_command_test_helper(
             exec_command,
             expected_command={
                 'kind': 'write_pin',
                 'args': {
-                    'pin_value': 255,
-                    'pin_mode': 1,
-                    'pin_number': {
-                        'kind': 'named_pin',
-                        'args': {'pin_type': 'Peripheral', 'pin_id': 123},
-                    },
+                    'pin_value': 1,
+                    'pin_mode': 0,
+                    'pin_number': 13,
                 },
             },
             extra_rpc_args={},
-            mock_api_response={'mode': 1})
+            mock_api_response={})
 
     def test_off(self):
         '''Test off command'''
         def exec_command():
-            self.fb.off(123)
+            self.fb.off(13)
         self.send_command_test_helper(
             exec_command,
             expected_command={
                 'kind': 'write_pin',
                 'args': {
                     'pin_value': 0,
-                    'pin_mode': 1,
-                    'pin_number': {
-                        'kind': 'named_pin',
-                        'args': {'pin_type': 'Peripheral', 'pin_id': 123},
-                    },
+                    'pin_mode': 0,
+                    'pin_number': 13,
                 },
             },
             extra_rpc_args={},
-            mock_api_response={'mode': 1})
+            mock_api_response={})
 
     def test_move(self):
         '''Test move command'''
@@ -963,13 +947,13 @@ def exec_command():
     def test_control_peripheral(self):
         '''Test control_peripheral command'''
         def exec_command():
-            self.fb.control_peripheral(123, 456, 0)
+            self.fb.control_peripheral('New Peripheral', 1)
         self.send_command_test_helper(
             exec_command,
             expected_command={
                 'kind': 'write_pin',
                 'args': {
-                    'pin_value': 456,
+                    'pin_value': 1,
                     'pin_mode': 0,
                     'pin_number': {
                         'kind': 'named_pin',
@@ -978,7 +962,17 @@ def exec_command():
                 },
             },
             extra_rpc_args={},
-            mock_api_response={'mode': 0})
+            mock_api_response=[{'label': 'New Peripheral', 'mode': 0, 'id': 123}])
+
+    def test_control_peripheral_not_found(self):
+        '''Test control_peripheral command: peripheral not found'''
+        def exec_command():
+            self.fb.control_peripheral('New Peripheral', 1)
+        self.send_command_test_helper(
+            exec_command,
+            expected_command=None,
+            extra_rpc_args={},
+            mock_api_response=[])
 
     def test_measure_soil_height(self):
         '''Test measure_soil_height command'''