diff --git a/mavsdk/generated/__init__.py b/mavsdk/generated/__init__.py index 6b774d74..3d387164 100644 --- a/mavsdk/generated/__init__.py +++ b/mavsdk/generated/__init__.py @@ -7,6 +7,7 @@ from .info import * from .gimbal import * from .geofence import * +from .mocap import * from .calibration import * from .core import * from .mission import * diff --git a/mavsdk/generated/mocap.py b/mavsdk/generated/mocap.py new file mode 100644 index 00000000..5e33d991 --- /dev/null +++ b/mavsdk/generated/mocap.py @@ -0,0 +1,1205 @@ +# -*- coding: utf-8 -*- +from .._base import AsyncBase +from ..generated import mocap_pb2, mocap_pb2_grpc +from enum import Enum + + +class VisionPositionEstimate: + """ + Global position/attitude estimate from a vision source. + + Parameters + ---------- + time_usec : uint64_t + PositionBody frame timestamp UNIX Epoch time (0 to use Backend timestamp) + + position_body : PositionBody + Global position (m) + + angle_body : AngleBody + Body angle (rad). + + pose_covariance : Covariance + Pose cross-covariance matrix. + + """ + + + + def __init__( + self, + time_usec, + position_body, + angle_body, + pose_covariance): + """ Initializes the VisionPositionEstimate object """ + self.time_usec = time_usec + self.position_body = position_body + self.angle_body = angle_body + self.pose_covariance = pose_covariance + + def __equals__(self, to_compare): + """ Checks if two VisionPositionEstimate are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # VisionPositionEstimate object + return \ + (self.time_usec == to_compare.time_usec) and \ + (self.position_body == to_compare.position_body) and \ + (self.angle_body == to_compare.angle_body) and \ + (self.pose_covariance == to_compare.pose_covariance) + + except AttributeError: + return False + + def __str__(self): + """ VisionPositionEstimate in string representation """ + struct_repr = ", ".join([ + "time_usec: " + str(self.time_usec), + "position_body: " + str(self.position_body), + "angle_body: " + str(self.angle_body), + "pose_covariance: " + str(self.pose_covariance) + ]) + + return f"VisionPositionEstimate: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcVisionPositionEstimate): + """ Translates a gRPC struct to the SDK equivalent """ + return VisionPositionEstimate( + + rpcVisionPositionEstimate.time_usec, + + + PositionBody.translate_from_rpc(rpcVisionPositionEstimate.position_body), + + + AngleBody.translate_from_rpc(rpcVisionPositionEstimate.angle_body), + + + Covariance.translate_from_rpc(rpcVisionPositionEstimate.pose_covariance) + ) + + def translate_to_rpc(self, rpcVisionPositionEstimate): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcVisionPositionEstimate.time_usec = self.time_usec + + + + + + self.position_body.translate_to_rpc(rpcVisionPositionEstimate.position_body) + + + + + + self.angle_body.translate_to_rpc(rpcVisionPositionEstimate.angle_body) + + + + + + self.pose_covariance.translate_to_rpc(rpcVisionPositionEstimate.pose_covariance) + + + + + +class AttitudePositionMocap: + """ + Motion capture attitude and position + + Parameters + ---------- + time_usec : uint64_t + PositionBody frame timestamp UNIX Epoch time (0 to use Backend timestamp) + + q : Quaternion + Attitude quaternion (w, x, y, z order, zero-rotation is 1, 0, 0, 0) + + position_body : PositionBody + Body Position (NED) + + pose_covariance : Covariance + Pose cross-covariance matrix. + + """ + + + + def __init__( + self, + time_usec, + q, + position_body, + pose_covariance): + """ Initializes the AttitudePositionMocap object """ + self.time_usec = time_usec + self.q = q + self.position_body = position_body + self.pose_covariance = pose_covariance + + def __equals__(self, to_compare): + """ Checks if two AttitudePositionMocap are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # AttitudePositionMocap object + return \ + (self.time_usec == to_compare.time_usec) and \ + (self.q == to_compare.q) and \ + (self.position_body == to_compare.position_body) and \ + (self.pose_covariance == to_compare.pose_covariance) + + except AttributeError: + return False + + def __str__(self): + """ AttitudePositionMocap in string representation """ + struct_repr = ", ".join([ + "time_usec: " + str(self.time_usec), + "q: " + str(self.q), + "position_body: " + str(self.position_body), + "pose_covariance: " + str(self.pose_covariance) + ]) + + return f"AttitudePositionMocap: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcAttitudePositionMocap): + """ Translates a gRPC struct to the SDK equivalent """ + return AttitudePositionMocap( + + rpcAttitudePositionMocap.time_usec, + + + Quaternion.translate_from_rpc(rpcAttitudePositionMocap.q), + + + PositionBody.translate_from_rpc(rpcAttitudePositionMocap.position_body), + + + Covariance.translate_from_rpc(rpcAttitudePositionMocap.pose_covariance) + ) + + def translate_to_rpc(self, rpcAttitudePositionMocap): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcAttitudePositionMocap.time_usec = self.time_usec + + + + + + self.q.translate_to_rpc(rpcAttitudePositionMocap.q) + + + + + + self.position_body.translate_to_rpc(rpcAttitudePositionMocap.position_body) + + + + + + self.pose_covariance.translate_to_rpc(rpcAttitudePositionMocap.pose_covariance) + + + + + +class Odometry: + """ + Odometry message to communicate odometry information with an external interface. + + Parameters + ---------- + time_usec : uint64_t + Timestamp (0 to use Backend timestamp). + + frame_id : MavFrame + Coordinate frame of reference for the pose data. + + position_body : PositionBody + Body Position. + + q : Quaternion + Quaternion components, w, x, y, z (1 0 0 0 is the null-rotation). + + speed_body : SpeedBody + Linear speed (m/s). + + angular_velocity_body : AngularVelocityBody + Angular speed (rad/s). + + pose_covariance : Covariance + Pose cross-covariance matrix. + + velocity_covariance : Covariance + Velocity cross-covariance matrix. + + """ + + + + class MavFrame(Enum): + """ + Mavlink frame id + + Values + ------ + MOCAP_NED + Odometry local coordinate frame of data given by a motion capture system, Z-down (x: north, y: east, z: down). + + LOCAL_FRD + Forward, Right, Down coordinate frame. This is a local frame with Z-down and arbitrary F/R alignment (i.e. not aligned with NED/earth frame). Replacement for MAV_FRAME_MOCAP_NED, MAV_FRAME_VISION_NED, MAV_FRAME_ESTIM_NED. + + """ + + + MOCAP_NED = 14 + LOCAL_FRD = 20 + + def translate_to_rpc(self, rpcMavFrame): + return { + 14: mocap_pb2.Odometry.MOCAP_NED, + 20: mocap_pb2.Odometry.LOCAL_FRD + }.get(self.value, None) + + @staticmethod + def translate_from_rpc(rpc_enum_value): + """ Parses a gRPC response """ + return { + 14: Odometry.MavFrame.MOCAP_NED, + 20: Odometry.MavFrame.LOCAL_FRD, + }.get(rpc_enum_value, None) + + def __str__(self): + return self.name + + + def __init__( + self, + time_usec, + frame_id, + position_body, + q, + speed_body, + angular_velocity_body, + pose_covariance, + velocity_covariance): + """ Initializes the Odometry object """ + self.time_usec = time_usec + self.frame_id = frame_id + self.position_body = position_body + self.q = q + self.speed_body = speed_body + self.angular_velocity_body = angular_velocity_body + self.pose_covariance = pose_covariance + self.velocity_covariance = velocity_covariance + + def __equals__(self, to_compare): + """ Checks if two Odometry are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # Odometry object + return \ + (self.time_usec == to_compare.time_usec) and \ + (self.frame_id == to_compare.frame_id) and \ + (self.position_body == to_compare.position_body) and \ + (self.q == to_compare.q) and \ + (self.speed_body == to_compare.speed_body) and \ + (self.angular_velocity_body == to_compare.angular_velocity_body) and \ + (self.pose_covariance == to_compare.pose_covariance) and \ + (self.velocity_covariance == to_compare.velocity_covariance) + + except AttributeError: + return False + + def __str__(self): + """ Odometry in string representation """ + struct_repr = ", ".join([ + "time_usec: " + str(self.time_usec), + "frame_id: " + str(self.frame_id), + "position_body: " + str(self.position_body), + "q: " + str(self.q), + "speed_body: " + str(self.speed_body), + "angular_velocity_body: " + str(self.angular_velocity_body), + "pose_covariance: " + str(self.pose_covariance), + "velocity_covariance: " + str(self.velocity_covariance) + ]) + + return f"Odometry: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcOdometry): + """ Translates a gRPC struct to the SDK equivalent """ + return Odometry( + + rpcOdometry.time_usec, + + + Odometry.MavFrame.translate_from_rpc(rpcOdometry.frame_id), + + + PositionBody.translate_from_rpc(rpcOdometry.position_body), + + + Quaternion.translate_from_rpc(rpcOdometry.q), + + + SpeedBody.translate_from_rpc(rpcOdometry.speed_body), + + + AngularVelocityBody.translate_from_rpc(rpcOdometry.angular_velocity_body), + + + Covariance.translate_from_rpc(rpcOdometry.pose_covariance), + + + Covariance.translate_from_rpc(rpcOdometry.velocity_covariance) + ) + + def translate_to_rpc(self, rpcOdometry): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcOdometry.time_usec = self.time_usec + + + + + + self.frame_id.translate_to_rpc(rpcOdometry.frame_id) + + + + + + self.position_body.translate_to_rpc(rpcOdometry.position_body) + + + + + + self.q.translate_to_rpc(rpcOdometry.q) + + + + + + self.speed_body.translate_to_rpc(rpcOdometry.speed_body) + + + + + + self.angular_velocity_body.translate_to_rpc(rpcOdometry.angular_velocity_body) + + + + + + self.pose_covariance.translate_to_rpc(rpcOdometry.pose_covariance) + + + + + + self.velocity_covariance.translate_to_rpc(rpcOdometry.velocity_covariance) + + + + + +class PositionBody: + """ + Body position type + + Parameters + ---------- + x_m : float + X position in metres. + + y_m : float + Y position in metres. + + z_m : float + Z position in metres. + + """ + + + + def __init__( + self, + x_m, + y_m, + z_m): + """ Initializes the PositionBody object """ + self.x_m = x_m + self.y_m = y_m + self.z_m = z_m + + def __equals__(self, to_compare): + """ Checks if two PositionBody are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # PositionBody object + return \ + (self.x_m == to_compare.x_m) and \ + (self.y_m == to_compare.y_m) and \ + (self.z_m == to_compare.z_m) + + except AttributeError: + return False + + def __str__(self): + """ PositionBody in string representation """ + struct_repr = ", ".join([ + "x_m: " + str(self.x_m), + "y_m: " + str(self.y_m), + "z_m: " + str(self.z_m) + ]) + + return f"PositionBody: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcPositionBody): + """ Translates a gRPC struct to the SDK equivalent """ + return PositionBody( + + rpcPositionBody.x_m, + + + rpcPositionBody.y_m, + + + rpcPositionBody.z_m + ) + + def translate_to_rpc(self, rpcPositionBody): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcPositionBody.x_m = self.x_m + + + + + + rpcPositionBody.y_m = self.y_m + + + + + + rpcPositionBody.z_m = self.z_m + + + + + +class AngleBody: + """ + Body angle type + + Parameters + ---------- + roll_rad : float + Roll angle in radians. + + pitch_rad : float + Pitch angle in radians. + + yaw_rad : float + Yaw angle in radians. + + """ + + + + def __init__( + self, + roll_rad, + pitch_rad, + yaw_rad): + """ Initializes the AngleBody object """ + self.roll_rad = roll_rad + self.pitch_rad = pitch_rad + self.yaw_rad = yaw_rad + + def __equals__(self, to_compare): + """ Checks if two AngleBody are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # AngleBody object + return \ + (self.roll_rad == to_compare.roll_rad) and \ + (self.pitch_rad == to_compare.pitch_rad) and \ + (self.yaw_rad == to_compare.yaw_rad) + + except AttributeError: + return False + + def __str__(self): + """ AngleBody in string representation """ + struct_repr = ", ".join([ + "roll_rad: " + str(self.roll_rad), + "pitch_rad: " + str(self.pitch_rad), + "yaw_rad: " + str(self.yaw_rad) + ]) + + return f"AngleBody: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcAngleBody): + """ Translates a gRPC struct to the SDK equivalent """ + return AngleBody( + + rpcAngleBody.roll_rad, + + + rpcAngleBody.pitch_rad, + + + rpcAngleBody.yaw_rad + ) + + def translate_to_rpc(self, rpcAngleBody): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcAngleBody.roll_rad = self.roll_rad + + + + + + rpcAngleBody.pitch_rad = self.pitch_rad + + + + + + rpcAngleBody.yaw_rad = self.yaw_rad + + + + + +class SpeedBody: + """ + Speed type, represented in the Body (X Y Z) frame and in metres/second. + + Parameters + ---------- + x_m_s : float + Velocity in X in metres/second. + + y_m_s : float + Velocity in Y in metres/second. + + z_m_s : float + Velocity in Z in metres/second. + + """ + + + + def __init__( + self, + x_m_s, + y_m_s, + z_m_s): + """ Initializes the SpeedBody object """ + self.x_m_s = x_m_s + self.y_m_s = y_m_s + self.z_m_s = z_m_s + + def __equals__(self, to_compare): + """ Checks if two SpeedBody are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # SpeedBody object + return \ + (self.x_m_s == to_compare.x_m_s) and \ + (self.y_m_s == to_compare.y_m_s) and \ + (self.z_m_s == to_compare.z_m_s) + + except AttributeError: + return False + + def __str__(self): + """ SpeedBody in string representation """ + struct_repr = ", ".join([ + "x_m_s: " + str(self.x_m_s), + "y_m_s: " + str(self.y_m_s), + "z_m_s: " + str(self.z_m_s) + ]) + + return f"SpeedBody: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcSpeedBody): + """ Translates a gRPC struct to the SDK equivalent """ + return SpeedBody( + + rpcSpeedBody.x_m_s, + + + rpcSpeedBody.y_m_s, + + + rpcSpeedBody.z_m_s + ) + + def translate_to_rpc(self, rpcSpeedBody): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcSpeedBody.x_m_s = self.x_m_s + + + + + + rpcSpeedBody.y_m_s = self.y_m_s + + + + + + rpcSpeedBody.z_m_s = self.z_m_s + + + + + +class AngularVelocityBody: + """ + Angular velocity type + + Parameters + ---------- + roll_rad_s : float + Roll angular velocity in radians/second. + + pitch_rad_s : float + Pitch angular velocity in radians/second. + + yaw_rad_s : float + Yaw angular velocity in radians/second. + + """ + + + + def __init__( + self, + roll_rad_s, + pitch_rad_s, + yaw_rad_s): + """ Initializes the AngularVelocityBody object """ + self.roll_rad_s = roll_rad_s + self.pitch_rad_s = pitch_rad_s + self.yaw_rad_s = yaw_rad_s + + def __equals__(self, to_compare): + """ Checks if two AngularVelocityBody are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # AngularVelocityBody object + return \ + (self.roll_rad_s == to_compare.roll_rad_s) and \ + (self.pitch_rad_s == to_compare.pitch_rad_s) and \ + (self.yaw_rad_s == to_compare.yaw_rad_s) + + except AttributeError: + return False + + def __str__(self): + """ AngularVelocityBody in string representation """ + struct_repr = ", ".join([ + "roll_rad_s: " + str(self.roll_rad_s), + "pitch_rad_s: " + str(self.pitch_rad_s), + "yaw_rad_s: " + str(self.yaw_rad_s) + ]) + + return f"AngularVelocityBody: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcAngularVelocityBody): + """ Translates a gRPC struct to the SDK equivalent """ + return AngularVelocityBody( + + rpcAngularVelocityBody.roll_rad_s, + + + rpcAngularVelocityBody.pitch_rad_s, + + + rpcAngularVelocityBody.yaw_rad_s + ) + + def translate_to_rpc(self, rpcAngularVelocityBody): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcAngularVelocityBody.roll_rad_s = self.roll_rad_s + + + + + + rpcAngularVelocityBody.pitch_rad_s = self.pitch_rad_s + + + + + + rpcAngularVelocityBody.yaw_rad_s = self.yaw_rad_s + + + + + +class Covariance: + """ + Covariance type. + Row-major representation of a 6x6 cross-covariance matrix + upper right triangle. + Set first to NaN if unknown. + + Parameters + ---------- + covariance_matrix : [float] + + """ + + + + def __init__( + self, + covariance_matrix): + """ Initializes the Covariance object """ + self.covariance_matrix = covariance_matrix + + def __equals__(self, to_compare): + """ Checks if two Covariance are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # Covariance object + return \ + (self.covariance_matrix == to_compare.covariance_matrix) + + except AttributeError: + return False + + def __str__(self): + """ Covariance in string representation """ + struct_repr = ", ".join([ + "covariance_matrix: " + str(self.covariance_matrix) + ]) + + return f"Covariance: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcCovariance): + """ Translates a gRPC struct to the SDK equivalent """ + return Covariance( + + rpcCovariance.covariance_matrix + ) + + def translate_to_rpc(self, rpcCovariance): + """ Translates this SDK object into its gRPC equivalent """ + + + + + for elem in self.covariance_matrix: + rpcCovariance.covariance_matrix.append(elem) + + + + + +class Quaternion: + """ + Quaternion type. + + All rotations and axis systems follow the right-hand rule. + The Hamilton quaternion product definition is used. + A zero-rotation quaternion is represented by (1,0,0,0). + The quaternion could also be written as w + xi + yj + zk. + + For more info see: https://en.wikipedia.org/wiki/Quaternion + + Parameters + ---------- + w : float + Quaternion entry 0, also denoted as a + + x : float + Quaternion entry 1, also denoted as b + + y : float + Quaternion entry 2, also denoted as c + + z : float + Quaternion entry 3, also denoted as d + + """ + + + + def __init__( + self, + w, + x, + y, + z): + """ Initializes the Quaternion object """ + self.w = w + self.x = x + self.y = y + self.z = z + + def __equals__(self, to_compare): + """ Checks if two Quaternion are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # Quaternion object + return \ + (self.w == to_compare.w) and \ + (self.x == to_compare.x) and \ + (self.y == to_compare.y) and \ + (self.z == to_compare.z) + + except AttributeError: + return False + + def __str__(self): + """ Quaternion in string representation """ + struct_repr = ", ".join([ + "w: " + str(self.w), + "x: " + str(self.x), + "y: " + str(self.y), + "z: " + str(self.z) + ]) + + return f"Quaternion: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcQuaternion): + """ Translates a gRPC struct to the SDK equivalent """ + return Quaternion( + + rpcQuaternion.w, + + + rpcQuaternion.x, + + + rpcQuaternion.y, + + + rpcQuaternion.z + ) + + def translate_to_rpc(self, rpcQuaternion): + """ Translates this SDK object into its gRPC equivalent """ + + + + + rpcQuaternion.w = self.w + + + + + + rpcQuaternion.x = self.x + + + + + + rpcQuaternion.y = self.y + + + + + + rpcQuaternion.z = self.z + + + + + +class MocapResult: + """ + Result type. + + Parameters + ---------- + result : Result + Result enum value + + result_str : std::string + Human-readable English string describing the result + + """ + + + + class Result(Enum): + """ + Possible results returned for mocap requests + + Values + ------ + UNKNOWN + Unknown error + + SUCCESS + Request succeeded + + NO_SYSTEM + No system is connected + + CONNECTION_ERROR + Connection error + + INVALID_REQUEST_DATA + Invalid request data + + """ + + + UNKNOWN = 0 + SUCCESS = 1 + NO_SYSTEM = 2 + CONNECTION_ERROR = 3 + INVALID_REQUEST_DATA = 4 + + def translate_to_rpc(self, rpcResult): + return { + 0: mocap_pb2.MocapResult.UNKNOWN, + 1: mocap_pb2.MocapResult.SUCCESS, + 2: mocap_pb2.MocapResult.NO_SYSTEM, + 3: mocap_pb2.MocapResult.CONNECTION_ERROR, + 4: mocap_pb2.MocapResult.INVALID_REQUEST_DATA + }.get(self.value, None) + + @staticmethod + def translate_from_rpc(rpc_enum_value): + """ Parses a gRPC response """ + return { + 0: MocapResult.Result.UNKNOWN, + 1: MocapResult.Result.SUCCESS, + 2: MocapResult.Result.NO_SYSTEM, + 3: MocapResult.Result.CONNECTION_ERROR, + 4: MocapResult.Result.INVALID_REQUEST_DATA, + }.get(rpc_enum_value, None) + + def __str__(self): + return self.name + + + def __init__( + self, + result, + result_str): + """ Initializes the MocapResult object """ + self.result = result + self.result_str = result_str + + def __equals__(self, to_compare): + """ Checks if two MocapResult are the same """ + try: + # Try to compare - this likely fails when it is compared to a non + # MocapResult object + return \ + (self.result == to_compare.result) and \ + (self.result_str == to_compare.result_str) + + except AttributeError: + return False + + def __str__(self): + """ MocapResult in string representation """ + struct_repr = ", ".join([ + "result: " + str(self.result), + "result_str: " + str(self.result_str) + ]) + + return f"MocapResult: [{struct_repr}]" + + @staticmethod + def translate_from_rpc(rpcMocapResult): + """ Translates a gRPC struct to the SDK equivalent """ + return MocapResult( + + MocapResult.Result.translate_from_rpc(rpcMocapResult.result), + + + rpcMocapResult.result_str + ) + + def translate_to_rpc(self, rpcMocapResult): + """ Translates this SDK object into its gRPC equivalent """ + + + + + self.result.translate_to_rpc(rpcMocapResult.result) + + + + + + rpcMocapResult.result_str = self.result_str + + + + + + +class MocapError(Exception): + """ Raised when a MocapResult is a fail code """ + + def __init__(self, result, origin, *params): + self._result = result + self._origin = origin + self._params = params + + def __str__(self): + return f"{self._result.result}: '{self._result.result_str}'; origin: {self._origin}; params: {self._params}" + + +class Mocap(AsyncBase): + """ + * + Motion Capture allow vehicles to navigate when a global + position source is unavailable or unreliable + (e.g. indoors, or when flying under a bridge. etc.). + + Generated by dcsdkgen - MAVSDK Mocap API + """ + + # Plugin name + name = "Mocap" + + def _setup_stub(self, channel): + """ Setups the api stub """ + self._stub = mocap_pb2_grpc.MocapServiceStub(channel) + + + def _extract_result(self, response): + """ Returns the response status and description """ + return MocapResult.translate_from_rpc(response.mocap_result) + + + async def set_vision_position_estimate(self, vision_position_estimate): + """ + Send Global position/attitude estimate from a vision source. + + Parameters + ---------- + vision_position_estimate : VisionPositionEstimate + + Raises + ------ + MocapError + If the request fails. The error contains the reason for the failure. + """ + + request = mocap_pb2.SetVisionPositionEstimateRequest() + + vision_position_estimate.translate_to_rpc(request.vision_position_estimate) + + + response = await self._stub.SetVisionPositionEstimate(request) + + + result = self._extract_result(response) + + if result.result is not MocapResult.Result.SUCCESS: + raise MocapError(result, "set_vision_position_estimate()", vision_position_estimate) + + + async def set_attitude_position_mocap(self, attitude_position_mocap): + """ + Send motion capture attitude and position. + + Parameters + ---------- + attitude_position_mocap : AttitudePositionMocap + + Raises + ------ + MocapError + If the request fails. The error contains the reason for the failure. + """ + + request = mocap_pb2.SetAttitudePositionMocapRequest() + + attitude_position_mocap.translate_to_rpc(request.attitude_position_mocap) + + + response = await self._stub.SetAttitudePositionMocap(request) + + + result = self._extract_result(response) + + if result.result is not MocapResult.Result.SUCCESS: + raise MocapError(result, "set_attitude_position_mocap()", attitude_position_mocap) + + + async def set_odometry(self, odometry): + """ + Send odometry information with an external interface. + + Parameters + ---------- + odometry : Odometry + + Raises + ------ + MocapError + If the request fails. The error contains the reason for the failure. + """ + + request = mocap_pb2.SetOdometryRequest() + + odometry.translate_to_rpc(request.odometry) + + + response = await self._stub.SetOdometry(request) + + + result = self._extract_result(response) + + if result.result is not MocapResult.Result.SUCCESS: + raise MocapError(result, "set_odometry()", odometry) + \ No newline at end of file diff --git a/mavsdk/generated/mocap_pb2.py b/mavsdk/generated/mocap_pb2.py new file mode 100644 index 00000000..cfaaa6ca --- /dev/null +++ b/mavsdk/generated/mocap_pb2.py @@ -0,0 +1,957 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: mocap.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='mocap.proto', + package='mavsdk.rpc.mocap', + syntax='proto3', + serialized_options=_b('\n\017io.mavsdk.mocapB\nMocapProto'), + serialized_pb=_b('\n\x0bmocap.proto\x12\x10mavsdk.rpc.mocap\"n\n SetVisionPositionEstimateRequest\x12J\n\x18vision_position_estimate\x18\x01 \x01(\x0b\x32(.mavsdk.rpc.mocap.VisionPositionEstimate\"X\n!SetVisionPositionEstimateResponse\x12\x33\n\x0cmocap_result\x18\x01 \x01(\x0b\x32\x1d.mavsdk.rpc.mocap.MocapResult\"k\n\x1fSetAttitudePositionMocapRequest\x12H\n\x17\x61ttitude_position_mocap\x18\x01 \x01(\x0b\x32\'.mavsdk.rpc.mocap.AttitudePositionMocap\"W\n SetAttitudePositionMocapResponse\x12\x33\n\x0cmocap_result\x18\x01 \x01(\x0b\x32\x1d.mavsdk.rpc.mocap.MocapResult\"B\n\x12SetOdometryRequest\x12,\n\x08odometry\x18\x01 \x01(\x0b\x32\x1a.mavsdk.rpc.mocap.Odometry\"J\n\x13SetOdometryResponse\x12\x33\n\x0cmocap_result\x18\x01 \x01(\x0b\x32\x1d.mavsdk.rpc.mocap.MocapResult\"\xca\x01\n\x16VisionPositionEstimate\x12\x11\n\ttime_usec\x18\x01 \x01(\x04\x12\x35\n\rposition_body\x18\x02 \x01(\x0b\x32\x1e.mavsdk.rpc.mocap.PositionBody\x12/\n\nangle_body\x18\x03 \x01(\x0b\x32\x1b.mavsdk.rpc.mocap.AngleBody\x12\x35\n\x0fpose_covariance\x18\x04 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Covariance\"\xc1\x01\n\x15\x41ttitudePositionMocap\x12\x11\n\ttime_usec\x18\x01 \x01(\x04\x12\'\n\x01q\x18\x02 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Quaternion\x12\x35\n\rposition_body\x18\x03 \x01(\x0b\x32\x1e.mavsdk.rpc.mocap.PositionBody\x12\x35\n\x0fpose_covariance\x18\x04 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Covariance\"\xd1\x03\n\x08Odometry\x12\x11\n\ttime_usec\x18\x01 \x01(\x04\x12\x35\n\x08\x66rame_id\x18\x02 \x01(\x0e\x32#.mavsdk.rpc.mocap.Odometry.MavFrame\x12\x35\n\rposition_body\x18\x03 \x01(\x0b\x32\x1e.mavsdk.rpc.mocap.PositionBody\x12\'\n\x01q\x18\x04 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Quaternion\x12/\n\nspeed_body\x18\x05 \x01(\x0b\x32\x1b.mavsdk.rpc.mocap.SpeedBody\x12\x44\n\x15\x61ngular_velocity_body\x18\x06 \x01(\x0b\x32%.mavsdk.rpc.mocap.AngularVelocityBody\x12\x35\n\x0fpose_covariance\x18\x07 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Covariance\x12\x39\n\x13velocity_covariance\x18\x08 \x01(\x0b\x32\x1c.mavsdk.rpc.mocap.Covariance\"2\n\x08MavFrame\x12\x08\n\x04STUB\x10\x00\x12\r\n\tMOCAP_NED\x10\x0e\x12\r\n\tLOCAL_FRD\x10\x14\"5\n\x0cPositionBody\x12\x0b\n\x03x_m\x18\x01 \x01(\x02\x12\x0b\n\x03y_m\x18\x02 \x01(\x02\x12\x0b\n\x03z_m\x18\x03 \x01(\x02\"A\n\tAngleBody\x12\x10\n\x08roll_rad\x18\x01 \x01(\x02\x12\x11\n\tpitch_rad\x18\x02 \x01(\x02\x12\x0f\n\x07yaw_rad\x18\x03 \x01(\x02\"8\n\tSpeedBody\x12\r\n\x05x_m_s\x18\x01 \x01(\x02\x12\r\n\x05y_m_s\x18\x02 \x01(\x02\x12\r\n\x05z_m_s\x18\x03 \x01(\x02\"Q\n\x13\x41ngularVelocityBody\x12\x12\n\nroll_rad_s\x18\x01 \x01(\x02\x12\x13\n\x0bpitch_rad_s\x18\x02 \x01(\x02\x12\x11\n\tyaw_rad_s\x18\x03 \x01(\x02\"\'\n\nCovariance\x12\x19\n\x11\x63ovariance_matrix\x18\x01 \x03(\x02\"8\n\nQuaternion\x12\t\n\x01w\x18\x01 \x01(\x02\x12\t\n\x01x\x18\x02 \x01(\x02\x12\t\n\x01y\x18\x03 \x01(\x02\x12\t\n\x01z\x18\x04 \x01(\x02\"\xba\x01\n\x0bMocapResult\x12\x34\n\x06result\x18\x01 \x01(\x0e\x32$.mavsdk.rpc.mocap.MocapResult.Result\x12\x12\n\nresult_str\x18\x02 \x01(\t\"a\n\x06Result\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SUCCESS\x10\x01\x12\r\n\tNO_SYSTEM\x10\x02\x12\x14\n\x10\x43ONNECTION_ERROR\x10\x03\x12\x18\n\x14INVALID_REQUEST_DATA\x10\x04\x32\xfb\x02\n\x0cMocapService\x12\x86\x01\n\x19SetVisionPositionEstimate\x12\x32.mavsdk.rpc.mocap.SetVisionPositionEstimateRequest\x1a\x33.mavsdk.rpc.mocap.SetVisionPositionEstimateResponse\"\x00\x12\x83\x01\n\x18SetAttitudePositionMocap\x12\x31.mavsdk.rpc.mocap.SetAttitudePositionMocapRequest\x1a\x32.mavsdk.rpc.mocap.SetAttitudePositionMocapResponse\"\x00\x12\\\n\x0bSetOdometry\x12$.mavsdk.rpc.mocap.SetOdometryRequest\x1a%.mavsdk.rpc.mocap.SetOdometryResponse\"\x00\x42\x1d\n\x0fio.mavsdk.mocapB\nMocapProtob\x06proto3') +) + + + +_ODOMETRY_MAVFRAME = _descriptor.EnumDescriptor( + name='MavFrame', + full_name='mavsdk.rpc.mocap.Odometry.MavFrame', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='STUB', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='MOCAP_NED', index=1, number=14, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='LOCAL_FRD', index=2, number=20, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=1394, + serialized_end=1444, +) +_sym_db.RegisterEnumDescriptor(_ODOMETRY_MAVFRAME) + +_MOCAPRESULT_RESULT = _descriptor.EnumDescriptor( + name='Result', + full_name='mavsdk.rpc.mocap.MocapResult.Result', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNKNOWN', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SUCCESS', index=1, number=1, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NO_SYSTEM', index=2, number=2, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CONNECTION_ERROR', index=3, number=3, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INVALID_REQUEST_DATA', index=4, number=4, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=1898, + serialized_end=1995, +) +_sym_db.RegisterEnumDescriptor(_MOCAPRESULT_RESULT) + + +_SETVISIONPOSITIONESTIMATEREQUEST = _descriptor.Descriptor( + name='SetVisionPositionEstimateRequest', + full_name='mavsdk.rpc.mocap.SetVisionPositionEstimateRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='vision_position_estimate', full_name='mavsdk.rpc.mocap.SetVisionPositionEstimateRequest.vision_position_estimate', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=33, + serialized_end=143, +) + + +_SETVISIONPOSITIONESTIMATERESPONSE = _descriptor.Descriptor( + name='SetVisionPositionEstimateResponse', + full_name='mavsdk.rpc.mocap.SetVisionPositionEstimateResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='mocap_result', full_name='mavsdk.rpc.mocap.SetVisionPositionEstimateResponse.mocap_result', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=145, + serialized_end=233, +) + + +_SETATTITUDEPOSITIONMOCAPREQUEST = _descriptor.Descriptor( + name='SetAttitudePositionMocapRequest', + full_name='mavsdk.rpc.mocap.SetAttitudePositionMocapRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='attitude_position_mocap', full_name='mavsdk.rpc.mocap.SetAttitudePositionMocapRequest.attitude_position_mocap', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=235, + serialized_end=342, +) + + +_SETATTITUDEPOSITIONMOCAPRESPONSE = _descriptor.Descriptor( + name='SetAttitudePositionMocapResponse', + full_name='mavsdk.rpc.mocap.SetAttitudePositionMocapResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='mocap_result', full_name='mavsdk.rpc.mocap.SetAttitudePositionMocapResponse.mocap_result', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=344, + serialized_end=431, +) + + +_SETODOMETRYREQUEST = _descriptor.Descriptor( + name='SetOdometryRequest', + full_name='mavsdk.rpc.mocap.SetOdometryRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='odometry', full_name='mavsdk.rpc.mocap.SetOdometryRequest.odometry', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=433, + serialized_end=499, +) + + +_SETODOMETRYRESPONSE = _descriptor.Descriptor( + name='SetOdometryResponse', + full_name='mavsdk.rpc.mocap.SetOdometryResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='mocap_result', full_name='mavsdk.rpc.mocap.SetOdometryResponse.mocap_result', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=501, + serialized_end=575, +) + + +_VISIONPOSITIONESTIMATE = _descriptor.Descriptor( + name='VisionPositionEstimate', + full_name='mavsdk.rpc.mocap.VisionPositionEstimate', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='time_usec', full_name='mavsdk.rpc.mocap.VisionPositionEstimate.time_usec', index=0, + number=1, type=4, cpp_type=4, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='position_body', full_name='mavsdk.rpc.mocap.VisionPositionEstimate.position_body', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='angle_body', full_name='mavsdk.rpc.mocap.VisionPositionEstimate.angle_body', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='pose_covariance', full_name='mavsdk.rpc.mocap.VisionPositionEstimate.pose_covariance', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=578, + serialized_end=780, +) + + +_ATTITUDEPOSITIONMOCAP = _descriptor.Descriptor( + name='AttitudePositionMocap', + full_name='mavsdk.rpc.mocap.AttitudePositionMocap', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='time_usec', full_name='mavsdk.rpc.mocap.AttitudePositionMocap.time_usec', index=0, + number=1, type=4, cpp_type=4, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='q', full_name='mavsdk.rpc.mocap.AttitudePositionMocap.q', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='position_body', full_name='mavsdk.rpc.mocap.AttitudePositionMocap.position_body', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='pose_covariance', full_name='mavsdk.rpc.mocap.AttitudePositionMocap.pose_covariance', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=783, + serialized_end=976, +) + + +_ODOMETRY = _descriptor.Descriptor( + name='Odometry', + full_name='mavsdk.rpc.mocap.Odometry', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='time_usec', full_name='mavsdk.rpc.mocap.Odometry.time_usec', index=0, + number=1, type=4, cpp_type=4, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='frame_id', full_name='mavsdk.rpc.mocap.Odometry.frame_id', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='position_body', full_name='mavsdk.rpc.mocap.Odometry.position_body', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='q', full_name='mavsdk.rpc.mocap.Odometry.q', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='speed_body', full_name='mavsdk.rpc.mocap.Odometry.speed_body', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='angular_velocity_body', full_name='mavsdk.rpc.mocap.Odometry.angular_velocity_body', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='pose_covariance', full_name='mavsdk.rpc.mocap.Odometry.pose_covariance', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='velocity_covariance', full_name='mavsdk.rpc.mocap.Odometry.velocity_covariance', index=7, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _ODOMETRY_MAVFRAME, + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=979, + serialized_end=1444, +) + + +_POSITIONBODY = _descriptor.Descriptor( + name='PositionBody', + full_name='mavsdk.rpc.mocap.PositionBody', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='x_m', full_name='mavsdk.rpc.mocap.PositionBody.x_m', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='y_m', full_name='mavsdk.rpc.mocap.PositionBody.y_m', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='z_m', full_name='mavsdk.rpc.mocap.PositionBody.z_m', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1446, + serialized_end=1499, +) + + +_ANGLEBODY = _descriptor.Descriptor( + name='AngleBody', + full_name='mavsdk.rpc.mocap.AngleBody', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='roll_rad', full_name='mavsdk.rpc.mocap.AngleBody.roll_rad', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='pitch_rad', full_name='mavsdk.rpc.mocap.AngleBody.pitch_rad', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='yaw_rad', full_name='mavsdk.rpc.mocap.AngleBody.yaw_rad', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1501, + serialized_end=1566, +) + + +_SPEEDBODY = _descriptor.Descriptor( + name='SpeedBody', + full_name='mavsdk.rpc.mocap.SpeedBody', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='x_m_s', full_name='mavsdk.rpc.mocap.SpeedBody.x_m_s', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='y_m_s', full_name='mavsdk.rpc.mocap.SpeedBody.y_m_s', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='z_m_s', full_name='mavsdk.rpc.mocap.SpeedBody.z_m_s', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1568, + serialized_end=1624, +) + + +_ANGULARVELOCITYBODY = _descriptor.Descriptor( + name='AngularVelocityBody', + full_name='mavsdk.rpc.mocap.AngularVelocityBody', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='roll_rad_s', full_name='mavsdk.rpc.mocap.AngularVelocityBody.roll_rad_s', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='pitch_rad_s', full_name='mavsdk.rpc.mocap.AngularVelocityBody.pitch_rad_s', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='yaw_rad_s', full_name='mavsdk.rpc.mocap.AngularVelocityBody.yaw_rad_s', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1626, + serialized_end=1707, +) + + +_COVARIANCE = _descriptor.Descriptor( + name='Covariance', + full_name='mavsdk.rpc.mocap.Covariance', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='covariance_matrix', full_name='mavsdk.rpc.mocap.Covariance.covariance_matrix', index=0, + number=1, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1709, + serialized_end=1748, +) + + +_QUATERNION = _descriptor.Descriptor( + name='Quaternion', + full_name='mavsdk.rpc.mocap.Quaternion', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='w', full_name='mavsdk.rpc.mocap.Quaternion.w', index=0, + number=1, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='x', full_name='mavsdk.rpc.mocap.Quaternion.x', index=1, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='y', full_name='mavsdk.rpc.mocap.Quaternion.y', index=2, + number=3, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='z', full_name='mavsdk.rpc.mocap.Quaternion.z', index=3, + number=4, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1750, + serialized_end=1806, +) + + +_MOCAPRESULT = _descriptor.Descriptor( + name='MocapResult', + full_name='mavsdk.rpc.mocap.MocapResult', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='result', full_name='mavsdk.rpc.mocap.MocapResult.result', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='result_str', full_name='mavsdk.rpc.mocap.MocapResult.result_str', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _MOCAPRESULT_RESULT, + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1809, + serialized_end=1995, +) + +_SETVISIONPOSITIONESTIMATEREQUEST.fields_by_name['vision_position_estimate'].message_type = _VISIONPOSITIONESTIMATE +_SETVISIONPOSITIONESTIMATERESPONSE.fields_by_name['mocap_result'].message_type = _MOCAPRESULT +_SETATTITUDEPOSITIONMOCAPREQUEST.fields_by_name['attitude_position_mocap'].message_type = _ATTITUDEPOSITIONMOCAP +_SETATTITUDEPOSITIONMOCAPRESPONSE.fields_by_name['mocap_result'].message_type = _MOCAPRESULT +_SETODOMETRYREQUEST.fields_by_name['odometry'].message_type = _ODOMETRY +_SETODOMETRYRESPONSE.fields_by_name['mocap_result'].message_type = _MOCAPRESULT +_VISIONPOSITIONESTIMATE.fields_by_name['position_body'].message_type = _POSITIONBODY +_VISIONPOSITIONESTIMATE.fields_by_name['angle_body'].message_type = _ANGLEBODY +_VISIONPOSITIONESTIMATE.fields_by_name['pose_covariance'].message_type = _COVARIANCE +_ATTITUDEPOSITIONMOCAP.fields_by_name['q'].message_type = _QUATERNION +_ATTITUDEPOSITIONMOCAP.fields_by_name['position_body'].message_type = _POSITIONBODY +_ATTITUDEPOSITIONMOCAP.fields_by_name['pose_covariance'].message_type = _COVARIANCE +_ODOMETRY.fields_by_name['frame_id'].enum_type = _ODOMETRY_MAVFRAME +_ODOMETRY.fields_by_name['position_body'].message_type = _POSITIONBODY +_ODOMETRY.fields_by_name['q'].message_type = _QUATERNION +_ODOMETRY.fields_by_name['speed_body'].message_type = _SPEEDBODY +_ODOMETRY.fields_by_name['angular_velocity_body'].message_type = _ANGULARVELOCITYBODY +_ODOMETRY.fields_by_name['pose_covariance'].message_type = _COVARIANCE +_ODOMETRY.fields_by_name['velocity_covariance'].message_type = _COVARIANCE +_ODOMETRY_MAVFRAME.containing_type = _ODOMETRY +_MOCAPRESULT.fields_by_name['result'].enum_type = _MOCAPRESULT_RESULT +_MOCAPRESULT_RESULT.containing_type = _MOCAPRESULT +DESCRIPTOR.message_types_by_name['SetVisionPositionEstimateRequest'] = _SETVISIONPOSITIONESTIMATEREQUEST +DESCRIPTOR.message_types_by_name['SetVisionPositionEstimateResponse'] = _SETVISIONPOSITIONESTIMATERESPONSE +DESCRIPTOR.message_types_by_name['SetAttitudePositionMocapRequest'] = _SETATTITUDEPOSITIONMOCAPREQUEST +DESCRIPTOR.message_types_by_name['SetAttitudePositionMocapResponse'] = _SETATTITUDEPOSITIONMOCAPRESPONSE +DESCRIPTOR.message_types_by_name['SetOdometryRequest'] = _SETODOMETRYREQUEST +DESCRIPTOR.message_types_by_name['SetOdometryResponse'] = _SETODOMETRYRESPONSE +DESCRIPTOR.message_types_by_name['VisionPositionEstimate'] = _VISIONPOSITIONESTIMATE +DESCRIPTOR.message_types_by_name['AttitudePositionMocap'] = _ATTITUDEPOSITIONMOCAP +DESCRIPTOR.message_types_by_name['Odometry'] = _ODOMETRY +DESCRIPTOR.message_types_by_name['PositionBody'] = _POSITIONBODY +DESCRIPTOR.message_types_by_name['AngleBody'] = _ANGLEBODY +DESCRIPTOR.message_types_by_name['SpeedBody'] = _SPEEDBODY +DESCRIPTOR.message_types_by_name['AngularVelocityBody'] = _ANGULARVELOCITYBODY +DESCRIPTOR.message_types_by_name['Covariance'] = _COVARIANCE +DESCRIPTOR.message_types_by_name['Quaternion'] = _QUATERNION +DESCRIPTOR.message_types_by_name['MocapResult'] = _MOCAPRESULT +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +SetVisionPositionEstimateRequest = _reflection.GeneratedProtocolMessageType('SetVisionPositionEstimateRequest', (_message.Message,), { + 'DESCRIPTOR' : _SETVISIONPOSITIONESTIMATEREQUEST, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetVisionPositionEstimateRequest) + }) +_sym_db.RegisterMessage(SetVisionPositionEstimateRequest) + +SetVisionPositionEstimateResponse = _reflection.GeneratedProtocolMessageType('SetVisionPositionEstimateResponse', (_message.Message,), { + 'DESCRIPTOR' : _SETVISIONPOSITIONESTIMATERESPONSE, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetVisionPositionEstimateResponse) + }) +_sym_db.RegisterMessage(SetVisionPositionEstimateResponse) + +SetAttitudePositionMocapRequest = _reflection.GeneratedProtocolMessageType('SetAttitudePositionMocapRequest', (_message.Message,), { + 'DESCRIPTOR' : _SETATTITUDEPOSITIONMOCAPREQUEST, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetAttitudePositionMocapRequest) + }) +_sym_db.RegisterMessage(SetAttitudePositionMocapRequest) + +SetAttitudePositionMocapResponse = _reflection.GeneratedProtocolMessageType('SetAttitudePositionMocapResponse', (_message.Message,), { + 'DESCRIPTOR' : _SETATTITUDEPOSITIONMOCAPRESPONSE, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetAttitudePositionMocapResponse) + }) +_sym_db.RegisterMessage(SetAttitudePositionMocapResponse) + +SetOdometryRequest = _reflection.GeneratedProtocolMessageType('SetOdometryRequest', (_message.Message,), { + 'DESCRIPTOR' : _SETODOMETRYREQUEST, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetOdometryRequest) + }) +_sym_db.RegisterMessage(SetOdometryRequest) + +SetOdometryResponse = _reflection.GeneratedProtocolMessageType('SetOdometryResponse', (_message.Message,), { + 'DESCRIPTOR' : _SETODOMETRYRESPONSE, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SetOdometryResponse) + }) +_sym_db.RegisterMessage(SetOdometryResponse) + +VisionPositionEstimate = _reflection.GeneratedProtocolMessageType('VisionPositionEstimate', (_message.Message,), { + 'DESCRIPTOR' : _VISIONPOSITIONESTIMATE, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.VisionPositionEstimate) + }) +_sym_db.RegisterMessage(VisionPositionEstimate) + +AttitudePositionMocap = _reflection.GeneratedProtocolMessageType('AttitudePositionMocap', (_message.Message,), { + 'DESCRIPTOR' : _ATTITUDEPOSITIONMOCAP, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.AttitudePositionMocap) + }) +_sym_db.RegisterMessage(AttitudePositionMocap) + +Odometry = _reflection.GeneratedProtocolMessageType('Odometry', (_message.Message,), { + 'DESCRIPTOR' : _ODOMETRY, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.Odometry) + }) +_sym_db.RegisterMessage(Odometry) + +PositionBody = _reflection.GeneratedProtocolMessageType('PositionBody', (_message.Message,), { + 'DESCRIPTOR' : _POSITIONBODY, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.PositionBody) + }) +_sym_db.RegisterMessage(PositionBody) + +AngleBody = _reflection.GeneratedProtocolMessageType('AngleBody', (_message.Message,), { + 'DESCRIPTOR' : _ANGLEBODY, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.AngleBody) + }) +_sym_db.RegisterMessage(AngleBody) + +SpeedBody = _reflection.GeneratedProtocolMessageType('SpeedBody', (_message.Message,), { + 'DESCRIPTOR' : _SPEEDBODY, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.SpeedBody) + }) +_sym_db.RegisterMessage(SpeedBody) + +AngularVelocityBody = _reflection.GeneratedProtocolMessageType('AngularVelocityBody', (_message.Message,), { + 'DESCRIPTOR' : _ANGULARVELOCITYBODY, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.AngularVelocityBody) + }) +_sym_db.RegisterMessage(AngularVelocityBody) + +Covariance = _reflection.GeneratedProtocolMessageType('Covariance', (_message.Message,), { + 'DESCRIPTOR' : _COVARIANCE, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.Covariance) + }) +_sym_db.RegisterMessage(Covariance) + +Quaternion = _reflection.GeneratedProtocolMessageType('Quaternion', (_message.Message,), { + 'DESCRIPTOR' : _QUATERNION, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.Quaternion) + }) +_sym_db.RegisterMessage(Quaternion) + +MocapResult = _reflection.GeneratedProtocolMessageType('MocapResult', (_message.Message,), { + 'DESCRIPTOR' : _MOCAPRESULT, + '__module__' : 'mocap_pb2' + # @@protoc_insertion_point(class_scope:mavsdk.rpc.mocap.MocapResult) + }) +_sym_db.RegisterMessage(MocapResult) + + +DESCRIPTOR._options = None + +_MOCAPSERVICE = _descriptor.ServiceDescriptor( + name='MocapService', + full_name='mavsdk.rpc.mocap.MocapService', + file=DESCRIPTOR, + index=0, + serialized_options=None, + serialized_start=1998, + serialized_end=2377, + methods=[ + _descriptor.MethodDescriptor( + name='SetVisionPositionEstimate', + full_name='mavsdk.rpc.mocap.MocapService.SetVisionPositionEstimate', + index=0, + containing_service=None, + input_type=_SETVISIONPOSITIONESTIMATEREQUEST, + output_type=_SETVISIONPOSITIONESTIMATERESPONSE, + serialized_options=None, + ), + _descriptor.MethodDescriptor( + name='SetAttitudePositionMocap', + full_name='mavsdk.rpc.mocap.MocapService.SetAttitudePositionMocap', + index=1, + containing_service=None, + input_type=_SETATTITUDEPOSITIONMOCAPREQUEST, + output_type=_SETATTITUDEPOSITIONMOCAPRESPONSE, + serialized_options=None, + ), + _descriptor.MethodDescriptor( + name='SetOdometry', + full_name='mavsdk.rpc.mocap.MocapService.SetOdometry', + index=2, + containing_service=None, + input_type=_SETODOMETRYREQUEST, + output_type=_SETODOMETRYRESPONSE, + serialized_options=None, + ), +]) +_sym_db.RegisterServiceDescriptor(_MOCAPSERVICE) + +DESCRIPTOR.services_by_name['MocapService'] = _MOCAPSERVICE + +# @@protoc_insertion_point(module_scope) diff --git a/mavsdk/generated/mocap_pb2_grpc.py b/mavsdk/generated/mocap_pb2_grpc.py new file mode 100644 index 00000000..010b6df8 --- /dev/null +++ b/mavsdk/generated/mocap_pb2_grpc.py @@ -0,0 +1,86 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +import grpc + +from . import mocap_pb2 as mocap__pb2 + + +class MocapServiceStub(object): + """* + Motion Capture allow vehicles to navigate when a global + position source is unavailable or unreliable + (e.g. indoors, or when flying under a bridge. etc.). + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.SetVisionPositionEstimate = channel.unary_unary( + '/mavsdk.rpc.mocap.MocapService/SetVisionPositionEstimate', + request_serializer=mocap__pb2.SetVisionPositionEstimateRequest.SerializeToString, + response_deserializer=mocap__pb2.SetVisionPositionEstimateResponse.FromString, + ) + self.SetAttitudePositionMocap = channel.unary_unary( + '/mavsdk.rpc.mocap.MocapService/SetAttitudePositionMocap', + request_serializer=mocap__pb2.SetAttitudePositionMocapRequest.SerializeToString, + response_deserializer=mocap__pb2.SetAttitudePositionMocapResponse.FromString, + ) + self.SetOdometry = channel.unary_unary( + '/mavsdk.rpc.mocap.MocapService/SetOdometry', + request_serializer=mocap__pb2.SetOdometryRequest.SerializeToString, + response_deserializer=mocap__pb2.SetOdometryResponse.FromString, + ) + + +class MocapServiceServicer(object): + """* + Motion Capture allow vehicles to navigate when a global + position source is unavailable or unreliable + (e.g. indoors, or when flying under a bridge. etc.). + """ + + def SetVisionPositionEstimate(self, request, context): + """Send Global position/attitude estimate from a vision source. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetAttitudePositionMocap(self, request, context): + """Send motion capture attitude and position. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetOdometry(self, request, context): + """Send odometry information with an external interface. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_MocapServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'SetVisionPositionEstimate': grpc.unary_unary_rpc_method_handler( + servicer.SetVisionPositionEstimate, + request_deserializer=mocap__pb2.SetVisionPositionEstimateRequest.FromString, + response_serializer=mocap__pb2.SetVisionPositionEstimateResponse.SerializeToString, + ), + 'SetAttitudePositionMocap': grpc.unary_unary_rpc_method_handler( + servicer.SetAttitudePositionMocap, + request_deserializer=mocap__pb2.SetAttitudePositionMocapRequest.FromString, + response_serializer=mocap__pb2.SetAttitudePositionMocapResponse.SerializeToString, + ), + 'SetOdometry': grpc.unary_unary_rpc_method_handler( + servicer.SetOdometry, + request_deserializer=mocap__pb2.SetOdometryRequest.FromString, + response_serializer=mocap__pb2.SetOdometryResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'mavsdk.rpc.mocap.MocapService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/mavsdk/system.py b/mavsdk/system.py index 26972dce..d936952a 100644 --- a/mavsdk/system.py +++ b/mavsdk/system.py @@ -16,6 +16,7 @@ class System: "Gimbal", "Info", "Mission", + "Mocap", "Param", "Offboard", "Telemetry" @@ -133,6 +134,12 @@ def telemetry(self) -> Telemetry: raise RuntimeError("Telemetry plugin has not been initialized! Did you run `System.connect()`?") return self._plugins["telemetry"] + @property + def mocap(self) -> Mocap: + if "mocap" not in self._plugins: + raise RuntimeError("Mocap plugin has not been initialized! Did you run `System.connect()`?") + return self._plugins["mocap"] + @staticmethod def _start_mavsdk_server(system_address=None): """