remove fixedwing example module

Signed-off-by: Silvan Fuhrer <silvan@auterion.com>
2026-06-01 19:07:45 +08:00 · 2022-09-21 11:49:02 +02:00
parent a96187cb18
commit a53e1277dd
10 changed files with 0 additions and 644 deletions
@@ -78,7 +78,6 @@ CONFIG_EXAMPLES_DYN_HELLO=y
 CONFIG_EXAMPLES_FAKE_GPS=y
 CONFIG_EXAMPLES_FAKE_IMU=y
 CONFIG_EXAMPLES_FAKE_MAGNETOMETER=y
 CONFIG_EXAMPLES_FIXEDWING_CONTROL=y
 CONFIG_EXAMPLES_HELLO=y
 CONFIG_EXAMPLES_PX4_MAVLINK_DEBUG=y
 CONFIG_EXAMPLES_PX4_SIMPLE_APP=y
@@ -81,7 +81,6 @@ CONFIG_EXAMPLES_DYN_HELLO=y
 CONFIG_EXAMPLES_FAKE_GPS=y
 CONFIG_EXAMPLES_FAKE_IMU=y
 CONFIG_EXAMPLES_FAKE_MAGNETOMETER=y
 CONFIG_EXAMPLES_FIXEDWING_CONTROL=y
 CONFIG_EXAMPLES_HELLO=y
 CONFIG_EXAMPLES_PX4_MAVLINK_DEBUG=y
 CONFIG_EXAMPLES_PX4_SIMPLE_APP=y
@@ -78,7 +78,6 @@ CONFIG_EXAMPLES_DYN_HELLO=y
 CONFIG_EXAMPLES_FAKE_GPS=y
 CONFIG_EXAMPLES_FAKE_IMU=y
 CONFIG_EXAMPLES_FAKE_MAGNETOMETER=y
 CONFIG_EXAMPLES_FIXEDWING_CONTROL=y
 CONFIG_EXAMPLES_HELLO=y
 CONFIG_EXAMPLES_PX4_MAVLINK_DEBUG=y
 CONFIG_EXAMPLES_PX4_SIMPLE_APP=y
@@ -63,7 +63,6 @@ CONFIG_EXAMPLES_DYN_HELLO=y
 CONFIG_EXAMPLES_FAKE_GPS=y
 CONFIG_EXAMPLES_FAKE_IMU=y
 CONFIG_EXAMPLES_FAKE_MAGNETOMETER=y
 CONFIG_EXAMPLES_FIXEDWING_CONTROL=y
 CONFIG_EXAMPLES_HELLO=y
 CONFIG_EXAMPLES_PX4_MAVLINK_DEBUG=y
 CONFIG_EXAMPLES_PX4_SIMPLE_APP=y
@@ -72,7 +72,6 @@ CONFIG_SYSTEMCMDS_VER=y
 CONFIG_SYSTEMCMDS_WORK_QUEUE=y
 CONFIG_EXAMPLES_DYN_HELLO=y
 CONFIG_EXAMPLES_FAKE_GPS=y
 CONFIG_EXAMPLES_FIXEDWING_CONTROL=y
 CONFIG_EXAMPLES_HELLO=y
 CONFIG_EXAMPLES_PX4_MAVLINK_DEBUG=y
 CONFIG_EXAMPLES_PX4_SIMPLE_APP=y
@@ -1,40 +0,0 @@
 ############################################################################
 #
 #   Copyright (c) 2015 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_module(
 	MODULE examples__fixedwing_control
 	MAIN ex_fixedwing_control
 	STACK_MAX 1300
 	SRCS
 		main.cpp
 	DEPENDS
 	)
@@ -1,5 +0,0 @@
 menuconfig EXAMPLES_FIXEDWING_CONTROL
 	bool "fixedwing_control"
 	default n
 	---help---
 		Enable support for fixedwing_control
@@ -1,485 +0,0 @@
 /****************************************************************************
 *
 *   Copyright (c) 2013-2017 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 main.c
 *
 * Example implementation of a fixed wing attitude controller. This file is a complete
 * fixed wing controller for manual attitude control or auto waypoint control.
 * There is no need to touch any other system components to extend / modify the
 * complete control architecture.
 *
 * @author Lorenz Meier <lm@inf.ethz.ch>
 */
 #include "params.h"
 #include <poll.h>
 #include <drivers/drv_hrt.h>
 #include <lib/geo/geo.h>
 #include <matrix/math.hpp>
 #include <px4_platform_common/px4_config.h>
 #include <px4_platform_common/tasks.h>
 #include <systemlib/err.h>
 #include <parameters/param.h>
 #include <perf/perf_counter.h>
 #include <uORB/Subscription.hpp>
 #include <uORB/SubscriptionInterval.hpp>
 #include <uORB/topics/actuator_controls.h>
 #include <uORB/topics/manual_control_setpoint.h>
 #include <uORB/topics/parameter_update.h>
 #include <uORB/topics/position_setpoint_triplet.h>
 #include <uORB/topics/vehicle_attitude.h>
 #include <uORB/topics/vehicle_attitude_setpoint.h>
 #include <uORB/topics/vehicle_global_position.h>
 #include <uORB/topics/vehicle_global_position.h>
 #include <uORB/topics/vehicle_rates_setpoint.h>
 #include <uORB/topics/vehicle_status.h>
 using namespace time_literals;
 /* Prototypes */
 /**
 * Initialize all parameter handles and values
 *
 */
 extern "C" int parameters_init(struct param_handles *h);
 /**
 * Update all parameters
 *
 */
 extern "C" int parameters_update(const struct param_handles *h, struct params *p);
 /**
 * Daemon management function.
 *
 * This function allows to start / stop the background task (daemon).
 * The purpose of it is to be able to start the controller on the
 * command line, query its status and stop it, without giving up
 * the command line to one particular process or the need for bg/fg
 * ^Z support by the shell.
 */
 extern "C" __EXPORT int ex_fixedwing_control_main(int argc, char *argv[]);
 /**
 * Mainloop of daemon.
 */
 int fixedwing_control_thread_main(int argc, char *argv[]);
 /**
 * Print the correct usage.
 */
 static void usage(const char *reason);
 /**
 * Control roll and pitch angle.
 *
 * This very simple roll and pitch controller takes the current roll angle
 * of the system and compares it to a reference. Pitch is controlled to zero and yaw remains
 * uncontrolled (tutorial code, not intended for flight).
 *
 * @param att_sp The current attitude setpoint - the values the system would like to reach.
 * @param att The current attitude. The controller should make the attitude match the setpoint
 * @param rates_sp The angular rate setpoint. This is the output of the controller.
 */
 void control_attitude(const struct vehicle_attitude_setpoint_s *att_sp, const struct vehicle_attitude_s *att,
 		      struct vehicle_rates_setpoint_s *rates_sp,
 		      struct actuator_controls_s *actuators);
 /**
 * Control heading.
 *
 * This very simple heading to roll angle controller outputs the desired roll angle based on
 * the current position of the system, the desired position (the setpoint) and the current
 * heading.
 *
 * @param pos The current position of the system
 * @param sp The current position setpoint
 * @param att The current attitude
 * @param att_sp The attitude setpoint. This is the output of the controller
 */
 void control_heading(const struct vehicle_global_position_s *pos, const struct position_setpoint_s *sp,
 		     const struct vehicle_attitude_s *att, struct vehicle_attitude_setpoint_s *att_sp);
 /* Variables */
 static bool thread_should_exit = false;		/**< Daemon exit flag */
 static bool thread_running = false;		/**< Daemon status flag */
 static int deamon_task;				/**< Handle of deamon task / thread */
 static struct params p;
 static struct param_handles ph;
 void control_attitude(const struct vehicle_attitude_setpoint_s *att_sp, const struct vehicle_attitude_s *att,
 		      struct vehicle_rates_setpoint_s *rates_sp,
 		      struct actuator_controls_s *actuators)
 {
 	/*
 	 * The PX4 architecture provides a mixer outside of the controller.
 	 * The mixer is fed with a default vector of actuator controls, representing
 	 * moments applied to the vehicle frame. This vector
 	 * is structured as:
 	 *
 	 * Control Group 0 (attitude):
 	 *
 	 *    0  -  roll   (-1..+1)
 	 *    1  -  pitch  (-1..+1)
 	 *    2  -  yaw    (-1..+1)
 	 *    3  -  thrust ( 0..+1)
 	 *    4  -  flaps  (-1..+1)
 	 *    ...
 	 *
 	 * Control Group 1 (payloads / special):
 	 *
 	 *    ...
 	 */
 	/*
 	 * Calculate roll error and apply P gain
 	 */
 	matrix::Eulerf att_euler = matrix::Quatf(att->q);
 	matrix::Eulerf att_sp_euler = matrix::Quatf(att_sp->q_d);
 	float roll_err = att_euler.phi() - att_sp_euler.phi();
 	actuators->control[0] = roll_err * p.roll_p;
 	/*
 	 * Calculate pitch error and apply P gain
 	 */
 	float pitch_err = att_euler.theta() - att_sp_euler.theta();
 	actuators->control[1] = pitch_err * p.pitch_p;
 }
 void control_heading(const struct vehicle_global_position_s *pos, const struct position_setpoint_s *sp,
 		     const struct vehicle_attitude_s *att, struct vehicle_attitude_setpoint_s *att_sp)
 {
 	/*
 	 * Calculate heading error of current position to desired position
 	 */
 	float bearing = get_bearing_to_next_waypoint(pos->lat, pos->lon, sp->lat, sp->lon);
 	matrix::Eulerf att_euler = matrix::Quatf(att->q);
 	/* calculate heading error */
 	float yaw_err = att_euler.psi() - bearing;
 	/* apply control gain */
 	float roll_body = yaw_err * p.hdng_p;
 	/* limit output, this commonly is a tuning parameter, too */
 	if (roll_body < -0.6f) {
 		roll_body = -0.6f;
 	} else if (att_sp->roll_body > 0.6f) {
 		roll_body = 0.6f;
 	}
 	matrix::Eulerf att_spe(roll_body, 0, bearing);
 	matrix::Quatf(att_spe).copyTo(att_sp->q_d);
 }
 int parameters_init(struct param_handles *handles)
 {
 	/* PID parameters */
 	handles->hdng_p 	=	param_find("EXFW_HDNG_P");
 	handles->roll_p 	=	param_find("EXFW_ROLL_P");
 	handles->pitch_p 	=	param_find("EXFW_PITCH_P");
 	return 0;
 }
 int parameters_update(const struct param_handles *handles, struct params *parameters)
 {
 	param_get(handles->hdng_p, &(parameters->hdng_p));
 	param_get(handles->roll_p, &(parameters->roll_p));
 	param_get(handles->pitch_p, &(parameters->pitch_p));
 	return 0;
 }
 /* Main Thread */
 int fixedwing_control_thread_main(int argc, char *argv[])
 {
 	/* read arguments */
 	bool verbose = false;
 	for (int i = 1; i < argc; i++) {
 		if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
 			verbose = true;
 		}
 	}
 	/* welcome user (warnx prints a line, including an appended\n, with variable arguments */
 	warnx("[example fixedwing control] started");
 	/* initialize parameters, first the handles, then the values */
 	parameters_init(&ph);
 	parameters_update(&ph, &p);
 	/*
 	 * PX4 uses a publish/subscribe design pattern to enable
 	 * multi-threaded communication.
 	 *
 	 * The most elegant aspect of this is that controllers and
 	 * other processes can either 'react' to new data, or run
 	 * at their own pace.
 	 *
 	 * PX4 developer guide:
 	 * https://pixhawk.ethz.ch/px4/dev/shared_object_communication
 	 *
 	 * Wikipedia description:
 	 * http://en.wikipedia.org/wiki/Publish–subscribe_pattern
 	 *
 	 */
 	/*
 	 * Declare and safely initialize all structs to zero.
 	 *
 	 * These structs contain the system state and things
 	 * like attitude, position, the current waypoint, etc.
 	 */
 	vehicle_attitude_s att{};
 	vehicle_rates_setpoint_s rates_sp{};
 	manual_control_setpoint_s manual_control_setpoint{};
 	vehicle_status_s vstatus{};
 	position_setpoint_s global_sp{};
 	/* output structs - this is what is sent to the mixer */
 	actuator_controls_s actuators{};
 	/* publish actuator controls with zero values */
 	for (unsigned i = 0; i < actuator_controls_s::NUM_ACTUATOR_CONTROLS; i++) {
 		actuators.control[i] = 0.0f;
 	}
 	/*
 	 * Advertise that this controller will publish actuator
 	 * control values and the rate setpoint
 	 */
 	orb_advert_t actuator_pub = orb_advertise(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, &actuators);
 	orb_advert_t rates_pub = orb_advertise(ORB_ID(vehicle_rates_setpoint), &rates_sp);
 	/* subscribe to topics. */
 	int att_sub = orb_subscribe(ORB_ID(vehicle_attitude));
 	int global_pos_sub = orb_subscribe(ORB_ID(vehicle_global_position));
 	int manual_control_setpoint_sub = orb_subscribe(ORB_ID(manual_control_setpoint));
 	int vstatus_sub = orb_subscribe(ORB_ID(vehicle_status));
 	int global_sp_sub = orb_subscribe(ORB_ID(position_setpoint_triplet));
 	uORB::SubscriptionInterval parameter_update_sub{ORB_ID(parameter_update), 1_s};
 	/* Setup of loop */
 	struct pollfd fds[1] {};
 	fds[0].fd = att_sub;
 	fds[0].events = POLLIN;
 	while (!thread_should_exit) {
 		/*
 		 * Wait for a sensor or param update, check for exit condition every 500 ms.
 		 * This means that the execution will block here without consuming any resources,
 		 * but will continue to execute the very moment a new attitude measurement or
 		 * a param update is published. So no latency in contrast to the polling
 		 * design pattern (do not confuse the poll() system call with polling).
 		 *
 		 * This design pattern makes the controller also agnostic of the attitude
 		 * update speed - it runs as fast as the attitude updates with minimal latency.
 		 */
 		int ret = poll(fds, 1, 500);
 		if (ret < 0) {
 			/*
 			 * Poll error, this will not really happen in practice,
 			 * but its good design practice to make output an error message.
 			 */
 			warnx("poll error");
 		} else if (ret == 0) {
 			/* no return value = nothing changed for 500 ms, ignore */
 		} else {
 			// check for parameter updates
 			if (parameter_update_sub.updated()) {
 				// clear update
 				parameter_update_s pupdate;
 				parameter_update_sub.copy(&pupdate);
 				// if a param update occured, re-read our parameters
 				parameters_update(&ph, &p);
 			}
 			/* only run controller if attitude changed */
 			if (fds[0].revents & POLLIN) {
 				/* Check if there is a new position measurement or position setpoint */
 				bool pos_updated;
 				orb_check(global_pos_sub, &pos_updated);
 				bool global_sp_updated;
 				orb_check(global_sp_sub, &global_sp_updated);
 				bool manual_control_setpoint_updated;
 				orb_check(manual_control_setpoint_sub, &manual_control_setpoint_updated);
 				/* get a local copy of attitude */
 				orb_copy(ORB_ID(vehicle_attitude), att_sub, &att);
 				if (global_sp_updated) {
 					struct position_setpoint_triplet_s triplet;
 					orb_copy(ORB_ID(position_setpoint_triplet), global_sp_sub, &triplet);
 					memcpy(&global_sp, &triplet.current, sizeof(global_sp));
 				}
 				if (manual_control_setpoint_updated)
 					/* get the RC (or otherwise user based) input */
 				{
 					orb_copy(ORB_ID(manual_control_setpoint), manual_control_setpoint_sub, &manual_control_setpoint);
 				}
 				/* check if the throttle was ever more than 50% - go later only to failsafe if yes */
 				if (PX4_ISFINITE(manual_control_setpoint.z) &&
 				    (manual_control_setpoint.z >= 0.6f) &&
 				    (manual_control_setpoint.z <= 1.0f)) {
 				}
 				/* get the system status and the flight mode we're in */
 				orb_copy(ORB_ID(vehicle_status), vstatus_sub, &vstatus);
 				/* publish rates */
 				orb_publish(ORB_ID(vehicle_rates_setpoint), rates_pub, &rates_sp);
 				/* sanity check and publish actuator outputs */
 				if (PX4_ISFINITE(actuators.control[0]) &&
 				    PX4_ISFINITE(actuators.control[1]) &&
 				    PX4_ISFINITE(actuators.control[2]) &&
 				    PX4_ISFINITE(actuators.control[3])) {
 					orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators);
 					if (verbose) {
 						warnx("published");
 					}
 				}
 			}
 		}
 	}
 	printf("[ex_fixedwing_control] exiting, stopping all motors.\n");
 	thread_running = false;
 	/* kill all outputs */
 	for (unsigned i = 0; i < actuator_controls_s::NUM_ACTUATOR_CONTROLS; i++) {
 		actuators.control[i] = 0.0f;
 	}
 	orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators);
 	fflush(stdout);
 	return 0;
 }
 /* Startup Functions */
 static void
 usage(const char *reason)
 {
 	if (reason) {
 		fprintf(stderr, "%s\n", reason);
 	}
 	fprintf(stderr, "usage: ex_fixedwing_control {start|stop|status}\n\n");
 }
 /**
 * The daemon app only briefly exists to start
 * the background job. The stack size assigned in the
 * Makefile does only apply to this management task.
 *
 * The actual stack size should be set in the call
 * to px4_task_spawn_cmd().
 */
 int ex_fixedwing_control_main(int argc, char *argv[])
 {
 	if (argc < 2) {
 		usage("missing command");
 		return 1;
 	}
 	if (!strcmp(argv[1], "start")) {
 		if (thread_running) {
 			printf("ex_fixedwing_control already running\n");
 			/* this is not an error */
 			return 0;
 		}
 		thread_should_exit = false;
 		deamon_task = px4_task_spawn_cmd("ex_fixedwing_control",
 						 SCHED_DEFAULT,
 						 SCHED_PRIORITY_MAX - 20,
 						 2048,
 						 fixedwing_control_thread_main,
 						 (argv) ? (char *const *)&argv[2] : (char *const *)nullptr);
 		thread_running = true;
 		return 0;
 	}
 	if (!strcmp(argv[1], "stop")) {
 		thread_should_exit = true;
 		return 0;
 	}
 	if (!strcmp(argv[1], "status")) {
 		if (thread_running) {
 			printf("\tex_fixedwing_control is running\n");
 		} else {
 			printf("\tex_fixedwing_control not started\n");
 		}
 		return 0;
 	}
 	usage("unrecognized command");
 	return 0;
 }
@@ -1,56 +0,0 @@
 /****************************************************************************
 *
 *   Copyright (c) 2013 PX4 Development Team. All rights reserved.
 *   Author: Lorenz Meier <lm@inf.ethz.ch>
 *
 * 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 params.c
 *
 * Parameters for fixedwing demo
 */
 /* controller parameters, use max. 15 characters for param name! */
 /**
 *
 */
 PARAM_DEFINE_FLOAT(EXFW_HDNG_P, 0.1f);
 /**
 *
 */
 PARAM_DEFINE_FLOAT(EXFW_ROLL_P, 0.2f);
 /**
 *
 */
 PARAM_DEFINE_FLOAT(EXFW_PITCH_P, 0.2f);
@@ -1,53 +0,0 @@
 /****************************************************************************
 *
 *   Copyright (c) 2013 PX4 Development Team. All rights reserved.
 *   Author: Lorenz Meier <lm@inf.ethz.ch>
 *
 * 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 params.h
 *
 * Definition of parameters for fixedwing example
 */
 #include <parameters/param.h>
 struct params {
 	float hdng_p;
 	float roll_p;
 	float pitch_p;
 };
 struct param_handles {
 	param_t hdng_p;
 	param_t roll_p;
 	param_t pitch_p;
 };