[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[paparazzi-commits] [6006] rename b2_gv/B2_GV to gv/GV
|
From: |
Felix Ruess |
|
Subject: |
[paparazzi-commits] [6006] rename b2_gv/B2_GV to gv/GV |
|
Date: |
Tue, 28 Sep 2010 14:05:10 +0000 |
Revision: 6006
http://svn.sv.gnu.org/viewvc/?view=rev&root=paparazzi&revision=6006
Author: flixr
Date: 2010-09-28 14:05:05 +0000 (Tue, 28 Sep 2010)
Log Message:
-----------
rename b2_gv/B2_GV to gv/GV
Modified Paths:
--------------
paparazzi3/trunk/sw/airborne/booz/booz2_telemetry.h
paparazzi3/trunk/sw/airborne/booz/test/test_vg_adpt.c
paparazzi3/trunk/sw/airborne/booz/test/test_vg_ref.c
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.c
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.h
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.c
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.h
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_adpt.h
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_ref.h
Modified: paparazzi3/trunk/sw/airborne/booz/booz2_telemetry.h
===================================================================
--- paparazzi3/trunk/sw/airborne/booz/booz2_telemetry.h 2010-09-28 14:04:56 UTC
(rev 6005)
+++ paparazzi3/trunk/sw/airborne/booz/booz2_telemetry.h 2010-09-28 14:05:05 UTC
(rev 6006)
@@ -613,9 +613,9 @@
&guidance_v_z_ref, \
&guidance_v_zd_ref, \
&guidance_v_zdd_ref, \
- &b2_gv_adapt_X, \
- &b2_gv_adapt_P, \
- &b2_gv_adapt_Xmeas, \
+ &gv_adapt_X, \
+ &gv_adapt_P, \
+ &gv_adapt_Xmeas, \
&guidance_v_z_sum_err, \
&guidance_v_ff_cmd, \
&guidance_v_fb_cmd, \
Modified: paparazzi3/trunk/sw/airborne/booz/test/test_vg_adpt.c
===================================================================
--- paparazzi3/trunk/sw/airborne/booz/test/test_vg_adpt.c 2010-09-28
14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/booz/test/test_vg_adpt.c 2010-09-28
14:05:05 UTC (rev 6006)
@@ -1,6 +1,6 @@
/*
* $Id$
- *
+ *
* Copyright (C) 2008-2009 Antoine Drouin <address@hidden>
*
* This file is part of paparazzi.
@@ -18,7 +18,7 @@
* You should have received a copy of the GNU General Public License
* along with paparazzi; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Boston, MA 02111-1307, USA.
*/
#define _GNU_SOURCE
@@ -28,7 +28,7 @@
#include "std.h"
#include "booz_geometry_mixed.h"
#define GUIDANCE_V_C
-#include "guidance_v_adpt.h"
+#include "guidance/guidance_v_adpt.h"
@@ -63,8 +63,8 @@
double ffP[NB_STEP];
static void float_filter_init(void) {
- ffX[0] = B2_GV_ADAPT_X0_F;
- ffP[0] = B2_GV_ADAPT_P0_F;
+ ffX[0] = GV_ADAPT_X0_F;
+ ffP[0] = GV_ADAPT_P0_F;
}
static void float_filter_run( int i) {
@@ -73,10 +73,10 @@
ffX[i] = ffX[prev];
ffP[i] = ffP[prev];
if (delta_t[prev] == 0) return;
- ffP[i] = ffP[i] + B2_GV_ADAPT_SYS_NOISE_F;
+ ffP[i] = ffP[i] + GV_ADAPT_SYS_NOISE_F;
ffm[i] = (9.81 - (double)est_zdd[i]/(double)(1<<10)) / (double)delta_t[prev];
double residual = ffm[i] - ffX[i];
- double E = ffP[i] + B2_GV_ADAPT_MEAS_NOISE_F;
+ double E = ffP[i] + GV_ADAPT_MEAS_NOISE_F;
double K = ffP[i] / E;
ffP[i] = ffP[i] - K * ffP[i];
ffX[i] = ffX[i] + K * residual;
@@ -88,19 +88,19 @@
fp = fopen(filename, "r");
if (fp == NULL)
return -1;
-
+
char * line = NULL;
size_t len = 0;
size_t read;
n_dat = 0;
while ((read = getline(&line, &len, fp)) != -1 && n_dat< NB_STEP) {
- if (sscanf(line, "%lf %*d BOOZ2_VERT_LOOP %d %d %d %d %d %d %d %d %d %d %d
%d %d %d",
- &time[n_dat],
- &z_sp[n_dat], &zd_sp[n_dat],
- &est_z[n_dat], &est_zd[n_dat], &est_zdd[n_dat],
- &ref_z[n_dat], &ref_zd[n_dat], &ref_zdd[n_dat],
- &adp_inv_m[n_dat], &adp_cov[n_dat], &sum_err[n_dat],
- &ff_cmd[n_dat], &fb_cmd[n_dat], &delta_t[n_dat]) == 15) n_dat++;
+ if (sscanf(line, "%lf %*d BOOZ2_VERT_LOOP %d %d %d %d %d %d %d %d %d %d %d
%d %d %d",
+ &time[n_dat],
+ &z_sp[n_dat], &zd_sp[n_dat],
+ &est_z[n_dat], &est_zd[n_dat], &est_zdd[n_dat],
+ &ref_z[n_dat], &ref_zd[n_dat], &ref_zdd[n_dat],
+ &adp_inv_m[n_dat], &adp_cov[n_dat], &sum_err[n_dat],
+ &ff_cmd[n_dat], &fb_cmd[n_dat], &delta_t[n_dat]) == 15) n_dat++;
}
if (line)
free(line);
@@ -128,16 +128,16 @@
printf("%f %d %d %d %f %f %f %d %d\n", time[i], est_zdd[i], delta_t[i],
ref_zdd[i], ffX[i], ffP[i], ffm[i], ifX[i], ifP[i]);
i++;
}
-
+
}
#define FF_CMD_FRAC 18
void test_command(int i) {
- const int32_t inv_m_i = b2_gv_adapt_X>>(B2_GV_ADAPT_X_FRAC - FF_CMD_FRAC);
+ const int32_t inv_m_i = gv_adapt_X>>(GV_ADAPT_X_FRAC - FF_CMD_FRAC);
int32_t cmd_i = (BOOZ_INT_OF_FLOAT(9.81, FF_CMD_FRAC) -
(ref_zdd[i]<<(FF_CMD_FRAC - IACCEL_RES))) / inv_m_i;
- double inv_m_f = (double)BOOZ_FLOAT_OF_INT(b2_gv_adapt_X,
B2_GV_ADAPT_X_FRAC);
+ double inv_m_f = (double)BOOZ_FLOAT_OF_INT(gv_adapt_X, GV_ADAPT_X_FRAC);
double cmd_f = (9.81 - (double)BOOZ_FLOAT_OF_INT(ref_zdd[i], IACCEL_RES)) /
inv_m_f;
int32_t cmd_i_fixed;
@@ -149,26 +149,26 @@
else
cmd_i_fixed = (BOOZ_INT_OF_FLOAT(9.81, FF_CMD_FRAC) -
(ref_zdd[i]<<(FF_CMD_FRAC - IACCEL_RES)) - (inv_m_i>>1) ) / inv_m_i;
- printf("%d %f %d\n",cmd_i, cmd_f, cmd_i_fixed);
+ printf("%d %f %d\n",cmd_i, cmd_f, cmd_i_fixed);
}
int main(int argc, char** argv) {
// gen_data();
read_data("09_02_15__20_45_58.data");
printf("read %d\n", n_dat);
- b2_gv_adapt_init();
+ gv_adapt_init();
float_filter_init();
int i = 0;
while (i<n_dat) {
Bound(delta_t[i], 1, 200);
- b2_gv_adapt_run(est_zdd[i], delta_t[i]);
- ifX[i] = b2_gv_adapt_X;
- ifP[i] = b2_gv_adapt_P;
+ gv_adapt_run(est_zdd[i], delta_t[i]);
+ ifX[i] = gv_adapt_X;
+ ifP[i] = gv_adapt_P;
float_filter_run(i);
// test_command(i);
i++;
}
-
+
dump_res();
return 0;
Modified: paparazzi3/trunk/sw/airborne/booz/test/test_vg_ref.c
===================================================================
--- paparazzi3/trunk/sw/airborne/booz/test/test_vg_ref.c 2010-09-28
14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/booz/test/test_vg_ref.c 2010-09-28
14:05:05 UTC (rev 6006)
@@ -1,6 +1,6 @@
/*
* $Id$
- *
+ *
* Copyright (C) 2008-2009 Antoine Drouin <address@hidden>
*
* This file is part of paparazzi.
@@ -18,17 +18,17 @@
* You should have received a copy of the GNU General Public License
* along with paparazzi; see the file COPYING. If not, write to
* the Free Software Foundation, 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include "booz_geometry_mixed.h"
#define GUIDANCE_V_C
-#include "guidance_v_ref.h"
+#include "guidance/guidance_v_ref.h"
#define NB_STEP 10000
-#define DT (1./B2_GV_FREQ)
+#define DT (1./GV_FREQ)
double z_sp, zd_sp, z_ref, zd_ref, zdd_ref;
@@ -42,17 +42,17 @@
z_ref += (zd_ref * DT);
zd_ref += (zdd_ref * DT);
- zdd_ref = -2.*B2_GV_ZETA*B2_GV_OMEGA*zd_ref - B2_GV_OMEGA*B2_GV_OMEGA*(z_ref
- z_sp);
+ zdd_ref = -2.*GV_ZETA*GV_OMEGA*zd_ref - GV_OMEGA*GV_OMEGA*(z_ref - z_sp);
- Bound(zdd_ref, B2_GV_MIN_ZDD_F, B2_GV_MAX_ZDD_F);
+ Bound(zdd_ref, GV_MIN_ZDD_F, GV_MAX_ZDD_F);
- if (zd_ref <= B2_GV_MIN_ZD_F) {
- zd_ref = B2_GV_MIN_ZD_F;
+ if (zd_ref <= GV_MIN_ZD_F) {
+ zd_ref = GV_MIN_ZD_F;
if (zdd_ref < 0)
zdd_ref = 0;
}
- else if (zd_ref >= B2_GV_MAX_ZD_F) {
- zd_ref = B2_GV_MAX_ZD_F;
+ else if (zd_ref >= GV_MAX_ZD_F) {
+ zd_ref = GV_MAX_ZD_F;
if (zdd_ref > 0)
zdd_ref = 0;
}
@@ -60,20 +60,20 @@
}
void update_ref_from_zd(void) {
-
+
z_ref += (zd_ref * DT);
zd_ref += (zdd_ref * DT);
- zdd_ref = -1/B2_GV_REF_THAU_F*(zd_ref - zd_sp);
+ zdd_ref = -1/GV_REF_THAU_F*(zd_ref - zd_sp);
- Bound(zdd_ref, B2_GV_MIN_ZDD_F, B2_GV_MAX_ZDD_F);
+ Bound(zdd_ref, GV_MIN_ZDD_F, GV_MAX_ZDD_F);
- if (zd_ref <= B2_GV_MIN_ZD_F) {
- zd_ref = B2_GV_MIN_ZD_F;
+ if (zd_ref <= GV_MIN_ZD_F) {
+ zd_ref = GV_MIN_ZD_F;
if (zdd_ref < 0)
zdd_ref = 0;
}
- else if (zd_ref >= B2_GV_MAX_ZD_F) {
- zd_ref = B2_GV_MAX_ZD_F;
+ else if (zd_ref >= GV_MAX_ZD_F) {
+ zd_ref = GV_MAX_ZD_F;
if (zdd_ref > 0)
zdd_ref = 0;
}
@@ -81,13 +81,13 @@
}
void print_ref(int i) {
- double i2f_z = BOOZ_FLOAT_OF_INT( b2_gv_z_ref, B2_GV_Z_REF_FRAC);
- double i2f_zd = BOOZ_FLOAT_OF_INT( b2_gv_zd_ref, B2_GV_ZD_REF_FRAC);
- double i2f_zdd = BOOZ_FLOAT_OF_INT( b2_gv_zdd_ref, B2_GV_ZDD_REF_FRAC);
- printf("%f %f %f %f %f %f %f %f %f\n",
- (double)i*DT, z_sp, zd_sp,
- z_ref, zd_ref, zdd_ref,
- i2f_z, i2f_zd, i2f_zdd );
+ double i2f_z = BOOZ_FLOAT_OF_INT( gv_z_ref, GV_Z_REF_FRAC);
+ double i2f_zd = BOOZ_FLOAT_OF_INT( gv_zd_ref, GV_ZD_REF_FRAC);
+ double i2f_zdd = BOOZ_FLOAT_OF_INT( gv_zdd_ref, GV_ZDD_REF_FRAC);
+ printf("%f %f %f %f %f %f %f %f %f\n",
+ (double)i*DT, z_sp, zd_sp,
+ z_ref, zd_ref, zdd_ref,
+ i2f_z, i2f_zd, i2f_zdd );
}
int32_t get_sp (int i) {
@@ -98,13 +98,13 @@
int main(int argc, char** argv) {
- b2_gv_set_ref(0, 0, 0);
+ gv_set_ref(0, 0, 0);
set_ref(0., 0., 0.);
int i = 0;
while (i<NB_STEP) {
int32_t sp_i = get_sp(i);
- // b2_gv_update_ref_from_z_sp(sp_i);
- b2_gv_update_ref_from_zd_sp(sp_i);
+ // gv_update_ref_from_z_sp(sp_i);
+ gv_update_ref_from_zd_sp(sp_i);
// z_sp = BOOZ_FLOAT_OF_INT(sp_i, IPOS_FRAC);
// update_ref_from_z();
zd_sp = BOOZ_FLOAT_OF_INT(sp_i, ISPEED_RES);
@@ -113,8 +113,6 @@
i++;
}
-
+
return 0;
}
-
-
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.c
===================================================================
--- paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.c
2010-09-28 14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.c
2010-09-28 14:05:05 UTC (rev 6006)
@@ -23,7 +23,7 @@
#define GUIDANCE_H_C
//#define GUIDANCE_H_USE_REF
-#include "guidance_h.h"
+#include "guidance/guidance_h.h"
#include "ahrs.h"
#include "booz_stabilization.h"
@@ -70,7 +70,7 @@
static inline void guidance_h_hover_enter(void);
static inline void guidance_h_nav_enter(void);
-#define Booz2GuidanceHSetRef(_pos, _speed, _accel) { \
+#define GuidanceHSetRef(_pos, _speed, _accel) { \
b2_gh_set_ref(_pos, _speed, _accel); \
VECT2_COPY(guidance_h_pos_ref, _pos); \
VECT2_COPY(guidance_h_speed_ref, _speed); \
@@ -385,7 +385,7 @@
INT_VECT2_ZERO(zero);
VECT2_COPY(pos, ins_ltp_pos);
VECT2_COPY(speed, ins_ltp_speed);
- Booz2GuidanceHSetRef(pos, speed, zero);
+ GuidanceHSetRef(pos, speed, zero);
struct Int32Eulers tmp_sp;
BOOZ_STABILIZATION_ATTITUDE_RESET_PSI_REF( tmp_sp );
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.h
===================================================================
--- paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.h
2010-09-28 14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_h.h
2010-09-28 14:05:05 UTC (rev 6006)
@@ -27,7 +27,7 @@
#include "math/pprz_algebra_int.h"
-#include "guidance_h_ref.h"
+#include "guidance/guidance_h_ref.h"
#define GUIDANCE_H_MODE_KILL 0
#define GUIDANCE_H_MODE_RATE 1
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.c
===================================================================
--- paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.c
2010-09-28 14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.c
2010-09-28 14:05:05 UTC (rev 6006)
@@ -23,7 +23,7 @@
#define GUIDANCE_V_C
#define GUIDANCE_V_USE_REF
-#include "guidance_v.h"
+#include "guidance/guidance_v.h"
#include "booz_radio_control.h"
@@ -74,8 +74,8 @@
int32_t guidance_v_z_sum_err;
-#define Booz2GuidanceVSetRef(_pos, _speed, _accel) { \
- b2_gv_set_ref(_pos, _speed, _accel); \
+#define GuidanceVSetRef(_pos, _speed, _accel) { \
+ gv_set_ref(_pos, _speed, _accel); \
guidance_v_z_ref = _pos; \
guidance_v_zd_ref = _speed; \
guidance_v_zdd_ref = _accel; \
@@ -95,7 +95,7 @@
guidance_v_z_sum_err = 0;
- b2_gv_adapt_init();
+ gv_adapt_init();
}
@@ -126,7 +126,7 @@
case GUIDANCE_V_MODE_HOVER:
case GUIDANCE_V_MODE_NAV:
guidance_v_z_sum_err = 0;
- Booz2GuidanceVSetRef(ins_ltp_pos.z, ins_ltp_speed.z, 0);
+ GuidanceVSetRef(ins_ltp_pos.z, ins_ltp_speed.z, 0);
break;
default:
break;
@@ -139,7 +139,7 @@
void guidance_v_notify_in_flight( bool_t in_flight) {
if (in_flight)
- b2_gv_adapt_init();
+ gv_adapt_init();
}
@@ -150,7 +150,7 @@
if (in_flight) {
// we should use something after the supervision!!! fuck!!!
int32_t cmd_hack = Chop(booz_stabilization_cmd[COMMAND_THRUST], 1, 200);
- b2_gv_adapt_run(ins_ltp_accel.z, cmd_hack);
+ gv_adapt_run(ins_ltp_accel.z, cmd_hack);
}
else {
// reset vertical filter until takeoff
@@ -161,13 +161,13 @@
case GUIDANCE_V_MODE_RC_DIRECT:
guidance_v_z_sp = ins_ltp_pos.z; // not sure why we do that
- Booz2GuidanceVSetRef(ins_ltp_pos.z, 0, 0); // or that - mode enter should
take care of it ?
+ GuidanceVSetRef(ins_ltp_pos.z, 0, 0); // or that - mode enter should take
care of it ?
booz_stabilization_cmd[COMMAND_THRUST] = guidance_v_rc_delta_t;
break;
case GUIDANCE_V_MODE_RC_CLIMB:
guidance_v_zd_sp = guidance_v_rc_zd_sp;
- b2_gv_update_ref_from_zd_sp(guidance_v_zd_sp);
+ gv_update_ref_from_zd_sp(guidance_v_zd_sp);
run_hover_loop(in_flight);
booz_stabilization_cmd[COMMAND_THRUST] = guidance_v_delta_t;
break;
@@ -177,7 +177,7 @@
if (fms.enabled && fms.input.v_mode == GUIDANCE_V_MODE_CLIMB)
guidance_v_zd_sp = fms.input.v_sp.climb;
#endif
- b2_gv_update_ref_from_zd_sp(guidance_v_zd_sp);
+ gv_update_ref_from_zd_sp(guidance_v_zd_sp);
run_hover_loop(in_flight);
// saturate max authority with RC stick
booz_stabilization_cmd[COMMAND_THRUST] = Min( guidance_v_rc_delta_t,
guidance_v_delta_t);
@@ -188,7 +188,7 @@
if (fms.enabled && fms.input.v_mode == GUIDANCE_V_MODE_HOVER)
guidance_v_z_sp = fms.input.v_sp.height;
#endif
- b2_gv_update_ref_from_z_sp(guidance_v_z_sp);
+ gv_update_ref_from_z_sp(guidance_v_z_sp);
run_hover_loop(in_flight);
// saturate max authority with RC stick
booz_stabilization_cmd[COMMAND_THRUST] = Min( guidance_v_rc_delta_t,
guidance_v_delta_t);
@@ -198,12 +198,12 @@
{
if (vertical_mode == VERTICAL_MODE_ALT) {
guidance_v_z_sp = -nav_flight_altitude;
- b2_gv_update_ref_from_z_sp(guidance_v_z_sp);
+ gv_update_ref_from_z_sp(guidance_v_z_sp);
run_hover_loop(in_flight);
}
else if (vertical_mode == VERTICAL_MODE_CLIMB) {
guidance_v_zd_sp = -nav_climb;
- b2_gv_update_ref_from_zd_sp(guidance_v_zd_sp);
+ gv_update_ref_from_zd_sp(guidance_v_zd_sp);
nav_flight_altitude = -guidance_v_z_sp;
run_hover_loop(in_flight);
}
@@ -231,10 +231,10 @@
static inline void run_hover_loop(bool_t in_flight) {
/* convert our reference to generic representation */
- int64_t tmp = b2_gv_z_ref>>(B2_GV_Z_REF_FRAC - INT32_POS_FRAC);
+ int64_t tmp = gv_z_ref>>(GV_Z_REF_FRAC - INT32_POS_FRAC);
guidance_v_z_ref = (int32_t)tmp;
- guidance_v_zd_ref = b2_gv_zd_ref<<(INT32_SPEED_FRAC - B2_GV_ZD_REF_FRAC);
- guidance_v_zdd_ref = b2_gv_zdd_ref<<(INT32_ACCEL_FRAC - B2_GV_ZDD_REF_FRAC);
+ guidance_v_zd_ref = gv_zd_ref<<(INT32_SPEED_FRAC - GV_ZD_REF_FRAC);
+ guidance_v_zdd_ref = gv_zdd_ref<<(INT32_ACCEL_FRAC - GV_ZDD_REF_FRAC);
/* compute the error to our reference */
int32_t err_z = ins_ltp_pos.z - guidance_v_z_ref;
Bound(err_z, GUIDANCE_V_MIN_ERR_Z, GUIDANCE_V_MAX_ERR_Z);
@@ -250,9 +250,9 @@
/* our nominal command : (g + zdd)*m */
#ifdef GUIDANCE_V_INV_M
- const int32_t inv_m = BFP_OF_REAL(GUIDANCE_V_INV_M, B2_GV_ADAPT_X_FRAC);
+ const int32_t inv_m = BFP_OF_REAL(GUIDANCE_V_INV_M, GV_ADAPT_X_FRAC);
#else
- const int32_t inv_m = b2_gv_adapt_X>>(B2_GV_ADAPT_X_FRAC - FF_CMD_FRAC);
+ const int32_t inv_m = gv_adapt_X>>(GV_ADAPT_X_FRAC - FF_CMD_FRAC);
#endif
const int32_t g_m_zdd = (int32_t)BFP_OF_REAL(9.81, FF_CMD_FRAC) -
(guidance_v_zdd_ref<<(FF_CMD_FRAC -
INT32_ACCEL_FRAC));
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.h
===================================================================
--- paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.h
2010-09-28 14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v.h
2010-09-28 14:05:05 UTC (rev 6006)
@@ -26,8 +26,8 @@
#include "std.h"
-#include "guidance_v_ref.h"
-#include "guidance_v_adpt.h"
+#include "guidance/guidance_v_ref.h"
+#include "guidance/guidance_v_adpt.h"
#define GUIDANCE_V_MODE_KILL 0
#define GUIDANCE_V_MODE_RC_DIRECT 1
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_adpt.h
===================================================================
---
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_adpt.h
2010-09-28 14:04:56 UTC (rev 6005)
+++
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_adpt.h
2010-09-28 14:05:05 UTC (rev 6006)
@@ -30,9 +30,9 @@
#ifndef GUIDANCE_V_ADPT
#define GUIDANCE_V_ADPT
-extern int32_t b2_gv_adapt_X;
-extern int32_t b2_gv_adapt_P;
-extern int32_t b2_gv_adapt_Xmeas;
+extern int32_t gv_adapt_X;
+extern int32_t gv_adapt_P;
+extern int32_t gv_adapt_Xmeas;
#ifdef GUIDANCE_V_C
@@ -40,52 +40,52 @@
/* Our State
Q13.18
*/
-int32_t b2_gv_adapt_X;
-#define B2_GV_ADAPT_X_FRAC 18
+int32_t gv_adapt_X;
+#define GV_ADAPT_X_FRAC 18
/* Our covariance
Q13.18
*/
-int32_t b2_gv_adapt_P;
-#define B2_GV_ADAPT_P_FRAC 18
+int32_t gv_adapt_P;
+#define GV_ADAPT_P_FRAC 18
/* Our measurement */
-int32_t b2_gv_adapt_Xmeas;
+int32_t gv_adapt_Xmeas;
/* Initial State and Covariance */
-#define B2_GV_ADAPT_X0_F 0.15
-#define B2_GV_ADAPT_X0 BFP_OF_REAL(B2_GV_ADAPT_X0_F, B2_GV_ADAPT_X_FRAC)
-#define B2_GV_ADAPT_P0_F 0.5
-#define B2_GV_ADAPT_P0 BFP_OF_REAL(B2_GV_ADAPT_P0_F, B2_GV_ADAPT_P_FRAC)
+#define GV_ADAPT_X0_F 0.15
+#define GV_ADAPT_X0 BFP_OF_REAL(GV_ADAPT_X0_F, GV_ADAPT_X_FRAC)
+#define GV_ADAPT_P0_F 0.5
+#define GV_ADAPT_P0 BFP_OF_REAL(GV_ADAPT_P0_F, GV_ADAPT_P_FRAC)
/* System and Measuremement noises */
-#define B2_GV_ADAPT_SYS_NOISE_F 0.00005
-#define B2_GV_ADAPT_SYS_NOISE BFP_OF_REAL(B2_GV_ADAPT_SYS_NOISE_F,
B2_GV_ADAPT_P_FRAC)
+#define GV_ADAPT_SYS_NOISE_F 0.00005
+#define GV_ADAPT_SYS_NOISE BFP_OF_REAL(GV_ADAPT_SYS_NOISE_F, GV_ADAPT_P_FRAC)
#ifndef USE_ADAPT_HOVER
-#define B2_GV_ADAPT_MEAS_NOISE_F 2.0
-#define B2_GV_ADAPT_MEAS_NOISE BFP_OF_REAL(B2_GV_ADAPT_MEAS_NOISE_F,
B2_GV_ADAPT_P_FRAC)
+#define GV_ADAPT_MEAS_NOISE_F 2.0
+#define GV_ADAPT_MEAS_NOISE BFP_OF_REAL(GV_ADAPT_MEAS_NOISE_F, GV_ADAPT_P_FRAC)
#else /* USE_ADAPT_HOVER */
-#define B2_GV_ADAPT_MEAS_NOISE_HOVER_F 10.0
-#define B2_GV_ADAPT_MEAS_NOISE_HOVER
BFP_OF_REAL(B2_GV_ADAPT_MEAS_NOISE_HOVER_F, B2_GV_ADAPT_P_FRAC)
-#define B2_GV_ADAPT_MEAS_NOISE_F 50.0
-#define B2_GV_ADAPT_MEAS_NOISE BFP_OF_REAL(B2_GV_ADAPT_MEAS_NOISE_F,
B2_GV_ADAPT_P_FRAC)
+#define GV_ADAPT_MEAS_NOISE_HOVER_F 10.0
+#define GV_ADAPT_MEAS_NOISE_HOVER BFP_OF_REAL(GV_ADAPT_MEAS_NOISE_HOVER_F,
GV_ADAPT_P_FRAC)
+#define GV_ADAPT_MEAS_NOISE_F 50.0
+#define GV_ADAPT_MEAS_NOISE BFP_OF_REAL(GV_ADAPT_MEAS_NOISE_F, GV_ADAPT_P_FRAC)
-#define B2_GV_ADAPT_MAX_ACCEL ACCEL_BFP_OF_REAL(4.0)
-#define B2_GV_ADAPT_HOVER_ACCEL ACCEL_BFP_OF_REAL(1.0)
-#define B2_GV_ADAPT_MAX_CMD 180
-#define B2_GV_ADAPT_MIN_CMD 20
-#define B2_GV_ADAPT_HOVER_MAX_CMD 120
-#define B2_GV_ADAPT_HOVER_MIN_CMD 60
+#define GV_ADAPT_MAX_ACCEL ACCEL_BFP_OF_REAL(4.0)
+#define GV_ADAPT_HOVER_ACCEL ACCEL_BFP_OF_REAL(1.0)
+#define GV_ADAPT_MAX_CMD 180
+#define GV_ADAPT_MIN_CMD 20
+#define GV_ADAPT_HOVER_MAX_CMD 120
+#define GV_ADAPT_HOVER_MIN_CMD 60
#endif
-static inline void b2_gv_adapt_init(void) {
- b2_gv_adapt_X = B2_GV_ADAPT_X0;
- b2_gv_adapt_P = B2_GV_ADAPT_P0;
+static inline void gv_adapt_init(void) {
+ gv_adapt_X = GV_ADAPT_X0;
+ gv_adapt_P = GV_ADAPT_P0;
}
/*
@@ -93,52 +93,52 @@
thrust_applied : controller input [2-200]
*/
#define K_FRAC 12
-static inline void b2_gv_adapt_run(int32_t zdd_meas, int32_t thrust_applied) {
+static inline void gv_adapt_run(int32_t zdd_meas, int32_t thrust_applied) {
/* Do you really think we want to divide by zero ? */
if (thrust_applied == 0) return;
/* We don't propagate state, it's constant ! */
/* We propagate our covariance */
- b2_gv_adapt_P = b2_gv_adapt_P + B2_GV_ADAPT_SYS_NOISE;
+ gv_adapt_P = gv_adapt_P + GV_ADAPT_SYS_NOISE;
/* Compute our measurement. If zdd_meas is in the range +/-5g, meas is less
than 24 bits */
- const int32_t g_m_zdd = ((int32_t)BFP_OF_REAL(9.81, INT32_ACCEL_FRAC) -
zdd_meas)<<(B2_GV_ADAPT_X_FRAC - INT32_ACCEL_FRAC);
+ const int32_t g_m_zdd = ((int32_t)BFP_OF_REAL(9.81, INT32_ACCEL_FRAC) -
zdd_meas)<<(GV_ADAPT_X_FRAC - INT32_ACCEL_FRAC);
#ifdef USE_ADAPT_HOVER
/* Update only if accel and commands are in a valid range */
- if (thrust_applied < B2_GV_ADAPT_MIN_CMD || thrust_applied >
B2_GV_ADAPT_MAX_CMD
- || zdd_meas < -B2_GV_ADAPT_MAX_ACCEL || zdd_meas > B2_GV_ADAPT_MAX_ACCEL)
+ if (thrust_applied < GV_ADAPT_MIN_CMD || thrust_applied > GV_ADAPT_MAX_CMD
+ || zdd_meas < -GV_ADAPT_MAX_ACCEL || zdd_meas > GV_ADAPT_MAX_ACCEL)
return;
#endif
if ( g_m_zdd > 0)
- b2_gv_adapt_Xmeas = (g_m_zdd + (thrust_applied>>1)) / thrust_applied;
+ gv_adapt_Xmeas = (g_m_zdd + (thrust_applied>>1)) / thrust_applied;
else
- b2_gv_adapt_Xmeas = (g_m_zdd - (thrust_applied>>1)) / thrust_applied;
+ gv_adapt_Xmeas = (g_m_zdd - (thrust_applied>>1)) / thrust_applied;
/* Compute a residual */
- int32_t residual = b2_gv_adapt_Xmeas - b2_gv_adapt_X;
+ int32_t residual = gv_adapt_Xmeas - gv_adapt_X;
/* Covariance Error */
int32_t E = 0;
#ifdef USE_ADAPT_HOVER
- if ((thrust_applied > B2_GV_ADAPT_HOVER_MIN_CMD && thrust_applied <
B2_GV_ADAPT_HOVER_MAX_CMD) ||
- (zdd_meas > -B2_GV_ADAPT_HOVER_ACCEL && zdd_meas <
B2_GV_ADAPT_HOVER_ACCEL))
- E = b2_gv_adapt_P + B2_GV_ADAPT_MEAS_NOISE_HOVER;
+ if ((thrust_applied > GV_ADAPT_HOVER_MIN_CMD && thrust_applied <
GV_ADAPT_HOVER_MAX_CMD) ||
+ (zdd_meas > -GV_ADAPT_HOVER_ACCEL && zdd_meas < GV_ADAPT_HOVER_ACCEL))
+ E = gv_adapt_P + GV_ADAPT_MEAS_NOISE_HOVER;
else
#endif
- E = b2_gv_adapt_P + B2_GV_ADAPT_MEAS_NOISE;
+ E = gv_adapt_P + GV_ADAPT_MEAS_NOISE;
/* Kalman gain */
- int32_t K = (b2_gv_adapt_P<<K_FRAC) / E;
+ int32_t K = (gv_adapt_P<<K_FRAC) / E;
/* Update Covariance */
- b2_gv_adapt_P = b2_gv_adapt_P - ((K * b2_gv_adapt_P)>>K_FRAC);
+ gv_adapt_P = gv_adapt_P - ((K * gv_adapt_P)>>K_FRAC);
/* Don't let covariance climb over initial value */
- if (b2_gv_adapt_P > B2_GV_ADAPT_P0) b2_gv_adapt_P = B2_GV_ADAPT_P0;
+ if (gv_adapt_P > GV_ADAPT_P0) gv_adapt_P = GV_ADAPT_P0;
/* Update State */
- b2_gv_adapt_X = b2_gv_adapt_X + ((K * residual)>>K_FRAC);
+ gv_adapt_X = gv_adapt_X + ((K * residual)>>K_FRAC);
/* Again don't let it climb over a value that would
give less than zero throttle and don't let it down to zero.
- 30254 = MAX_ACCEL*B2_GV_ADAPT_X_FRAC/MAX_THROTTLE
+ 30254 = MAX_ACCEL*GV_ADAPT_X_FRAC/MAX_THROTTLE
aka
30254 = 3*9.81*2^8/255
2571632 = 9.81*2^18
*/
- Bound(b2_gv_adapt_X, 10000, 2571632);
+ Bound(gv_adapt_X, 10000, 2571632);
}
Modified:
paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_ref.h
===================================================================
--- paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_ref.h
2010-09-28 14:04:56 UTC (rev 6005)
+++ paparazzi3/trunk/sw/airborne/firmwares/rotorcraft/guidance/guidance_v_ref.h
2010-09-28 14:05:05 UTC (rev 6006)
@@ -30,45 +30,45 @@
#include "math/pprz_algebra_int.h"
/* update frequency */
-#define B2_GV_FREQ_FRAC 9
-#define B2_GV_FREQ (1<<B2_GV_FREQ_FRAC)
+#define GV_FREQ_FRAC 9
+#define GV_FREQ (1<<GV_FREQ_FRAC)
/* reference model vaccel in meters/sec2 (output) */
/* Q23.8 : accuracy 0.0039 , range 8388km/s2 */
/* int32_4_8_t */
-extern int32_t b2_gv_zdd_ref;
-#define B2_GV_ZDD_REF_FRAC 8
+extern int32_t gv_zdd_ref;
+#define GV_ZDD_REF_FRAC 8
/* reference model vspeed in meters/sec (output) */
/* Q14.17 : accuracy 0.0000076 , range 16384m/s2 */
-extern int32_t b2_gv_zd_ref;
-#define B2_GV_ZD_REF_FRAC (B2_GV_ZDD_REF_FRAC + B2_GV_FREQ_FRAC)
+extern int32_t gv_zd_ref;
+#define GV_ZD_REF_FRAC (GV_ZDD_REF_FRAC + GV_FREQ_FRAC)
/* reference model altitude in meters (output) */
/* Q37.26 : */
-extern int64_t b2_gv_z_ref;
-#define B2_GV_Z_REF_FRAC (B2_GV_ZD_REF_FRAC + B2_GV_FREQ_FRAC)
+extern int64_t gv_z_ref;
+#define GV_Z_REF_FRAC (GV_ZD_REF_FRAC + GV_FREQ_FRAC)
/* Saturations definition */
#ifndef GUIDANCE_V_REF_MIN_ZDD
#define GUIDANCE_V_REF_MIN_ZDD (-2.0*9.81)
#endif
-#define B2_GV_MIN_ZDD BFP_OF_REAL(GUIDANCE_V_REF_MIN_ZDD, B2_GV_ZDD_REF_FRAC)
+#define GV_MIN_ZDD BFP_OF_REAL(GUIDANCE_V_REF_MIN_ZDD, GV_ZDD_REF_FRAC)
#ifndef GUIDANCE_V_REF_MAX_ZDD
#define GUIDANCE_V_REF_MAX_ZDD ( 0.8*9.81)
#endif
-#define B2_GV_MAX_ZDD BFP_OF_REAL(GUIDANCE_V_REF_MAX_ZDD, B2_GV_ZDD_REF_FRAC)
+#define GV_MAX_ZDD BFP_OF_REAL(GUIDANCE_V_REF_MAX_ZDD, GV_ZDD_REF_FRAC)
#ifndef GUIDANCE_V_REF_MIN_ZD
#define GUIDANCE_V_REF_MIN_ZD (-3.)
#endif
-#define B2_GV_MIN_ZD BFP_OF_REAL(GUIDANCE_V_REF_MIN_ZD , B2_GV_ZD_REF_FRAC)
+#define GV_MIN_ZD BFP_OF_REAL(GUIDANCE_V_REF_MIN_ZD , GV_ZD_REF_FRAC)
#ifndef GUIDANCE_V_REF_MAX_ZD
#define GUIDANCE_V_REF_MAX_ZD ( 3.)
#endif
-#define B2_GV_MAX_ZD BFP_OF_REAL(GUIDANCE_V_REF_MAX_ZD , B2_GV_ZD_REF_FRAC)
+#define GV_MAX_ZD BFP_OF_REAL(GUIDANCE_V_REF_MAX_ZD , GV_ZD_REF_FRAC)
/* second order model natural frequency and damping */
#ifndef GUIDANCE_V_REF_OMEGA
@@ -77,86 +77,86 @@
#ifndef GUIDANCE_V_REF_ZETA
#define GUIDANCE_V_REF_ZETA 0.85
#endif
-#define B2_GV_ZETA_OMEGA_FRAC 10
-#define B2_GV_ZETA_OMEGA
BFP_OF_REAL((GUIDANCE_V_REF_ZETA*GUIDANCE_V_REF_OMEGA), B2_GV_ZETA_OMEGA_FRAC)
-#define B2_GV_OMEGA_2_FRAC 7
-#define B2_GV_OMEGA_2
BFP_OF_REAL((GUIDANCE_V_REF_OMEGA*GUIDANCE_V_REF_OMEGA), B2_GV_OMEGA_2_FRAC)
+#define GV_ZETA_OMEGA_FRAC 10
+#define GV_ZETA_OMEGA BFP_OF_REAL((GUIDANCE_V_REF_ZETA*GUIDANCE_V_REF_OMEGA),
GV_ZETA_OMEGA_FRAC)
+#define GV_OMEGA_2_FRAC 7
+#define GV_OMEGA_2 BFP_OF_REAL((GUIDANCE_V_REF_OMEGA*GUIDANCE_V_REF_OMEGA),
GV_OMEGA_2_FRAC)
/* first order time constant */
-#define B2_GV_REF_THAU_F 0.25
-#define B2_GV_REF_INV_THAU_FRAC 16
-#define B2_GV_REF_INV_THAU BFP_OF_REAL((1./0.25), B2_GV_REF_INV_THAU_FRAC)
+#define GV_REF_THAU_F 0.25
+#define GV_REF_INV_THAU_FRAC 16
+#define GV_REF_INV_THAU BFP_OF_REAL((1./0.25), GV_REF_INV_THAU_FRAC)
#ifdef GUIDANCE_V_C
-static inline void b2_gv_set_ref(int32_t alt, int32_t speed, int32_t accel);
-static inline void b2_gv_update_ref_from_z_sp(int32_t z_sp);
-static inline void b2_gv_update_ref_from_zd_sp(int32_t zd_sp);
+static inline void gv_set_ref(int32_t alt, int32_t speed, int32_t accel);
+static inline void gv_update_ref_from_z_sp(int32_t z_sp);
+static inline void gv_update_ref_from_zd_sp(int32_t zd_sp);
-int64_t b2_gv_z_ref;
-int32_t b2_gv_zd_ref;
-int32_t b2_gv_zdd_ref;
+int64_t gv_z_ref;
+int32_t gv_zd_ref;
+int32_t gv_zdd_ref;
-static inline void b2_gv_set_ref(int32_t alt, int32_t speed, int32_t accel) {
- int64_t new_z = ((int64_t)alt)<<(B2_GV_Z_REF_FRAC - INT32_POS_FRAC);
- b2_gv_z_ref = new_z;
- b2_gv_zd_ref = speed>>(INT32_SPEED_FRAC - B2_GV_ZD_REF_FRAC);
- b2_gv_zdd_ref = accel>>(INT32_ACCEL_FRAC - B2_GV_ZDD_REF_FRAC);
+static inline void gv_set_ref(int32_t alt, int32_t speed, int32_t accel) {
+ int64_t new_z = ((int64_t)alt)<<(GV_Z_REF_FRAC - INT32_POS_FRAC);
+ gv_z_ref = new_z;
+ gv_zd_ref = speed>>(INT32_SPEED_FRAC - GV_ZD_REF_FRAC);
+ gv_zdd_ref = accel>>(INT32_ACCEL_FRAC - GV_ZDD_REF_FRAC);
}
-static inline void b2_gv_update_ref_from_z_sp(int32_t z_sp) {
+static inline void gv_update_ref_from_z_sp(int32_t z_sp) {
- b2_gv_z_ref += b2_gv_zd_ref;
- b2_gv_zd_ref += b2_gv_zdd_ref;
+ gv_z_ref += gv_zd_ref;
+ gv_zd_ref += gv_zdd_ref;
// compute the "speed part" of zdd = -2*zeta*omega*zd -omega^2(z_sp - z)
- int32_t zd_zdd_res = b2_gv_zd_ref>>(B2_GV_ZD_REF_FRAC - B2_GV_ZDD_REF_FRAC);
- int32_t zdd_speed =
((int32_t)(-2*B2_GV_ZETA_OMEGA)*zd_zdd_res)>>(B2_GV_ZETA_OMEGA_FRAC);
+ int32_t zd_zdd_res = gv_zd_ref>>(GV_ZD_REF_FRAC - GV_ZDD_REF_FRAC);
+ int32_t zdd_speed =
((int32_t)(-2*GV_ZETA_OMEGA)*zd_zdd_res)>>(GV_ZETA_OMEGA_FRAC);
// compute z error in z_sp resolution
- int32_t z_err_sp = z_sp -
(int32_t)(b2_gv_z_ref>>(B2_GV_Z_REF_FRAC-INT32_POS_FRAC));
+ int32_t z_err_sp = z_sp -
(int32_t)(gv_z_ref>>(GV_Z_REF_FRAC-INT32_POS_FRAC));
// convert to accel resolution
- int32_t z_err_accel = z_err_sp>>(INT32_POS_FRAC-B2_GV_ZDD_REF_FRAC);
- int32_t zdd_pos = ((int32_t)(B2_GV_OMEGA_2)*z_err_accel)>>B2_GV_OMEGA_2_FRAC;
- b2_gv_zdd_ref = zdd_speed + zdd_pos;
+ int32_t z_err_accel = z_err_sp>>(INT32_POS_FRAC-GV_ZDD_REF_FRAC);
+ int32_t zdd_pos = ((int32_t)(GV_OMEGA_2)*z_err_accel)>>GV_OMEGA_2_FRAC;
+ gv_zdd_ref = zdd_speed + zdd_pos;
/* Saturate accelerations */
- Bound(b2_gv_zdd_ref, B2_GV_MIN_ZDD, B2_GV_MAX_ZDD);
+ Bound(gv_zdd_ref, GV_MIN_ZDD, GV_MAX_ZDD);
/* Saturate speed and adjust acceleration accordingly */
- if (b2_gv_zd_ref <= B2_GV_MIN_ZD) {
- b2_gv_zd_ref = B2_GV_MIN_ZD;
- if (b2_gv_zdd_ref < 0)
- b2_gv_zdd_ref = 0;
+ if (gv_zd_ref <= GV_MIN_ZD) {
+ gv_zd_ref = GV_MIN_ZD;
+ if (gv_zdd_ref < 0)
+ gv_zdd_ref = 0;
}
- else if (b2_gv_zd_ref >= B2_GV_MAX_ZD) {
- b2_gv_zd_ref = B2_GV_MAX_ZD;
- if (b2_gv_zdd_ref > 0)
- b2_gv_zdd_ref = 0;
+ else if (gv_zd_ref >= GV_MAX_ZD) {
+ gv_zd_ref = GV_MAX_ZD;
+ if (gv_zdd_ref > 0)
+ gv_zdd_ref = 0;
}
}
-static inline void b2_gv_update_ref_from_zd_sp(int32_t zd_sp) {
+static inline void gv_update_ref_from_zd_sp(int32_t zd_sp) {
- b2_gv_z_ref += b2_gv_zd_ref;
- b2_gv_zd_ref += b2_gv_zdd_ref;
+ gv_z_ref += gv_zd_ref;
+ gv_zd_ref += gv_zdd_ref;
- int32_t zd_err = b2_gv_zd_ref - (zd_sp>>(INT32_SPEED_FRAC -
B2_GV_ZD_REF_FRAC));
- int32_t zd_err_zdd_res = zd_err>>(B2_GV_ZD_REF_FRAC-B2_GV_ZDD_REF_FRAC);
- b2_gv_zdd_ref = (-(int32_t)B2_GV_REF_INV_THAU *
zd_err_zdd_res)>>B2_GV_REF_INV_THAU_FRAC;
+ int32_t zd_err = gv_zd_ref - (zd_sp>>(INT32_SPEED_FRAC - GV_ZD_REF_FRAC));
+ int32_t zd_err_zdd_res = zd_err>>(GV_ZD_REF_FRAC-GV_ZDD_REF_FRAC);
+ gv_zdd_ref = (-(int32_t)GV_REF_INV_THAU *
zd_err_zdd_res)>>GV_REF_INV_THAU_FRAC;
/* Saturate accelerations */
- Bound(b2_gv_zdd_ref, B2_GV_MIN_ZDD, B2_GV_MAX_ZDD);
+ Bound(gv_zdd_ref, GV_MIN_ZDD, GV_MAX_ZDD);
/* Saturate speed and adjust acceleration accordingly */
- if (b2_gv_zd_ref <= B2_GV_MIN_ZD) {
- b2_gv_zd_ref = B2_GV_MIN_ZD;
- if (b2_gv_zdd_ref < 0)
- b2_gv_zdd_ref = 0;
+ if (gv_zd_ref <= GV_MIN_ZD) {
+ gv_zd_ref = GV_MIN_ZD;
+ if (gv_zdd_ref < 0)
+ gv_zdd_ref = 0;
}
- else if (b2_gv_zd_ref >= B2_GV_MAX_ZD) {
- b2_gv_zd_ref = B2_GV_MAX_ZD;
- if (b2_gv_zdd_ref > 0)
- b2_gv_zdd_ref = 0;
+ else if (gv_zd_ref >= GV_MAX_ZD) {
+ gv_zd_ref = GV_MAX_ZD;
+ if (gv_zdd_ref > 0)
+ gv_zdd_ref = 0;
}
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [paparazzi-commits] [6006] rename b2_gv/B2_GV to gv/GV,
Felix Ruess <=