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

Final parameter interface cleanup - removed last bit of old cruft, fixed a bug on parameter update notification, cleaned up API slightly in naming

Browse Source
This commit is contained in:
Lorenz Meier
2012-08-27 22:57:20 +02:00
parent 2a6a151342
commit 2d2548e714
15 changed files with 82 additions and 636 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/commander/commander.c
+9 -9
View File
@@ -125,8 +125,8 @@ static void led_deinit(void);
static int led_toggle(int led);
static int led_on(int led);
static int led_off(int led);
static void do_gyro_calibration(int status_pub, struct vehicle_status_s *current_status);
static void do_mag_calibration(int status_pub, struct vehicle_status_s *current_status);
static void do_gyro_calibration(int status_pub, struct vehicle_status_s *status);
static void do_mag_calibration(int status_pub, struct vehicle_status_s *status);
static void handle_command(int status_pub, struct vehicle_status_s *current_status, struct vehicle_command_s *cmd);
int trigger_audio_alarm(uint8_t old_mode, uint8_t old_state, uint8_t new_mode, uint8_t new_state);
@@ -444,7 +444,7 @@ void do_mag_calibration(int status_pub, struct vehicle_status_s *status)
close(sub_sensor_combined);
}
void do_gyro_calibration(int status_pub, struct vehicle_status_s *current_status)
void do_gyro_calibration(int status_pub, struct vehicle_status_s *status)
{
const int calibration_count = 3000;
@@ -942,13 +942,13 @@ int commander_thread_main(int argc, char *argv[])
led_toggle(LED_AMBER);
} else {
/* Constant error indication in standby mode without GPS */
if (flight_env == PX4_FLIGHT_ENVIRONMENT_OUTDOOR && !current_status.gps_valid) {
led_on(LED_AMBER);
// /* Constant error indication in standby mode without GPS */
// if (!current_status.gps_valid) {
// led_on(LED_AMBER);
} else {
led_off(LED_AMBER);
}
// } else {
// led_off(LED_AMBER);
// }
}
if (counter % (1000000 / COMMANDER_MONITORING_INTERVAL) == 0) {
apps/commander/state_machine_helper.c
+10 -7
View File
@@ -39,7 +39,7 @@
*/
#include <stdio.h>
#include "state_machine_helper.h"
#include <unistd.h>
#include <uORB/uORB.h>
#include <uORB/topics/vehicle_status.h>
@@ -47,6 +47,8 @@
#include <arch/board/up_hrt.h>
#include <mavlink/mavlink_log.h>
#include "state_machine_helper.h"
static const char* system_state_txt[] = {
"SYSTEM_STATE_PREFLIGHT",
"SYSTEM_STATE_STANDBY",
@@ -75,14 +77,12 @@ int do_state_update(int status_pub, struct vehicle_status_s *current_status, con
switch (new_state) {
case SYSTEM_STATE_MISSION_ABORT: {
/* Indoor or outdoor */
uint8_t flight_environment_parameter = (uint8_t)(global_data_parameter_storage->pm.param_values[PARAM_FLIGHT_ENV]);
if (flight_environment_parameter == PX4_FLIGHT_ENVIRONMENT_OUTDOOR) {
// if (flight_environment_parameter == PX4_FLIGHT_ENVIRONMENT_OUTDOOR) {
ret = do_state_update(status_pub, current_status, mavlink_fd, (commander_state_machine_t)SYSTEM_STATE_EMCY_LANDING);
} else {
ret = do_state_update(status_pub, current_status, mavlink_fd, (commander_state_machine_t)SYSTEM_STATE_EMCY_CUTOFF);
}
// } else {
// ret = do_state_update(status_pub, current_status, mavlink_fd, (commander_state_machine_t)SYSTEM_STATE_EMCY_CUTOFF);
// }
}
break;
@@ -198,10 +198,13 @@ int do_state_update(int status_pub, struct vehicle_status_s *current_status, con
if (invalid_state == false || old_state != new_state) {
current_status->state_machine = new_state;
state_machine_publish(status_pub, current_status, mavlink_fd);
ret = OK;
}
if (invalid_state) {
mavlink_log_critical(mavlink_fd, "[commander] REJECTING invalid state transition");
ret = ERROR;
}
return ret;
}
void state_machine_publish(int status_pub, struct vehicle_status_s *current_status, const int mavlink_fd) {
apps/drivers/mpu6000/mpu6000.cpp
+1 -14
View File
@@ -55,6 +55,7 @@
#include <systemlib/perf_counter.h>
#include <systemlib/err.h>
#include <systemlib/conversions.h>
#include <nuttx/arch.h>
#include <nuttx/clock.h>
@@ -761,20 +762,6 @@ MPU6000::measure_trampoline(void *arg)
dev->measure();
}
int16_t
int16_t_from_bytes(uint8_t bytes[])
{
union {
uint8_t b[2];
int16_t w;
} u;
u.b[1] = bytes[0];
u.b[0] = bytes[1];
return u.w;
}
void
MPU6000::measure()
{
apps/fixedwing_control/fixedwing_control.c
+20 -50
View File
@@ -575,18 +575,13 @@ static float calc_roll_setpoint()
{
float setpoint = 0;
if (plane_data.mode == TAKEOFF) {
setpoint = 0;
setpoint = calc_bearing() - plane_data.yaw;
} else {
setpoint = calc_bearing() - plane_data.yaw;
if (setpoint < (-35.0f/180.0f)*M_PI_F)
return (-35.0f/180.0f)*M_PI_F;
if (setpoint < (-35.0f/180.0f)*M_PI_F)
return (-35.0f/180.0f)*M_PI_F;
if (setpoint > (35/180.0f)*M_PI_F)
return (-35.0f/180.0f)*M_PI_F;
}
if (setpoint > (35/180.0f)*M_PI_F)
return (-35.0f/180.0f)*M_PI_F;
return setpoint;
}
@@ -605,10 +600,10 @@ static float calc_pitch_setpoint()
{
float setpoint = 0.0f;
if (plane_data.mode == TAKEOFF) {
setpoint = ((35/180.0f)*M_PI_F);
// if (plane_data.mode == TAKEOFF) {
// setpoint = ((35/180.0f)*M_PI_F);
} else {
// } else {
setpoint = atanf((plane_data.wp_z - plane_data.alt) / calc_wp_distance());
if (setpoint < (-35.0f/180.0f)*M_PI_F)
@@ -616,7 +611,7 @@ static float calc_pitch_setpoint()
if (setpoint > (35/180.0f)*M_PI_F)
return (-35.0f/180.0f)*M_PI_F;
}
// }
return setpoint;
}
@@ -634,46 +629,24 @@ static float calc_throttle_setpoint()
{
float setpoint = 0;
// if TAKEOFF full throttle
if (plane_data.mode == TAKEOFF) {
setpoint = 60.0f;
}
// // if TAKEOFF full throttle
// if (plane_data.mode == TAKEOFF) {
// setpoint = 60.0f;
// }
// if CRUISE - parameter value
if (plane_data.mode == CRUISE) {
// // if CRUISE - parameter value
// if (plane_data.mode == CRUISE) {
setpoint = plane_data.airspeed;
}
// }
// if LAND no throttle
if (plane_data.mode == LAND) {
setpoint = 0.0f;
}
// // if LAND no throttle
// if (plane_data.mode == LAND) {
// setpoint = 0.0f;
// }
return setpoint;
}
/**
* set_plane_mode
*
* Sets the plane mode
* (TAKEOFF, CRUISE, LOITER or LAND)
*
*/
static void set_plane_mode()
{
if (plane_data.alt < 10.0f) {
plane_data.mode = TAKEOFF;
} else {
plane_data.mode = CRUISE;
// TODO: if reached waypoint and no further waypoint exists, go to LOITER mode
}
// Debug override - don't need TAKEOFF mode for now
plane_data.mode = CRUISE;
}
/*
* fixedwing_control_main
*
@@ -835,9 +808,6 @@ int fixedwing_control_main(int argc, char *argv[])
/************************************************************************************************************/
}
/* Set plane mode */
set_plane_mode();
/* Calculate the P,Q,R body rates of the aircraft */
//calc_body_angular_rates(plane_data.roll, plane_data.pitch, plane_data.yaw,
// plane_data.rollspeed, plane_data.pitchspeed, plane_data.yawspeed);
apps/sensors/sensors.cpp
+25 -1
View File
@@ -69,6 +69,7 @@
#include <uORB/topics/rc_channels.h>
#include <uORB/topics/manual_control_setpoint.h>
#include <uORB/topics/vehicle_status.h>
#include <uORB/topics/parameter_update.h>
#define GYRO_HEALTH_COUNTER_LIMIT_ERROR 20 /* 40 ms downtime at 500 Hz update rate */
#define ACC_HEALTH_COUNTER_LIMIT_ERROR 20 /* 40 ms downtime at 500 Hz update rate */
@@ -162,6 +163,7 @@ private:
int _mag_sub; /**< raw mag data subscription */
int _baro_sub; /**< raw baro data subscription */
int _vstatus_sub; /**< vehicle status subscription */
int _params_sub; /**< notification of parameter updates */
orb_advert_t _sensor_pub; /**< combined sensor data topic */
orb_advert_t _manual_control_pub; /**< manual control signal topic */
@@ -280,6 +282,11 @@ private:
*/
void vehicle_status_poll();
/**
* Check for changes in parameters.
*/
void parameter_update_poll();
/**
* Poll the ADC and update readings to suit.
*
@@ -330,6 +337,7 @@ Sensors::Sensors() :
_mag_sub(-1),
_baro_sub(-1),
_vstatus_sub(-1),
_params_sub(-1),
/* publications */
_sensor_pub(-1),
@@ -724,9 +732,21 @@ Sensors::vehicle_status_poll()
_publishing = true;
}
}
}
/* XXX run the param update more often right now */
void
Sensors::parameter_update_poll()
{
bool param_updated;
/* Check if any parameter has changed */
orb_check(_params_sub, &param_updated);
if (param_updated)
{
/* read from param to clear updated flag */
struct parameter_update_s update;
orb_copy(ORB_ID(parameter_update), _params_sub, &update);
printf("PARAMS UPDATED\n");
/* update parameters */
parameters_update();
@@ -886,6 +906,7 @@ Sensors::task_main()
_mag_sub = orb_subscribe(ORB_ID(sensor_mag));
_baro_sub = orb_subscribe(ORB_ID(sensor_baro));
_vstatus_sub = orb_subscribe(ORB_ID(vehicle_status));
_params_sub = orb_subscribe(ORB_ID(parameter_update));
/* rate limit vehicle status updates to 5Hz */
orb_set_interval(_vstatus_sub, 200);
@@ -957,6 +978,9 @@ Sensors::task_main()
/* check vehicle status for changes to publication state */
vehicle_status_poll();
/* check parameters for updates */
parameter_update_poll();
/* store the time closest to all measurements (this is bogus, sensor timestamps should be propagated...) */
raw.timestamp = hrt_absolute_time();
apps/systemlib/Makefile
+2 -1
View File
@@ -39,7 +39,8 @@ CSRCS = err.c \
hx_stream.c \
perf_counter.c \
param/param.c \
bson/tinybson.c
bson/tinybson.c \
conversions.c
#
# XXX this really should be a CONFIG_* test
apps/systemlib/param/param.c
+4 -3
View File
@@ -57,7 +57,7 @@
#include "systemlib/bson/tinybson.h"
#include "uORB/uORB.h"
#include "uORB/topics/parameters.h"
#include "uORB/topics/parameter_update.h"
#if 1
# define debug(fmt, args...) do { warnx(fmt, ##args); } while(0)
@@ -318,6 +318,7 @@ int
param_set(param_t param, const void *val)
{
int result = -1;
bool params_changed = false;
param_lock();
@@ -378,7 +379,7 @@ param_set(param_t param, const void *val)
}
s->unsaved = true;
params_changed = true;
result = 0;
}
@@ -389,7 +390,7 @@ out:
* If we set something, now that we have unlocked, go ahead and advertise that
* a thing has been set.
*/
if (result != 0) {
if (params_changed) {
struct parameter_update_s pup = { .timestamp = hrt_absolute_time() };
/*
apps/systemlib/systemlib.c
+1 -3
View File
@@ -3,7 +3,6 @@
* Copyright (C) 2012 PX4 Development Team. All rights reserved.
* Author: @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:
@@ -35,7 +34,7 @@
/**
* @file systemlib.c
* Implementation of commonly used low-level system-call like functions
* Implementation of commonly used low-level system-call like functions.
*/
#include <nuttx/config.h>
@@ -47,7 +46,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <arch/board/drv_eeprom.h>
#include <uORB/parameter_storage.h>
#include <float.h>
#include <string.h>
apps/systemlib/systemlib.h
+1 -1
View File
@@ -34,7 +34,7 @@
/**
* @file systemlib.h
* Definition of commonly used low-level system-call like functions
* Definition of commonly used low-level system-call like functions.
*/
#ifndef SYSTEMLIB_H_
apps/uORB/objects_common.cpp
+1 -1
View File
@@ -32,7 +32,7 @@
****************************************************************************/
/**
* @file objects_common.h
* @file objects_common.cpp
*
* Common object definitions without a better home.
*/
apps/uORB/parameter_storage.c
-379
View File
@@ -1,379 +0,0 @@
#include "parameter_storage.h"
#include <stdbool.h>
/* Global symbols / flags */
struct global_data_parameter_storage_t global_data_parameter_storage_d = { /*.counter = 0, .timestamp = 0,*/ .pm = {.size = PARAM_MAX_COUNT,
.param_values[PARAM_SYSTEM_ID] = 12,
.param_names[PARAM_SYSTEM_ID] = "SYS_ID",
.param_needs_write[PARAM_SYSTEM_ID] = false,
.param_values[PARAM_COMP_ID] = 200,
.param_names[PARAM_COMP_ID] = "COMP_ID",
.param_needs_write[PARAM_COMP_ID] = false,
.param_values[PARAM_FLIGHT_ENV] = (float)PX4_FLIGHT_ENVIRONMENT_INDOOR,
.param_names[PARAM_FLIGHT_ENV] = "FLIGHT_ENV",
.param_needs_write[PARAM_FLIGHT_ENV] = false,
.param_values[PARAM_BATTERYVOLTAGE_CONVERSION] = -1.f,
.param_names[PARAM_BATTERYVOLTAGE_CONVERSION] = "BATVOLTAG_CONV",
.param_needs_write[PARAM_BATTERYVOLTAGE_CONVERSION] = false,
.param_values[PARAM_PID_YAWPOS_P] = 0.3f,
.param_names[PARAM_PID_YAWPOS_P] = "PID_YAWPOS_P",
.param_needs_write[PARAM_PID_YAWPOS_P] = false,
.param_values[PARAM_PID_YAWPOS_I] = 0.15f,
.param_names[PARAM_PID_YAWPOS_I] = "PID_YAWPOS_I",
.param_needs_write[PARAM_PID_YAWPOS_I] = false,
.param_values[PARAM_PID_YAWPOS_D] = 0.0f,
.param_names[PARAM_PID_YAWPOS_D] = "PID_YAWPOS_D",
.param_needs_write[PARAM_PID_YAWPOS_D] = false,
.param_values[PARAM_PID_YAWPOS_AWU] = 1.0f,
.param_names[PARAM_PID_YAWPOS_AWU] = "PID_YAWPOS_AWU",
.param_needs_write[PARAM_PID_YAWPOS_AWU] = false,
.param_values[PARAM_PID_YAWPOS_LIM] = 3.0f,
.param_names[PARAM_PID_YAWPOS_LIM] = "PID_YAWPOS_LIM",
.param_needs_write[PARAM_PID_YAWPOS_LIM] = false,
.param_values[PARAM_PID_YAWSPEED_P] = 0.1f,
.param_names[PARAM_PID_YAWSPEED_P] = "PID_YAWSPD_P",
.param_needs_write[PARAM_PID_YAWSPEED_P] = false,
.param_values[PARAM_PID_YAWSPEED_I] = 0.02f,
.param_names[PARAM_PID_YAWSPEED_I] = "PID_YAWSPD_I",
.param_needs_write[PARAM_PID_YAWSPEED_I] = false,
.param_values[PARAM_PID_YAWSPEED_D] = 0.0f,
.param_names[PARAM_PID_YAWSPEED_D] = "PID_YAWSPD_D",
.param_needs_write[PARAM_PID_YAWSPEED_D] = false,
.param_values[PARAM_PID_YAWSPEED_AWU] = 0.02f,
.param_names[PARAM_PID_YAWSPEED_AWU] = "PID_YAWSPD_AWU",
.param_needs_write[PARAM_PID_YAWSPEED_AWU] = false,
.param_values[PARAM_PID_YAWSPEED_LIM] = 0.1f,
.param_names[PARAM_PID_YAWSPEED_LIM] = "PID_YAWSPD_LIM",
.param_needs_write[PARAM_PID_YAWSPEED_LIM] = false,
.param_values[PARAM_PID_ATT_P] = 0.3f,
.param_names[PARAM_PID_ATT_P] = "PID_ATT_P",
.param_needs_write[PARAM_PID_ATT_P] = false,
.param_values[PARAM_PID_ATT_I] = 0.0f,
.param_names[PARAM_PID_ATT_I] = "PID_ATT_I",
.param_needs_write[PARAM_PID_ATT_I] = false,
.param_values[PARAM_PID_ATT_D] = 0.1f,
.param_names[PARAM_PID_ATT_D] = "PID_ATT_D",
.param_needs_write[PARAM_PID_ATT_D] = false,
.param_values[PARAM_PID_ATT_AWU] = 0.05f,
.param_names[PARAM_PID_ATT_AWU] = "PID_ATT_AWU",
.param_needs_write[PARAM_PID_ATT_AWU] = false,
.param_values[PARAM_PID_ATT_LIM] = 0.3f,
.param_names[PARAM_PID_ATT_LIM] = "PID_ATT_LIM",
.param_needs_write[PARAM_PID_ATT_LIM] = false,
.param_values[PARAM_PID_POS_P] = 40.0f,
.param_names[PARAM_PID_POS_P] = "PID_POS_P",
.param_needs_write[PARAM_PID_POS_P] = false,
.param_values[PARAM_PID_POS_I] = 0.0f,
.param_names[PARAM_PID_POS_I] = "PID_POS_I",
.param_needs_write[PARAM_PID_POS_I] = false,
.param_values[PARAM_PID_POS_D] = 0.0f,
.param_names[PARAM_PID_POS_D] = "PID_POS_D",
.param_needs_write[PARAM_PID_POS_D] = false,
.param_values[PARAM_PID_POS_AWU] = 5.0f,
.param_names[PARAM_PID_POS_AWU] = "PID_POS_AWU",
.param_needs_write[PARAM_PID_POS_AWU] = false,
.param_values[PARAM_PID_POS_LIM] = 0.3f,
.param_names[PARAM_PID_POS_LIM] = "PID_POS_LIM",
.param_needs_write[PARAM_PID_POS_LIM] = false,
.param_values[PARAM_PID_POS_Z_P] = 10.0f,
.param_names[PARAM_PID_POS_Z_P] = "PID_POS_Z_P",
.param_needs_write[PARAM_PID_POS_Z_P] = false,
.param_values[PARAM_PID_POS_Z_I] = 0.0f,
.param_names[PARAM_PID_POS_Z_I] = "PID_POS_Z_I",
.param_needs_write[PARAM_PID_POS_Z_I] = false,
.param_values[PARAM_PID_POS_Z_D] = 0.0f,
.param_names[PARAM_PID_POS_Z_D] = "PID_POS_Z_D",
.param_needs_write[PARAM_PID_POS_Z_D] = false,
.param_values[PARAM_PID_POS_Z_AWU] = 3.0f,
.param_names[PARAM_PID_POS_Z_AWU] = "PID_POS_Z_AWU",
.param_needs_write[PARAM_PID_POS_Z_AWU] = false,
.param_values[PARAM_PID_POS_Z_LIM] = 0.3f,
.param_names[PARAM_PID_POS_Z_LIM] = "PID_POS_Z_LIM",
.param_needs_write[PARAM_PID_POS_Z_LIM] = false,
.param_values[PARAM_AIRSPEED] = 30.0f,
.param_names[PARAM_AIRSPEED] = "AIRSPEED",
.param_needs_write[PARAM_AIRSPEED] = false,
.param_values[PARAM_WPLON] = -120.0f,
.param_names[PARAM_WPLON] = "WPLON",
.param_needs_write[PARAM_WPLON] = false,
.param_values[PARAM_WPLAT] = 38.0f,
.param_names[PARAM_WPLAT] = "WPLAT",
.param_needs_write[PARAM_WPLAT] = false,
.param_values[PARAM_WPALT] = 500.0f,
.param_names[PARAM_WPALT] = "WPALT",
.param_needs_write[PARAM_WPALT] = false,
.param_values[PARAM_FLIGHTMODE] = CRUISE,
.param_names[PARAM_FLIGHTMODE] = "FLIGHTMODE",
.param_needs_write[PARAM_FLIGHTMODE] = false,
.param_values[PARAM_SENSOR_GYRO_XOFFSET] = 700.f,
.param_names[PARAM_SENSOR_GYRO_XOFFSET] = "SENSOR_GYRO_XOF",
.param_needs_write[PARAM_SENSOR_GYRO_XOFFSET] = false,
.param_values[PARAM_SENSOR_GYRO_YOFFSET] = 1400.0f,
.param_names[PARAM_SENSOR_GYRO_YOFFSET] = "SENSOR_GYRO_YOF",
.param_needs_write[PARAM_SENSOR_GYRO_YOFFSET] = false,
.param_values[PARAM_SENSOR_GYRO_ZOFFSET] = 0.0f,
.param_names[PARAM_SENSOR_GYRO_ZOFFSET] = "SENSOR_GYRO_ZOF",
.param_needs_write[PARAM_SENSOR_GYRO_ZOFFSET] = false,
.param_values[PARAM_SENSOR_MAG_XOFFSET] = 422.0f,
.param_names[PARAM_SENSOR_MAG_XOFFSET] = "SENSOR_MAG_XOF",
.param_needs_write[PARAM_SENSOR_MAG_XOFFSET] = false,
.param_values[PARAM_SENSOR_MAG_YOFFSET] = -85.0f,
.param_names[PARAM_SENSOR_MAG_YOFFSET] = "SENSOR_MAG_YOF",
.param_needs_write[PARAM_SENSOR_MAG_YOFFSET] = false,
.param_values[PARAM_SENSOR_MAG_ZOFFSET] = -370.0f,
.param_names[PARAM_SENSOR_MAG_ZOFFSET] = "SENSOR_MAG_ZOF",
.param_needs_write[PARAM_SENSOR_MAG_ZOFFSET] = false,
.param_values[PARAM_ATT_XOFFSET] = 0.0f,
.param_names[PARAM_ATT_XOFFSET] = "ATT_XOFF",
.param_needs_write[PARAM_ATT_XOFFSET] = false,
.param_values[PARAM_ATT_YOFFSET] = 0.0f,
.param_names[PARAM_ATT_YOFFSET] = "ATT_YOFF",
.param_needs_write[PARAM_ATT_YOFFSET] = false,
.param_values[PARAM_RC1_MIN] = 1000.0f,
.param_names[PARAM_RC1_MIN] = "RC1_MIN",
.param_needs_write[PARAM_RC1_MIN] = false,
.param_values[PARAM_RC1_MAX] = 2000.0f,
.param_names[PARAM_RC1_MAX] = "RC1_MAX",
.param_needs_write[PARAM_RC1_MAX] = false,
.param_values[PARAM_RC1_TRIM] = 1500.0f,
.param_names[PARAM_RC1_TRIM] = "RC1_TRIM",
.param_needs_write[PARAM_RC1_TRIM] = false,
.param_values[PARAM_RC1_REV] = 1.0f,
.param_names[PARAM_RC1_REV] = "RC1_REV",
.param_needs_write[PARAM_RC1_REV] = false,
.param_values[PARAM_RC2_MIN] = 1000.0f,
.param_names[PARAM_RC2_MIN] = "RC2_MIN",
.param_needs_write[PARAM_RC2_MIN] = false,
.param_values[PARAM_RC2_MAX] = 2000.0f,
.param_names[PARAM_RC2_MAX] = "RC2_MAX",
.param_needs_write[PARAM_RC2_MAX] = false,
.param_values[PARAM_RC2_TRIM] = 1500.0f,
.param_names[PARAM_RC2_TRIM] = "RC2_TRIM",
.param_needs_write[PARAM_RC2_TRIM] = false,
.param_values[PARAM_RC2_REV] = 1.0f,
.param_names[PARAM_RC2_REV] = "RC2_REV",
.param_needs_write[PARAM_RC2_REV] = false,
.param_values[PARAM_RC3_MIN] = 1000.0f,
.param_names[PARAM_RC3_MIN] = "RC3_MIN",
.param_needs_write[PARAM_RC3_MIN] = false,
.param_values[PARAM_RC3_MAX] = 2000.0f,
.param_names[PARAM_RC3_MAX] = "RC3_MAX",
.param_needs_write[PARAM_RC3_MAX] = false,
.param_values[PARAM_RC3_TRIM] = 1500.0f,
.param_names[PARAM_RC3_TRIM] = "RC3_TRIM",
.param_needs_write[PARAM_RC3_TRIM] = false,
.param_values[PARAM_RC3_REV] = 1.0f,
.param_names[PARAM_RC3_REV] = "RC3_REV",
.param_needs_write[PARAM_RC3_REV] = false,
.param_values[PARAM_RC4_MIN] = 1000.0f,
.param_names[PARAM_RC4_MIN] = "RC4_MIN",
.param_needs_write[PARAM_RC4_MIN] = false,
.param_values[PARAM_RC4_MAX] = 2000.0f,
.param_names[PARAM_RC4_MAX] = "RC4_MAX",
.param_needs_write[PARAM_RC4_MAX] = false,
.param_values[PARAM_RC4_TRIM] = 1500.0f,
.param_names[PARAM_RC4_TRIM] = "RC4_TRIM",
.param_needs_write[PARAM_RC4_TRIM] = false,
.param_values[PARAM_RC4_REV] = 1.0f,
.param_names[PARAM_RC4_REV] = "RC4_REV",
.param_needs_write[PARAM_RC4_MIN] = false,
.param_values[PARAM_RC5_MIN] = 1000.0f,
.param_names[PARAM_RC5_MIN] = "RC5_MIN",
.param_needs_write[PARAM_RC5_MIN] = false,
.param_values[PARAM_RC5_MAX] = 2000.0f,
.param_names[PARAM_RC5_MAX] = "RC5_MAX",
.param_needs_write[PARAM_RC5_MAX] = false,
.param_values[PARAM_RC5_TRIM] = 1500.0f,
.param_names[PARAM_RC5_TRIM] = "RC5_TRIM",
.param_needs_write[PARAM_RC5_TRIM] = false,
.param_values[PARAM_RC5_REV] = 1.0f,
.param_names[PARAM_RC5_REV] = "RC5_REV",
.param_needs_write[PARAM_RC5_REV] = false,
.param_values[PARAM_RC6_MIN] = 1000.0f,
.param_names[PARAM_RC6_MIN] = "RC6_MIN",
.param_needs_write[PARAM_RC6_MIN] = false,
.param_values[PARAM_RC6_MAX] = 2000.0f,
.param_names[PARAM_RC6_MAX] = "RC6_MAX",
.param_needs_write[PARAM_RC6_MAX] = false,
.param_values[PARAM_RC6_TRIM] = 1500.0f,
.param_names[PARAM_RC6_TRIM] = "RC6_TRIM",
.param_needs_write[PARAM_RC6_TRIM] = false,
.param_values[PARAM_RC6_REV] = 1.0f,
.param_names[PARAM_RC6_REV] = "RC6_REV",
.param_needs_write[PARAM_RC6_REV] = false,
.param_values[PARAM_RC7_MIN] = 1000,
.param_names[PARAM_RC7_MIN] = "RC7_MIN",
.param_needs_write[PARAM_RC7_MIN] = false,
.param_values[PARAM_RC7_MAX] = 2000,
.param_names[PARAM_RC7_MAX] = "RC7_MAX",
.param_needs_write[PARAM_RC7_MAX] = false,
.param_values[PARAM_RC7_TRIM] = 1500,
.param_names[PARAM_RC7_TRIM] = "RC7_TRIM",
.param_needs_write[PARAM_RC7_TRIM] = false,
.param_values[PARAM_RC7_REV] = 1.0f,
.param_names[PARAM_RC7_REV] = "RC7_REV",
.param_needs_write[PARAM_RC7_REV] = false,
.param_values[PARAM_RC8_MIN] = 1000,
.param_names[PARAM_RC8_MIN] = "RC8_MIN",
.param_needs_write[PARAM_RC8_MIN] = false,
.param_values[PARAM_RC8_MAX] = 2000,
.param_names[PARAM_RC8_MAX] = "RC8_MAX",
.param_needs_write[PARAM_RC8_MAX] = false,
.param_values[PARAM_RC8_TRIM] = 1500,
.param_names[PARAM_RC8_TRIM] = "RC8_TRIM",
.param_needs_write[PARAM_RC8_TRIM] = false,
.param_values[PARAM_RC8_REV] = 1.0f,
.param_names[PARAM_RC8_REV] = "RC8_REV",
.param_needs_write[PARAM_RC8_REV] = false,
.param_values[PARAM_ROLL_CHAN] = 1,
.param_names[PARAM_ROLL_CHAN] = "ROLL_CHAN",
.param_needs_write[PARAM_ROLL_CHAN] = false,
.param_values[PARAM_PITCH_CHAN] = 2,
.param_names[PARAM_PITCH_CHAN] = "PITCH_CHAN",
.param_needs_write[PARAM_PITCH_CHAN] = false,
.param_values[PARAM_THROTTLE_CHAN] = 3,
.param_names[PARAM_THROTTLE_CHAN] = "THROTTLE_CHAN",
.param_needs_write[PARAM_THROTTLE_CHAN] = false,
.param_values[PARAM_YAW_CHAN] = 4,
.param_names[PARAM_YAW_CHAN] = "YAW_CHAN",
.param_needs_write[PARAM_YAW_CHAN] = false,
.param_values[PARAM_OVERRIDE_CHAN] = 5,
.param_names[PARAM_OVERRIDE_CHAN] = "OVERRIDE_CHAN",
.param_needs_write[PARAM_OVERRIDE_CHAN] = false,
.param_values[PARAM_SERVO1_MIN] = 1000.0f,
.param_names[PARAM_SERVO1_MIN] = "SERVO1_MIN",
.param_needs_write[PARAM_SERVO1_MIN] = false,
.param_values[PARAM_SERVO1_MAX] = 2000.0f,
.param_names[PARAM_SERVO1_MAX] = "SERVO1_MAX",
.param_needs_write[PARAM_SERVO1_MAX] = false,
.param_values[PARAM_SERVO1_TRIM] = 1500.0f,
.param_names[PARAM_SERVO1_TRIM] = "SERVO1_TRIM",
.param_needs_write[PARAM_SERVO1_TRIM] = false,
.param_values[PARAM_SERVO2_MIN] = 1000.0f,
.param_names[PARAM_SERVO2_MIN] = "SERVO2_MIN",
.param_needs_write[PARAM_SERVO2_MIN] = false,
.param_values[PARAM_SERVO2_MAX] = 2000.0f,
.param_names[PARAM_SERVO2_MAX] = "SERVO2_MAX",
.param_needs_write[PARAM_SERVO2_MAX] = false,
.param_values[PARAM_SERVO2_TRIM] = 1500.0f,
.param_names[PARAM_SERVO2_TRIM] = "SERVO2_TRIM",
.param_needs_write[PARAM_SERVO2_TRIM] = false,
.param_values[PARAM_SERVO3_MIN] = 1000.0f,
.param_names[PARAM_SERVO3_MIN] = "SERVO3_MIN",
.param_needs_write[PARAM_SERVO3_MIN] = false,
.param_values[PARAM_SERVO3_MAX] = 2000.0f,
.param_names[PARAM_SERVO3_MAX] = "SERVO3_MAX",
.param_needs_write[PARAM_SERVO3_MAX] = false,
.param_values[PARAM_SERVO3_TRIM] = 1500.0f,
.param_names[PARAM_SERVO3_TRIM] = "SERVO3_TRIM",
.param_needs_write[PARAM_SERVO3_TRIM] = false,
.param_values[PARAM_SERVO4_MIN] = 1000.0f,
.param_names[PARAM_SERVO4_MIN] = "SERVO4_MIN",
.param_needs_write[PARAM_SERVO4_MIN] = false,
.param_values[PARAM_SERVO4_MAX] = 2000.0f,
.param_names[PARAM_SERVO4_MAX] = "SERVO4_MAX",
.param_needs_write[PARAM_SERVO4_MAX] = false,
.param_values[PARAM_SERVO4_TRIM] = 1500.0f,
.param_names[PARAM_SERVO4_TRIM] = "SERVO4_TRIM",
.param_needs_write[PARAM_SERVO4_TRIM] = false,
.param_values[PARAM_SERVO_SCALE] = 20.0f,
.param_names[PARAM_SERVO_SCALE] = "SERVO_SCALE",
.param_needs_write[PARAM_SERVO_SCALE] = false
}
};
struct global_data_parameter_storage_t *global_data_parameter_storage = &global_data_parameter_storage_d;
apps/uORB/parameter_storage.h
-152
View File
@@ -1,152 +0,0 @@
/* Structure for storage of parameters */
#ifndef GLOBAL_DATA_PARAMETER_STORAGE_T_H_ //adjust this line!
#define GLOBAL_DATA_PARAMETER_STORAGE_T_H_ //adjust this line!
#define PX4_MSG_PARAM_VALUE_FIELD_PARAM_ID_LEN 16
#define MAX_PARAM_NAME_LEN 16
#include <stdbool.h>
#include <stdint.h>
enum MODE {
TAKEOFF = 1,
CRUISE,
LOITER,
LAND
};
enum PARAM {
PARAM_SYSTEM_ID = 0, ///< System ID used for communication
PARAM_COMP_ID, ///< Component ID
PARAM_FLIGHT_ENV, ///< Flight environment, indoor or outdoor
PARAM_BATTERYVOLTAGE_CONVERSION, ///< Conversion factor from adc measurement to millivolts. if not set the sensor app will use the default value for the ardrone board
PARAM_PID_YAWPOS_P,
PARAM_PID_YAWPOS_I,
PARAM_PID_YAWPOS_D,
PARAM_PID_YAWPOS_AWU,
PARAM_PID_YAWPOS_LIM,
PARAM_PID_YAWSPEED_P,
PARAM_PID_YAWSPEED_I,
PARAM_PID_YAWSPEED_D,
PARAM_PID_YAWSPEED_AWU,
PARAM_PID_YAWSPEED_LIM,
PARAM_PID_ATT_P,
PARAM_PID_ATT_I,
PARAM_PID_ATT_D,
PARAM_PID_ATT_AWU,
PARAM_PID_ATT_LIM,
PARAM_PID_POS_P,
PARAM_PID_POS_I,
PARAM_PID_POS_D,
PARAM_PID_POS_AWU,
PARAM_PID_POS_LIM,
PARAM_PID_POS_Z_P,
PARAM_PID_POS_Z_I,
PARAM_PID_POS_Z_D,
PARAM_PID_POS_Z_AWU,
PARAM_PID_POS_Z_LIM,
PARAM_AIRSPEED,
PARAM_WPLON,
PARAM_WPLAT,
PARAM_WPALT,
PARAM_FLIGHTMODE,
PARAM_SENSOR_GYRO_XOFFSET,
PARAM_SENSOR_GYRO_YOFFSET,
PARAM_SENSOR_GYRO_ZOFFSET,
PARAM_SENSOR_MAG_XOFFSET,
PARAM_SENSOR_MAG_YOFFSET,
PARAM_SENSOR_MAG_ZOFFSET,
PARAM_ATT_XOFFSET,
PARAM_ATT_YOFFSET,
PARAM_RC1_MIN,
PARAM_RC1_MAX,
PARAM_RC1_TRIM,
PARAM_RC1_REV,
PARAM_RC2_MIN,
PARAM_RC2_MAX,
PARAM_RC2_TRIM,
PARAM_RC2_REV,
PARAM_RC3_MIN,
PARAM_RC3_MAX,
PARAM_RC3_TRIM,
PARAM_RC3_REV,
PARAM_RC4_MIN,
PARAM_RC4_MAX,
PARAM_RC4_TRIM,
PARAM_RC4_REV,
PARAM_RC5_MIN,
PARAM_RC5_MAX,
PARAM_RC5_TRIM,
PARAM_RC5_REV,
PARAM_RC6_MIN,
PARAM_RC6_MAX,
PARAM_RC6_TRIM,
PARAM_RC6_REV,
PARAM_RC7_MIN,
PARAM_RC7_MAX,
PARAM_RC7_TRIM,
PARAM_RC7_REV,
PARAM_RC8_MIN,
PARAM_RC8_MAX,
PARAM_RC8_TRIM,
PARAM_RC8_REV,
PARAM_THROTTLE_CHAN,
PARAM_ROLL_CHAN,
PARAM_PITCH_CHAN,
PARAM_YAW_CHAN,
PARAM_OVERRIDE_CHAN,
PARAM_SERVO1_MIN,
PARAM_SERVO1_MAX,
PARAM_SERVO1_TRIM,
PARAM_SERVO2_MIN,
PARAM_SERVO2_MAX,
PARAM_SERVO2_TRIM,
PARAM_SERVO3_MIN,
PARAM_SERVO3_MAX,
PARAM_SERVO3_TRIM,
PARAM_SERVO4_MIN,
PARAM_SERVO4_MAX,
PARAM_SERVO4_TRIM,
PARAM_SERVO_SCALE,
PARAM_MAX_COUNT ///< LEAVE THIS IN PLACE AS LAST ELEMENT!
};
#pragma pack(push, 1)
struct px4_parameter_storage_t {
float param_values[PARAM_MAX_COUNT]; ///< Parameter values
bool param_needs_write[PARAM_MAX_COUNT];
const char *param_names[PARAM_MAX_COUNT]; ///< Parameter names
uint16_t next_param;
uint16_t size;
};
#pragma pack(pop)
#define PX4_FLIGHT_ENVIRONMENT_INDOOR 0
#define PX4_FLIGHT_ENVIRONMENT_OUTDOOR 1
#define PX4_FLIGHT_ENVIRONMENT_TESTING 2 //NO check for position fix in this environment
#pragma pack(push, 1)
struct global_data_parameter_storage_t {
/* use of a counter and timestamp recommended (but not necessary) */
// uint16_t counter; //incremented by the writing thread everytime new data is stored
uint64_t timestamp; //in microseconds since system start, is set whenever the writing thread stores new data
/* Actual data, this is specific to the type of data which is stored in this struct */
//***** Start: Add your variables here *****
/* Parameters (set by a param_set mavlink message */
struct px4_parameter_storage_t pm;
//*****END: Add your variables here *****
};
#pragma pack(pop)
__attribute__ ((visibility ("default"))) extern struct global_data_parameter_storage_t *global_data_parameter_storage; //adjust this line!
#endif
apps/uORB/topics/parameters.h → apps/uORB/topics/parameter_update.h
+4 -11
View File
@@ -32,19 +32,12 @@
****************************************************************************/
/**
* @file parameters.h
*
* Actuator control topics - mixer inputs.
*
* Values published to these topics are the outputs of the vehicle control
* system, and are expected to be mixed and used to drive the actuators
* (servos, speed controls, etc.) that operate the vehicle.
*
* Each topic can be published by a single controller
* @file parameter_update.h
* Notification about a parameter update.
*/
#ifndef TOPIC_PARAMETERS_H
#define TOPIC_PARAMETERS_H
#ifndef TOPIC_PARAMETER_UPDATE_H
#define TOPIC_PARAMETER_UPDATE_H
#include <stdint.h>
#include "../uORB.h"
apps/uORB/uORB.cpp
+2 -1
View File
@@ -32,7 +32,8 @@
****************************************************************************/
/**
* @file A lightweight object broker.
* @file uORB.cpp
* A lightweight object broker.
*/
#include <nuttx/config.h>
apps/uORB/uORB.h
+2 -3
View File
@@ -35,14 +35,13 @@
#define _UORB_UORB_H
/**
* @file API for the uORB lightweight object broker.
* @file uORB.h
* API for the uORB lightweight object broker.
*/
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
// Hack until parameter storage is cleaned up
#include "parameter_storage.h"
// Hack until everything is using this header
#include <systemlib/visibility.h>