public int main_deploy;
public int apogee_delay;
public int apogee_lockout;
-
+
/* HAS_RADIO */
public int radio_frequency;
public String callsign;
return r;
}
-
+
public int compare_version(String other) {
int[] me = parse_version(version);
int[] them = parse_version(other);
log_format = AltosLib.AO_LOG_FORMAT_UNKNOWN;
version = "unknown";
- main_deploy = 250;
- apogee_delay = 0;
- apogee_lockout = 0;
+ main_deploy = -1;
+ apogee_delay = -1;
+ apogee_lockout = -1;
- radio_frequency = 0;
- callsign = "N0CALL";
+ radio_frequency = -1;
+ callsign = null;
radio_enable = -1;
- radio_calibration = 0;
+ radio_calibration = -1;
radio_channel = -1;
radio_setting = -1;
accel_cal_minus = -1;
pad_orientation = -1;
- flight_log_max = 0;
+ flight_log_max = -1;
ignite_mode = -1;
aes_key = "";
storage_erase_unit = -1;
stored_flight = -1;
}
-
+
public void parse_line(String line) {
lines.add(line);
/* Version replies */
if (npyro > 0) {
try {
AltosPyro p = new AltosPyro(pyro, line);
- if (pyro < npyro - 1)
+ if (pyro < npyro)
pyros[pyro++] = p;
} catch (Exception e) {}
}
-
+
/* Storage info replies */
try { storage_size = get_int(line, "Storage size:"); } catch (Exception e) {}
try { storage_erase_unit = get_int(line, "Storage erase unit"); } catch (Exception e) {}
}
}
+ public boolean has_frequency() {
+ return radio_frequency >= 0 || radio_setting >= 0 || radio_channel >= 0;
+ }
+
+ public void set_frequency(double freq) {
+ int frequency = radio_frequency;
+ int setting = radio_setting;
+
+ if (frequency > 0) {
+ radio_frequency = (int) Math.floor (freq * 1000 + 0.5);
+ radio_channel = -1;
+ } else if (setting > 0) {
+ radio_setting =AltosConvert.radio_frequency_to_setting(freq,
+ radio_calibration);
+ radio_channel = -1;
+ } else {
+ radio_channel = AltosConvert.radio_frequency_to_channel(freq);
+ }
+ }
+
+ public double frequency() {
+ int channel = radio_channel;
+ int setting = radio_setting;
+ if (channel < 0)
+ channel = 0;
+ if (setting < 0)
+ setting = 0;
+
+ return AltosConvert.radio_to_frequency(radio_frequency,
+ setting,
+ radio_calibration,
+ channel);
+ }
+
+ public int log_limit() {
+ if (storage_size > 0 && storage_erase_unit > 0) {
+ int log_limit = storage_size - storage_erase_unit;
+ if (log_limit > 0)
+ return log_limit / 1024;
+ }
+ return 1024;
+ }
+
+ public void get_values(AltosConfigValues source) {
+
+ /* HAS_FLIGHT */
+ if (main_deploy >= 0)
+ main_deploy = source.main_deploy();
+ if (apogee_delay >= 0)
+ apogee_delay = source.apogee_delay();
+ if (apogee_lockout >= 0)
+ apogee_lockout = source.apogee_lockout();
+
+ /* HAS_RADIO */
+ if (has_frequency())
+ set_frequency(source.radio_frequency());
+ if (radio_enable >= 0)
+ radio_enable = source.radio_enable();
+ if (callsign != null)
+ callsign = source.callsign();
+ if (radio_calibration >= 0)
+ radio_calibration = source.radio_calibration();
+
+ /* HAS_ACCEL */
+ if (pad_orientation >= 0)
+ pad_orientation = source.pad_orientation();
+
+ /* HAS_LOG */
+ if (flight_log_max >= 0)
+ flight_log_max = source.flight_log_max();
+
+ /* HAS_IGNITE */
+ if (ignite_mode >= 0)
+ ignite_mode = source.ignite_mode();
+
+ /* AO_PYRO_NUM */
+ if (npyro > 0)
+ pyros = source.pyros();
+ }
+
+ public void set_values(AltosConfigValues dest) {
+ dest.set_serial(serial);
+ dest.set_product(product);
+ dest.set_version(version);
+ dest.set_main_deploy(main_deploy);
+ dest.set_apogee_delay(apogee_delay);
+ dest.set_apogee_lockout(apogee_lockout);
+ dest.set_radio_calibration(radio_calibration);
+ dest.set_radio_frequency(frequency());
+ boolean max_enabled = true;
+ switch (log_format) {
+ case AltosLib.AO_LOG_FORMAT_TINY:
+ max_enabled = false;
+ break;
+ default:
+ if (stored_flight >= 0)
+ max_enabled = false;
+ break;
+ }
+ dest.set_flight_log_max_enabled(max_enabled);
+ dest.set_radio_enable(radio_enable);
+ dest.set_flight_log_max_limit(log_limit());
+ dest.set_flight_log_max(flight_log_max);
+ dest.set_ignite_mode(ignite_mode);
+ dest.set_pad_orientation(pad_orientation);
+ dest.set_callsign(callsign);
+ if (npyro > 0)
+ dest.set_pyros(pyros);
+ else
+ dest.set_pyros(null);
+ }
+
+ public void save(AltosLink link, boolean remote) throws InterruptedException, TimeoutException {
+
+ /* HAS_FLIGHT */
+ if (main_deploy >= 0)
+ link.printf("c m %d\n", main_deploy);
+ if (apogee_delay >= 0)
+ link.printf("c d %d\n", apogee_delay);
+ if (apogee_lockout >= 0)
+ link.printf("c L %d\n", apogee_lockout);
+
+ /* Don't mess with radio calibration when remote */
+ if (radio_calibration > 0 && !remote)
+ link.printf("c f %d\n", radio_calibration);
+
+ /* HAS_RADIO */
+ if (has_frequency()) {
+ boolean has_frequency = radio_frequency >= 0;
+ boolean has_setting = radio_setting > 0;
+ double frequency = frequency();
+ link.set_radio_frequency(frequency,
+ has_frequency,
+ has_setting,
+ radio_calibration);
+ /* When remote, reset the dongle frequency at the same time */
+ if (remote) {
+ link.stop_remote();
+ link.set_radio_frequency(frequency);
+ link.start_remote();
+ }
+ }
+
+ if (callsign != null)
+ link.printf("c c %s\n", callsign);
+ if (radio_enable >= 0)
+ link.printf("c e %d\n", radio_enable);
+
+ /* HAS_ACCEL */
+ /* UI doesn't support accel cal */
+ if (pad_orientation >= 0)
+ link.printf("c o %d\n", pad_orientation);
+
+ /* HAS_LOG */
+ if (flight_log_max != 0)
+ link.printf("c l %d\n", flight_log_max);
+
+ /* HAS_IGNITE */
+ if (ignite_mode >= 0)
+ link.printf("c i %d\n", ignite_mode);
+
+ /* HAS_AES */
+ /* UI doesn't support AES key config */
+
+ /* AO_PYRO_NUM */
+ if (pyros.length > 0) {
+ for (int p = 0; p < pyros.length; p++) {
+ link.printf("c P %s\n",
+ pyros[p].toString());
+ }
+ }
+
+ link.printf("c w\n");
+ link.flush_output();
+ }
+
public AltosConfigData(AltosLink link) throws InterruptedException, TimeoutException {
reset();
link.printf("c s\nf\nv\n");
--- /dev/null
+/*
+ * Copyright © 2012 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+package org.altusmetrum.AltosLib;
+
+public interface AltosConfigValues {
+ /* set and get all of the dialog values */
+ public abstract void set_product(String product);
+
+ public abstract void set_version(String version);
+
+ public abstract void set_serial(int serial);
+
+ public abstract void set_main_deploy(int new_main_deploy);
+
+ public abstract int main_deploy();
+
+ public abstract void set_apogee_delay(int new_apogee_delay);
+
+ public abstract int apogee_delay();
+
+ public abstract void set_apogee_lockout(int new_apogee_lockout);
+
+ public abstract int apogee_lockout();
+
+ public abstract void set_radio_frequency(double new_radio_frequency);
+
+ public abstract double radio_frequency();
+
+ public abstract void set_radio_calibration(int new_radio_calibration);
+
+ public abstract int radio_calibration();
+
+ public abstract void set_radio_enable(int new_radio_enable);
+
+ public abstract int radio_enable();
+
+ public abstract void set_callsign(String new_callsign);
+
+ public abstract String callsign();
+
+ public abstract void set_flight_log_max(int new_flight_log_max);
+
+ public abstract void set_flight_log_max_enabled(boolean enable);
+
+ public abstract int flight_log_max();
+
+ public abstract void set_flight_log_max_limit(int flight_log_max_limit);
+
+ public abstract void set_ignite_mode(int new_ignite_mode);
+
+ public abstract int ignite_mode();
+
+ public abstract void set_pad_orientation(int new_pad_orientation);
+
+ public abstract int pad_orientation();
+
+ public abstract void set_pyros(AltosPyro[] new_pyros);
+
+ public abstract AltosPyro[] pyros();
+}
AltosLib_JAVA = \
$(SRC)/AltosLib.java \
$(SRC)/AltosConfigData.java \
+ $(SRC)/AltosConfigValues.java \
$(SRC)/AltosConvert.java \
$(SRC)/AltosCRCException.java \
$(SRC)/AltosEepromChunk.java \
serial_line.stop_remote();
}
- int log_limit() {
- if (data.storage_size > 0 && data.storage_erase_unit > 0) {
- int log_limit = data.storage_size - data.storage_erase_unit;
- if (log_limit > 0)
- return log_limit / 1024;
- }
- return 1024;
- }
-
void update_ui() {
- config_ui.set_serial(data.serial);
- config_ui.set_product(data.product);
- config_ui.set_version(data.version);
- config_ui.set_main_deploy(data.main_deploy);
- config_ui.set_apogee_delay(data.apogee_delay);
- config_ui.set_apogee_lockout(data.apogee_lockout);
- config_ui.set_radio_calibration(data.radio_calibration);
- config_ui.set_radio_frequency(frequency());
- boolean max_enabled = true;
- switch (data.log_format) {
- case Altos.AO_LOG_FORMAT_TINY:
- max_enabled = false;
- break;
- default:
- if (data.stored_flight >= 0)
- max_enabled = false;
- break;
- }
- config_ui.set_flight_log_max_enabled(max_enabled);
- config_ui.set_radio_enable(data.radio_enable);
- config_ui.set_flight_log_max_limit(log_limit());
- config_ui.set_flight_log_max(data.flight_log_max);
- config_ui.set_ignite_mode(data.ignite_mode);
- config_ui.set_pad_orientation(data.pad_orientation);
- config_ui.set_callsign(data.callsign);
- config_ui.set_pyros(data.pyros);
- config_ui.set_has_pyro(data.npyro > 0);
+ data.set_values(config_ui);
config_ui.set_clean();
if (!made_visible) {
made_visible = true;
void save_data() {
try {
- double frequency = frequency();
- boolean has_frequency = data.radio_frequency > 0;
- boolean has_setting = data.radio_setting > 0;
start_serial();
- serial_line.printf("c m %d\n", data.main_deploy);
- serial_line.printf("c d %d\n", data.apogee_delay);
- serial_line.printf("c L %d\n", data.apogee_lockout);
- if (!remote)
- serial_line.printf("c f %d\n", data.radio_calibration);
- serial_line.set_radio_frequency(frequency,
- has_frequency,
- has_setting,
- data.radio_calibration);
- if (remote) {
- serial_line.stop_remote();
- serial_line.set_radio_frequency(frequency);
- AltosUIPreferences.set_frequency(device.getSerial(), frequency);
- serial_line.start_remote();
- }
- serial_line.printf("c c %s\n", data.callsign);
- if (data.flight_log_max != 0)
- serial_line.printf("c l %d\n", data.flight_log_max);
- if (data.radio_enable >= 0)
- serial_line.printf("c e %d\n", data.radio_enable);
- if (data.ignite_mode >= 0)
- serial_line.printf("c i %d\n", data.ignite_mode);
- if (data.pad_orientation >= 0)
- serial_line.printf("c o %d\n", data.pad_orientation);
- if (data.pyros.length > 0) {
- for (int p = 0; p < data.pyros.length; p++) {
- serial_line.printf("c P %s\n",
- data.pyros[p].toString());
- }
- }
- serial_line.printf("c w\n");
+ data.save(serial_line, remote);
+ if (remote)
+ AltosUIPreferences.set_frequency(device.getSerial(),
+ data.frequency());
} catch (InterruptedException ie) {
} catch (TimeoutException te) {
} finally {
data.radio_channel);
}
- void set_frequency(double freq) {
- int frequency = data.radio_frequency;
- int setting = data.radio_setting;
-
- if (frequency > 0) {
- data.radio_frequency = (int) Math.floor (freq * 1000 + 0.5);
- data.radio_channel = 0;
- } else if (setting > 0) {
- data.radio_setting =AltosConvert.radio_frequency_to_setting(freq,
- data.radio_calibration);
- data.radio_channel = 0;
- } else {
- data.radio_channel = AltosConvert.radio_frequency_to_channel(freq);
- }
- }
-
void save_data() {
/* bounds check stuff */
- if (config_ui.flight_log_max() > log_limit()) {
+ if (config_ui.flight_log_max() > data.log_limit()) {
JOptionPane.showMessageDialog(owner,
String.format("Requested flight log, %dk, is larger than the available space, %dk.\n",
config_ui.flight_log_max(),
- log_limit()),
+ data.log_limit()),
"Maximum Flight Log Too Large",
JOptionPane.ERROR_MESSAGE);
return;
}
- data.main_deploy = config_ui.main_deploy();
- data.apogee_delay = config_ui.apogee_delay();
- data.apogee_lockout = config_ui.apogee_lockout();
- data.radio_calibration = config_ui.radio_calibration();
- set_frequency(config_ui.radio_frequency());
- data.flight_log_max = config_ui.flight_log_max();
- if (data.radio_enable >= 0)
- data.radio_enable = config_ui.radio_enable();
- if (data.ignite_mode >= 0)
- data.ignite_mode = config_ui.ignite_mode();
- if (data.pad_orientation >= 0)
- data.pad_orientation = config_ui.pad_orientation();
- data.callsign = config_ui.callsign();
- if (data.npyro > 0) {
- data.pyros = config_ui.pyros();
- }
+ /* Pull data out of the UI and stuff back into our local data record */
+
+ data.get_values(config_ui);
+
run_serial_thread(serial_mode_save);
}
public class AltosConfigUI
extends AltosDialog
- implements ActionListener, ItemListener, DocumentListener
+ implements ActionListener, ItemListener, DocumentListener, AltosConfigValues
{
Container pane;
public void set_apogee_delay(int new_apogee_delay) {
apogee_delay_value.setSelectedItem(Integer.toString(new_apogee_delay));
+ apogee_delay_value.setEnabled(new_apogee_delay >= 0);
}
public int apogee_delay() {
public void set_apogee_lockout(int new_apogee_lockout) {
apogee_lockout_value.setSelectedItem(Integer.toString(new_apogee_lockout));
+ apogee_lockout_value.setEnabled(new_apogee_lockout >= 0);
}
public int apogee_lockout() {
return -1;
}
- public void set_has_pyro(boolean has_pyro) {
- pyro.setEnabled(has_pyro);
- }
-
public void set_pyros(AltosPyro[] new_pyros) {
pyros = new_pyros;
- if (pyro_ui != null)
+ pyro.setEnabled(pyros != null);
+ if (pyros != null && pyro_ui != null)
pyro_ui.set_pyros(pyros);
}