Merge branch 'feature/new-rvr-sdk-cmds' into 'develop'

Feature/new rvr sdk cmds

See merge request sdk/v4/convenience/raspberry-pi!73

Author: Rabia Aslam

getting_started/asyncio/driving/control_system_selection.py

@@ -106,11 +106,13 @@ async def main():
     # Delay to allow RVR to drive
     await asyncio.sleep(1)
 
-    # Set the default control system for RC and drive some more
-    control_system_type = ControlSystemTypesEnum.control_system_type_rc_drive
-    controller_id = ControlSystemIdsEnum.rc_drive_rate_mode
-    print('Setting default control system for RC drive to {}'.format(controller_id.name))
-    await rvr.set_default_control_system_for_type(control_system_type = control_system_type, controller_id = controller_id)
+    # Stop the robot
+    print('Stopping...')
+    await rvr.stop_active_controller()
+
+    # Restore initial default control systems
+    print('Restore initial default control systems')
+    await rvr.restore_initial_default_control_systems()
 
     print('Driving with RC...')
     await rvr.drive_rc_si_units(linear_velocity=1, yaw_angular_velocity=0, flags=0 )

getting_started/asyncio/driving/get_encoder_counts.py

@@ -0,0 +1,49 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
+
+import asyncio
+from sphero_sdk import SpheroRvrAsync
+from sphero_sdk import SerialAsyncDal
+
+
+loop = asyncio.get_event_loop()
+
+rvr = SpheroRvrAsync(
+    dal=SerialAsyncDal(
+        loop
+    )
+)
+
+
+async def main():
+    """ This program demonstrates how to get encoder counts on RVR.
+    """
+
+    await rvr.wake()
+
+    # Give RVR time to wake up
+    await asyncio.sleep(2)
+
+    encoder_counts = await rvr.get_encoder_counts()
+    print('Encoder counts: ', encoder_counts)
+
+    await rvr.close()
+
+
+if __name__ == '__main__':
+    try:
+        loop.run_until_complete(
+            main()
+        )
+
+    except KeyboardInterrupt:
+        print('\nProgram terminated with keyboard interrupt.')
+
+        loop.run_until_complete(
+            rvr.close()
+        )
+
+    finally:
+        if loop.is_running():
+            loop.close()

getting_started/asyncio/magnetometer/__init__.py

@@ -0,0 +1,49 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
+
+import asyncio
+from sphero_sdk import SpheroRvrAsync
+from sphero_sdk import SerialAsyncDal
+
+
+loop = asyncio.get_event_loop()
+
+rvr = SpheroRvrAsync(
+    dal=SerialAsyncDal(
+        loop
+    )
+)
+
+
+async def main():
+    """ This program demonstrates how to get a reading from the magnetometer on RVR.
+    """
+
+    await rvr.wake()
+
+    # Give RVR time to wake up
+    await asyncio.sleep(2)
+
+    magnetometer_reading = await rvr.get_magnetometer_reading()
+    print('Magnetometer reading: ', magnetometer_reading)
+
+    await rvr.close()
+
+
+if __name__ == '__main__':
+    try:
+        loop.run_until_complete(
+            main()
+        )
+
+    except KeyboardInterrupt:
+        print('\nProgram terminated with keyboard interrupt.')
+
+        loop.run_until_complete(
+            rvr.close()
+        )
+
+    finally:
+        if loop.is_running():
+            loop.close()

getting_started/asyncio/magnetometer/get_magnetometer_reading.py

@@ -0,0 +1,73 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
+
+import asyncio
+from sphero_sdk import SpheroRvrAsync
+from sphero_sdk import SerialAsyncDal
+
+
+loop = asyncio.get_event_loop()
+
+rvr = SpheroRvrAsync(
+    dal=SerialAsyncDal(
+        loop
+    )
+)
+
+# Flag used to indicate that calibration is complete 
+calibration_completed = False
+
+# Handler for completion of calibration 
+async def on_calibration_complete_notify_handler(response):
+    global calibration_completed
+
+    print('Calibration complete, response:', response)
+    calibration_completed = True 
+
+
+async def main():
+    """ This program demonstrates the magnetometer calibration to find north. 
+    """
+
+    global calibration_completed
+
+    await rvr.wake()
+
+    # Give RVR time to wake up
+    await asyncio.sleep(2)
+
+    # Register for the async on completion of calibration
+    await rvr.on_magnetometer_calibration_complete_notify(handler=on_calibration_complete_notify_handler)
+
+    # Begin calibration 
+    print('Begin magnetometer calibration to find North...')
+    await rvr.magnetometer_calibrate_to_north()
+
+    # Wait to complete the calibration.  Note: In a real project, a timeout mechanism
+    # should be here to prevent the script from getting caught in an infinite loop
+    while (calibration_completed == False):
+        await asyncio.sleep(0)
+
+    await rvr.close();
+    
+
+if __name__ == '__main__':
+    try:
+        loop.run_until_complete(
+            main()
+        )
+
+    except KeyboardInterrupt:
+        print('\nProgram terminated with keyboard interrupt.')
+
+        loop.run_until_complete(
+            asyncio.gather(
+                rvr.disable_notifications_and_active_commands(),
+                rvr.close()
+            )
+        )
+
+    finally:
+        if loop.is_running():
+            loop.close()

getting_started/asyncio/magnetometer/magnetometer_calibrate_to_north.py

@@ -0,0 +1,92 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
+
+import asyncio
+from sphero_sdk import SpheroRvrAsync
+from sphero_sdk import SerialAsyncDal
+from sphero_sdk import RvrStreamingServices
+
+
+loop = asyncio.get_event_loop()
+
+rvr = SpheroRvrAsync(
+    dal=SerialAsyncDal(
+        loop
+    )
+)
+
+
+async def imu_handler(imu_data):
+    print('IMU data response: ', imu_data)
+
+
+async def color_detected_handler(color_detected_data):
+    print('Color detection data response: ', color_detected_data)
+
+
+async def main():
+    """ This program demonstrates how to disable all notifications and active commands.
+    """
+
+    await rvr.wake()
+
+    # Give RVR time to wake up
+    await asyncio.sleep(2)
+
+    print('Initiate streaming IMU and color sensor data...')
+    await rvr.enable_color_detection(is_enabled=True)
+    await rvr.sensor_control.add_sensor_data_handler(
+        service=RvrStreamingServices.imu,
+        handler=imu_handler
+    )
+    await rvr.sensor_control.add_sensor_data_handler(
+        service=RvrStreamingServices.color_detection,
+        handler=color_detected_handler
+    )
+    await rvr.sensor_control.start(interval=1000)
+
+    print('Set the control system timeout to 10s and initiate a drive command...')
+    await rvr.set_custom_control_system_timeout(command_timeout=10000)
+    await rvr.drive_with_yaw_normalized(
+        linear_velocity=32,  # Valid linear_velocity values are in the range [-127..+127]
+        yaw_angle=0  # Valid yaw values are traditionally [-179..+180], but will continue wrapping outside of that range
+    )
+
+    # Delay to allow commands to run 
+    await asyncio.sleep(5)
+
+    # Disable notifications and active commands 
+    await rvr.disable_notifications_and_active_commands()
+    print('Disabling notifications and active commands...')
+
+    # Delay to allow observation that notifications and active commands have been disabled 
+    await asyncio.sleep(5)
+
+    # Restore the default timeout (2 seconds)
+    await rvr.restore_default_control_system_timeout()
+
+    await rvr.close()
+
+
+if __name__ == '__main__':
+    try:
+        loop.run_until_complete(
+            main()
+        )
+
+    except KeyboardInterrupt:
+        print('\nProgram terminated with keyboard interrupt.')
+
+        loop.run_until_complete(
+            asyncio.gather(
+                rvr.disable_notifications_and_active_commands(),
+                # Restore the default timeout (2 seconds)
+                rvr.restore_default_control_system_timeout(),
+                rvr.close()
+            )
+        )
+
+    finally:
+        if loop.is_running():
+            loop.close()

getting_started/asyncio/system/disable_notifications_and_active_commands.py

@@ -2,8 +2,8 @@
 # This file is automatically generated!
 # Toy Name:           Sphero RVR
 # Prefix:             RV
-# Command Count:      86
-# Timestamp:          05/19/2020 @ 15:46:04.409781 (UTC)
+# Command Count:      92
+# Timestamp:          05/30/2020 @ 00:36:04.915980 (UTC)
 
 import asyncio
 import logging.config
@@ -647,6 +647,15 @@ async def get_active_control_system_id(self, timeout=None):
         command_dict = drive.get_active_control_system_id(target=2, timeout=timeout)
         return await self._dal.send_command(**command_dict)
 
+    async def restore_initial_default_control_systems(self, timeout=None): 
+        """Restore initial default control systems.
+
+        Args:
+            timeout (float): maximum time to await a response.
+        """
+        command_dict = drive.restore_initial_default_control_systems(target=2, timeout=timeout)
+        return await self._dal.send_command(**command_dict)
+
     async def get_default_control_system_for_type(self, control_system_type, timeout=None): 
         """Get the ID of the default control system for the given type
 
@@ -729,6 +738,15 @@ async def get_rgbc_sensor_values(self, timeout=None):
         command_dict = sensor.get_rgbc_sensor_values(target=1, timeout=timeout)
         return await self._dal.send_command(**command_dict)
 
+    async def magnetometer_calibrate_to_north(self, timeout=None): 
+        """Start magnetometer calibration to find north.
+
+        Args:
+            timeout (float): maximum time to await a response.
+        """
+        command_dict = sensor.magnetometer_calibrate_to_north(target=2, timeout=timeout)
+        return await self._dal.send_command(**command_dict)
+
     async def start_robot_to_robot_infrared_broadcasting(self, far_code, near_code, timeout=None): 
         """For robot following, broadcasting robots emit two codes: one for long distance (3 meters +), and one for short distance (< 1 meter). Following robots use both of these codes to determine direction and distance from the broadcasting robot.
 
@@ -996,6 +1014,54 @@ async def on_motor_thermal_protection_status_notify(self, handler=None, timeout=
             self._dal.on_command(**command_dict)
         )
 
+    async def on_magnetometer_calibration_complete_notify(self, handler=None, timeout=None): 
+        """Magnetometer calibration complete notify.
+
+        Args:
+            handler (function): called asynchronously, takes form handler(isSuccessful, yawNorthDirection).
+            timeout (float): maximum time to await a response.
+        Returns:
+            Task (Future) from which `handler` will be called
+        """
+        command_dict = sensor.on_magnetometer_calibration_complete_notify(target=2, timeout=timeout)
+        command_dict['handler'] = handler
+        return asyncio.ensure_future( 
+            self._dal.on_command(**command_dict)
+        )
+
+    async def get_magnetometer_reading(self, timeout=None): 
+        """Get current magnetometer reading.
+
+        Args:
+            timeout (float): maximum time to await a response.
+
+        Returns:
+            dict: x_axis (float), y_axis (float), z_axis (float)
+        """
+        command_dict = sensor.get_magnetometer_reading(target=2, timeout=timeout)
+        return await self._dal.send_command(**command_dict)
+
+    async def get_encoder_counts(self, timeout=None): 
+        """Get array of all encoder counts. Returned as left wheel and then right wheel encoder counts.
+
+        Args:
+            timeout (float): maximum time to await a response.
+
+        Returns:
+            dict: encoder_counts (list(int32_t))
+        """
+        command_dict = sensor.get_encoder_counts(target=2, timeout=timeout)
+        return await self._dal.send_command(**command_dict)
+
+    async def disable_notifications_and_active_commands(self, timeout=None): 
+        """Disable notifications and active commands.
+
+        Args:
+            timeout (float): maximum time to await a response.
+        """
+        command_dict = sensor.disable_notifications_and_active_commands(target=1, timeout=timeout)
+        return await self._dal.send_command(**command_dict)
+
     async def get_bluetooth_advertising_name(self, timeout=None): 
         """Returns null-terminated string with the BLE advertising name (e.g., "BL-ABCD").
 

sphero_sdk/asyncio/client/toys/sphero_rvr_async.py

@@ -3,7 +3,7 @@
 # Source File:        0x10-api_and_shell.json
 # Device ID:          0x10
 # Device Name:        api_and_shell
-# Timestamp:          05/19/2020 @ 15:46:04.396461 (UTC)
+# Timestamp:          05/30/2020 @ 00:36:04.905021 (UTC)
 
 from sphero_sdk.common.enums.api_and_shell_enums import CommandsEnum
 from sphero_sdk.common.devices import DevicesEnum