Struct mav_sdk::grpc::action::action_service_client::ActionServiceClient

pub struct ActionServiceClient<T> { /* fields omitted */ }

Enable simple actions such as arming, taking off, and landing.

Implementations

impl ActionServiceClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error> where
    D: TryInto<Endpoint>,
    D::Error: Into<StdError>, 

Attempt to create a new client by connecting to a given endpoint.

impl<T> ActionServiceClient<T> where
    T: GrpcService<BoxBody>,
    T::ResponseBody: Body + Send + Sync + 'static,
    T::Error: Into<StdError>,
    <T::ResponseBody as Body>::Error: Into<StdError> + Send, 

pub fn new(inner: T) -> Self

pub fn with_interceptor<F>(
    inner: T,
    interceptor: F
) -> ActionServiceClient<InterceptedService<T, F>> where
    F: Interceptor,
    T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>,
    <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync, 

pub fn send_gzip(self) -> Self

Compress requests with gzip.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_gzip(self) -> Self

Enable decompressing responses with gzip.

pub async fn arm(
    &mut self,
    request: impl IntoRequest<ArmRequest>
) -> Result<Response<ArmResponse>, Status>

Send command to arm the drone.

Arming a drone normally causes motors to spin at idle. Before arming take all safety precautions and stand clear of the drone!

pub async fn disarm(
    &mut self,
    request: impl IntoRequest<DisarmRequest>
) -> Result<Response<DisarmResponse>, Status>

Send command to disarm the drone.

This will disarm a drone that considers itself landed. If flying, the drone should reject the disarm command. Disarming means that all motors will stop.

pub async fn takeoff(
    &mut self,
    request: impl IntoRequest<TakeoffRequest>
) -> Result<Response<TakeoffResponse>, Status>

Send command to take off and hover.

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.

pub async fn land(
    &mut self,
    request: impl IntoRequest<LandRequest>
) -> Result<Response<LandResponse>, Status>

Send command to land at the current position.

This switches the drone to ‘Land’ flight mode.

pub async fn reboot(
    &mut self,
    request: impl IntoRequest<RebootRequest>
) -> Result<Response<RebootResponse>, Status>

Send command to reboot the drone components.

This will reboot the autopilot, companion computer, camera and gimbal.

pub async fn shutdown(
    &mut self,
    request: impl IntoRequest<ShutdownRequest>
) -> Result<Response<ShutdownResponse>, Status>

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.

pub async fn terminate(
    &mut self,
    request: impl IntoRequest<TerminateRequest>
) -> Result<Response<TerminateResponse>, Status>

Send command to terminate the drone.

This will run the terminate routine as configured on the drone (e.g. disarm and open the parachute).

pub async fn kill(
    &mut self,
    request: impl IntoRequest<KillRequest>
) -> Result<Response<KillResponse>, Status>

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.

pub async fn return_to_launch(
    &mut self,
    request: impl IntoRequest<ReturnToLaunchRequest>
) -> Result<Response<ReturnToLaunchResponse>, Status>

Send command to return to the launch (takeoff) position and land.

This switches the drone into Return mode 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.

pub async fn goto_location(
    &mut self,
    request: impl IntoRequest<GotoLocationRequest>
) -> Result<Response<GotoLocationResponse>, Status>

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).

pub async fn transition_to_fixedwing(
    &mut self,
    request: impl IntoRequest<TransitionToFixedwingRequest>
) -> Result<Response<TransitionToFixedwingResponse>, Status>

Send command to transition the drone to fixedwing.

The associated action will only be executed for VTOL vehicles (on other vehicle types the command will fail). The command will succeed if called when the vehicle is already in fixedwing mode.

pub async fn transition_to_multicopter(
    &mut self,
    request: impl IntoRequest<TransitionToMulticopterRequest>
) -> Result<Response<TransitionToMulticopterResponse>, Status>

Send command to transition the drone to multicopter.

The associated action will only be executed for VTOL vehicles (on other vehicle types the command will fail). The command will succeed if called when the vehicle is already in multicopter mode.

pub async fn get_takeoff_altitude(
    &mut self,
    request: impl IntoRequest<GetTakeoffAltitudeRequest>
) -> Result<Response<GetTakeoffAltitudeResponse>, Status>

Get the takeoff altitude (in meters above ground).

pub async fn set_takeoff_altitude(
    &mut self,
    request: impl IntoRequest<SetTakeoffAltitudeRequest>
) -> Result<Response<SetTakeoffAltitudeResponse>, Status>

Set takeoff altitude (in meters above ground).

pub async fn get_maximum_speed(
    &mut self,
    request: impl IntoRequest<GetMaximumSpeedRequest>
) -> Result<Response<GetMaximumSpeedResponse>, Status>

Get the vehicle maximum speed (in metres/second).

pub async fn set_maximum_speed(
    &mut self,
    request: impl IntoRequest<SetMaximumSpeedRequest>
) -> Result<Response<SetMaximumSpeedResponse>, Status>

Set vehicle maximum speed (in metres/second).

pub async fn get_return_to_launch_altitude(
    &mut self,
    request: impl IntoRequest<GetReturnToLaunchAltitudeRequest>
) -> Result<Response<GetReturnToLaunchAltitudeResponse>, Status>

Get the return to launch minimum return altitude (in meters).

pub async fn set_return_to_launch_altitude(
    &mut self,
    request: impl IntoRequest<SetReturnToLaunchAltitudeRequest>
) -> Result<Response<SetReturnToLaunchAltitudeResponse>, Status>

Set the return to launch minimum return altitude (in meters).

Trait Implementations

impl<T: Clone> Clone for ActionServiceClient<T>

fn clone(&self) -> ActionServiceClient<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ActionServiceClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.