/* * Copyright © 2010 Keith Packard * * 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. */ /* * Sensor data conversion functions */ package org.altusmetrum.altoslib_2; public class AltosConvert { /* * Pressure Sensor Model, version 1.1 * * written by Holly Grimes * * Uses the International Standard Atmosphere as described in * "A Quick Derivation relating altitude to air pressure" (version 1.03) * from the Portland State Aerospace Society, except that the atmosphere * is divided into layers with each layer having a different lapse rate. * * Lapse rate data for each layer was obtained from Wikipedia on Sept. 1, 2007 * at site MAXIMUM_ALTITUDE) /* FIX ME: use sensor data to improve model */ return 0; /* calculate the base temperature and pressure for the atmospheric layer associated with the inputted altitude */ for(layer_number = 0; layer_number < NUMBER_OF_LAYERS - 1 && altitude > base_altitude[layer_number + 1]; layer_number++) { delta_z = base_altitude[layer_number + 1] - base_altitude[layer_number]; if (lapse_rate[layer_number] == 0.0) { exponent = GRAVITATIONAL_ACCELERATION * delta_z / AIR_GAS_CONSTANT / base_temperature; base_pressure *= Math.exp(exponent); } else { base = (lapse_rate[layer_number] * delta_z / base_temperature) + 1.0; exponent = GRAVITATIONAL_ACCELERATION / (AIR_GAS_CONSTANT * lapse_rate[layer_number]); base_pressure *= Math.pow(base, exponent); } base_temperature += delta_z * lapse_rate[layer_number]; } /* calculate the pressure at the inputted altitude */ delta_z = altitude - base_altitude[layer_number]; if (lapse_rate[layer_number] == 0.0) { exponent = GRAVITATIONAL_ACCELERATION * delta_z / AIR_GAS_CONSTANT / base_temperature; pressure = base_pressure * Math.exp(exponent); } else { base = (lapse_rate[layer_number] * delta_z / base_temperature) + 1.0; exponent = GRAVITATIONAL_ACCELERATION / (AIR_GAS_CONSTANT * lapse_rate[layer_number]); pressure = base_pressure * Math.pow(base, exponent); } return pressure; } /* outputs the altitude associated with the given pressure. the altitude returned is measured with respect to the mean sea level */ public static double pressure_to_altitude(double pressure) { double next_base_temperature = LAYER0_BASE_TEMPERATURE; double next_base_pressure = LAYER0_BASE_PRESSURE; double altitude; double base_pressure; double base_temperature; double base; /* base for function to determine base pressure of next layer */ double exponent; /* exponent for function to determine base pressure of next layer */ double coefficient; int layer_number; /* identifies layer in the atmosphere */ int delta_z; /* difference between two altitudes */ if (pressure < 0) /* illegal pressure */ return -1; if (pressure < MINIMUM_PRESSURE) /* FIX ME: use sensor data to improve model */ return MAXIMUM_ALTITUDE; /* calculate the base temperature and pressure for the atmospheric layer associated with the inputted pressure. */ layer_number = -1; do { layer_number++; base_pressure = next_base_pressure; base_temperature = next_base_temperature; delta_z = base_altitude[layer_number + 1] - base_altitude[layer_number]; if (lapse_rate[layer_number] == 0.0) { exponent = GRAVITATIONAL_ACCELERATION * delta_z / AIR_GAS_CONSTANT / base_temperature; next_base_pressure *= Math.exp(exponent); } else { base = (lapse_rate[layer_number] * delta_z / base_temperature) + 1.0; exponent = GRAVITATIONAL_ACCELERATION / (AIR_GAS_CONSTANT * lapse_rate[layer_number]); next_base_pressure *= Math.pow(base, exponent); } next_base_temperature += delta_z * lapse_rate[layer_number]; } while(layer_number < NUMBER_OF_LAYERS - 1 && pressure < next_base_pressure); /* calculate the altitude associated with the inputted pressure */ if (lapse_rate[layer_number] == 0.0) { coefficient = (AIR_GAS_CONSTANT / GRAVITATIONAL_ACCELERATION) * base_temperature; altitude = base_altitude[layer_number] + coefficient * Math.log(pressure / base_pressure); } else { base = pressure / base_pressure; exponent = AIR_GAS_CONSTANT * lapse_rate[layer_number] / GRAVITATIONAL_ACCELERATION; coefficient = base_temperature / lapse_rate[layer_number]; altitude = base_altitude[layer_number] + coefficient * (Math.pow(base, exponent) - 1); } return altitude; } public static double cc_battery_to_voltage(double battery) { return battery / 32767.0 * 5.0; } public static double cc_ignitor_to_voltage(double ignite) { return ignite / 32767 * 15.0; } public static double barometer_to_pressure(double count) { return ((count / 16.0) / 2047.0 + 0.095) / 0.009 * 1000.0; } static double thermometer_to_temperature(double thermo) { return (thermo - 19791.268) / 32728.0 * 1.25 / 0.00247; } static double mega_adc(int raw) { return raw / 4095.0; } static public double mega_battery_voltage(int v_batt) { if (v_batt != AltosLib.MISSING) return 3.3 * mega_adc(v_batt) * (15.0 + 27.0) / 27.0; return AltosLib.MISSING; } static double mega_pyro_voltage(int raw) { if (raw != AltosLib.MISSING) return 3.3 * mega_adc(raw) * (100.0 + 27.0) / 27.0; return AltosLib.MISSING; } static double tele_mini_voltage(int sensor) { double supply = 3.3; return sensor / 32767.0 * supply * 127/27; } static double easy_mini_voltage(int sensor) { double supply = 3.0; return sensor / 32767.0 * supply * 127/27; } public static double radio_to_frequency(int freq, int setting, int cal, int channel) { double f; if (freq > 0) f = freq / 1000.0; else { if (setting <= 0) setting = cal; f = 434.550 * setting / cal; /* Round to nearest 50KHz */ f = Math.floor (20.0 * f + 0.5) / 20.0; } return f + channel * 0.100; } public static int radio_frequency_to_setting(double frequency, int cal) { double set = frequency / 434.550 * cal; return (int) Math.floor (set + 0.5); } public static int radio_frequency_to_channel(double frequency) { int channel = (int) Math.floor ((frequency - 434.550) / 0.100 + 0.5); if (channel < 0) channel = 0; if (channel > 9) channel = 9; return channel; } public static double radio_channel_to_frequency(int channel) { return 434.550 + channel * 0.100; } public static int[] ParseHex(String line) { String[] tokens = line.split("\\s+"); int[] array = new int[tokens.length]; for (int i = 0; i < tokens.length; i++) try { array[i] = Integer.parseInt(tokens[i], 16); } catch (NumberFormatException ne) { return null; } return array; } public static double meters_to_feet(double meters) { return meters * (100 / (2.54 * 12)); } public static double feet_to_meters(double feet) { return feet * 12 * 2.54 / 100.0; } public static double meters_to_miles(double meters) { return meters_to_feet(meters) / 5280; } public static double miles_to_meters(double miles) { return feet_to_meters(miles * 5280); } public static double meters_to_mph(double mps) { return meters_to_miles(mps) * 3600; } public static double mph_to_meters(double mps) { return miles_to_meters(mps) / 3600; } public static double meters_to_mach(double meters) { return meters / 343; /* something close to mach at usual rocket sites */ } public static double meters_to_g(double meters) { return meters / 9.80665; } public static double c_to_f(double c) { return c * 9/5 + 32; } public static double f_to_c(double c) { return (c - 32) * 5/9; } public static boolean imperial_units = false; public static AltosDistance distance = new AltosDistance(); public static AltosHeight height = new AltosHeight(); public static AltosSpeed speed = new AltosSpeed(); public static AltosAccel accel = new AltosAccel(); public static AltosTemperature temperature = new AltosTemperature(); public static String show_gs(String format, double a) { a = meters_to_g(a); format = format.concat(" g"); return String.format(format, a); } public static String say_gs(double a) { return String.format("%6.0 gees", meters_to_g(a)); } public static int checksum(int[] data, int start, int length) { int csum = 0x5a; for (int i = 0; i < length; i++) csum += data[i + start]; return csum & 0xff; } }