* General Public License for more details.
*/
-package org.altusmetrum.altoslib_11;
+package org.altusmetrum.altoslib_13;
import java.util.*;
public ArrayList<AltosTimeSeries> series = new ArrayList<AltosTimeSeries>();
public double speed_filter_width = 4.0;
- public double accel_filter_width = 4.0;
+ public double accel_filter_width = 1.0;
public int[] indices() {
int[] indices = new int[series.size()];
}
public void add_series(AltosTimeSeries s) {
+ for (int e = 0; e < series.size(); e++) {
+ if (s.compareTo(series.get(e)) < 0){
+ series.add(e, s);
+ return;
+ }
+ }
series.add(s);
}
public static final String state_name = "State";
public void set_state(int state) {
- if (state_series == null)
- state_series = add_series(state_name, AltosConvert.state_name);
- else if (this.state == state)
- return;
- this.state = state;
- state_series.add(time(), state);
+
+ if (state != AltosLib.ao_flight_pad && state != AltosLib.MISSING && state != AltosLib.ao_flight_stateless) {
+ if (state_series == null)
+ state_series = add_series(state_name, AltosConvert.state_name);
+ if (this.state() != state)
+ state_series.add(time(), state);
+ }
+ super.set_state(state);
}
public AltosTimeSeries accel_series;
+ public boolean accel_computed;
public static final String accel_name = "Accel";
+ public AltosTimeSeries vert_accel_series;
+
+ public static final String vert_accel_name = "Vertical Accel";
+
public void set_acceleration(double acceleration) {
if (acceleration == AltosLib.MISSING)
return;
accel_series = add_series(accel_name, AltosConvert.accel);
accel_series.add(time(), acceleration);
+ accel_computed = false;
}
- private void compute_accel() {
- if (accel_series != null)
- return;
+ private AltosTimeSeries compute_accel() {
+ AltosTimeSeries new_accel_series = null;
if (speed_series != null) {
- AltosTimeSeries temp_series = make_series(speed_name, AltosConvert.speed);
- speed_series.filter(temp_series, accel_filter_width);
- accel_series = add_series(accel_name, AltosConvert.accel);
- temp_series.differentiate(accel_series);
+ AltosTimeSeries temp_series;
+ if (accel_filter_width > 0) {
+ temp_series = make_series(speed_name, AltosConvert.speed);
+ speed_series.filter(temp_series, accel_filter_width);
+ } else
+ temp_series = speed_series;
+
+ new_accel_series = make_series(accel_name, AltosConvert.accel);
+ temp_series.differentiate(new_accel_series);
+ }
+ return new_accel_series;
+ }
+
+ public void set_filter(double speed_filter, double accel_filter) {
+ this.speed_filter_width = speed_filter;
+ this.accel_filter_width = accel_filter;
+
+ AltosTimeSeries new_speed_series = compute_speed();
+
+ if (new_speed_series != null) {
+ speed_series.erase_values();
+ for (AltosTimeValue tv : new_speed_series)
+ speed_series.add(tv);
+ }
+ if (accel_computed) {
+ AltosTimeSeries new_accel_series = compute_accel();
+ if (new_accel_series != null) {
+ accel_series.erase_values();
+ for (AltosTimeValue tv : new_accel_series)
+ accel_series.add(tv);
+ }
}
}
public void set_received_time(long received_time) {
}
+ public AltosTimeSeries tick_series;
+
+ public static final String tick_name = "Tick";
+
+ public void set_tick(int tick) {
+ super.set_tick(tick);
+ if (tick_series == null)
+ tick_series = add_series(tick_name, null);
+ tick_series.add(time(), tick);
+ }
+
public AltosTimeSeries rssi_series;
public static final String rssi_name = "RSSI";
public AltosTimeSeries height_series;
+ public double max_height = AltosLib.MISSING;
+
+ public void set_min_pressure(double pa) {
+ double ground_altitude = cal_data().ground_altitude;
+ if (ground_altitude != AltosLib.MISSING)
+ max_height = AltosConvert.pressure_to_altitude(pa) -
+ ground_altitude;
+ }
+
public static final String height_name = "Height";
public void set_pressure(double pa) {
if (altitude_series == null)
altitude_series = add_series(altitude_name, AltosConvert.height);
- if (cal_data.ground_pressure == AltosLib.MISSING)
- cal_data.set_ground_pressure(pa);
+ if (cal_data().ground_pressure == AltosLib.MISSING)
+ cal_data().set_ground_pressure(pa);
double altitude = AltosConvert.pressure_to_altitude(pa);
altitude_series.add(time(), altitude);
}
private void compute_height() {
- double ground_altitude = cal_data.ground_altitude;
+ double ground_altitude = cal_data().ground_altitude;
if (height_series == null && ground_altitude != AltosLib.MISSING && altitude_series != null) {
height_series = add_series(height_name, AltosConvert.height);
for (AltosTimeValue alt : altitude_series)
height_series.add(alt.time, alt.value - ground_altitude);
}
+
+ if (gps_height == null && cal_data().gps_pad != null && cal_data().gps_pad.alt != AltosLib.MISSING && gps_altitude != null) {
+ double gps_ground_altitude = cal_data().gps_pad.alt;
+ gps_height = add_series(gps_height_name, AltosConvert.height);
+ for (AltosTimeValue gps_alt : gps_altitude)
+ gps_height.add(gps_alt.time, gps_alt.value - gps_ground_altitude);
+ }
}
public AltosTimeSeries speed_series;
public static final String speed_name = "Speed";
- private void compute_speed() {
- if (speed_series != null)
- return;
-
+ private AltosTimeSeries compute_speed() {
+ AltosTimeSeries new_speed_series = null;
AltosTimeSeries alt_speed_series = null;
AltosTimeSeries accel_speed_series = null;
if (altitude_series != null) {
- AltosTimeSeries temp_series = make_series(altitude_name, AltosConvert.height);
- altitude_series.filter(temp_series, speed_filter_width);
+ AltosTimeSeries temp_series;
+
+ if (speed_filter_width > 0) {
+ temp_series = make_series(speed_name, AltosConvert.height);
+ altitude_series.filter(temp_series, speed_filter_width);
+ } else
+ temp_series = altitude_series;
alt_speed_series = make_series(speed_name, AltosConvert.speed);
temp_series.differentiate(alt_speed_series);
}
- if (accel_series != null) {
+ if (accel_series != null && !accel_computed) {
+
+ if (orient_series != null) {
+ vert_accel_series = add_series(vert_accel_name, AltosConvert.accel);
+
+ for (AltosTimeValue a : accel_series) {
+ double orient = orient_series.value(a.time);
+ double a_abs = a.value + AltosConvert.gravity;
+ double v_a = a_abs * Math.cos(AltosConvert.degrees_to_radians(orient)) - AltosConvert.gravity;
+
+ vert_accel_series.add(a.time, v_a);
+ }
+ }
+
AltosTimeSeries temp_series = make_series(speed_name, AltosConvert.speed);
- accel_series.integrate(temp_series);
+
+ if (vert_accel_series != null)
+ vert_accel_series.integrate(temp_series);
+ else
+ accel_series.integrate(temp_series);
accel_speed_series = make_series(speed_name, AltosConvert.speed);
temp_series.filter(accel_speed_series, 0.1);
}
}
if (apogee_time == AltosLib.MISSING) {
- speed_series = alt_speed_series;
+ new_speed_series = alt_speed_series;
} else {
- speed_series = make_series(speed_name, AltosConvert.speed);
+ new_speed_series = make_series(speed_name, AltosConvert.speed);
for (AltosTimeValue d : accel_speed_series) {
if (d.time <= apogee_time)
- speed_series.add(d);
+ new_speed_series.add(d);
}
for (AltosTimeValue d : alt_speed_series) {
if (d.time > apogee_time)
- speed_series.add(d);
+ new_speed_series.add(d);
}
}
} else if (alt_speed_series != null) {
- speed_series = alt_speed_series;
+ new_speed_series = alt_speed_series;
} else if (accel_speed_series != null) {
- speed_series = accel_speed_series;
+ new_speed_series = accel_speed_series;
+ }
+ return new_speed_series;
+ }
+
+ public AltosTimeSeries orient_series;
+
+ public static final String orient_name = "Tilt Angle";
+
+ private void compute_orient() {
+
+ if (orient_series != null)
+ return;
+
+ if (accel_ground_across == AltosLib.MISSING)
+ return;
+
+ if (cal_data().pad_orientation == AltosLib.MISSING)
+ return;
+
+ if (cal_data().accel_zero_across == AltosLib.MISSING)
+ return;
+
+ AltosRotation rotation = new AltosRotation(AltosIMU.convert_accel(accel_ground_across - cal_data().accel_zero_across),
+ AltosIMU.convert_accel(accel_ground_through - cal_data().accel_zero_through),
+ AltosIMU.convert_accel(accel_ground_along - cal_data().accel_zero_along),
+ cal_data().pad_orientation);
+ double prev_time = ground_time;
+
+ orient_series = add_series(orient_name, AltosConvert.orient);
+ orient_series.add(ground_time, rotation.tilt());
+
+ for (AltosTimeValue roll_v : gyro_roll) {
+ double time = roll_v.time;
+ double dt = time - prev_time;
+
+ if (dt > 0) {
+ double roll = AltosConvert.degrees_to_radians(roll_v.value) * dt;
+ double pitch = AltosConvert.degrees_to_radians(gyro_pitch.value(time)) * dt;
+ double yaw = AltosConvert.degrees_to_radians(gyro_yaw.value(time)) * dt;
+
+ rotation.rotate(pitch, yaw, roll);
+ orient_series.add(time, rotation.tilt());
+ }
+ prev_time = time;
}
- if (speed_series != null)
- add_series(speed_series);
}
public AltosTimeSeries kalman_height_series, kalman_speed_series, kalman_accel_series;
public ArrayList<AltosGPSTimeValue> gps_series;
public AltosGPS gps_before(double time) {
- AltosGPS gps = null;
- for (AltosGPSTimeValue gtv : gps_series)
- if (gtv.time <= time)
- gps = gtv.gps;
- else
- break;
- return gps;
+ AltosGPSTimeValue nearest = null;
+ for (AltosGPSTimeValue gtv : gps_series) {
+ if (nearest == null)
+ nearest = gtv;
+ else {
+ if (gtv.time <= time) {
+ if (nearest.time <= time && gtv.time > nearest.time)
+ nearest = gtv;
+ } else {
+ if (nearest.time > time && gtv.time < nearest.time)
+ nearest = gtv;
+ }
+ }
+ }
+ if (nearest != null)
+ return nearest.gps;
+ else
+ return null;
}
public AltosTimeSeries sats_in_view;
public static final String gps_hdop_name = "GPS Horizontal Dilution of Precision";
public void set_gps(AltosGPS gps) {
+ super.set_gps(gps);
if (gps_series == null)
gps_series = new ArrayList<AltosGPSTimeValue>();
gps_series.add(new AltosGPSTimeValue(time(), gps));
gps_vdop.add(time(), gps.vdop);
}
if (gps.locked) {
- if (gps_altitude == null) {
- gps_altitude = add_series(gps_altitude_name, AltosConvert.height);
- gps_height = add_series(gps_height_name, AltosConvert.height);
- gps_ground_speed = add_series(gps_ground_speed_name, AltosConvert.speed);
- gps_ascent_rate = add_series(gps_ascent_rate_name, AltosConvert.speed);
- gps_course = add_series(gps_course_name, null);
- gps_speed = add_series(gps_speed_name, null);
- }
if (gps.alt != AltosLib.MISSING) {
+ if (gps_altitude == null)
+ gps_altitude = add_series(gps_altitude_name, AltosConvert.height);
gps_altitude.add(time(), gps.alt);
- if (cal_data.gps_pad != null)
- gps_height.add(time(), gps.alt - cal_data.gps_pad.alt);
}
- if (gps.ground_speed != AltosLib.MISSING)
+ if (gps.ground_speed != AltosLib.MISSING) {
+ if (gps_ground_speed == null)
+ gps_ground_speed = add_series(gps_ground_speed_name, AltosConvert.speed);
gps_ground_speed.add(time(), gps.ground_speed);
- if (gps.climb_rate != AltosLib.MISSING)
+ }
+ if (gps.climb_rate != AltosLib.MISSING) {
+ if (gps_ascent_rate == null)
+ gps_ascent_rate = add_series(gps_ascent_rate_name, AltosConvert.speed);
gps_ascent_rate.add(time(), gps.climb_rate);
- if (gps.course != AltosLib.MISSING)
+ }
+ if (gps.course != AltosLib.MISSING) {
+ if (gps_course == null)
+ gps_course = add_series(gps_course_name, null);
gps_course.add(time(), gps.course);
- if (gps.ground_speed != AltosLib.MISSING && gps.climb_rate != AltosLib.MISSING)
+ }
+ if (gps.ground_speed != AltosLib.MISSING && gps.climb_rate != AltosLib.MISSING) {
+ if (gps_speed == null)
+ gps_speed = add_series(gps_speed_name, null);
gps_speed.add(time(), Math.sqrt(gps.ground_speed * gps.ground_speed +
gps.climb_rate * gps.climb_rate));
+ }
}
if (gps.cc_gps_sat != null) {
if (sats_in_view == null)
accel_through.add(time(), through);
}
+ private double accel_ground_along = AltosLib.MISSING;
+ private double accel_ground_across = AltosLib.MISSING;
+ private double accel_ground_through = AltosLib.MISSING;
+
+ private double ground_time;
+
public void set_accel_ground(double along, double across, double through) {
+ accel_ground_along = along;
+ accel_ground_across = across;
+ accel_ground_through = through;
+ ground_time = time();
}
public void set_gyro(double roll, double pitch, double yaw) {
mag_through.add(time(), through);
}
- public static final String orient_name = "Tilt Angle";
-
- public AltosTimeSeries orient_series;
-
public void set_orient(double orient) {
if (orient_series == null)
orient_series = add_series(orient_name, AltosConvert.orient);
public void set_igniter_voltage(double[] voltage) {
int channels = voltage.length;
if (igniter_voltage == null || igniter_voltage.length <= channels) {
- AltosTimeSeries[] new_igniter_voltage = new AltosTimeSeries[channels + 1];
+ AltosTimeSeries[] new_igniter_voltage = new AltosTimeSeries[channels];
int i = 0;
if (igniter_voltage != null) {
}
public void finish() {
- compute_speed();
- compute_accel();
+ compute_orient();
+ if (speed_series == null) {
+ speed_series = compute_speed();
+ if (speed_series != null)
+ add_series(speed_series);
+ }
+ if (accel_series == null) {
+ accel_series = compute_accel();
+ if (accel_series != null) {
+ add_series(accel_series);
+ accel_computed = true;
+ }
+ }
compute_height();
}
projects / fw / altos / blobdiff