Merge pull request #171 from mavlink/pr-cpp-autogeneration

C++ auto-generation ripple effects

Author: julianoes

.travis.yml

@@ -67,7 +67,7 @@ script:
 - set -e
 - $PYTHON_BIN setup.py bdist_wheel
 - if [[ "${BUILD_TARGET}" = "linux" ]]; then
-    auditwheel repair dist/*.whl;
+    auditwheel repair --plat manylinux2010_x86_64 dist/*.whl;
   fi
 - if [[ "${BUILD_TARGET}" = "macos" ]]; then
     delocate-wheel -w wheelhouse -v dist/*.whl;

MAVSDK_SERVER_VERSION

@@ -1 +1 @@
-v0.23.0
+v0.25.0

README.md

@@ -79,11 +79,12 @@ Run the following helper script. It will generate the Python wrappers for each p
 ./other/tools/run_protoc.sh
 ```
 
-### Install the package locally
+### Build and install the package locally
 
 After generating the wrapper you can install a development (editable) version of the package using:
 
 ```
+python3 setup.py build
 pip3 install -e .
 ```
 

examples/camera.py

@@ -2,7 +2,7 @@
 
 import asyncio
 
-from mavsdk import (CameraError, CameraMode)
+from mavsdk import (CameraError, Mode)
 from mavsdk import System
 
 
@@ -17,11 +17,11 @@ async def run():
             break
 
     asyncio.ensure_future(print_camera_mode(drone))
-    asyncio.ensure_future(print_camera_status(drone))
+    asyncio.ensure_future(print_status(drone))
 
     print("Setting mode to 'PHOTO'")
     try:
-        await drone.camera.set_mode(CameraMode.PHOTO)
+        await drone.camera.set_mode(Mode.PHOTO)
     except CameraError as error:
         print(f"Setting mode failed with error code: {error._result.result}")
 
@@ -34,7 +34,7 @@ async def run():
         print(f"Couldn't take photo: {error._result.result}")
 
     # Shut down the running coroutines (here 'print_camera_mode()' and
-    # 'print_camera_status()')
+    # 'print_status()')
     await asyncio.get_event_loop().shutdown_asyncgens()
 
 
@@ -43,9 +43,9 @@ async def print_camera_mode(drone):
         print(f"Camera mode: {camera_mode}")
 
 
-async def print_camera_status(drone):
-    async for camera_status in drone.camera.camera_status():
-        print(camera_status)
+async def print_status(drone):
+    async for status in drone.camera.status():
+        print(status)
 
 
 if __name__ == "__main__":

examples/mission.py

@@ -3,7 +3,7 @@
 import asyncio
 
 from mavsdk import System
-from mavsdk import (MissionItem)
+from mavsdk import (MissionItem, MissionPlan)
 
 
 async def run():
@@ -51,10 +51,12 @@ async def run():
                                      float('nan'),
                                      float('nan')))
 
+    mission_plan = MissionPlan(mission_items)
+
     await drone.mission.set_return_to_launch_after_mission(True)
 
     print("-- Uploading mission")
-    await drone.mission.upload_mission(mission_items)
+    await drone.mission.upload_mission(mission_plan)
 
     print("-- Arming")
     await drone.action.arm()
@@ -68,8 +70,8 @@ async def run():
 async def print_mission_progress(drone):
     async for mission_progress in drone.mission.mission_progress():
         print(f"Mission progress: "
-              f"{mission_progress.current_item_index}/"
-              f"{mission_progress.mission_count}")
+              f"{mission_progress.current}/"
+              f"{mission_progress.total}")
 
 
 async def observe_is_in_air(drone):

mavsdk/generated/__init__.py

@@ -1,15 +1,15 @@
 # -*- coding: utf-8 -*-
 
-from .camera import *
-from .param import *
-from .telemetry import *
 from .action import *
-from .info import *
-from .gimbal import *
-from .geofence import *
-from .mocap import *
 from .calibration import *
+from .geofence import *
+from .gimbal import *
+from .camera import *
 from .core import *
+from .info import *
 from .mission import *
-from .shell import *
+from .mocap import *
 from .offboard import *
+from .param import *
+from .shell import *
+from .telemetry import *

mavsdk/generated/action.py

@@ -27,10 +27,10 @@ class Result(Enum):
          Values
          ------
          UNKNOWN
-              Unknown error
+              Unknown result
 
          SUCCESS
-              Success: the action command was accepted by the vehicle
+              Request was successful
 
          NO_SYSTEM
               No system is connected
@@ -54,7 +54,7 @@ class Result(Enum):
               Request timed out
 
          VTOL_TRANSITION_SUPPORT_UNKNOWN
-              Hybrid/VTOL transition refused because VTOL support is unknown
+              Hybrid/VTOL transition support is unknown
 
          NO_VTOL_TRANSITION_SUPPORT
               Vehicle does not support hybrid/VTOL transitions
@@ -79,38 +79,58 @@ class Result(Enum):
         PARAMETER_ERROR = 11
 
         def translate_to_rpc(self, rpcResult):
-            return {
-                    0: action_pb2.ActionResult.UNKNOWN,
-                    1: action_pb2.ActionResult.SUCCESS,
-                    2: action_pb2.ActionResult.NO_SYSTEM,
-                    3: action_pb2.ActionResult.CONNECTION_ERROR,
-                    4: action_pb2.ActionResult.BUSY,
-                    5: action_pb2.ActionResult.COMMAND_DENIED,
-                    6: action_pb2.ActionResult.COMMAND_DENIED_LANDED_STATE_UNKNOWN,
-                    7: action_pb2.ActionResult.COMMAND_DENIED_NOT_LANDED,
-                    8: action_pb2.ActionResult.TIMEOUT,
-                    9: action_pb2.ActionResult.VTOL_TRANSITION_SUPPORT_UNKNOWN,
-                    10: action_pb2.ActionResult.NO_VTOL_TRANSITION_SUPPORT,
-                    11: action_pb2.ActionResult.PARAMETER_ERROR
-                }.get(self.value, None)
+            if self == ActionResult.Result.UNKNOWN:
+                return action_pb2.ActionResult.RESULT_UNKNOWN
+            if self == ActionResult.Result.SUCCESS:
+                return action_pb2.ActionResult.RESULT_SUCCESS
+            if self == ActionResult.Result.NO_SYSTEM:
+                return action_pb2.ActionResult.RESULT_NO_SYSTEM
+            if self == ActionResult.Result.CONNECTION_ERROR:
+                return action_pb2.ActionResult.RESULT_CONNECTION_ERROR
+            if self == ActionResult.Result.BUSY:
+                return action_pb2.ActionResult.RESULT_BUSY
+            if self == ActionResult.Result.COMMAND_DENIED:
+                return action_pb2.ActionResult.RESULT_COMMAND_DENIED
+            if self == ActionResult.Result.COMMAND_DENIED_LANDED_STATE_UNKNOWN:
+                return action_pb2.ActionResult.RESULT_COMMAND_DENIED_LANDED_STATE_UNKNOWN
+            if self == ActionResult.Result.COMMAND_DENIED_NOT_LANDED:
+                return action_pb2.ActionResult.RESULT_COMMAND_DENIED_NOT_LANDED
+            if self == ActionResult.Result.TIMEOUT:
+                return action_pb2.ActionResult.RESULT_TIMEOUT
+            if self == ActionResult.Result.VTOL_TRANSITION_SUPPORT_UNKNOWN:
+                return action_pb2.ActionResult.RESULT_VTOL_TRANSITION_SUPPORT_UNKNOWN
+            if self == ActionResult.Result.NO_VTOL_TRANSITION_SUPPORT:
+                return action_pb2.ActionResult.RESULT_NO_VTOL_TRANSITION_SUPPORT
+            if self == ActionResult.Result.PARAMETER_ERROR:
+                return action_pb2.ActionResult.RESULT_PARAMETER_ERROR
 
         @staticmethod
         def translate_from_rpc(rpc_enum_value):
             """ Parses a gRPC response """
-            return {
-                    0: ActionResult.Result.UNKNOWN,
-                    1: ActionResult.Result.SUCCESS,
-                    2: ActionResult.Result.NO_SYSTEM,
-                    3: ActionResult.Result.CONNECTION_ERROR,
-                    4: ActionResult.Result.BUSY,
-                    5: ActionResult.Result.COMMAND_DENIED,
-                    6: ActionResult.Result.COMMAND_DENIED_LANDED_STATE_UNKNOWN,
-                    7: ActionResult.Result.COMMAND_DENIED_NOT_LANDED,
-                    8: ActionResult.Result.TIMEOUT,
-                    9: ActionResult.Result.VTOL_TRANSITION_SUPPORT_UNKNOWN,
-                    10: ActionResult.Result.NO_VTOL_TRANSITION_SUPPORT,
-                    11: ActionResult.Result.PARAMETER_ERROR,
-                }.get(rpc_enum_value, None)
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_UNKNOWN:
+                return ActionResult.Result.UNKNOWN
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_SUCCESS:
+                return ActionResult.Result.SUCCESS
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_NO_SYSTEM:
+                return ActionResult.Result.NO_SYSTEM
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_CONNECTION_ERROR:
+                return ActionResult.Result.CONNECTION_ERROR
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_BUSY:
+                return ActionResult.Result.BUSY
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_COMMAND_DENIED:
+                return ActionResult.Result.COMMAND_DENIED
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_COMMAND_DENIED_LANDED_STATE_UNKNOWN:
+                return ActionResult.Result.COMMAND_DENIED_LANDED_STATE_UNKNOWN
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_COMMAND_DENIED_NOT_LANDED:
+                return ActionResult.Result.COMMAND_DENIED_NOT_LANDED
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_TIMEOUT:
+                return ActionResult.Result.TIMEOUT
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_VTOL_TRANSITION_SUPPORT_UNKNOWN:
+                return ActionResult.Result.VTOL_TRANSITION_SUPPORT_UNKNOWN
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_NO_VTOL_TRANSITION_SUPPORT:
+                return ActionResult.Result.NO_VTOL_TRANSITION_SUPPORT
+            if rpc_enum_value == action_pb2.ActionResult.RESULT_PARAMETER_ERROR:
+                return ActionResult.Result.PARAMETER_ERROR
 
         def __str__(self):
             return self.name
@@ -257,7 +277,7 @@ async def takeoff(self):
         """
          Send command to take off and hover.
 
-         This switches the drone into position control mode and commands 
+         This switches the drone into position control mode and commands
          it to take off and hover at the takeoff altitude.
 
          Note that the vehicle must be armed before it can take off.
@@ -322,9 +342,33 @@ async def reboot(self):
             raise ActionError(result, "reboot()")
 
 
+    async def shutdown(self):
+        """
+         Send command to shut down the drone components.
+
+         This will shut down the autopilot, onboard computer, camera and gimbal.
+         This command should only be used when the autopilot is disarmed and autopilots commonly
+         reject it if they are not already ready to shut down.
+
+         Raises
+         ------
+         ActionError
+             If the request fails. The error contains the reason for the failure.
+        """
+
+        request = action_pb2.ShutdownRequest()
+        response = await self._stub.Shutdown(request)
+
+        
+        result = self._extract_result(response)
+
+        if result.result is not ActionResult.Result.SUCCESS:
+            raise ActionError(result, "shutdown()")
+        
+
     async def kill(self):
         """
-         Send command to kill the drone. 
+         Send command to kill the drone.
 
          This will disarm a drone irrespective of whether it is landed or flying.
          Note that the drone will fall out of the sky if this command is used while flying.
@@ -349,7 +393,7 @@ async def return_to_launch(self):
         """
          Send command to return to the launch (takeoff) position and land.
 
-         This switches the drone into [RTL mode](https://docs.px4.io/en/flight_modes/rtl.html) which
+         This switches the drone into [Return mode](https://docs.px4.io/master/en/flight_modes/return.html) which
          generally means it will rise up to a certain altitude to clear any obstacles before heading
          back to the launch (takeoff) position and land there.
 
@@ -369,7 +413,50 @@ async def return_to_launch(self):
             raise ActionError(result, "return_to_launch()")
 
 
-    async def transition_to_fixed_wing(self):
+    async def goto_location(self, latitude_deg, longitude_deg, absolute_altitude_m, yaw_deg):
+        """
+         Send command to move the vehicle to a specific global position.
+
+         The latitude and longitude are given in degrees (WGS84 frame) and the altitude
+         in meters AMSL (above mean sea level).
+
+         The yaw angle is in degrees (frame is NED, 0 is North, positive is clockwise).
+
+         Parameters
+         ----------
+         latitude_deg : double
+              Latitude (in degrees)
+
+         longitude_deg : double
+              Longitude (in degrees)
+
+         absolute_altitude_m : float
+              Altitude AMSL (in meters)
+
+         yaw_deg : float
+              Yaw angle (in degrees, frame is NED, 0 is North, positive is clockwise)
+
+         Raises
+         ------
+         ActionError
+             If the request fails. The error contains the reason for the failure.
+        """
+
+        request = action_pb2.GotoLocationRequest()
+        request.latitude_deg = latitude_deg
+        request.longitude_deg = longitude_deg
+        request.absolute_altitude_m = absolute_altitude_m
+        request.yaw_deg = yaw_deg
+        response = await self._stub.GotoLocation(request)
+
+        
+        result = self._extract_result(response)
+
+        if result.result is not ActionResult.Result.SUCCESS:
+            raise ActionError(result, "goto_location()", latitude_deg, longitude_deg, absolute_altitude_m, yaw_deg)
+        
+
+    async def transition_to_fixedwing(self):
         """
          Send command to transition the drone to fixedwing.
 
@@ -383,14 +470,14 @@ async def transition_to_fixed_wing(self):
              If the request fails. The error contains the reason for the failure.
         """
 
-        request = action_pb2.TransitionToFixedWingRequest()
-        response = await self._stub.TransitionToFixedWing(request)
+        request = action_pb2.TransitionToFixedwingRequest()
+        response = await self._stub.TransitionToFixedwing(request)
 
 
         result = self._extract_result(response)
 
         if result.result is not ActionResult.Result.SUCCESS:
-            raise ActionError(result, "transition_to_fixed_wing()")
+            raise ActionError(result, "transition_to_fixedwing()")
 
 
     async def transition_to_multicopter(self):