mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-11-08 04:31:35 +08:00
Copy over Attitude Control library
This commit is contained in:
Jaeyoung-Lim
@@ -0,0 +1,110 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* Copyright (c) 2019 PX4 Development Team. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* 3. Neither the name PX4 nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/**
|
||||
* @file AttitudeControl.cpp
|
||||
*/
|
||||
|
||||
#include <AttitudeControl.hpp>
|
||||
|
||||
#include <mathlib/math/Functions.hpp>
|
||||
|
||||
using namespace matrix;
|
||||
|
||||
void AttitudeControl::setProportionalGain(const matrix::Vector3f &proportional_gain, const float yaw_weight)
|
||||
{
|
||||
_proportional_gain = proportional_gain;
|
||||
_yaw_w = math::constrain(yaw_weight, 0.f, 1.f);
|
||||
|
||||
// compensate for the effect of the yaw weight rescaling the output
|
||||
if (_yaw_w > 1e-4f) {
|
||||
_proportional_gain(2) /= _yaw_w;
|
||||
}
|
||||
}
|
||||
|
||||
matrix::Vector3f AttitudeControl::update(const Quatf &q) const
|
||||
{
|
||||
Quatf qd = _attitude_setpoint_q;
|
||||
|
||||
// calculate reduced desired attitude neglecting vehicle's yaw to prioritize roll and pitch
|
||||
const Vector3f e_z = q.dcm_z();
|
||||
const Vector3f e_z_d = qd.dcm_z();
|
||||
Quatf qd_red(e_z, e_z_d);
|
||||
|
||||
if (fabsf(qd_red(1)) > (1.f - 1e-5f) || fabsf(qd_red(2)) > (1.f - 1e-5f)) {
|
||||
// In the infinitesimal corner case where the vehicle and thrust have the completely opposite direction,
|
||||
// full attitude control anyways generates no yaw input and directly takes the combination of
|
||||
// roll and pitch leading to the correct desired yaw. Ignoring this case would still be totally safe and stable.
|
||||
qd_red = qd;
|
||||
|
||||
} else {
|
||||
// transform rotation from current to desired thrust vector into a world frame reduced desired attitude
|
||||
qd_red *= q;
|
||||
}
|
||||
|
||||
// mix full and reduced desired attitude
|
||||
Quatf q_mix = qd_red.inversed() * qd;
|
||||
q_mix.canonicalize();
|
||||
// catch numerical problems with the domain of acosf and asinf
|
||||
q_mix(0) = math::constrain(q_mix(0), -1.f, 1.f);
|
||||
q_mix(3) = math::constrain(q_mix(3), -1.f, 1.f);
|
||||
qd = qd_red * Quatf(cosf(_yaw_w * acosf(q_mix(0))), 0, 0, sinf(_yaw_w * asinf(q_mix(3))));
|
||||
|
||||
// quaternion attitude control law, qe is rotation from q to qd
|
||||
const Quatf qe = q.inversed() * qd;
|
||||
|
||||
// using sin(alpha/2) scaled rotation axis as attitude error (see quaternion definition by axis angle)
|
||||
// also taking care of the antipodal unit quaternion ambiguity
|
||||
const Vector3f eq = 2.f * qe.canonical().imag();
|
||||
|
||||
// calculate angular rates setpoint
|
||||
matrix::Vector3f rate_setpoint = eq.emult(_proportional_gain);
|
||||
|
||||
// Feed forward the yaw setpoint rate.
|
||||
// yawspeed_setpoint is the feed forward commanded rotation around the world z-axis,
|
||||
// but we need to apply it in the body frame (because _rates_sp is expressed in the body frame).
|
||||
// Therefore we infer the world z-axis (expressed in the body frame) by taking the last column of R.transposed (== q.inversed)
|
||||
// and multiply it by the yaw setpoint rate (yawspeed_setpoint).
|
||||
// This yields a vector representing the commanded rotatation around the world z-axis expressed in the body frame
|
||||
// such that it can be added to the rates setpoint.
|
||||
if (is_finite(_yawspeed_setpoint)) {
|
||||
rate_setpoint += q.inversed().dcm_z() * _yawspeed_setpoint;
|
||||
}
|
||||
|
||||
// limit rates
|
||||
for (int i = 0; i < 3; i++) {
|
||||
rate_setpoint(i) = math::constrain(rate_setpoint(i), -_rate_limit(i), _rate_limit(i));
|
||||
}
|
||||
|
||||
return rate_setpoint;
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* Copyright (c) 2019 PX4 Development Team. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* 3. Neither the name PX4 nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/**
|
||||
* @file AttitudeControl.hpp
|
||||
*
|
||||
* A quaternion based attitude controller.
|
||||
*
|
||||
* @author Matthias Grob <maetugr@gmail.com>
|
||||
*
|
||||
* Publication documenting the implemented Quaternion Attitude Control:
|
||||
* Nonlinear Quadrocopter Attitude Control (2013)
|
||||
* by Dario Brescianini, Markus Hehn and Raffaello D'Andrea
|
||||
* Institute for Dynamic Systems and Control (IDSC), ETH Zurich
|
||||
*
|
||||
* https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/154099/eth-7387-01.pdf
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <matrix/matrix/math.hpp>
|
||||
#include <mathlib/math/Limits.hpp>
|
||||
|
||||
class AttitudeControl
|
||||
{
|
||||
public:
|
||||
AttitudeControl() = default;
|
||||
~AttitudeControl() = default;
|
||||
|
||||
/**
|
||||
* Set proportional attitude control gain
|
||||
* @param proportional_gain 3D vector containing gains for roll, pitch, yaw
|
||||
* @param yaw_weight A fraction [0,1] deprioritizing yaw compared to roll and pitch
|
||||
*/
|
||||
void setProportionalGain(const matrix::Vector3f &proportional_gain, const float yaw_weight);
|
||||
|
||||
/**
|
||||
* Set hard limit for output rate setpoints
|
||||
* @param rate_limit [rad/s] 3D vector containing limits for roll, pitch, yaw
|
||||
*/
|
||||
void setRateLimit(const matrix::Vector3f &rate_limit) { _rate_limit = rate_limit; }
|
||||
|
||||
/**
|
||||
* Set a new attitude setpoint replacing the one tracked before
|
||||
* @param qd desired vehicle attitude setpoint
|
||||
* @param yawspeed_setpoint [rad/s] yaw feed forward angular rate in world frame
|
||||
*/
|
||||
void setAttitudeSetpoint(const matrix::Quatf &qd, const float yawspeed_setpoint)
|
||||
{
|
||||
_attitude_setpoint_q = qd;
|
||||
_attitude_setpoint_q.normalize();
|
||||
_yawspeed_setpoint = yawspeed_setpoint;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust last known attitude setpoint by a delta rotation
|
||||
* Optional use to avoid glitches when attitude estimate reference e.g. heading changes.
|
||||
* @param q_delta delta rotation to apply
|
||||
*/
|
||||
void adaptAttitudeSetpoint(const matrix::Quatf &q_delta)
|
||||
{
|
||||
_attitude_setpoint_q = q_delta * _attitude_setpoint_q;
|
||||
_attitude_setpoint_q.normalize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Run one control loop cycle calculation
|
||||
* @param q estimation of the current vehicle attitude unit quaternion
|
||||
* @return [rad/s] body frame 3D angular rate setpoint vector to be executed by the rate controller
|
||||
*/
|
||||
matrix::Vector3f update(const matrix::Quatf &q) const;
|
||||
|
||||
private:
|
||||
matrix::Vector3f _proportional_gain;
|
||||
matrix::Vector3f _rate_limit;
|
||||
float _yaw_w{0.f}; ///< yaw weight [0,1] to deprioritize caompared to roll and pitch
|
||||
|
||||
matrix::Quatf _attitude_setpoint_q; ///< latest known attitude setpoint e.g. from position control
|
||||
float _yawspeed_setpoint{0.f}; ///< latest known yawspeed feed-forward setpoint
|
||||
};
|
||||
@@ -0,0 +1,140 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* Copyright (C) 2019 PX4 Development Team. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* 3. Neither the name PX4 nor the names of its contributors may be
|
||||
* used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <AttitudeControl.hpp>
|
||||
#include <mathlib/math/Functions.hpp>
|
||||
|
||||
using namespace matrix;
|
||||
|
||||
TEST(AttitudeControlTest, AllZeroCase)
|
||||
{
|
||||
AttitudeControl attitude_control;
|
||||
Vector3f rate_setpoint = attitude_control.update(Quatf());
|
||||
EXPECT_EQ(rate_setpoint, Vector3f());
|
||||
}
|
||||
|
||||
class AttitudeControlConvergenceTest : public ::testing::Test
|
||||
{
|
||||
public:
|
||||
AttitudeControlConvergenceTest()
|
||||
{
|
||||
_attitude_control.setProportionalGain(Vector3f(.5f, .6f, .3f), .4f);
|
||||
_attitude_control.setRateLimit(Vector3f(100.f, 100.f, 100.f));
|
||||
}
|
||||
|
||||
void checkConvergence()
|
||||
{
|
||||
int i; // need function scope to check how many steps
|
||||
Vector3f rate_setpoint(1000.f, 1000.f, 1000.f);
|
||||
|
||||
_attitude_control.setAttitudeSetpoint(_quat_goal, 0.f);
|
||||
|
||||
for (i = 100; i > 0; i--) {
|
||||
// run attitude control to get rate setpoints
|
||||
const Vector3f rate_setpoint_new = _attitude_control.update(_quat_state);
|
||||
// rotate the simulated state quaternion according to the rate setpoint
|
||||
_quat_state = _quat_state * Quatf(AxisAnglef(rate_setpoint_new));
|
||||
_quat_state = -_quat_state; // produce intermittent antipodal quaternion states to test against unwinding problem
|
||||
|
||||
// expect the error and hence also the output to get smaller with each iteration
|
||||
if (rate_setpoint_new.norm() >= rate_setpoint.norm()) {
|
||||
break;
|
||||
}
|
||||
|
||||
rate_setpoint = rate_setpoint_new;
|
||||
}
|
||||
|
||||
EXPECT_EQ(_quat_state.canonical(), _quat_goal.canonical());
|
||||
// it shouldn't have taken longer than an iteration timeout to converge
|
||||
EXPECT_GT(i, 0);
|
||||
}
|
||||
|
||||
AttitudeControl _attitude_control;
|
||||
Quatf _quat_state;
|
||||
Quatf _quat_goal;
|
||||
};
|
||||
|
||||
TEST_F(AttitudeControlConvergenceTest, AttitudeControlConvergence)
|
||||
{
|
||||
const int inputs = 8;
|
||||
|
||||
const Quatf QArray[inputs] = {
|
||||
Quatf(),
|
||||
Quatf(0, 1, 0, 0),
|
||||
Quatf(0, 0, 1, 0),
|
||||
Quatf(0, 0, 0, 1),
|
||||
Quatf(0.698f, 0.024f, -0.681f, -0.220f),
|
||||
Quatf(-0.820f, -0.313f, 0.225f, -0.423f),
|
||||
Quatf(0.599f, -0.172f, 0.755f, -0.204f),
|
||||
Quatf(0.216f, -0.662f, 0.290f, -0.656f)
|
||||
};
|
||||
|
||||
for (int i = 0; i < inputs; i++) {
|
||||
for (int j = 0; j < inputs; j++) {
|
||||
printf("--- Input combination: %d %d\n", i, j);
|
||||
_quat_state = QArray[i];
|
||||
_quat_goal = QArray[j];
|
||||
_quat_state.normalize();
|
||||
_quat_goal.normalize();
|
||||
checkConvergence();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(AttitudeControlTest, YawWeightScaling)
|
||||
{
|
||||
// GIVEN: default tuning and pure yaw turn command
|
||||
AttitudeControl attitude_control;
|
||||
const float yaw_gain = 2.8f;
|
||||
const float yaw_sp = .1f;
|
||||
Quatf pure_yaw_attitude(cosf(yaw_sp / 2.f), 0, 0, sinf(yaw_sp / 2.f));
|
||||
attitude_control.setProportionalGain(Vector3f(6.5f, 6.5f, yaw_gain), .4f);
|
||||
attitude_control.setRateLimit(Vector3f(1000.f, 1000.f, 1000.f));
|
||||
attitude_control.setAttitudeSetpoint(pure_yaw_attitude, 0.f);
|
||||
|
||||
// WHEN: we run one iteration of the controller
|
||||
Vector3f rate_setpoint = attitude_control.update(Quatf());
|
||||
|
||||
// THEN: no actuation in roll, pitch
|
||||
EXPECT_EQ(Vector2f(rate_setpoint), Vector2f());
|
||||
// THEN: actuation error * gain in yaw
|
||||
EXPECT_NEAR(rate_setpoint(2), yaw_sp * yaw_gain, 1e-4f);
|
||||
|
||||
// GIVEN: additional corner case of zero yaw weight
|
||||
attitude_control.setProportionalGain(Vector3f(6.5f, 6.5f, yaw_gain), 0.f);
|
||||
// WHEN: we run one iteration of the controller
|
||||
rate_setpoint = attitude_control.update(Quatf());
|
||||
// THEN: no actuation (also no NAN)
|
||||
EXPECT_EQ(rate_setpoint, Vector3f());
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
############################################################################
|
||||
#
|
||||
# Copyright (c) 2019 PX4 Development Team. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# 3. Neither the name PX4 nor the names of its contributors may be
|
||||
# used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
############################################################################
|
||||
|
||||
px4_add_library(FWAttitudeControl
|
||||
AttitudeControl.cpp
|
||||
AttitudeControl.hpp
|
||||
)
|
||||
target_compile_options(FWAttitudeControl PRIVATE ${MAX_CUSTOM_OPT_LEVEL})
|
||||
target_include_directories(FWAttitudeControl PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
|
||||
px4_add_unit_gtest(SRC AttitudeControlTest.cpp LINKLIBS FWAttitudeControl)
|
||||
@@ -32,6 +32,7 @@
|
||||
############################################################################
|
||||
|
||||
add_subdirectory(RateControl)
|
||||
add_subdirectory(AttitudeControl)
|
||||
|
||||
px4_add_module(
|
||||
MODULE modules__fw_att_control
|
||||
@@ -47,6 +48,7 @@ px4_add_module(
|
||||
ecl_yaw_controller.cpp
|
||||
DEPENDS
|
||||
px4_work_queue
|
||||
RateControl2
|
||||
FWRateControl
|
||||
FWAttitudeControl
|
||||
SlewRate
|
||||
)
|
||||
|
||||
@@ -31,12 +31,12 @@
|
||||
#
|
||||
############################################################################
|
||||
|
||||
px4_add_library(RateControl2
|
||||
px4_add_library(FWRateControl
|
||||
RateControl.cpp
|
||||
RateControl.hpp
|
||||
)
|
||||
target_compile_options(RateControl2 PRIVATE ${MAX_CUSTOM_OPT_LEVEL})
|
||||
target_include_directories(RateControl2 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
target_link_libraries(RateControl2 PRIVATE mathlib)
|
||||
target_compile_options(FWRateControl PRIVATE ${MAX_CUSTOM_OPT_LEVEL})
|
||||
target_include_directories(FWRateControl PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
target_link_libraries(FWRateControl PRIVATE mathlib)
|
||||
|
||||
px4_add_unit_gtest(SRC RateControlTest.cpp LINKLIBS RateControl2)
|
||||
px4_add_unit_gtest(SRC RateControlTest.cpp LINKLIBS FWRateControl)
|
||||
|
||||
Reference in New Issue
Block a user