fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-29 02:13:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #444 from PX4/multirotor_att_control_fix

Browse Source 
multirotor_att_control: cleanup, some refactoring
This commit is contained in:
Lorenz Meier
2013-10-13 03:36:06 -07:00
parent 1d2e6d1b2d 2fd8c6b958
commit 6baae41c5e
1 changed files with 216 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/multirotor_att_control/multirotor_att_control_main.c
+69 -70
View File
@@ -89,18 +89,18 @@ static int
mc_thread_main(int argc, char *argv[]) mc_thread_main(int argc, char *argv[])
{ {
/* declare and safely initialize all structs */ /* declare and safely initialize all structs */
struct vehicle_control_mode_s control_mode;
memset(&control_mode, 0, sizeof(control_mode));
struct vehicle_attitude_s att; struct vehicle_attitude_s att;
memset(&att, 0, sizeof(att)); memset(&att, 0, sizeof(att));
struct vehicle_attitude_setpoint_s att_sp; struct vehicle_attitude_setpoint_s att_sp;
memset(&att_sp, 0, sizeof(att_sp)); memset(&att_sp, 0, sizeof(att_sp));
struct manual_control_setpoint_s manual;
memset(&manual, 0, sizeof(manual));
struct sensor_combined_s raw;
memset(&raw, 0, sizeof(raw));
struct offboard_control_setpoint_s offboard_sp; struct offboard_control_setpoint_s offboard_sp;
memset(&offboard_sp, 0, sizeof(offboard_sp)); memset(&offboard_sp, 0, sizeof(offboard_sp));
struct vehicle_control_mode_s control_mode;
memset(&control_mode, 0, sizeof(control_mode));
struct manual_control_setpoint_s manual;
memset(&manual, 0, sizeof(manual));
struct sensor_combined_s sensor;
memset(&sensor, 0, sizeof(sensor));
struct vehicle_rates_setpoint_s rates_sp; struct vehicle_rates_setpoint_s rates_sp;
memset(&rates_sp, 0, sizeof(rates_sp)); memset(&rates_sp, 0, sizeof(rates_sp));
struct vehicle_status_s status; struct vehicle_status_s status;
@@ -108,29 +108,16 @@ mc_thread_main(int argc, char *argv[])
struct actuator_controls_s actuators; struct actuator_controls_s actuators;
memset(&actuators, 0, sizeof(actuators)); memset(&actuators, 0, sizeof(actuators));
/* subscribe to attitude, motor setpoints and system state */ /* subscribe */
int att_sub = orb_subscribe(ORB_ID(vehicle_attitude)); int vehicle_attitude_sub = orb_subscribe(ORB_ID(vehicle_attitude));
int param_sub = orb_subscribe(ORB_ID(parameter_update)); int parameter_update_sub = orb_subscribe(ORB_ID(parameter_update));
int att_setpoint_sub = orb_subscribe(ORB_ID(vehicle_attitude_setpoint)); int vehicle_attitude_setpoint_sub = orb_subscribe(ORB_ID(vehicle_attitude_setpoint));
int setpoint_sub = orb_subscribe(ORB_ID(offboard_control_setpoint)); int offboard_control_setpoint_sub = orb_subscribe(ORB_ID(offboard_control_setpoint));
int control_mode_sub = orb_subscribe(ORB_ID(vehicle_control_mode)); int vehicle_control_mode_sub = orb_subscribe(ORB_ID(vehicle_control_mode));
int manual_sub = orb_subscribe(ORB_ID(manual_control_setpoint)); int manual_control_setpoint_sub = orb_subscribe(ORB_ID(manual_control_setpoint));
int sensor_sub = orb_subscribe(ORB_ID(sensor_combined)); int sensor_combined_sub = orb_subscribe(ORB_ID(sensor_combined));
int rates_sp_sub = orb_subscribe(ORB_ID(vehicle_rates_setpoint)); int vehicle_rates_setpoint_sub = orb_subscribe(ORB_ID(vehicle_rates_setpoint));
int status_sub = orb_subscribe(ORB_ID(vehicle_status)); int vehicle_status_sub = orb_subscribe(ORB_ID(vehicle_status));
/*
* Do not rate-limit the loop to prevent aliasing
* if rate-limiting would be desired later, the line below would
* enable it.
*
* rate-limit the attitude subscription to 200Hz to pace our loop
* orb_set_interval(att_sub, 5);
*/
struct pollfd fds[2] = {
{ .fd = att_sub, .events = POLLIN },
{ .fd = param_sub, .events = POLLIN }
};
/* publish actuator controls */ /* publish actuator controls */
for (unsigned i = 0; i < NUM_ACTUATOR_CONTROLS; i++) { for (unsigned i = 0; i < NUM_ACTUATOR_CONTROLS; i++) {
@@ -146,70 +133,84 @@ mc_thread_main(int argc, char *argv[])
perf_counter_t mc_interval_perf = perf_alloc(PC_INTERVAL, "multirotor_att_control_interval"); perf_counter_t mc_interval_perf = perf_alloc(PC_INTERVAL, "multirotor_att_control_interval");
perf_counter_t mc_err_perf = perf_alloc(PC_COUNT, "multirotor_att_control_err"); perf_counter_t mc_err_perf = perf_alloc(PC_COUNT, "multirotor_att_control_err");
/* welcome user */
warnx("starting"); warnx("starting");
/* store last control mode to detect mode switches */ /* store last control mode to detect mode switches */
bool control_yaw_position = true; bool control_yaw_position = true;
bool reset_yaw_sp = true; bool reset_yaw_sp = true;
struct pollfd fds[1] = {
{ .fd = vehicle_attitude_sub, .events = POLLIN },
};
while (!thread_should_exit) { while (!thread_should_exit) {
/* wait for a sensor update, check for exit condition every 500 ms */ /* wait for a sensor update, check for exit condition every 500 ms */
int ret = poll(fds, 2, 500); int ret = poll(fds, 1, 500);
if (ret < 0) { if (ret < 0) {
/* poll error, count it in perf */ /* poll error, count it in perf */
perf_count(mc_err_perf); perf_count(mc_err_perf);
} else if (ret == 0) { } else if (ret > 0) {
/* no return value, ignore */ /* only run controller if attitude changed */
} else { perf_begin(mc_loop_perf);
/* only update parameters if they changed */ /* attitude */
if (fds[1].revents & POLLIN) { orb_copy(ORB_ID(vehicle_attitude), vehicle_attitude_sub, &att);
/* read from param to clear updated flag */
bool updated;
/* parameters */
orb_check(parameter_update_sub, &updated);
if (updated) {
struct parameter_update_s update; struct parameter_update_s update;
orb_copy(ORB_ID(parameter_update), param_sub, &update); orb_copy(ORB_ID(parameter_update), parameter_update_sub, &update);
/* update parameters */ /* update parameters */
} }
/* only run controller if attitude changed */ /* control mode */
if (fds[0].revents & POLLIN) { orb_check(vehicle_control_mode_sub, &updated);
perf_begin(mc_loop_perf);
/* get a local copy of system state */
bool updated;
orb_check(control_mode_sub, &updated);
if (updated) { if (updated) {
orb_copy(ORB_ID(vehicle_control_mode), control_mode_sub, &control_mode); orb_copy(ORB_ID(vehicle_control_mode), vehicle_control_mode_sub, &control_mode);
} }
/* get a local copy of manual setpoint */ /* manual control setpoint */
orb_copy(ORB_ID(manual_control_setpoint), manual_sub, &manual); orb_check(manual_control_setpoint_sub, &updated);
/* get a local copy of attitude */
orb_copy(ORB_ID(vehicle_attitude), att_sub, &att);
/* get a local copy of attitude setpoint */
orb_copy(ORB_ID(vehicle_attitude_setpoint), att_setpoint_sub, &att_sp);
/* get a local copy of rates setpoint */
orb_check(setpoint_sub, &updated);
if (updated) { if (updated) {
orb_copy(ORB_ID(offboard_control_setpoint), setpoint_sub, &offboard_sp); orb_copy(ORB_ID(manual_control_setpoint), manual_control_setpoint_sub, &manual);
} }
/* get a local copy of status */ /* attitude setpoint */
orb_check(status_sub, &updated); orb_check(vehicle_attitude_setpoint_sub, &updated);
if (updated) { if (updated) {
orb_copy(ORB_ID(vehicle_status), status_sub, &status); orb_copy(ORB_ID(vehicle_attitude_setpoint), vehicle_attitude_setpoint_sub, &att_sp);
} }
/* get a local copy of the current sensor values */ /* offboard control setpoint */
orb_copy(ORB_ID(sensor_combined), sensor_sub, &raw); orb_check(offboard_control_setpoint_sub, &updated);
if (updated) {
orb_copy(ORB_ID(offboard_control_setpoint), offboard_control_setpoint_sub, &offboard_sp);
}
/* vehicle status */
orb_check(vehicle_status_sub, &updated);
if (updated) {
orb_copy(ORB_ID(vehicle_status), vehicle_status_sub, &status);
}
/* sensors */
orb_check(sensor_combined_sub, &updated);
if (updated) {
orb_copy(ORB_ID(sensor_combined), sensor_combined_sub, &sensor);
}
/* set flag to safe value */ /* set flag to safe value */
control_yaw_position = true; control_yaw_position = true;
@@ -346,10 +347,10 @@ mc_thread_main(int argc, char *argv[])
if (control_mode.flag_control_rates_enabled) { if (control_mode.flag_control_rates_enabled) {
/* get current rate setpoint */ /* get current rate setpoint */
bool rates_sp_updated = false; bool rates_sp_updated = false;
orb_check(rates_sp_sub, &rates_sp_updated); orb_check(vehicle_rates_setpoint_sub, &rates_sp_updated);
if (rates_sp_updated) { if (rates_sp_updated) {
orb_copy(ORB_ID(vehicle_rates_setpoint), rates_sp_sub, &rates_sp); orb_copy(ORB_ID(vehicle_rates_setpoint), vehicle_rates_setpoint_sub, &rates_sp);
} }
/* apply controller */ /* apply controller */
@@ -371,8 +372,7 @@ mc_thread_main(int argc, char *argv[])
orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators); orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators);
perf_end(mc_loop_perf); perf_end(mc_loop_perf);
} /* end of poll call for attitude updates */ }
} /* end of poll return value check */
} }
warnx("stopping, disarming motors"); warnx("stopping, disarming motors");
@@ -383,10 +383,9 @@ mc_thread_main(int argc, char *argv[])
orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators); orb_publish(ORB_ID_VEHICLE_ATTITUDE_CONTROLS, actuator_pub, &actuators);
close(vehicle_attitude_sub);
close(att_sub); close(vehicle_control_mode_sub);
close(control_mode_sub); close(manual_control_setpoint_sub);
close(manual_sub);
close(actuator_pub); close(actuator_pub);
close(att_sp_pub); close(att_sp_pub);