Mercurial > public > hwos_code
annotate src/p2_deco.c @ 623:c40025d8e750
3.03 beta released
| author | heinrichsweikamp |
|---|---|
| date | Mon, 03 Jun 2019 14:01:48 +0200 |
| parents | 7b3903536213 |
| children | cd58f7fc86db |
| rev | line source |
|---|---|
| 582 | 1 // *************************************************************************** |
| 623 | 2 // p2_deco.c combined next generation V3.03.4 |
| 0 | 3 // |
| 4 // Created on: 12.05.2009 | |
| 560 | 5 // Author: heinrichs weikamp, contributions by Ralph Lembcke and others |
| 0 | 6 // |
| 582 | 7 // *************************************************************************** |
| 0 | 8 |
| 9 ////////////////////////////////////////////////////////////////////////////// | |
| 10 // OSTC - diving computer code | |
| 604 | 11 // Copyright (C) 2018 HeinrichsWeikamp GmbH |
| 0 | 12 // |
| 13 // This program is free software: you can redistribute it and/or modify | |
| 14 // it under the terms of the GNU General Public License as published by | |
| 623 | 15 // the Free Software Foundation, either version 3 of the License, or |
| 0 | 16 // (at your option) any later version. |
| 17 // | |
| 18 // This program is distributed in the hope that it will be useful, | |
| 19 // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 623 | 20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 0 | 21 // GNU General Public License for more details. |
| 22 // | |
| 23 // You should have received a copy of the GNU General Public License | |
| 623 | 24 // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 0 | 25 // |
| 26 ////////////////////////////////////////////////////////////////////////////// | |
| 27 | |
| 623 | 28 // History: |
| 0 | 29 // 01/03/08 v100: first release candidate |
| 30 // 03/13/08 v101: start of programming ppO2 code | |
| 560 | 31 // 03/13/25 v101a: backup of interim version with ppO2 calculation |
| 0 | 32 // 03/13/25 v101: open circuit gas change during deco |
| 623 | 33 // 03/13/25 v101: CNS_fraction_real calculation |
| 0 | 34 // 03/13/26 v101: optimization of tissue calc routines |
| 623 | 35 // 07/xx/2008 v102a: debug of bottom time routine |
| 36 // 09/xx/2008 v102d: Gradient Factor Model implementation | |
| 37 // 10/10/2008 v104: renamed to build v103 for v118 stable | |
| 38 // 10/14/2008 v104: integration of char_I_depth_last_deco for Gradient Model | |
| 39 // 03/31/2009 v107: integration of FONT Incon24 | |
| 40 // 05/23/2010 v109: 5 gas changes & 1 min timer | |
| 41 // 07/13/2010 v110: cns vault added | |
| 42 // 12/25/2010 v110: split in three files (deco.c, main.c, definitions.h) | |
| 0 | 43 // 2011/01/20: [jDG] Create a common file included in ASM and C code. |
| 623 | 44 // 2011/01/24: [jDG] Make ascent time an short. No more overflow! |
| 0 | 45 // 2011/01/25: [jDG] Fusion deco array for both models. |
| 46 // 2011/01/25: [jDG] Use CF(54) to reverse deco order. | |
| 47 // 2011/02/11: [jDG] Reworked gradient-factor implementation. | |
| 48 // 2011/02/15: [jDG] Fixed inconsistencies introduced by gas switch delays. | |
| 49 // 2011/03/21: [jDG] Added gas consumption (CF56 & CF57) evaluation for OCR mode. | |
| 623 | 50 // 2011/04/15: [jDG] Store GF_low_depth in 32 bits (w/o rounding), for a better stability. |
| 560 | 51 // 2011/04/25: [jDG] Added 1mn mode for CNS calculation, to allow it for deco planning. |
| 0 | 52 // 2011/04/27: [jDG] Fixed char_O_gradient_factor calculation when model uses gradient-factor. |
| 53 // 2011/05/02: [jDG] Added "Future TTS" function (CF58). | |
| 54 // 2011/05/17: [jDG] Various cleanups. | |
| 55 // 2011/08/08: [jDG] Computes CNS during deco planning ascent. | |
| 56 // 2011/11/24: [jDG] Slightly faster and better NDL computation. | |
| 57 // 2011/12/17: [mH] Remove of the useless debug stuff | |
| 58 // 2012/02/24: [jDG] Remove missed stop bug. | |
| 59 // 2012/02/25: [jDG] Looking for a more stable LOW grad factor reference. | |
| 60 // 2012/09/10: [mH] Fill char_O_deco_time_for_log for logbook write | |
| 623 | 61 // 2012/10/05: [jDG] Better calc_gas_needs_ascent accuracy (average depth, switch between stop). |
| 62 // 2013/03/05: [jDG] Should vault GF_low_depth too. | |
| 0 | 63 // 2013/03/05: [jDG] Wrobell remark: ascent_to_first_stop works better with finer steps (2sec). |
|
33
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
64 // 2013/05/08: [jDG] A. Salm remark: NOAA tables for CNS are in ATA, not bar. |
| 560 | 65 // 2013/12/21: [jDG] Fix CNS calculation in deco plan w/o marked gas switch |
| 66 // 2014/06/16: [jDG] Fix Helium diluent. Fix volumes with many travel mix. | |
|
324
0e9dcdcf03c1
FIX NDL prediction error with Buhlmann model: might be desaturating too fast.
jdg@air
parents:
323
diff
changeset
|
67 // 2014/06/29: [mH] Compute int_O_ceiling |
|
0e9dcdcf03c1
FIX NDL prediction error with Buhlmann model: might be desaturating too fast.
jdg@air
parents:
323
diff
changeset
|
68 // 2015/06/12: [jDG] Fix NDL prediction while desaturating with the Buhlmann model. |
| 560 | 69 // 2017/08/04: [mH] Switch to absolute GF everywhere and apply safety margin parameters to both models (GF and non-GF), fixes from Ralph Lembcke |
| 70 // 2017/10/31: [rl] enhancements for pSCR mode and introduction of 2nd deco plan computation | |
| 71 // 2017/12/31: [rl] completion of 2nd deco plan computation and various up-fixes | |
| 584 | 72 // 2018/02/17: [rl] switch-over to new ceiling rounding (V2.98a) |
| 0 | 73 // |
| 74 // | |
| 75 // Literature: | |
| 313 | 76 // Buhlmann, Albert: Tauchmedizin; 4. Auflage [2002]; |
| 604 | 77 // Schroeder, Kai & Reith, Steffen; 2000; Saettigungsvorgaenge beim Tauchen, das Modell ZH-L16, Funktionsweise von Tauchcomputern; http://www.achim-und-kai.de/kai/tausim/saett_faq |
| 0 | 78 // Morrison, Stuart; 2000; DIY DECOMPRESSION; http://www.lizardland.co.uk/DIYDeco.html |
| 79 // Balthasar, Steffen; Dekompressionstheorie I: Neo Haldane Modelle; http://www.txfreak.de/dekompressionstheorie_1.pdf | |
| 80 // Baker, Erik C.; Clearing Up The Confusion About "Deep Stops" | |
| 81 // Baker, Erik C.; Understanding M-values; http://www.txfreak.de/understanding_m-values.pdf | |
| 604 | 82 |
| 83 | |
| 84 // ********************************************************************************************************************************* | |
| 0 | 85 // |
| 604 | 86 // I N C L U D E S |
| 87 // | |
| 88 // ********************************************************************************************************************************* | |
| 89 | |
| 623 | 90 |
| 604 | 91 #include <math.h> |
| 582 | 92 #include "p2_definitions.h" |
| 93 #define TEST_MAIN | |
| 94 #include "shared_definitions.h" | |
| 623 | 95 #include "configuration.inc" |
| 0 | 96 |
| 560 | 97 |
| 604 | 98 // ********************************************************************************************************************************* |
| 99 // | |
| 100 // C O N S T A N T S D E F I N I T I O N S | |
| 101 // | |
| 102 // ********************************************************************************************************************************* | |
| 103 | |
| 623 | 104 |
| 105 // deco engine scheduling | |
| 106 #define INVOKES_PER_SECOND 2 // number of invocations of the deco engine per second (use powers of 2 only: 1, 2, 4, ...) | |
| 107 #define BUDGET_PER_SECOND 640 // [ms] total time budget per second for the deco engine, each invocation will preempt after BUDGET_PER_SECOND / INVOKES_PER_SECOND | |
| 108 | |
| 604 | 109 |
| 560 | 110 // ambient pressure at different mountain heights |
| 111 #define P_ambient_1000m 0.880 // [bar] based on 990 hPa and 20°C at sea level, 15°C at altitude | |
| 112 #define P_ambient_2000m 0.782 // [bar] | |
| 113 #define P_ambient_3000m 0.695 // [bar] | |
| 114 | |
| 115 // ambient pressure in aircraft cabin during flying - worst case according to Buhlmann | |
| 116 #define P_ambient_fly 0.600 // [bar], 0.600 bar is the value used by Buhlmann for his flying-after-diving calculations | |
| 582 | 117 // 0.735 bar is a typical cabin pressure for nowadays commercial jet aircrafts |
| 560 | 118 // ----- |
| 119 // 0.135 bar safety margin | |
| 120 | |
| 121 // constants and factors | |
| 604 | 122 #define ppWater 0.06270 // water vapor partial pressure in the lungs |
| 582 | 123 #define METER_TO_BAR 0.09985 // conversion factor |
| 124 #define BAR_TO_METER 10.0150 // conversion factor (1.0/METER_TO_BAR) | |
| 604 | 125 #define SURFACE_DESAT_FACTOR 0.70420 // surface desaturation safety factor |
| 560 | 126 #define HYST 1.0E-06 // threshold for tissue graphics on-gassing / off-gassing visualization |
| 127 | |
| 128 // thresholds | |
| 582 | 129 #define CNS_WARNING_THRESHOLD 100 // threshold for CNS warning |
| 130 #define CNS_ATTENTION_THRESHOLD 70 // threshold for CNS attention | |
| 131 #define ppO2_GAP_TO_SETPOINT 10 // gap between setpoint and max. ppO2 of the pure diluent [cbar] | |
| 604 | 132 #define GAS_NEEDS_ATTENTION_THRESHOLD 0.70 // threshold for gas needs attention [1.00 = 100%] |
| 133 #define PRESSURE_LIMIT_WARNING 200 // threshold for pressure reading warning : 20.0 bar | |
| 134 #define PRESSURE_LIMIT_ATTENTION 500 // threshold for pressure reading attention: 50.0 bar | |
| 135 #define O2_CONSUMPTION_LIMIT_ATTENTION 20 // threshold for O2 "SAC" attention: 2.0 l/min | |
| 623 | 136 #define ppO2_MARGIN_ON_MAX 3 // [cbar] margin on ppO2 max to compensate for surface pressures > 1.000 mbar |
| 137 | |
| 138 // deco engine states and modes - (char_O_)main_status: controls current tissue and deco status calculation (as-is situation) | |
| 139 #define CALC_VOLUME 0x01 // =1: calculate gas needs | |
| 140 #define CALCULATE_BOTTOM 0x02 // =1: calculate gas needs in deco calculator mode, =0: in dive mode | |
| 141 #define CAVE_MODE 0x04 // =1: calculate ascent and gas needs using backtracking data | |
| 142 #define USE_Z_FACTOR 0x08 // =1: calculate with Z factor when converting gas volumes <-> pressures | |
| 143 | |
| 144 #define TR_FUNCTIONS 0x10 // =1: calculate TR functions (pressure reading) processing | |
| 145 #define EXTENDED_STOPS 0x20 // =1: allow placement of gas switches below the depth of the 1st stop | |
| 146 | |
| 147 #define MODE_MASK 0xC0 // mask for real tissues mode selection | |
| 148 #define MODE_LOOP 0x40 // =1: CCR (MODE_PSCR needs to be cleared) or pSCR mode | |
| 149 #define MODE_CCR 0x40 // to be used with == operator in combination with MODE_MASK only! | |
| 150 #define MODE_PSCR 0x80 // =1: pSCR mode (MODE_LOOP needs to be set, too) | |
| 151 | |
| 152 // deco engine states and modes - (char_O_)deco_status: controls deco plan calculation (to-be scenario) | |
| 153 #define PLAN_MASK 0x03 // bit mask covering normal & alternative plan flag | |
| 154 #define COMMAND_MASK 0x07 // bit mask covering all command flags | |
| 155 #define CALCULATING 0x00 // calculations are ongoing | |
| 156 #define START_NORM 0x01 // input: start calculation of a normal deco plan | |
| 157 #define CALC_NORM 0x01 // internal: calculating a normal deco plan | |
| 158 #define COMPLETED_NORM 0x01 // output: calculation of a normal deco plan has completed | |
| 159 #define START_ALT 0x02 // input: start calculation of an alternative deco plan | |
| 160 #define CALC_ALT 0x02 // internal: calculating an alternative deco plan | |
| 161 #define COMPLETED_ALT 0x02 // output: calculation of an alternative deco plan has completed | |
| 162 #define INITIALIZE 0x04 // input: initialize deco engine | |
| 163 #define INITIALIZE_START_NORM 0x05 // input: initialize deco engine and start calculation of a normal deco plan | |
| 164 #define INITIALIZE_START_ALT 0x06 // input: initialize deco engine and start calculation of an alternative deco plan | |
| 165 // 0x08 // unused - reserved for further deco engine commands | |
| 166 | |
| 167 #define BAILOUT_MODE 0x10 // =1: allow gas switches before first deco stop | |
| 168 #define DELAYED_ASCENT 0x20 // =1: figure in a delayed ascent (fTTS) | |
| 169 | |
| 170 // MODE_MASK 0xC0 // mask for simulated tissues mode selection | |
| 171 // MODE_LOOP 0x40 // =1: CCR (MODE_PSCR needs to be cleared) or pSCR mode | |
| 172 // MODE_CCR 0x40 // to be used with == operator in combination with MODE_MASK only! | |
| 173 // MODE_PSCR 0x80 // =1: pSCR mode (MODE_LOOP needs to be set, too) | |
| 174 | |
| 175 | |
| 176 // deco engine warnings - (char_O_)deco_warnings | |
| 604 | 177 #define DECO_WARNING_IBCD 0x01 // IBCD occurring now |
| 178 #define DECO_WARNING_IBCD_lock 0x02 // IBCD has occurred during the dive | |
| 179 #define DECO_WARNING_MBUBBLES 0x04 // micro bubbles likely to develop now | |
| 180 #define DECO_WARNING_MBUBBLES_lock 0x08 // ditto, but sometime during the dive | |
| 181 #define DECO_WARNING_OUTSIDE 0x10 // tissue pressures outside the Buhlmann model now | |
| 182 #define DECO_WARNING_OUTSIDE_lock 0x20 // tissue pressures outside the model sometime during the dive | |
| 183 #define DECO_ATTENTION_OUTSIDE 0x40 // tissue pressures are very close to the Buhlmann limit | |
| 184 #define DECO_WARNING_STOPTABLE_OVERFLOW 0x80 // internal error: no more space in the deco stops table | |
| 185 | |
| 623 | 186 // deco engine status (char_O_)deco_info |
| 604 | 187 #define DECO_FLAG 0x01 // =1: deco ppO2 levels are permitted |
| 188 #define IND_DOUBLE_SWITCH_FLAG 0x02 // =1: switch to other tank advice active | |
| 623 | 189 // 0x04 // --- unused |
| 190 #define DECO_ZONE 0x08 // =1: fTTS < TTS (not updated when in bailout mode) | |
| 604 | 191 #define DECO_CEILING 0x10 // =1: ceiling depth > 0 |
| 623 | 192 #define DECO_STOPS 0x20 // =1: deco stops found |
| 193 #define GAS_NEEDS_CAVE 0x40 // =1: indicated gas needs are calculated in cave mode | |
| 194 // 0x80 // --- unused | |
| 195 | |
| 604 | 196 |
| 197 // deco engine control - tissue_increment | |
| 623 | 198 #define TIME_MASK 0x7F // =0: time increment is 2 seconds, 1..127: time increments is 1..127 minutes |
| 199 #define TISSUE_SELECTOR 0x80 // =1: calculate on real tissues, =0: calculate on simulated tissues | |
| 200 | |
| 201 | |
| 202 // deco engine control - next_planning_phase | |
| 203 #define PHASE_00_DONE 0x00 // calculation cycle finished | |
| 204 #define PHASE_10_DIVE_INIT 0x10 // once-per-dive initialization of the deco engine | |
| 205 #define PHASE_11_CYCLIC_INIT 0x11 // once-every-cycle initialization of the deco engine | |
| 206 #define PHASE_20_EXTENDED_BOTTOM_TIME 0x20 // calculate extended bottom time | |
| 207 #define PHASE_30_NDL_TIME 0x30 // calculate NDL time | |
| 208 #define PHASE_40_CAVE_ASCENT 0x40 // calculate cave mode return/ascent | |
| 209 #define PHASE_60_DECO_ASCENT 0x60 // calculate open water deco ascent | |
| 210 #define PHASE_70_RESULTS 0x70 // results - initialization | |
| 211 #define PHASE_71_RESULTS_STOPS_TABLE 0x71 // results - publish stops table | |
| 212 #define PHASE_72_RESULTS_NDL 0x72 // results - publish data / within NDL | |
| 213 #define PHASE_73_RESULTS_DECO 0x73 // results - publish data / in deco | |
| 214 #define PHASE_80_GAS_NEEDS_SWITCHES 0x80 // calculate gas needs - find gas switches in NDL bailout mode | |
| 215 #define PHASE_81_GAS_NEEDS_ASCENT 0x81 // calculate gas needs - needs of bottom segment and ascent | |
| 216 #define PHASE_82_GAS_NEEDS_PRESSURES 0x82 // calculate gas needs - conversion from volumes to pressures | |
| 217 #define PHASE_90_FINISH 0x90 // finish calculation cycle | |
| 218 | |
| 219 | |
| 220 // gas needs calculation - gas_needs_next_phase | |
| 221 #define GAS_NEEDS_INIT 0x00 // initialization | |
| 222 #define GAS_NEEDS_BOTTOM_SEGMENT 0x10 // demand during bottom segment | |
| 223 #define GAS_NEEDS_INITIAL_ASCENT 0x20 // demand of initial ascent | |
| 224 #define GAS_NEEDS_STOP 0x30 // demand on a stop | |
| 225 #define GAS_NEEDS_INTERMEDIATE_ASCENT 0x40 // demand on ascent between two stops | |
| 226 #define GAS_NEEDS_FINAL_ASCENT 0x50 // demand during final ascent | |
| 227 #define GAS_NEEDS_DONE 0x60 // calculation finished | |
| 560 | 228 |
| 229 | |
| 230 // flags used with integer numbers | |
| 604 | 231 #define INT_FLAG_INVALID 0x0400 // =1: value not valid |
| 623 | 232 #define INT_FLAG_NOT_COMPUTED_YET 0x0800 // =1: value not computed yet |
| 604 | 233 #define INT_FLAG_ZERO 0x0800 // =1: value is zero |
| 234 #define INT_FLAG_LOW 0x1000 // =1: value is below a lower warning threshold | |
| 235 #define INT_FLAG_NOT_AVAIL 0x1000 // =1: value is not available (not computed) | |
| 236 #define INT_FLAG_HIGH 0x2000 // =1: value is above an upper warning threshold | |
| 237 #define INT_FLAG_OUTDATED 0x2000 // =1: value has not been updated for too long | |
| 238 #define INT_FLAG_ATTENTION 0x4000 // =1: value exceeds the attention threshold | |
| 239 #define INT_FLAG_WARNING 0x8000 // =1: value exceeds the warning threshold | |
| 240 #define INT_FLAG_OUT_OF_RANGE 0x8000 // =1: value exceeds presentable range | |
| 241 | |
| 242 | |
| 243 | |
| 244 // ********************************************************************************************************************************* | |
| 245 // | |
| 246 // ** P R O T O T Y P E S ** | |
| 247 // | |
| 248 // The Functions are listed in sequence of intended usage / application. | |
| 249 // | |
| 250 // ********************************************************************************************************************************* | |
| 251 | |
| 623 | 252 // Functions used in Surface Mode |
| 604 | 253 static void calc_interval(PARAMETER unsigned char time_increment); |
| 254 // Calculates the tissue off-gassing under surface conditions. | |
| 255 static void calc_desaturation_time(void); // Calculates the desaturation and no-fly times. | |
| 256 static void clear_tissue(void); // Resets all tissues to surface pressure equilibrium state. | |
| 623 | 257 static void init_output_vars(void); // Initializes all deco engine output variables to defaults |
| 258 | |
| 259 // Main entry point in Dive Mode | |
| 604 | 260 static void calc_hauptroutine(void); // Sequences all calculations for the real tissues and the deco calculation. |
| 261 | |
| 623 | 262 // Functions dedicated to the real Tissues |
| 604 | 263 static void calc_hauptroutine_data_input(void);// Initializes environment data and sets gas ratios for the real tissues. |
| 264 | |
| 623 | 265 // Functions combined for real Tissues & Deco Calculations |
| 604 | 266 static void calc_alveolar_pressures(void); // Computes the partial pressures from the gas ratios and many more parameters, |
| 267 // needs either calc_hauptroutine_data_input() be called beforehand or | |
| 268 // gas_find_current()/gas_find_better() and gas_set_ratios(). | |
| 269 static void calc_tissues(void); // Updates the tissues dependent on the partial pressures of N2 and He. | |
| 270 static void calc_CNS(void); // Updates the CNS value dependent on the partial pressure of the O2. | |
| 271 static void calc_limit(PARAMETER float GF_current); | |
| 272 // Calculates ceiling, current GF (supersaturation) and some more data. | |
| 273 | |
| 623 | 274 // Functions for TR |
| 275 #ifdef _rx_functions | |
| 276 static void calc_TR_functions(void); // Calculates SAC etc. | |
| 277 #endif | |
| 278 | |
| 279 // Functions dedicated to Deco Calculations | |
| 604 | 280 static void clear_deco_table(void); // Clears the deco stops table, invoked at the start of each calculation cycle. |
| 281 static void gas_find_current(void); // Sets the first gas used for deco calculation, invoked at start of cycle, too. | |
| 282 static unsigned char gas_find_better(void); // Checks for, and eventually switches to, a better gas. | |
| 283 static void gas_set_ratios(void); // Sets the gas ratios for use in deco calculation (simulated tissues), | |
| 284 // needs to be called after each gas change (gas_find_current/_better). | |
| 623 | 285 static void calc_NDL_time_tissue(void); // Calculates the remaining NDL time for a given tissue. |
| 286 static void find_NDL_gas_changes(void); // Finds the gas changes in an OC bailout ascent that is within NDL. | |
| 287 static unsigned char find_next_stop(void); // Finds the next stop when in a deco ascent. | |
| 560 | 288 static unsigned char update_deco_table(PARAMETER unsigned char time_increment); |
| 604 | 289 // Enters a new stop or extends an existing stop in the deco stops table. |
| 290 static void calc_ascenttime(void); // Calculates the ascent time from current depth and deco stop times. | |
| 623 | 291 static void calc_gas_needs_ascent(void); // Calculates required gas volumes and pressures from the data in stops table. |
| 292 static void calc_due_by_depth_time_sac(void); // Calculates gas volume required for a given depth, time and usage (SAC rate). | |
| 293 static void convert_gas_needs_to_press(void); // Converts gas volumes into pressures and sets respective flags. | |
| 294 | |
| 295 // Functions for Results Reporting | |
| 604 | 296 static void publish_deco_table(void); // Copies the internal deco stops table to the export interface. |
| 623 | 297 static void convert_cur_CNS_for_display(void); // Converts the current CNS value from float to integer. |
| 604 | 298 static void convert_sim_CNS_for_display(void); // Converts the end-of-dive CNS value from float to integer. |
| 623 | 299 static void convert_sat_for_display(void); // Converts leading tissue saturation value from float to integer, 1.0 = 100%. |
| 604 | 300 static void convert_ceiling_for_display(void); // Converts ceiling from float to integer in mbar relative pressure. |
| 301 | |
| 302 | |
| 623 | 303 // internal helper Functions |
| 304 static void load_tmr5(void); // Loads a hardware timer which is used for preemptive scheduling. | |
| 305 static void read_tmr5(void); // Reads a hardware timer which is used for preemptive scheduling. | |
| 306 static void read_CNS_ab_coefficient(void); // Reads the CNS a and b coefficients from a ROM table. | |
| 307 static void read_CNS_c_coefficient(void); // Reads the CNS c coefficient from a ROM table. | |
| 308 static void read_Buhlmann_coefficients(void); // Reads the Buhlmann a and b coefficients from a ROM table. | |
| 604 | 309 static void read_Buhlmann_times(PARAMETER char period); |
| 310 // Reads pre-computed tissue increment factors from a ROM table. | |
| 311 static void read_Buhlmann_ht(void); // Reads the half-times from a ROM table. | |
| 312 static void adopt_Buhlmann_coefficients(void); // Computes average a and b coefficient by the N2/He tissue ratio. | |
| 313 static void push_tissues_to_vault(void); // Stores the state of the real tissues during simulator runs. | |
| 314 static void pull_tissues_from_vault(void); // Restores the state of the real tissues after a simulator run. | |
| 623 | 315 static void calc_N2_equilibrium(void); // Calculate partial pressure of N2 in respired air at surface pressure |
| 316 static void get_saturation_factors(void); // Get, safeguard and convert the saturation and desaturation factors | |
| 317 static void apply_saturation_factors(void); // Applies saturation and desaturation factors | |
| 604 | 318 |
| 319 | |
| 320 // ********************************************************************************************************************************* | |
| 321 // | |
| 322 // V A R I A B L E S D E F I N I T I O N S | |
| 323 // | |
| 324 // ********************************************************************************************************************************* | |
| 0 | 325 |
| 326 //---- Bank 5 parameters ----------------------------------------------------- | |
| 327 #ifndef UNIX | |
| 328 # pragma udata bank5=0x500 | |
| 329 #endif | |
| 330 | |
| 623 | 331 // Environmental and Gas Data (52 byte) |
| 560 | 332 |
| 582 | 333 static float pres_surface; // absolute pressure at the surface |
| 560 | 334 |
| 623 | 335 static float float_depth_real; // current real depth in meters, float |
| 336 static unsigned char char_depth_real; // current real depth in meters, integer | |
| 337 static unsigned char char_depth_sim; // current simulated depth in meters, integer | |
| 338 static unsigned char char_depth_last; // last simulated depth in meters, integer | |
| 339 static unsigned char char_depth_bottom; // bottom depth in meters, integer | |
| 604 | 340 |
| 341 static float real_pres_respiration; // current real depth in absolute pressure | |
| 342 static float real_O2_ratio; // real breathed gas oxygen ratio | |
| 343 static float real_N2_ratio; // real breathed gas nitrogen ratio | |
| 344 static float real_He_ratio; // real breathed gas helium ratio | |
| 345 static float real_pSCR_drop; // real ppO2 drop in pSCR loop | |
| 582 | 346 |
| 347 static float sim_pres_respiration; // simulated current depth in abs.pressure, used for deco calculations | |
| 348 static float sim_O2_ratio; // simulated breathed gas oxygen ratio | |
| 349 static float sim_N2_ratio; // simulated breathed gas nitrogen ratio | |
| 350 static float sim_He_ratio; // simulated breathed gas helium ratio | |
| 351 static float sim_pSCR_drop; // simulated ppO2 drop in pSCR loop | |
| 560 | 352 |
| 604 | 353 |
| 623 | 354 // general Deco Parameters (57 byte) |
| 355 | |
| 356 static float GF_low; // gradient factor to determine 1st stop | |
| 357 static float GF_high; // gradient factor to determine surfacing | |
| 358 | |
| 359 static unsigned char GF_low_last; // last GF low, used to detect changes | |
| 360 static unsigned char GF_high_last; // last GF high, used to detect changes | |
| 361 | |
| 362 static unsigned char GF_low_depth; // GF low reference depth in current calculation cycle | |
| 363 static unsigned char GF_low_depth_norm; // GF low reference depth in normal plan | |
| 364 static unsigned char GF_low_depth_alt; // GF low reference depth in alternative plan | |
| 365 | |
| 366 static float GF_slope; // (GF_high - GF_low) / GF_low_depth in current calculation cycle | |
| 367 static float GF_slope_norm; // (GF_high - GF_low) / GF_low_depth_norm in normal plan | |
| 368 static float GF_slope_alt; // (GF_high - GF_low) / GF_low_depth_alt in alternative plan | |
| 369 | |
| 370 static float float_ascent_speed; // ascent speed from options_table (5.0 .. 10.0 m/min) | |
| 371 static float float_deco_distance; // additional depth below stop depth for tissue, CNS and gas volume calculation | |
| 372 static float float_saturation_multiplier; // safety factor for on-gassing rates | |
| 373 static float float_desaturation_multiplier; // safety factor for off-gassing rates | |
| 374 | |
| 375 static unsigned char split_N2_He[NUM_COMP]; // used for calculating the desaturation time | |
| 376 | |
| 377 | |
| 378 // real Context: what we are doing now (16 byte) | |
| 379 | |
| 380 static float CNS_fraction_real; // current real CNS (1.00 = 100%) | |
| 381 static unsigned short IBCD_tissue_vector; // 16 bit vector to memorize all tissues that experience IBCD | |
| 382 | |
| 383 static float pres_respiration_sac; // used in SAC calculation: current depth in absolute pressure | |
| 384 static float float_sac; // used in SAC calculation: SAC value in float | |
| 385 static unsigned short max_sac_rate; // used in SAC calculation: threshold for SAC rate attention | |
| 386 | |
| 387 | |
| 388 // simulated Context: used to calculate Ascent (11 byte) | |
| 389 | |
| 390 static float CNS_fraction_sim; // CNS after predicted ascent, 0.01 = 1%, as float | |
| 391 static unsigned short int_sim_CNS_fraction; // CNS after predicted ascent, 1 = 1%, as integer | |
| 392 static unsigned char NDL_tissue_start_norm; // tissue to start with when calculating the normal NDL time | |
| 393 static unsigned char NDL_tissue_start_alt; // tissue to start with when calculating the alternative NDL time | |
| 394 static unsigned char NDL_tissue_start; // tissue to start with in current cycle | |
| 395 static unsigned char NDL_tissue_lead; // tissue with the shortest NDL time found in current cycle | |
| 396 static unsigned char NDL_tissue; // tissue for which the NDL is calculated right now | |
| 397 | |
| 398 // Result Values from Calculation Functions (9 byte) | |
| 399 | |
| 400 static float ceiling; // minimum tolerated relative pressure (i.e. without surface pressure) | |
| 401 static float lead_supersat; // supersaturation of the leading tissue, 1.0 = 100% | |
| 402 static unsigned char lead_tissue; // number of the leading tissue | |
| 403 | |
| 404 | |
| 405 // Transfer Variables between calc_desaturation_time() and calc_desaturation_time_helper() (18 byte) | |
| 406 | |
| 407 static float desat_factor; // used to cache a pre-computed factor | |
| 408 static float var_ht; // buffer for a half-time factor | |
| 409 static float pres_target; // target pressure for a compartment | |
| 410 static float pres_actual; // current pressure of the compartment | |
| 411 static unsigned short int_time; // time it takes for the compartment to reach the target pressure | |
| 412 | |
| 413 | |
| 414 // Gas in Use and Gas Needs (30 byte) | |
| 415 | |
| 416 static unsigned char sim_gas_current_num; // number of the currently used gas | |
| 417 static unsigned char sim_gas_current_depth; // change depth of the currently used gas | |
| 418 | |
| 419 static unsigned char gas_needs_stop_time; // duration of the stop in minutes | |
| 420 static unsigned char gas_needs_stop_gas; // gas used now (1-5 or 0) | |
| 421 static unsigned char gas_needs_stop_gas_last; // gas used before (1-5 or 0) | |
| 422 static unsigned char gas_needs_stop_depth; // depth of the stop in meters | |
| 423 static unsigned char gas_needs_stop_depth_last; // depth of the last stop in meters | |
| 424 static unsigned char gas_needs_stop_index; // index to the stop table | |
| 425 static unsigned char gas_needs_gas_index; // index to the gas and tank data arrays | |
| 426 static unsigned char gas_needs_next_phase; // next phase within the ascent gas needs calculation | |
| 427 | |
| 428 static float gas_volume_need[NUM_GAS]; // gas volumes required for return/ascent in liters | |
| 429 | |
| 430 | |
| 431 // Transfer Variables between calc_gas_needs_ascent() and calc_due_by_depth_time_sac() (13 byte) | |
| 432 | |
| 433 static float gas_needs_float_depth; // depth of the stop or half-way point | |
| 434 static float gas_needs_float_time; // duration of the stop or ascent phase | |
| 435 static unsigned char gas_needs_stop_usage; // gas usage in l/min | |
| 436 static float gas_needs_volume_due; // computed due of gas volume required | |
| 437 | |
| 438 | |
| 439 // CNS Coefficients (10 byte) | |
| 440 | |
| 441 static float var_cns_a; // two coefficients approximation, gain | |
| 442 static float var_cns_b; // two coefficients approximation, offset | |
| 443 static unsigned short var_cns_c; // one coefficient approximation, value | |
| 444 | |
| 445 | |
| 446 // Transfer values for convert_float_int and convert_float_to_char() (7 byte) | |
| 447 | |
| 448 static float float_value; // input value, float | |
| 449 static unsigned short int_value; // output value, 16 bit | |
| 450 static unsigned char char_value; // output value, 8 bit | |
| 451 | |
| 452 | |
| 453 // Auxiliary Variables for Data Buffering (28 byte) | |
| 454 | |
| 455 static float N2_equilibrium; // used for N2 tissue graphics scaling | |
| 456 static float temp_tissue; // auxiliary variable to buffer tissue pressures | |
| 457 static float float_pSCR_factor; // pre-computed factor for pSCR ppO2 drop calculation | |
| 458 static float calc_pres_tissue_N2; // auxiliary variable to buffer tissue N2 pressure | |
| 459 static float calc_pres_tissue_He; // auxiliary variable to buffer tissue He pressure | |
| 460 static float pres_tissue; // auxiliary variable to buffer total tissue pressure | |
| 461 static float old_pres_respiration; // auxiliary variable to buffer sim_pres_respiration | |
| 462 | |
| 463 | |
| 464 // Performance Profiling (4 byte) | |
| 465 | |
| 466 static unsigned short profiling_runtime; // performance measurement: runtime of current invocation | |
| 467 static unsigned char profiling_runs; // performance measurement: invocations per deco calculation cycle | |
| 468 static unsigned char profiling_phase; // performance measurement: current calculation phase | |
| 469 | |
| 470 | |
| 471 // 255 byte used, 1 byte left in this bank (4 bytes per float, 2 bytes per short, 1 byte per char) | |
| 472 | |
| 473 | |
| 474 //---- Bank 6 parameters ----------------------------------------------------- | |
| 475 #ifndef UNIX | |
| 476 # pragma udata bank6=0x600 | |
| 477 #endif | |
| 478 | |
| 479 // Timer5 Interface (3 byte) - Attention: keep order and keep at beginning of bank 6, i.e. at address 0x600 ! | |
| 480 | |
| 481 static volatile unsigned short tmr5_value; // timer 5 value buffer MUST be at address 0x600 | |
| 482 static volatile unsigned char tmr5_overflow; // timer 5 overflow flag MUST be at address 0x602 | |
| 483 | |
| 484 | |
| 485 // Modes, Sequencing and Indexing (11 byte) | |
| 486 | |
| 487 static unsigned char main_status; // shadow register for char_O_main_status | |
| 488 static unsigned char deco_status; // shadow register for char_O_deco_status | |
| 489 static unsigned char deco_info; // shadow register for char_O_deco_info | |
| 490 static unsigned char deco_warnings; // shadow register for char_O_deco_warnings | |
| 491 static unsigned char next_planning_phase; // next calculation phase to be executed | |
| 492 static unsigned char tissue_increment; // selector for real/simulated tissues and time increment | |
| 493 static unsigned char sequence_timer; // timer to sequence deco engine tasks | |
| 494 static unsigned char ci; // index to the Buhlmann tables (compartment index) | |
| 495 static unsigned char cns_i; // index to the CNS tables (ppO2 range index) | |
| 496 static unsigned char i; // general purpose loop counter and index | |
| 497 static unsigned char fast; // selects 1 minute or 2 second ascent steps | |
| 498 | |
| 499 | |
| 500 // Result Values from Calculation Functions (28 byte) | |
| 604 | 501 |
| 560 | 502 static float O2_ppO2; // ppO2 - calculated for pure oxygen at current depth |
| 604 | 503 static float OC_ppO2; // ppO2 - calculated for breathing in OC mode |
| 504 static float pSCR_ppO2; // ppO2 - calculated for breathing in pSCR mode | |
| 582 | 505 |
| 506 static float ppO2; // partial pressure of breathed oxygen | |
| 507 static float ppN2; // partial pressure of breathed nitrogen | |
| 508 static float ppHe; // partial pressure of breathed helium | |
| 509 | |
| 510 static unsigned char char_ppO2; // partial pressure of breathed oxygen, as integer 100 = 1.00 bar | |
| 511 static unsigned char NDL_time; // time in minutes until reaching NDL | |
| 623 | 512 static unsigned short ascent_time; // time in minutes needed for the ascent |
| 513 | |
| 514 | |
| 515 // Buhlmann Model Parameters (40 byte) | |
| 560 | 516 |
| 582 | 517 static float var_N2_a; // Buhlmann a, for current N2 tissue |
| 518 static float var_N2_b; // Buhlmann b, for current N2 tissue | |
| 519 static float var_He_a; // Buhlmann a, for current He tissue | |
| 520 static float var_He_b; // Buhlmann b, for current He tissue | |
| 623 | 521 static float var_a; // Buhlmann a, adopted to current N2/He ratio |
| 522 static float var_b; // Buhlmann b, adopted to current N2/He ratio | |
| 582 | 523 static float var_N2_e; // exposition, for current N2 tissue |
| 524 static float var_He_e; // exposition, for current He tissue | |
| 604 | 525 static float var_N2_ht; // half-time, for current N2 tissue |
| 526 static float var_He_ht; // half-time, for current He tissue | |
| 527 | |
| 528 | |
| 623 | 529 // Vault to back-up & restore Tissue related Data (134 byte) |
| 530 | |
| 531 static float vault_pres_tissue_N2[NUM_COMP]; // stores the nitrogen tissue pressures | |
| 532 static float vault_pres_tissue_He[NUM_COMP]; // stores the helium tissue pressures | |
| 533 static float vault_CNS_fraction_real; // stores current CNS (float representation) | |
| 534 static unsigned char vault_deco_warnings; // stores warnings status | |
| 535 static unsigned char vault_deco_info; // stores info status | |
| 536 | |
| 537 | |
| 538 // 7 byte occupied by compiler-placed vars | |
| 539 | |
| 540 | |
| 541 // 223 byte used, 33 byte left in this bank (4 bytes per float, 2 bytes per short, 1 byte per char) | |
| 542 | |
| 543 | |
| 544 | |
| 545 //---- Bank 12 parameters ----------------------------------------------------- | |
| 546 #ifndef UNIX | |
| 547 # pragma udata bank12=0xc00 | |
| 548 #endif | |
| 549 | |
| 550 // stops table (96 byte) | |
| 551 | |
| 552 static unsigned char internal_deco_depth[NUM_STOPS]; // depths of the stops in meters | |
| 553 static unsigned char internal_deco_time[NUM_STOPS]; // durations of the stops in minutes | |
| 554 static unsigned char internal_deco_gas[NUM_STOPS]; // gases used on the stops (0 / 1-5) | |
| 555 | |
| 556 | |
| 557 // 96 byte used, 160 byte left in this bank (4 bytes per float, 2 bytes per short, 1 byte per char) | |
| 560 | 558 |
| 0 | 559 |
| 560 //---- Bank 7 parameters ----------------------------------------------------- | |
| 561 #ifndef UNIX | |
| 562 # pragma udata bank7=0x700 | |
| 563 #endif | |
| 560 | 564 |
| 623 | 565 // Keep order and position of the variables in bank 7 as they are backed-up to & restored from EEPROM |
| 566 | |
| 567 static float real_pres_tissue_N2[NUM_COMP]; // 16 floats = 64 bytes | |
| 568 static float real_pres_tissue_He[NUM_COMP]; // 16 floats = 64 bytes | |
| 569 | |
| 570 static float sim_pres_tissue_N2[NUM_COMP]; // 16 floats = 64 bytes | |
| 571 static float sim_pres_tissue_He[NUM_COMP]; // 16 floats = 64 bytes | |
| 572 | |
| 573 // 256 byte used, bank is full | |
| 582 | 574 |
| 0 | 575 |
| 576 //---- Bank 8 parameters ----------------------------------------------------- | |
| 577 #ifndef UNIX | |
| 578 # pragma udata overlay bank8=0x800 | |
| 560 | 579 |
| 604 | 580 static char md_pi_subst[256]; // overlay C-code data stack here, too |
| 560 | 581 |
| 582 # define C_STACK md_pi_subst | |
| 0 | 583 #endif |
| 584 | |
| 582 | 585 |
| 0 | 586 // Back to bank6 for further tmp data |
| 582 | 587 // Do not delete this assignment, it is needed by the compiler/linker. |
| 0 | 588 #ifndef UNIX |
| 589 # pragma udata bank6 | |
| 590 #endif | |
| 591 | |
| 582 | 592 |
| 604 | 593 // ********************************************************************************************************************************* |
| 594 // | |
| 595 // L O O K - U P T A B L E S | |
| 596 // | |
| 597 // ********************************************************************************************************************************* | |
| 582 | 598 |
| 0 | 599 #ifndef UNIX |
| 623 | 600 # pragma romdata CNS_tables = 0x1DC80 // needs to be in the UPPER bank |
| 601 #endif | |
| 602 | |
| 603 rom const float CNS_ab[2*11] = { | |
| 604 // CNS increment per 2sec = 1 / (a*ppO2 + b) with ppO2 in [cbar] | |
| 605 // a b for ppO2 cbar range | |
| 606 -533.07, 54000, // 51 - 60 (index 0) | |
| 607 -444.22, 48600, // 61 - 70 (index 1) | |
| 608 -355.38, 42300, // 71 - 80 (index 2) | |
| 609 -266.53, 35100, // 81 - 90 (index 3) | |
| 610 -177.69, 27000, // 91 - 100 (index 4) | |
| 611 -177.69, 27000, // 101 - 110 (index 5) | |
| 612 -88.84, 17100, // 111 - 120 (index 6) | |
| 613 -88.84, 17100, // 121 - 130 (index 7) | |
| 614 -88.84, 17100, // 131 - 140 (index 8) | |
| 615 -88.84, 17100, // 141 - 150 (index 9) | |
| 616 -222.11, 37350 // 151 - 160 (index 10) | |
| 617 }; | |
| 618 | |
| 619 rom const unsigned short CNS_c[1*20] = { | |
| 620 // CNS increment per 2sec = c / 100000.0 | |
| 621 // c in [1/100000] for ppO2 cbar range | |
| 622 75, // 161 - 165 (index 0) | |
| 623 102, // 166 - 170 (index 1) | |
| 624 136, // 171 - 175 (index 2) | |
| 625 180, // 176 - 180 (index 3) | |
| 626 237, // 181 - 185 (index 4) | |
| 627 310, // 186 - 190 (index 5) | |
| 628 401, // 191 - 195 (index 6) | |
| 629 517, // 196 - 200 (index 7) | |
| 630 760, // 201 - 205 (index 8) | |
| 631 1100, // 206 - 210 (index 9) | |
| 632 1500, // 211 - 215 (index 10) | |
| 633 2090, // 216 - 220 (index 11) | |
| 634 2900, // 221 - 225 (index 12) | |
| 635 3900, // 226 - 230 (index 13) | |
| 636 4820, // 231 - 235 (index 14) | |
| 637 4820, // 236 - 240 (index 15) | |
| 638 4820, // 241 - 245 (index 16) | |
| 639 4820, // 246 - 250 (index 17) | |
| 640 4820, // 251 - 255 (index 18) | |
| 641 0 // not used, just to fill up the memory block | |
| 642 }; | |
| 643 | |
| 644 | |
| 645 #ifndef UNIX | |
| 604 | 646 # pragma romdata Buhlmann_tables = 0x1DD00 // needs to be in the UPPER bank |
| 0 | 647 #endif |
| 648 | |
| 560 | 649 rom const float Buhlmann_ab[4*16] = { |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
650 // Data ZH-L16C, from Bühlmann Tauchmedizin 2002, option 1a (4mn) |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
651 // a for N2 b for N2 a of He b for He |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
652 1.2599, 0.5050, 1.7424, 0.4245, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
653 1.0000, 0.6514, 1.3830, 0.5747, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
654 0.8618, 0.7222, 1.1919, 0.6527, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
655 0.7562, 0.7825, 1.0458, 0.7223, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
656 0.6200, 0.8126, 0.9220, 0.7582, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
657 0.5043, 0.8434, 0.8205, 0.7957, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
658 0.4410, 0.8693, 0.7305, 0.8279, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
659 0.4000, 0.8910, 0.6502, 0.8553, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
660 0.3750, 0.9092, 0.5950, 0.8757, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
661 0.3500, 0.9222, 0.5545, 0.8903, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
662 0.3295, 0.9319, 0.5333, 0.8997, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
663 0.3065, 0.9403, 0.5189, 0.9073, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
664 0.2835, 0.9477, 0.5181, 0.9122, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
665 0.2610, 0.9544, 0.5176, 0.9171, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
666 0.2480, 0.9602, 0.5172, 0.9217, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
667 0.2327, 0.9653, 0.5119, 0.9267 |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
668 }; |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
669 |
| 560 | 670 rom const float Buhlmann_ht[2*16] = { |
| 671 // Compartment half-life, in minute | |
| 672 //--- N2 ---- He ---------------------- | |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
673 4.0, 1.51, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
674 8.0, 3.02, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
675 12.5, 4.72, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
676 18.5, 6.99, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
677 27.0, 10.21, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
678 38.3, 14.48, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
679 54.3, 20.53, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
680 77.0, 29.11, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
681 109.0, 41.20, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
682 146.0, 55.19, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
683 187.0, 70.69, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
684 239.0, 90.34, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
685 305.0, 115.29, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
686 390.0, 147.42, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
687 498.0, 188.24, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
688 635.0, 240.03 |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
689 }; |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
690 |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
691 rom const float e2secs[2*16] = { |
| 560 | 692 // result of 1 - 2^(-1/(2sec*HT)) |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
693 //---- N2 ------------- He ------------ |
| 623 | 694 5.75958E-03, 1.51848E-02, |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
695 2.88395E-03, 7.62144E-03, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
696 1.84669E-03, 4.88315E-03, |
| 582 | 697 1.24813E-03, 3.29997E-03, |
| 698 8.55371E-04, 2.26041E-03, | |
| 699 6.03079E-04, 1.59437E-03, | |
| 700 4.25414E-04, 1.12479E-03, | |
| 701 3.00019E-04, 7.93395E-04, | |
| 702 2.11949E-04, 5.60641E-04, | |
| 703 1.58240E-04, 4.18555E-04, | |
| 704 1.23548E-04, 3.26795E-04, | |
| 705 9.66686E-05, 2.55722E-04, | |
| 706 7.57509E-05, 2.00387E-04, | |
| 707 5.92416E-05, 1.56716E-04, | |
| 708 4.63943E-05, 1.22734E-04, | |
| 709 3.63850E-05, 9.62538E-05 | |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
710 //------------------------------------- |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
711 }; |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
712 |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
713 rom const float e1min[2*16] = { |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
714 // Integration constant for 1 minute, |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
715 // Ie. 1- 2^(-1/HT) |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
716 //----- N2 --------- e 1min He -------- |
| 582 | 717 1.59104E-01, 3.68109E-01, |
| 718 8.29960E-02, 2.05084E-01, | |
| 719 5.39424E-02, 1.36579E-01, | |
| 720 3.67742E-02, 9.44046E-02, | |
| 721 2.53454E-02, 6.56359E-02, | |
| 722 1.79351E-02, 4.67416E-02, | |
| 723 1.26840E-02, 3.31991E-02, | |
| 724 8.96152E-03, 2.35301E-02, | |
| 725 6.33897E-03, 1.66832E-02, | |
| 726 4.73633E-03, 1.24808E-02, | |
| 727 3.69981E-03, 9.75753E-03, | |
| 728 2.89600E-03, 7.64329E-03, | |
| 729 2.27003E-03, 5.99417E-03, | |
| 730 1.77572E-03, 4.69082E-03, | |
| 731 1.39089E-03, 3.67548E-03, | |
| 732 1.09097E-03, 2.88359E-03 | |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
733 //------------------------------------- |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
734 }; |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
735 |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
736 rom const float e10min[2*16] = { |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
737 // The 10 min Value in float notation: |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
738 // result of 1 - 2^(-10/ht) |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
739 //---- N2 -------------- He ----------- |
| 582 | 740 8.23223E-01, 9.89851E-01, |
| 741 5.79552E-01, 8.99258E-01, | |
| 742 4.25651E-01, 7.69737E-01, | |
| 743 3.12487E-01, 6.29027E-01, | |
| 744 2.26416E-01, 4.92821E-01, | |
| 745 1.65547E-01, 3.80407E-01, | |
| 746 1.19840E-01, 2.86538E-01, | |
| 747 8.60863E-02, 2.11886E-01, | |
| 748 6.16117E-02, 1.54849E-01, | |
| 749 4.63665E-02, 1.18026E-01, | |
| 750 3.63881E-02, 9.34005E-02, | |
| 751 2.85855E-02, 7.38569E-02, | |
| 752 2.24698E-02, 5.83504E-02, | |
| 753 1.76160E-02, 4.59303E-02, | |
| 754 1.38222E-02, 3.61528E-02, | |
| 755 1.08563E-02, 2.84646E-02 | |
|
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
756 //------------------------------------- |
|
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
757 }; |
| 0 | 758 |
| 604 | 759 |
| 760 // ********************************************************************************************************************************* | |
| 0 | 761 // |
| 604 | 762 // H E L P E R F U N C T I O N S |
| 763 // | |
| 764 // ********************************************************************************************************************************* | |
| 765 | |
| 766 | |
| 0 | 767 // moved from 0x0D000 to 0x0C000 in v.108 |
| 768 #ifndef UNIX | |
| 584 | 769 # pragma code p2_deco = 0x0C000 |
| 0 | 770 #endif |
| 771 | |
| 772 | |
| 773 ////////////////////////////////////////////////////////////////////////////// | |
| 774 // Bump to blue-screen when an assert is wrong | |
| 623 | 775 #ifdef _DEBUG |
| 0 | 776 void assert_failed(PARAMETER short int line) |
| 777 { | |
| 778 } | |
| 779 #endif | |
| 780 | |
| 604 | 781 |
| 0 | 782 ////////////////////////////////////////////////////////////////////////////// |
| 783 // When calling C code from ASM context, the data stack pointer and | |
| 623 | 784 // frames should be reset. Bank 8 is used by stack. |
| 0 | 785 |
| 786 #ifdef CROSS_COMPILE | |
| 584 | 787 # define RESET_C_STACK |
| 0 | 788 #else |
| 623 | 789 # ifdef _DEBUG |
| 584 | 790 # define RESET_C_STACK fillDataStack(); |
| 791 void fillDataStack(void) | |
| 792 { | |
| 793 _asm | |
| 604 | 794 LFSR 1,C_STACK |
| 795 MOVLW 0xCC | |
| 796 loop: MOVWF POSTINC1,0 | |
| 797 TSTFSZ FSR1L,0 | |
| 798 BRA loop | |
| 799 | |
| 800 LFSR 1,C_STACK | |
| 801 LFSR 2,C_STACK | |
| 584 | 802 _endasm |
| 803 } | |
| 804 # else | |
| 805 # define RESET_C_STACK \ | |
| 806 _asm \ | |
| 604 | 807 LFSR 1,C_STACK \ |
| 808 LFSR 2,C_STACK \ | |
| 584 | 809 _endasm |
| 810 # endif | |
| 0 | 811 #endif |
| 812 | |
| 604 | 813 |
| 0 | 814 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 815 // Reset timer 5 |
| 816 // | |
| 817 // Note: TMR5 is configured in 16 bit mode: a value written to TMR5H is buffered | |
| 818 // and will be written to TMR5 together with a successive write to TMR5L. | |
| 819 // As we don't know in which bank the code will be executed, we use either | |
| 820 // the bank-save "movff" command, or address mapping via access bank (",0"). | |
| 821 // | |
| 822 static void load_tmr5(void) | |
| 0 | 823 { |
| 824 #ifndef CROSS_COMPILE | |
| 584 | 825 _asm |
| 623 | 826 movff 0x601,0xF7D // bank-safe load TMR5H from C variable tmr5_value first |
| 827 movff 0x600,0xF7C // bank-safe load TMR5L from c variable tmr5_value thereafter | |
| 828 bcf 0xFBA,1,0 // clear timer 5 overrun flag (0xFBA = PIR5, bit 1 = TMR5IF) | |
| 829 _endasm | |
| 0 | 830 #else |
| 623 | 831 return; |
| 832 #endif | |
| 833 } | |
| 834 | |
| 835 | |
| 836 ////////////////////////////////////////////////////////////////////////////// | |
| 837 // Read timer 5 | |
| 838 // | |
| 839 // Note: TMR5 reads in multiples of 1/32 ms, 30.51757813 us/bit to be precise. | |
| 840 // TMR5 is configured in 16 bit mode: on reading of TMR5L the contents of | |
| 841 // TMR5H is latched and can be read afterwards without potential rollover. | |
| 842 // As we don't know in which bank the code will be executed, we use either | |
| 843 // the bank-save "movff" command, or address mapping via access bank (",0"). | |
| 844 // | |
| 845 static void read_tmr5(void) | |
| 846 { | |
| 847 #ifndef CROSS_COMPILE | |
| 848 _asm | |
| 849 movff 0xF7C,0x600 // copy TMR5L to C variable tmr5_value, low byte first | |
| 850 movff 0xF7D,0x601 // copy TMR5H to C variable tmr5_value, high byte thereafter | |
| 851 clrf WREG,0 // clear WREG to 0x00 = no overrun by default | |
| 852 btfsc 0xFBA,1,0 // did timer 5 overrun? (0xFBA = PIR5, bit 1 = TMR5IF) | |
| 853 setf WREG,0 // YES - set WREG to 0xff = overrun detected | |
| 854 movff WREG,0x602 // copy WREG to C variable tmr5_overflow | |
| 855 _endasm | |
| 856 #else | |
| 857 return; | |
| 0 | 858 #endif |
| 859 } | |
| 860 | |
| 604 | 861 |
| 0 | 862 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 863 // Read CNS coefficients a and b |
| 864 // | |
| 865 static void read_CNS_ab_coefficient(void) | |
| 866 { | |
| 867 #ifndef CROSS_COMPILE | |
| 868 // Note: We don't use far ROM pointer, because handling | |
| 869 // 24 bit is to complex, hence we have to set the | |
| 870 // UPPER page ourself... | |
| 871 // -> set to zero if tables are moved to lower pages! | |
| 872 _asm | |
| 873 movlw 1 | |
| 874 movwf TBLPTRU,0 | |
| 875 _endasm | |
| 876 #endif | |
| 877 | |
| 878 { | |
| 879 overlay rom const float* ptr = &CNS_ab[2*cns_i]; | |
| 880 var_cns_a = *ptr++; | |
| 881 var_cns_b = *ptr++; | |
| 882 } | |
| 883 } | |
| 884 | |
| 885 | |
| 886 ////////////////////////////////////////////////////////////////////////////// | |
| 887 // Read CNS coefficient c | |
| 888 // | |
| 889 static void read_CNS_c_coefficient(void) | |
| 890 { | |
| 891 #ifndef CROSS_COMPILE | |
| 892 // Note: We don't use far ROM pointer, because handling | |
| 893 // 24 bit is to complex, hence we have to set the | |
| 894 // UPPER page ourself... | |
| 895 // -> set to zero if tables are moved to lower pages! | |
| 896 _asm | |
| 897 movlw 1 | |
| 898 movwf TBLPTRU,0 | |
| 899 _endasm | |
| 900 #endif | |
| 901 | |
| 902 { | |
| 903 overlay rom const unsigned short* ptr = &CNS_c[cns_i]; | |
| 904 var_cns_c = *ptr++; | |
| 905 } | |
| 906 } | |
| 907 | |
| 908 ////////////////////////////////////////////////////////////////////////////// | |
| 909 // Read Buhlmann coefficients a and b for compartment ci | |
| 0 | 910 // |
| 560 | 911 static void read_Buhlmann_coefficients(void) |
| 0 | 912 { |
| 913 #ifndef CROSS_COMPILE | |
| 604 | 914 // Note: We don't use far ROM pointer, because handling |
| 915 // 24 bit is too complex, hence we have to set the | |
| 916 // UPPER page ourself... | |
| 917 // -> Set to zero if tables are moved to lower pages! | |
| 584 | 918 _asm |
| 604 | 919 movlw 1 |
| 920 movwf TBLPTRU,0 | |
| 584 | 921 _endasm |
| 0 | 922 #endif |
| 923 | |
| 584 | 924 assert( ci < NUM_COMP ); |
| 925 | |
| 604 | 926 // use an interleaved array (AoS) to access coefficients with a single addressing |
| 584 | 927 { |
| 928 overlay rom const float* ptr = &Buhlmann_ab[4*ci]; | |
| 929 var_N2_a = *ptr++; | |
| 930 var_N2_b = *ptr++; | |
| 931 var_He_a = *ptr++; | |
| 932 var_He_b = *ptr++; | |
| 933 } | |
| 0 | 934 } |
| 935 | |
| 604 | 936 |
| 0 | 937 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 938 // Read Buhlmann increments for compartment ci |
| 604 | 939 // If period == 0 : 2 sec interval |
| 940 // 1 : 1 min interval | |
| 941 // 2 : 10 min interval | |
| 560 | 942 static void read_Buhlmann_times(PARAMETER char period) |
| 0 | 943 { |
| 944 #ifndef CROSS_COMPILE | |
| 604 | 945 // Note: We don't use far ROM pointer, because handling |
| 946 // 24 bit is to complex, hence we have to set the | |
| 947 // UPPER page ourself... | |
| 948 // -> set to zero if tables are moved to lower pages! | |
| 584 | 949 _asm |
| 604 | 950 movlw 1 |
| 951 movwf TBLPTRU,0 | |
| 584 | 952 _endasm |
| 0 | 953 #endif |
| 954 | |
| 584 | 955 assert( ci < NUM_COMP ); |
| 956 | |
| 623 | 957 // Integration Intervals |
| 584 | 958 switch(period) |
| 959 { | |
| 960 case 0: //---- 2 sec ----------------------------------------------------- | |
| 961 { | |
| 962 overlay rom const float* ptr = &e2secs[2*ci]; | |
| 963 var_N2_e = *ptr++; | |
| 964 var_He_e = *ptr++; | |
| 965 } | |
| 966 break; | |
| 967 | |
| 968 case 1: //---- 1 min ----------------------------------------------------- | |
| 969 { | |
| 970 overlay rom const float* ptr = &e1min[2*ci]; | |
| 971 var_N2_e = *ptr++; | |
| 972 var_He_e = *ptr++; | |
| 973 } | |
| 974 break; | |
| 975 | |
| 976 case 2: //---- 10 min ---------------------------------------------------- | |
| 977 { | |
| 978 overlay rom const float* ptr = &e10min[2*ci]; | |
| 979 var_N2_e = *ptr++; | |
| 980 var_He_e = *ptr++; | |
| 981 } | |
| 623 | 982 break; |
| 584 | 983 |
| 984 default: | |
| 623 | 985 assert(0); // code execution shall never pass along here! |
| 584 | 986 } |
| 0 | 987 } |
| 988 | |
| 604 | 989 |
| 0 | 990 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 991 // Read Buhlmann half-times for compartment ci |
| 0 | 992 // |
| 560 | 993 static void read_Buhlmann_ht(void) |
| 0 | 994 { |
| 995 | |
| 996 #ifndef CROSS_COMPILE | |
| 604 | 997 // Note: We don't use far ROM pointer, because handling |
| 998 // 24 bit is to complex, hence we have to set the | |
| 999 // UPPER page ourself... | |
| 1000 // -> Set to zero if tables are moved to lower pages! | |
| 584 | 1001 _asm |
| 604 | 1002 movlw 1 |
| 1003 movwf TBLPTRU,0 | |
| 584 | 1004 _endasm |
| 0 | 1005 #endif |
| 1006 | |
| 584 | 1007 assert( ci < NUM_COMP ); |
| 1008 { | |
| 1009 overlay rom const float* ptr = &Buhlmann_ht[2*ci]; | |
| 1010 var_N2_ht = *ptr++; | |
| 1011 var_He_ht = *ptr++; | |
| 1012 } | |
| 1013 | |
| 604 | 1014 assert( 4.0 <= var_N2_ht && var_N2_ht <= 635.0 ); |
| 584 | 1015 assert( 1.5099 <= var_He_ht && var_He_ht <= 240.03 ); |
| 0 | 1016 } |
| 1017 | |
| 604 | 1018 |
| 0 | 1019 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 1020 // Calculate adopted Buhlmann coefficients |
| 1021 // | |
| 1022 // Input: var_N2_a, var_N2_b coefficients for N2 | |
| 1023 // var_He_a, var_He_b coefficients for He | |
| 1024 // calc_pres_tissue_N2 partial pressure of N2 in tissue | |
| 1025 // calc_pres_tissue_He partial pressure of He in tissue | |
| 1026 // pres_tissue total pressure in tissue | |
| 1027 // | |
| 1028 // Output: var_a, var_b coefficients adopted by N2/He ratio | |
| 604 | 1029 // |
| 1030 static void adopt_Buhlmann_coefficients(void) | |
| 1031 { | |
| 1032 // adopt a and b coefficients to current N2/He ratio inside the tissue | |
| 623 | 1033 |
| 1034 #ifdef _helium | |
| 1035 | |
| 1036 var_a = (var_N2_a * calc_pres_tissue_N2 + var_He_a * calc_pres_tissue_He) / pres_tissue; | |
| 1037 var_b = (var_N2_b * calc_pres_tissue_N2 + var_He_b * calc_pres_tissue_He) / pres_tissue; | |
| 1038 | |
| 1039 #else | |
| 1040 | |
| 1041 var_a = var_N2_a; | |
| 1042 var_b = var_N2_b; | |
| 1043 | |
| 1044 #endif | |
| 1045 | |
| 1046 } | |
| 1047 | |
| 1048 | |
| 1049 ////////////////////////////////////////////////////////////////////////////// | |
| 1050 // Calculate partial pressure of N2 in respired air at surface pressure | |
| 1051 // | |
| 1052 // Input: pres_surface surface pressure | |
| 1053 // | |
| 1054 // Output: N2_equilibrium partial pressure of N2 in surface air | |
| 1055 // | |
| 1056 static void calc_N2_equilibrium(void) | |
| 1057 { | |
| 1058 N2_equilibrium = 0.7902 * (pres_surface - ppWater); | |
| 1059 } | |
| 1060 | |
| 1061 | |
| 1062 ////////////////////////////////////////////////////////////////////////////// | |
| 1063 // Get, safeguard and convert the saturation and desaturation factors | |
| 1064 // | |
| 1065 // Input: char_I_saturation_multiplier saturation factor (integer) | |
| 1066 // char_I_desaturation_multiplier desaturation factor (integer) | |
| 1067 // | |
| 1068 // Output: float_saturation_multiplier saturation factor (float) | |
| 1069 // float_desaturation_multiplier desaturation factor (float) | |
| 1070 // | |
| 1071 static void get_saturation_factors(void) | |
| 1072 { | |
| 1073 // safeguard input parameters that are constant during the course of the dive | |
| 1074 if( char_I_saturation_multiplier < 100 ) char_I_saturation_multiplier = 100; | |
| 1075 if( char_I_saturation_multiplier > 140 ) char_I_saturation_multiplier = 140; | |
| 1076 | |
| 1077 if( char_I_desaturation_multiplier < 60 ) char_I_desaturation_multiplier = 60; | |
| 1078 if( char_I_desaturation_multiplier > 100 ) char_I_desaturation_multiplier = 100; | |
| 1079 | |
| 1080 // convert input parameters to float numbers | |
| 1081 float_saturation_multiplier = 0.01 * char_I_saturation_multiplier; | |
| 1082 float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier; | |
| 1083 } | |
| 1084 | |
| 1085 | |
| 1086 ////////////////////////////////////////////////////////////////////////////// | |
| 1087 // apply_saturation_factors | |
| 1088 // | |
| 1089 // Apply safety factors for both ZH-L16 models. | |
| 1090 // | |
| 1091 // Modified: temp_tissue safeguarded tissue increment/decrement | |
| 1092 // | |
| 1093 static void apply_saturation_factors(void) | |
| 1094 { | |
| 1095 assert( 0.0 < float_desaturation_multiplier && float_desaturation_multiplier <= 1.0 ); | |
| 1096 assert( 1.0 <= float_saturation_multiplier && float_saturation_multiplier <= 2.0 ); | |
| 1097 | |
| 1098 if ( temp_tissue < 0.0 ) temp_tissue *= float_desaturation_multiplier; | |
| 1099 else temp_tissue *= float_saturation_multiplier; | |
| 1100 } | |
| 1101 | |
| 1102 | |
| 1103 ////////////////////////////////////////////////////////////////////////////// | |
| 1104 // convert_float_to_int | |
| 1105 // | |
| 1106 // Converts a float within range 0.0 - 9.99 into 16 bit integer scaled in 1/100. | |
| 1107 // | |
| 1108 static void convert_float_to_int(void) | |
| 1109 { | |
| 1110 if ( float_value < 0.005 ) int_value = 0; | |
| 1111 else if ( float_value >= 9.985 ) int_value = 999; | |
| 1112 else int_value = (unsigned short)(100 * float_value + 0.5); | |
| 1113 } | |
| 1114 | |
| 1115 | |
| 1116 ////////////////////////////////////////////////////////////////////////////// | |
| 1117 // convert_float_to_char | |
| 1118 // | |
| 1119 // Converts a float within range 0.0 - 255 into 8 bit integer | |
| 1120 // | |
| 1121 static void convert_float_to_char(void) | |
| 1122 { | |
| 1123 if (float_value < 0.0) char_value = 0; | |
| 1124 else if (float_value >= 254.5) char_value = 255; | |
| 1125 else char_value = (unsigned char)(float_value + 0.5); | |
| 604 | 1126 } |
| 1127 | |
| 1128 | |
| 1129 // ********************************************************************************************************************************* | |
| 1130 // | |
| 1131 // J U M P I N F U N C T I O N S | |
| 1132 // | |
| 1133 // ********************************************************************************************************************************* | |
| 1134 | |
| 582 | 1135 |
| 1136 ////////////////////////////////////////////////////////////////////////////// | |
| 1137 // deco_calc_hauptroutine | |
| 1138 // | |
| 1139 // called from: divemode.asm | |
| 1140 // | |
| 1141 // Called every second during diving, | |
| 1142 // updates tissues on every second invocation. | |
| 1143 // | |
| 1144 // Every few seconds (or slower when TTS > 16): | |
| 1145 // - Updates deco table (char_O_deco_time/depth) with new values, | |
| 1146 // - updates ascent time, and | |
| 1147 // - sets status to zero (so we can check there is new results). | |
| 1148 // | |
| 1149 void deco_calc_hauptroutine(void) | |
| 1150 { | |
| 1151 RESET_C_STACK | |
| 1152 calc_hauptroutine(); | |
| 1153 } | |
| 1154 | |
| 623 | 1155 |
| 1156 ////////////////////////////////////////////////////////////////////////////// | |
| 1157 // deco_init_output_vars | |
| 1158 // | |
| 1159 // called from divemode.asm | |
| 1160 // | |
| 1161 // Initializes all output variables to their default values. | |
| 1162 // | |
| 1163 void deco_init_output_vars(void) | |
| 1164 { | |
| 1165 RESET_C_STACK | |
| 1166 init_output_vars(); | |
| 1167 } | |
| 1168 | |
| 582 | 1169 ////////////////////////////////////////////////////////////////////////////// |
| 1170 // deco_clear_tissue | |
| 1171 // | |
| 1172 // called from: start.asm | |
| 1173 // menu_tree.asm | |
| 1174 // simulator.asm | |
| 1175 // | |
| 1176 // Sets all tissues to equilibrium with Air at ambient pressure, | |
| 1177 // resets all CNS values, any warnings and resets all model output. | |
| 1178 // | |
| 1179 void deco_clear_tissue(void) | |
| 1180 { | |
| 1181 RESET_C_STACK | |
| 1182 clear_tissue(); | |
| 1183 } | |
| 1184 | |
| 623 | 1185 |
| 582 | 1186 ////////////////////////////////////////////////////////////////////////////// |
| 1187 // deco_calc_dive_interval | |
| 1188 // | |
| 1189 // called from: simulator.asm | |
| 1190 // | |
| 604 | 1191 // Updates tissues and CNS value for char_I_dive_interval minutes on air |
| 582 | 1192 // at ambient pressure and calculates resulting GF factor and ceiling for |
| 1193 // a GF-high of 100% (ceiling and GF factor not used by simulator.asm) | |
| 1194 // | |
| 1195 void deco_calc_dive_interval(void) | |
| 1196 { | |
| 1197 RESET_C_STACK | |
| 1198 calc_interval(char_I_dive_interval); | |
| 1199 } | |
| 1200 | |
| 623 | 1201 |
| 582 | 1202 ////////////////////////////////////////////////////////////////////////////// |
| 1203 // deco_calc_dive_interval_1min | |
| 1204 // | |
| 1205 // called from: start.asm | |
| 1206 // sleepmode.asm | |
| 1207 // surfmode.asm | |
| 1208 // menu_tree.asm | |
| 1209 // ghostwriter.asm | |
| 1210 // | |
| 604 | 1211 // Updates tissues and CNS value for 1 minute on air at ambient pressure and |
| 582 | 1212 // calculates resulting GF factor and ceiling for a GF-high of 100% (ceiling |
| 1213 // is not used by *.asm files). | |
| 1214 // | |
| 1215 void deco_calc_dive_interval_1min(void) | |
| 1216 { | |
| 1217 RESET_C_STACK | |
| 1218 calc_interval(1); | |
| 1219 } | |
| 1220 | |
| 1221 | |
| 1222 ////////////////////////////////////////////////////////////////////////////// | |
| 604 | 1223 // deco_calc_dive_interval_10min |
| 582 | 1224 // |
| 1225 // called from: sleepmode.asm | |
| 1226 // | |
| 604 | 1227 // Updates tissues and CNS value for 10 minutes on air at ambient pressure and |
| 582 | 1228 // calculates resulting GF factor and ceiling for a GF-high of 100% (ceiling |
| 1229 // is not used by sleepmode.asm). | |
| 1230 // | |
| 1231 void deco_calc_dive_interval_10min(void) | |
| 1232 { | |
| 1233 RESET_C_STACK | |
| 1234 calc_interval(10); | |
| 1235 } | |
| 1236 | |
| 1237 | |
| 1238 ////////////////////////////////////////////////////////////////////////////// | |
| 1239 // deco_calc_desaturation_time | |
| 1240 // | |
| 1241 // called from: start.asm | |
| 1242 // surfmode.asm | |
| 1243 // menu_tree.asm | |
| 1244 // ghostwriter.asm | |
| 1245 // | |
| 1246 // Computes desaturation and no-fly times. | |
| 1247 // | |
| 1248 void deco_calc_desaturation_time(void) | |
| 1249 { | |
| 1250 RESET_C_STACK | |
| 1251 calc_desaturation_time(); | |
| 1252 } | |
| 1253 | |
| 623 | 1254 |
| 582 | 1255 ////////////////////////////////////////////////////////////////////////////// |
| 1256 // deco_push_tissues_to_vault | |
| 1257 // | |
| 1258 // called from: simulator.asm | |
| 1259 // | |
| 1260 // Makes a backup of the state of the real tissues and the deco engine. | |
| 1261 // | |
| 1262 void deco_push_tissues_to_vault(void) | |
| 1263 { | |
| 1264 RESET_C_STACK | |
| 1265 push_tissues_to_vault(); | |
| 1266 } | |
| 1267 | |
| 623 | 1268 |
| 582 | 1269 ////////////////////////////////////////////////////////////////////////////// |
| 1270 // deco_pull_tissues_from_vault | |
| 1271 // | |
| 1272 // called from: simulator.asm | |
| 1273 // ghostwriter.asm | |
| 1274 // | |
| 1275 // Restores the state of the real tissues and the deco engine from the backup. | |
| 1276 // | |
| 1277 void deco_pull_tissues_from_vault(void) | |
| 1278 { | |
| 1279 RESET_C_STACK | |
| 1280 pull_tissues_from_vault(); | |
| 1281 } | |
| 1282 | |
| 604 | 1283 |
| 1284 // ********************************************************************************************************************************* | |
| 1285 // | |
| 1286 // M A I N F U N C T I O N S | |
| 1287 // | |
| 1288 // ********************************************************************************************************************************* | |
| 582 | 1289 |
| 1290 | |
| 1291 ////////////////////////////////////////////////////////////////////////////// | |
| 623 | 1292 // find_next_stop |
| 0 | 1293 // |
| 1294 // INPUT, fixed during dive: | |
| 623 | 1295 // pres_surface : surface pressure (as absolute pressure) |
| 1296 // char_I_depth_last_deco : depth of the last deco stop | |
| 1297 // | |
| 1298 // INPUT, changing during dive: | |
| 1299 // float_depth_real : current real depth in meters (float) | |
| 1300 // char_depth_real : current real depth in meters (integer) | |
| 1301 // GF_high : GF high factor | |
| 1302 // GF_low : GF low factor | |
| 1303 // | |
| 1304 // INPUT & OUTPUT | |
| 1305 // char_depth_sim : simulated depth in meters | |
| 1306 // GF_low_depth : GF low depth in current calculation cycle | |
| 1307 // GF_slope : GF slope in current calculation cycle | |
| 1308 // GF_low_depth_norm/_alt : frozen GF low depth reference | |
| 1309 // GF_slope_norm/_alt : frozen GF slope | |
| 0 | 1310 // |
| 1311 // OUTPUT | |
| 623 | 1312 // char_depth_last : depth we came from |
| 1313 // sim_pres_respiration : simulated depth in absolute pressure | |
| 1314 // | |
| 1315 // RETURN | |
| 1316 // TRUE: a stop is needed, FALSE: no stop needed | |
| 1317 // | |
| 1318 static unsigned char find_next_stop(void) | |
| 0 | 1319 { |
| 623 | 1320 overlay unsigned char depth_1min; |
| 1321 overlay unsigned char depth_limit; | |
| 1322 overlay unsigned char first_stop; | |
| 582 | 1323 overlay unsigned char need_stop; |
| 1324 | |
| 623 | 1325 |
| 1326 // ----------------------------------------------------------------------- | |
| 1327 // we start with the assumption that a stop is not required | |
| 1328 // ----------------------------------------------------------------------- | |
| 1329 | |
| 1330 need_stop = 0; | |
| 1331 | |
| 1332 // remember the depth we came from | |
| 1333 char_depth_last = char_depth_sim; | |
| 1334 | |
| 1335 // calculate the limit for the current depth | |
| 1336 if( char_I_deco_model == 0 ) calc_limit(1.0); // straight Buhlmann | |
| 1337 else if( char_depth_sim >= GF_low_depth ) calc_limit(GF_low); // with GF, below low depth reference | |
| 1338 else calc_limit(GF_high - GF_slope * (float)char_depth_sim); // with GF, above low depth reference | |
| 1339 | |
| 1340 // check if we can surface directly | |
| 1341 if( ceiling <= 0.0 ) | |
| 582 | 1342 { |
| 623 | 1343 // YES - ascent to surface is allowed |
| 1344 char_depth_sim = 0; | |
| 1345 | |
| 1346 // - done | |
| 1347 goto done; | |
| 1348 } | |
| 1349 | |
| 1350 // ----------------------------------------------------------------------- | |
| 1351 // a stop is required, but maybe not yet within the running minute | |
| 1352 // ----------------------------------------------------------------------- | |
| 1353 | |
| 1354 // convert the depth we can ascent to from relative pressure to meters, | |
| 1355 // rounded up (i.e. made deeper) to next full meter. | |
| 1356 depth_limit = (unsigned char)(ceiling * BAR_TO_METER + 0.99); | |
| 1357 | |
| 1358 // calculate the stop depth, i.e. round up to the next multiple of 3 meters | |
| 1359 // using integer arithmetics | |
| 1360 first_stop = 3 * ( (depth_limit + 2) / 3 ); | |
| 1361 | |
| 1362 // apply correction for the shallowest stop | |
| 1363 if( first_stop == 3 ) first_stop = char_I_depth_last_deco; | |
| 1364 | |
| 1365 // compute depth in meters that will be reached in 1 minute of ascent | |
| 1366 // at a speed of char_I_ascent_speed (5..10 m/min) | |
| 1367 if( char_depth_sim > char_I_ascent_speed ) | |
| 1368 { | |
| 1369 depth_1min = char_depth_sim - char_I_ascent_speed; | |
| 1370 } | |
| 1371 else | |
| 1372 { | |
| 1373 depth_1min = 0; | |
| 1374 } | |
| 1375 | |
| 1376 // is the stop shallower than the depth that can be reached within 1 minute? | |
| 1377 if( depth_1min > first_stop ) | |
| 1378 { | |
| 1379 // YES - report the depth that will be reached within 1 minute of ascent | |
| 1380 char_depth_sim = depth_1min; | |
| 1381 | |
| 1382 // - done | |
| 1383 goto done; | |
| 1384 } | |
| 1385 | |
| 1386 // ----------------------------------------------------------------------- | |
| 1387 // we need to make a stop now | |
| 1388 // ----------------------------------------------------------------------- | |
| 1389 | |
| 1390 // set stop data | |
| 1391 need_stop = 1; | |
| 1392 char_depth_sim = first_stop; | |
| 1393 | |
| 1394 // done so far if using straight Buhlmann | |
| 1395 if( char_I_deco_model == 0 ) goto done; | |
| 1396 | |
| 1397 // ----------------------------------------------------------------------- | |
| 1398 // we need to make a stop now and we are using the GF extension | |
| 1399 // ----------------------------------------------------------------------- | |
| 1400 | |
| 1401 // is the depth limit deeper than the GF low depth reference used up to now? | |
| 1402 if( depth_limit > GF_low_depth ) | |
| 1403 { | |
| 1404 // YES - update the reference | |
| 1405 GF_low_depth = depth_limit; | |
| 1406 GF_slope = (GF_high - GF_low) / (float)GF_low_depth; | |
| 1407 | |
| 1408 // store for use in next cycles | |
| 1409 if( deco_status & CALC_NORM ) | |
| 560 | 1410 { |
| 623 | 1411 GF_low_depth_norm = GF_low_depth; |
| 1412 GF_slope_norm = GF_slope; | |
| 582 | 1413 } |
| 560 | 1414 else |
| 1415 { | |
| 623 | 1416 GF_low_depth_alt = GF_low_depth; |
| 1417 GF_slope_alt = GF_slope; | |
| 560 | 1418 } |
| 623 | 1419 } |
| 1420 | |
| 1421 // keep the stop as it is when it is the first stop | |
| 1422 // (i.e. there are no stops in the stops table yet) | |
| 1423 if( internal_deco_depth[0] == 0 ) goto done; | |
| 1424 | |
| 1425 // keep the stop as it is when extended stops are activated | |
| 1426 if( main_status & EXTENDED_STOPS ) goto done; | |
| 1427 | |
| 1428 // We have a (first) stop. But with a steep GF slope, the stop(s) after this | |
| 1429 // first stop may be allowed to ascent to, too. This is because the gradient | |
| 1430 // factor that will be used at the next depth(s) will allow more tissue super- | |
| 1431 // saturation, maybe so much more that the next stop(s) will be allowed to | |
| 1432 // ascent to. So we have to probe the next stops that are within the reach of | |
| 1433 // 1 minute of ascent as well. | |
| 1434 | |
| 1435 // no need to probe for a stop that is beyond 1 minute of ascent | |
| 1436 while( first_stop >= (depth_1min + 3) ) | |
| 1437 { | |
| 1438 overlay unsigned char next_stop; | |
| 1439 | |
| 1440 // compute the depth of the next stop | |
| 1441 if ( first_stop <= char_I_depth_last_deco ) next_stop = 0; | |
| 1442 else if ( first_stop == 6 ) next_stop = char_I_depth_last_deco; | |
| 1443 else next_stop = first_stop - 3; | |
| 1444 | |
| 1445 // compute the depth limit at the next stop depth | |
| 1446 calc_limit(GF_high - GF_slope * (float)next_stop); | |
| 1447 | |
| 1448 // check if ascent to the next stop is allowed | |
| 1449 if( next_stop < (unsigned char)(ceiling * BAR_TO_METER + 0.99) ) | |
| 582 | 1450 { |
| 623 | 1451 // NO - the next stop would be too shallow |
| 1452 break; | |
| 582 | 1453 } |
| 1454 else | |
| 560 | 1455 { |
| 623 | 1456 // YES - the next stop is allowed |
| 1457 char_depth_sim = next_stop; | |
| 1458 | |
| 1459 // - ascent to next stop | |
| 1460 first_stop = next_stop; | |
| 1461 | |
| 1462 // - loop to probe the stop following next | |
| 1463 continue; | |
| 560 | 1464 } |
| 582 | 1465 } |
| 1466 | |
| 623 | 1467 |
| 1468 // ----------------------------------------------------------------------- | |
| 1469 // common end for straight Buhlmann and Buhlmann with GF extension | |
| 1470 // ----------------------------------------------------------------------- | |
| 1471 | |
| 1472 done: | |
| 1473 | |
| 1474 // calculate absolute pressure at the depth found | |
| 1475 sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface; | |
| 0 | 1476 |
| 582 | 1477 return need_stop; |
| 0 | 1478 } |
| 1479 | |
| 604 | 1480 |
| 0 | 1481 ////////////////////////////////////////////////////////////////////////////// |
| 582 | 1482 // publish_deco_table |
| 0 | 1483 // |
| 623 | 1484 // Input: internal_deco_depth[] depth in internal stops table |
| 1485 // internal_deco_time[] times ... | |
| 1486 // internal_deco_gas[] gases ... | |
| 1487 // | |
| 1488 // Output: char_O_deco_depth[] depth in the external stops table | |
| 1489 // char_O_deco_time[] times ... | |
| 1490 // char_O_deco_gas[] gases ... | |
| 1491 // char_O_deco_time_for_log times in reverse order | |
| 0 | 1492 // |
| 582 | 1493 static void publish_deco_table(void) |
| 0 | 1494 { |
| 623 | 1495 overlay unsigned char x = 0; |
| 1496 overlay unsigned char y; | |
| 1497 | |
| 1498 | |
| 1499 // copy all entries from internal to external stops table | |
| 1500 for( y = 0; y < NUM_STOPS; y++ ) | |
| 582 | 1501 { |
| 623 | 1502 // remember index of last entry with a non-null depth |
| 1503 if( internal_deco_depth[y] > 0 ) x = y; | |
| 1504 | |
| 1505 // copy depth, time and gas | |
| 1506 char_O_deco_depth[y] = internal_deco_depth[y]; | |
| 1507 char_O_deco_time [y] = internal_deco_time [y]; | |
| 1508 char_O_deco_gas [y] = internal_deco_gas [y]; | |
| 582 | 1509 } |
| 1510 | |
| 623 | 1511 |
| 1512 // copy times of shallowest stops to logging table | |
| 1513 for( y = 0; y < NUM_STOPS_LOG; y++, --x ) | |
| 582 | 1514 { |
| 1515 char_O_deco_time_for_log[y] = internal_deco_time [x]; | |
| 1516 | |
| 623 | 1517 // stop when all entries are copied |
| 582 | 1518 if( x == 0 ) break; |
| 1519 } | |
| 1520 | |
| 623 | 1521 // fill the remainder of the logging table with null |
| 1522 // if it is not completely filled already | |
| 1523 for( y++; y < NUM_STOPS_LOG; y++ ) | |
| 582 | 1524 char_O_deco_time_for_log[y] = 0; |
| 0 | 1525 } |
| 1526 | |
| 604 | 1527 |
| 0 | 1528 ////////////////////////////////////////////////////////////////////////////// |
| 560 | 1529 // Find current gas in the list (if any) and get its change depth |
| 1530 // | |
| 623 | 1531 // Input: char_I_current_gas_num number of current gas (1..5 or 6) |
| 1532 // | |
| 1533 // Output: sim_gas_current_num 1..6 or 0 for the manually configured gas/dil | |
| 1534 // sim_gas_current_depth change depth (MOD) of the gas/dil in meters | |
| 560 | 1535 // |
| 1536 static void gas_find_current(void) | |
| 1537 { | |
| 623 | 1538 assert( 1 <= char_I_current_gas_num && char_I_current_gas_num <= 6 ); |
| 1539 | |
| 1540 if( char_I_current_gas_num <= NUM_GAS ) // gas/diluent 1-5 | |
| 582 | 1541 { |
| 623 | 1542 sim_gas_current_num = char_I_current_gas_num; |
| 1543 sim_gas_current_depth = char_I_deco_gas_change[sim_gas_current_num-1]; | |
| 582 | 1544 } |
| 1545 else | |
| 560 | 1546 { |
| 623 | 1547 sim_gas_current_num = 0; |
| 604 | 1548 sim_gas_current_depth = char_I_gas6_depth; |
| 560 | 1549 } |
| 1550 } | |
| 1551 | |
| 1552 | |
| 1553 ////////////////////////////////////////////////////////////////////////////// | |
| 604 | 1554 // Find the deco gas with the shallowest change depth below or at the current depth |
| 560 | 1555 // |
| 623 | 1556 // Input: char_depth_sim simulated depth in meters |
| 1557 // sim_gas_current_num number of the currently used gas/dil | |
| 1558 // sim_gas_current_depth change depth of the currently used gas/dil | |
| 1559 // char_I_deco_gas_type[] types of the gases/dils | |
| 1560 // char_I_deco_gas_change[] change depths of the gases/dils | |
| 1561 // | |
| 1562 // Modified: sim_gas_current_num index of the gas (1..5) - only if return value is true | |
| 1563 // sim_gas_current_depth switch depth - only if return value is true | |
| 1564 // | |
| 1565 // Return value is TRUE if a better gas is available | |
| 560 | 1566 // |
| 1567 static unsigned char gas_find_better(void) | |
| 1568 { | |
| 1569 overlay unsigned char switch_depth = 255; | |
| 604 | 1570 overlay unsigned char switch_gas = 0; |
| 560 | 1571 overlay unsigned char j; |
| 582 | 1572 |
| 623 | 1573 // // no automatic gas changes in CCR mode |
| 1574 // if( (deco_status & MODE_MASK) == MODE_CCR ) return 0; | |
| 604 | 1575 |
| 1576 // loop over all deco gases to find the shallowest one below or at current depth | |
| 1577 for( j = 0; j < NUM_GAS; ++j ) | |
| 560 | 1578 { |
| 604 | 1579 // Is this gas not the one we are already breathing? |
| 623 | 1580 if( j+1 != sim_gas_current_num ) |
| 1581 | |
| 1582 // Is this gas available? | |
| 1583 if( char_I_deco_gas_type[j] > 0 ) | |
| 604 | 1584 |
| 1585 // Is the change depth of the this gas deeper than or | |
| 1586 // at least equal to the current depth? | |
| 623 | 1587 if( char_I_deco_gas_change[j] >= char_depth_sim ) |
| 604 | 1588 |
| 1589 // Is the change depth of this gas shallower than the | |
| 1590 // change depth of the gas we are currently on? | |
| 1591 if( char_I_deco_gas_change[j] < sim_gas_current_depth ) | |
| 1592 | |
| 1593 // Is the change depth of this gas shallower than the change | |
| 1594 // depth of the best gas found so far, or is it the first | |
| 1595 // better gas found? | |
| 587 | 1596 if( char_I_deco_gas_change[j] < switch_depth ) |
| 604 | 1597 |
| 1598 // If there is a yes to all these questions, we have a better gas! | |
| 560 | 1599 { |
| 1600 switch_gas = j+1; // remember this gas (1..5) | |
| 1601 switch_depth = char_I_deco_gas_change[j]; // remember its change depth | |
| 1602 } | |
| 604 | 1603 |
| 560 | 1604 } // continue looping through all gases to eventually find an even better gas |
| 1605 | |
| 1606 // has a better gas been found? | |
| 1607 if( switch_gas ) | |
| 1608 { | |
| 604 | 1609 // YES - set the better gas as the new gas |
| 623 | 1610 sim_gas_current_num = switch_gas; |
| 604 | 1611 |
| 1612 // set its change depth as the last used change depth | |
| 1613 sim_gas_current_depth = switch_depth; | |
| 1614 | |
| 1615 assert( sim_gas_current_depth < switch_depth ); | |
| 1616 | |
| 1617 // signal a better gas was found | |
| 1618 return 1; | |
| 560 | 1619 } |
| 1620 else | |
| 1621 { | |
| 604 | 1622 // NO - signal no better gas was found |
| 1623 return 0; | |
| 560 | 1624 } |
| 0 | 1625 } |
| 1626 | |
| 604 | 1627 |
| 0 | 1628 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 1629 // Set calc_N2/He/O2_ratios by sim_gas_current_num |
| 1630 // | |
| 1631 // Input: sim_gas_current_num index of gas to use | |
| 1632 // real_O2_ratio, real_He_ratio if gas = 0 (the manually set gas) | |
| 1633 // char_I_deco_O2/He_ratio[] if gas = 1..5 (the configured gases) | |
| 1634 // | |
| 1635 // Output: sim_N2_ratio, sim_He_ratio ratios of the inert gases | |
| 1636 // sim_pSCR_drop ppO2 drop in pSCR loop | |
| 0 | 1637 // |
| 582 | 1638 static void gas_set_ratios(void) |
| 0 | 1639 { |
| 582 | 1640 overlay float sim_IG_ratio; |
| 1641 | |
| 623 | 1642 assert( 0 <= sim_gas_current_num <= NUM_GAS ); |
| 1643 | |
| 1644 | |
| 1645 #ifdef _helium | |
| 582 | 1646 // get gas ratios |
| 623 | 1647 if( sim_gas_current_num == 0 ) |
| 560 | 1648 { |
| 604 | 1649 sim_O2_ratio = real_O2_ratio; |
| 1650 sim_He_ratio = real_He_ratio; | |
| 560 | 1651 } |
| 1652 else | |
| 1653 { | |
| 623 | 1654 sim_O2_ratio = 0.01 * char_I_deco_O2_ratio[sim_gas_current_num-1]; |
| 1655 sim_He_ratio = 0.01 * char_I_deco_He_ratio[sim_gas_current_num-1]; | |
| 560 | 1656 } |
| 1657 | |
| 582 | 1658 // inert gas ratio (local helper variable) |
| 604 | 1659 sim_IG_ratio = 1.00 - sim_O2_ratio; |
| 582 | 1660 |
| 1661 // N2 ratio | |
| 604 | 1662 sim_N2_ratio = sim_IG_ratio - sim_He_ratio; |
| 623 | 1663 #else |
| 1664 // get O2 ratio | |
| 1665 sim_O2_ratio = ( sim_gas_current_num == 0 ) ? real_O2_ratio : 0.01 * char_I_deco_O2_ratio[sim_gas_current_num-1]; | |
| 1666 | |
| 1667 // set H2 ratio to zero | |
| 1668 sim_He_ratio = 0.0; | |
| 1669 | |
| 1670 // inert gas ratio (local helper variable) | |
| 1671 sim_IG_ratio = 1.00 - sim_O2_ratio; | |
| 1672 | |
| 1673 // N2 ratio | |
| 1674 sim_N2_ratio = sim_IG_ratio; | |
| 1675 #endif | |
| 1676 | |
| 1677 #ifdef _ccr_pscr | |
| 582 | 1678 // ppO2 drop in pSCR loop |
| 604 | 1679 sim_pSCR_drop = sim_IG_ratio * float_pSCR_factor; |
| 623 | 1680 #endif |
| 582 | 1681 |
| 1682 | |
| 1683 assert( 0.0 <= sim_N2_ratio && sim_N2_ratio <= 0.95 ); | |
| 1684 assert( 0.0 <= sim_He_ratio && sim_He_ratio <= 0.95 ); | |
| 1685 assert( (sim_N2_ratio + sim_He_ratio) <= 0.95 ); | |
| 0 | 1686 } |
| 1687 | |
| 604 | 1688 |
| 0 | 1689 ////////////////////////////////////////////////////////////////////////////// |
| 604 | 1690 // Compute respired ppO2, ppN2 and ppHe |
| 0 | 1691 // |
| 604 | 1692 // Input: tissue_increment : selector for targeting simulated or real tissues |
| 623 | 1693 // main_status : breathing mode for real tissues |
| 1694 // deco_status : breathing mode for simulated tissues | |
| 604 | 1695 // sim_/real_O2_ratio : (simulated) O2 ratio breathed |
| 1696 // sim_/real_N2_ratio : (simulated) N2 ratio breathed | |
| 1697 // sim_/real_He_ratio : (simulated) He ratio breathed | |
| 1698 // sim_/real_pres_respiration : (simulated) respiration pressure [bar] | |
| 1699 // sim_/real_pSCR_drop : (simulated) pSCR O2 drop | |
| 1700 // pres_surface : surface pressure [bar] | |
| 1701 // char_I_const_ppO2 : ppO2 reported from sensors or setpoint [cbar] | |
| 1702 // float_deco_distance : safety factor, additional depth below stop depth [bar] | |
| 1703 // ppWater : water-vapor pressure inside respiratory tract [bar] | |
| 0 | 1704 // |
| 604 | 1705 // Output: ppN2 : respired N2 partial pressure |
| 1706 // ppHe : respired He partial pressure | |
| 623 | 1707 // char_ppO2 : breathed ppO2 in %, used for CNS calculation |
| 0 | 1708 // |
| 582 | 1709 void calc_alveolar_pressures(void) |
| 0 | 1710 { |
| 604 | 1711 overlay float calc_pres_respiration; |
| 582 | 1712 overlay float calc_O2_ratio; |
| 1713 overlay float calc_N2_ratio; | |
| 623 | 1714 |
| 1715 #ifdef _helium | |
| 582 | 1716 overlay float calc_He_ratio; |
| 623 | 1717 #endif |
| 1718 | |
| 1719 #ifdef _ccr_pscr | |
| 582 | 1720 overlay float calc_pSCR_drop; |
| 623 | 1721 #endif |
| 582 | 1722 |
| 1723 overlay unsigned char status; | |
| 1724 | |
| 1725 | |
| 623 | 1726 assert( 0.00 <= real_N2_ratio && real_N2_ratio <= 1.00 ); |
| 1727 assert( 0.00 <= real_He_ratio && real_He_ratio <= 1.00 ); | |
| 1728 assert( (real_N2_ratio + real_He_ratio) <= 1.00 ); | |
| 604 | 1729 assert( 0.800 < real_pres_respiration && real_pres_respiration < 14.0 ); |
| 1730 | |
| 623 | 1731 assert( 0.00 <= sim_N2_ratio && real_N2_ratio <= 1.00 ); |
| 1732 assert( 0.00 <= sim_He_ratio && real_He_ratio <= 1.00 ); | |
| 1733 assert( (sim_N2_ratio + sim_He_ratio) <= 1.00 ); | |
| 582 | 1734 assert( 0.800 < sim_pres_respiration && sim_pres_respiration < 14.0 ); |
| 1735 | |
| 1736 | |
| 1737 // get input data according to context | |
| 623 | 1738 if( tissue_increment & TISSUE_SELECTOR ) |
| 582 | 1739 { |
| 1740 //---- real tissues ----------------------------------------------------------- | |
| 604 | 1741 calc_pres_respiration = real_pres_respiration; |
| 623 | 1742 |
| 1743 status = main_status; | |
| 604 | 1744 calc_O2_ratio = real_O2_ratio; |
| 1745 calc_N2_ratio = real_N2_ratio; | |
| 623 | 1746 |
| 1747 #ifdef _helium | |
| 604 | 1748 calc_He_ratio = real_He_ratio; |
| 623 | 1749 #endif |
| 1750 | |
| 1751 #ifdef _ccr_pscr | |
| 1752 calc_pSCR_drop = real_pSCR_drop; | |
| 1753 #endif | |
| 582 | 1754 } |
| 1755 else | |
| 1756 { | |
| 1757 //---- simulated tissues ------------------------------------------------------ | |
| 623 | 1758 |
| 1759 // correct sim_pres_respiration if shallower than calculated stop depth | |
| 1760 calc_pres_respiration = ( real_pres_respiration < sim_pres_respiration ) ? real_pres_respiration : sim_pres_respiration; | |
| 1761 | |
| 1762 status = deco_status; | |
| 604 | 1763 calc_O2_ratio = sim_O2_ratio; |
| 1764 calc_N2_ratio = sim_N2_ratio; | |
| 623 | 1765 |
| 1766 #ifdef _helium | |
| 604 | 1767 calc_He_ratio = sim_He_ratio; |
| 623 | 1768 #endif |
| 1769 | |
| 1770 #ifdef _ccr_pscr | |
| 1771 calc_pSCR_drop = sim_pSCR_drop; | |
| 1772 #endif | |
| 582 | 1773 } |
| 1774 | |
| 1775 //---- OC, CCR and Bailout Mode Gas Calculations ----------------------------------- | |
| 1776 | |
| 1777 // calculate ppO2 of pure oxygen | |
| 604 | 1778 O2_ppO2 = calc_pres_respiration - ppWater; |
| 1779 | |
| 1780 // capture failure condition in case real_pres_respiration is < ppWater (should never happen...) | |
| 582 | 1781 if( O2_ppO2 < 0.0 ) O2_ppO2 = 0.0; |
| 1782 | |
| 602 | 1783 // calculate ppO2 of the pure gas (OC, diluent) |
| 582 | 1784 OC_ppO2 = O2_ppO2 * calc_O2_ratio; |
| 1785 | |
| 623 | 1786 #ifdef _ccr_pscr |
| 1787 | |
| 582 | 1788 // calculate pSCR ppO2 |
| 1789 pSCR_ppO2 = OC_ppO2 - calc_pSCR_drop; | |
| 1790 | |
| 1791 // capture failure condition in case pSCR_ppO2 becomes negative | |
| 1792 if( pSCR_ppO2 < 0.0 ) pSCR_ppO2 = 0.0; | |
| 1793 | |
| 1794 | |
| 1795 //---- Loop modes : adjust ppN2 and ppHe for change in ppO2 due to setpoint (CCR) or drop (pSCR) --- | |
| 623 | 1796 if( status & MODE_LOOP ) |
| 582 | 1797 { |
| 1798 overlay float const_ppO2; | |
| 604 | 1799 overlay float max_ppO2; |
| 582 | 1800 |
| 1801 // get the current sensor reading (CCR / pSCR if fitted) or the fixed setpoint (CCR) / a zero (pSCR) | |
| 1802 const_ppO2 = 0.01 * char_I_const_ppO2; | |
| 1803 | |
| 1804 // Limit the setpoint to the maximum physically possible ppO2. This prevents for | |
| 1805 // example calculating with a setpoint of 1.3 bar in only 2 meters of depth. | |
| 604 | 1806 // Additionally, the ppO2 can be further reduced to account for exhaled inert gases |
| 623 | 1807 // accumulating in the loop by the user-adjustable setting char_I_CC_max_frac_O2. |
| 604 | 1808 // (ppWater is neglected here) |
| 623 | 1809 max_ppO2 = 0.01 * char_I_CC_max_frac_O2 * calc_pres_respiration; |
| 604 | 1810 |
| 1811 if( const_ppO2 > max_ppO2 ) const_ppO2 = max_ppO2; | |
| 582 | 1812 |
| 1813 // check which kind of loop we are on | |
| 623 | 1814 if( status & MODE_PSCR ) |
| 560 | 1815 { |
| 582 | 1816 //---- pSCR Mode -------------------------------------------------------------------------- |
| 1817 | |
| 1818 // Use the sensor value if available, but only in real tissue context! | |
| 1819 // In all other cases use calculated ppO2. | |
| 623 | 1820 if ( char_I_const_ppO2 && (tissue_increment & TISSUE_SELECTOR)) ppO2 = const_ppO2; |
| 1821 else ppO2 = pSCR_ppO2; | |
| 582 | 1822 } |
| 560 | 1823 else |
| 1824 { | |
| 582 | 1825 //---- CCR Mode --------------------------------------------------------------------------- |
| 1826 | |
| 604 | 1827 // derive breathed ppO2 from (char_I_)const_ppO2, which holds sensor reading or selected setpoint |
| 582 | 1828 ppO2 = const_ppO2; |
| 560 | 1829 } |
| 1830 | |
| 604 | 1831 // adjust overall gas pressure for change in ppO2 due to setpoint (CCR) or drop (pSCR), |
| 1832 // capture potential failure conditions first: | |
| 1833 if( ( calc_pres_respiration < ppO2 ) // sensor reading or selected setpoint is higher than ambient pressure | |
| 623 | 1834 || ( calc_O2_ratio > 0.995 ) ) // diluent is pure O2, i.e. calc_N2_ratio + calc_He_ratio = 0 would give a div/0 |
| 560 | 1835 { |
| 604 | 1836 // failure condition present, set predetermined result |
| 1837 calc_pres_respiration = 0.0; | |
| 1838 } | |
| 1839 else | |
| 1840 { | |
| 1841 // no failure conditions present, equation can be executed | |
| 1842 calc_pres_respiration -= ppO2; | |
| 623 | 1843 #ifdef _helium |
| 604 | 1844 calc_pres_respiration /= calc_N2_ratio + calc_He_ratio; |
| 623 | 1845 #else |
| 1846 calc_pres_respiration /= calc_N2_ratio; | |
| 1847 #endif | |
| 560 | 1848 } |
| 582 | 1849 } |
| 1850 else | |
| 623 | 1851 #endif // _ccr_pscr |
| 604 | 1852 { |
| 1853 //---- OC mode --------------------------------------------------------------------------------- | |
| 582 | 1854 |
| 1855 // breathed ppO2 is ppO2 of pure gas | |
| 1856 ppO2 = OC_ppO2; | |
| 560 | 1857 } |
| 1858 | |
| 582 | 1859 |
| 604 | 1860 //---- derive char_ppO2 in [cbar], used for calculating CNS% --------------------------------------- |
| 1861 | |
| 582 | 1862 if ( ppO2 < 0.01 ) char_ppO2 = 0; |
| 1863 else if ( ppO2 >= 2.545 ) char_ppO2 = 255; | |
| 1864 else char_ppO2 = (unsigned char)(100 * ppO2 + 0.5); | |
| 1865 | |
| 1866 | |
| 1867 //---- calculate ppN2 and ppHe --------------------------------------------------------------------- | |
| 1868 | |
| 604 | 1869 // add deco safety distance when working on simulated tissues |
| 623 | 1870 if( !(tissue_increment & TISSUE_SELECTOR) ) calc_pres_respiration += float_deco_distance; |
| 604 | 1871 |
| 1872 // compute ppN2 and ppHe, capture potential failure conditions first: | |
| 1873 if( calc_pres_respiration > ppWater ) | |
| 582 | 1874 { |
| 604 | 1875 // subtract water vapor pressure |
| 1876 calc_pres_respiration -= ppWater; | |
| 1877 | |
| 1878 // calculate partial pressures | |
| 1879 ppN2 = calc_N2_ratio * calc_pres_respiration; | |
| 623 | 1880 |
| 1881 #ifdef _helium | |
| 604 | 1882 ppHe = calc_He_ratio * calc_pres_respiration; |
| 623 | 1883 #else |
| 1884 ppHe = 0.0; | |
| 1885 #endif | |
| 1886 | |
| 582 | 1887 } |
| 1888 else | |
| 1889 { | |
| 604 | 1890 // calculated respired pressure is < water vapor pressure, thus set ppN2 and ppHe to 0 |
| 582 | 1891 ppN2 = 0.0; |
| 1892 ppHe = 0.0; | |
| 1893 } | |
| 0 | 1894 } |
| 1895 | |
| 604 | 1896 |
| 0 | 1897 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 1898 // init_output_vars |
| 1899 // | |
| 1900 // Initializes all output variables to their default values | |
| 1901 // | |
| 1902 static void init_output_vars(void) | |
| 1903 { | |
| 1904 // clear the internal stops table from remains lasting from the previous dive or deco calculator run | |
| 1905 clear_deco_table(); | |
| 1906 | |
| 1907 // publish the cleared stops table to the display functions | |
| 1908 publish_deco_table(); | |
| 1909 | |
| 1910 // clear the published gas needs in volume and pressure | |
| 1911 for( i = 0; i < NUM_GAS; ++i ) | |
| 1912 { | |
| 1913 int_O_gas_need_vol[i] = 0; | |
| 1914 int_O_gas_need_pres[i] = 0 + INT_FLAG_ZERO + INT_FLAG_INVALID; | |
| 1915 } | |
| 1916 | |
| 1917 // values initially to be set to zero | |
| 1918 int_O_ceiling = 0; // ceiling depth in mbar | |
| 1919 char_O_deco_info = 0; // clear all deco information flags | |
| 1920 char_O_deco_warnings = 0; // clear all deco warning flags | |
| 1921 | |
| 1922 // default desaturation time to 24 hours (it will not be computed during a dive) | |
| 1923 int_O_desaturation_time = 1440; | |
| 1924 | |
| 1925 // initialize CNS values | |
| 1926 int_O_CNS_norm = 0 + INT_FLAG_INVALID; | |
| 1927 int_O_CNS_alt = 0 + INT_FLAG_INVALID; | |
| 1928 | |
| 1929 // initialize NDL times | |
| 1930 char_O_NDL_norm = 240; | |
| 1931 char_O_NDL_alt = 240; | |
| 1932 | |
| 1933 // initialize ascent times | |
| 1934 int_O_TTS_norm = 0; | |
| 1935 int_O_TTS_alt = 0 + INT_FLAG_INVALID + INT_FLAG_NOT_COMPUTED_YET; | |
| 1936 | |
| 1937 #ifdef _rx_functions | |
| 1938 // clear TR values | |
| 1939 int_O_SAC_measured = 0 + INT_FLAG_NOT_AVAIL; // SAC rate | |
| 1940 int_O_pressure_need[0] = 0 + INT_FLAG_NOT_AVAIL; // pressure need to reading 1 | |
| 1941 int_O_pressure_need[1] = 0 + INT_FLAG_NOT_AVAIL; // pressure need to reading 2 | |
| 1942 #endif | |
| 1943 | |
| 1944 } | |
| 1945 | |
| 1946 | |
| 1947 ////////////////////////////////////////////////////////////////////////////// | |
| 0 | 1948 // clear_tissue |
| 1949 // | |
| 623 | 1950 // Reset all tissues to surface pressure equilibrium state |
| 1951 // | |
| 1952 // Input: int_I_pres_surface current surface pressure in hPa (mbar) | |
| 1953 // | |
| 1954 // Output: real_pres_tissue_N2[] partial pressure of N2 in real tissues | |
| 1955 // real_pres_tissue_He[] partial pressure of He in real tissues | |
| 1956 // char_O_tissue_pres_N2[] partial pressure of N2 for tissue graphics | |
| 1957 // char_O_tissue_pres_He[] partial pressure of He for tissue graphics | |
| 1958 // char_O_tissue_pressure[] total pressure for tissue graphics | |
| 1959 // CNS_fraction_real internal CNS value | |
| 1960 // int_O_CNS_current current CNS value | |
| 1961 // int_O_CNS_norm CNS value at end of normal dive plan | |
| 1962 // int_O_CNS_alt CNS value at end of alternative dive plan | |
| 1963 // char_O_deco_warnings deco warnings vector | |
| 1964 // char_O_NDL_norm remaining NDL time in normal dive plan | |
| 1965 // char_O_NDL_alt remaining NDL time in alternative dive plan | |
| 1966 // int_O_TTS_norm ascent time (TTS) in normal dive plan | |
| 1967 // int_O_TTS_alt ascent time (TTS) in alternative dive plan | |
| 1968 // int_O_lead_supersat supersaturation of the leading tissue | |
| 0 | 1969 // |
| 1970 static void clear_tissue(void) | |
| 1971 { | |
| 623 | 1972 // safeguard and convert the surface pressure (mbar -> bar) (*) |
| 1973 if( int_I_pres_surface < 500 ) pres_surface = 0.500; | |
| 1974 else pres_surface = 0.001 * int_I_pres_surface; | |
| 1975 | |
| 1976 // calculate partial pressure of N2 in respired air at surface pressure | |
| 1977 calc_N2_equilibrium(); | |
| 1978 | |
| 1979 // cycle through the 16 Buhlmann tissues | |
| 604 | 1980 for( ci = 0; ci < NUM_COMP; ci++ ) |
| 582 | 1981 { |
| 623 | 1982 // reset tissue pressures |
| 1983 real_pres_tissue_He[ci] = 0.0; // He | |
| 1984 real_pres_tissue_N2[ci] = N2_equilibrium; // N2 | |
| 1985 | |
| 1986 // reset tissue pressures for scaled for tissue graphics | |
| 1987 char_O_tissue_pres_He[ci] = 0; // He | |
| 1988 char_O_tissue_pres_N2[ci] = 10; // N2 | |
| 1989 char_O_tissue_pressure[ci] = 10; // combined | |
| 582 | 1990 } |
| 1991 | |
| 1992 // reset CNS values | |
| 623 | 1993 CNS_fraction_real = 0.0; |
| 1994 int_O_CNS_current = int_O_CNS_norm = int_O_CNS_alt = 0; | |
| 582 | 1995 |
| 1996 // reset some more vars to their defaults | |
| 623 | 1997 char_O_NDL_norm = 240; |
| 1998 char_O_NDL_alt = 240; | |
| 1999 int_O_TTS_norm = 0; | |
| 2000 int_O_TTS_alt = 0; | |
| 2001 int_O_lead_supersat = 0; | |
| 2002 | |
| 2003 // reset all warning and info flags | |
| 2004 char_O_deco_warnings = 0; | |
| 2005 char_O_deco_info = 0; | |
| 0 | 2006 } |
| 2007 | |
| 582 | 2008 |
| 0 | 2009 ////////////////////////////////////////////////////////////////////////////// |
| 2010 // calc_hauptroutine | |
| 2011 // | |
| 623 | 2012 // This is the major code in dive mode, it calculates the tissue pressures, |
| 2013 // the bottom time, and it calculates the ascend with all deco stops, etc. | |
| 2014 // | |
| 2015 // Input: char_O_main_status deco engine control and real tissues mode | |
| 2016 // char_O_deco_status deco engine control and simulated tissues mode | |
| 2017 // char_I_sim_advance_time mailbox for bottom time incrementing | |
| 2018 // | |
| 2019 // char_I_SAC_work gas usage rate during working phase in l/min | |
| 2020 // char_I_SAC_deco gas usage rate during deco stops phase in l/min | |
| 2021 // | |
| 2022 // char_I_deco_model selector for GF extension | |
| 2023 // char_I_ascent_speed ascent speed | |
| 2024 // char_I_deco_distance safety distance between stop depth and calculated depth | |
| 2025 // char_I_saturation_multiplier safety factor for tissue saturation | |
| 2026 // char_I_desaturation_multiplier safety factor for tissue desaturation | |
| 2027 // | |
| 2028 // char_I_pressure_gas[] amount of gas available for ascent in bar | |
| 2029 // int_I_pressure_drop[] pressure drop used to calculate SAC rate | |
| 2030 // char_I_gas_avail_size[] size of the tanks in liters | |
| 2031 // | |
| 2032 // Output: int_O_O2_ppO2 partial pressure of pure O2 at current depth | |
| 2033 // int_O_pure_ppO2 partial pressure of O2 in gas at current depth | |
| 2034 // int_O_pSCR_ppO2 partial pressure of O2 in gas at current depth, corrected for pSCR mode | |
| 2035 // int_O_breathed_ppO2 partial pressure of O2 currently breathed | |
| 2036 // | |
| 2037 // char_O_deco_status deco engine computations status | |
| 2038 // char_O_deco_info deco engine information vector | |
| 2039 // char_O_deco_warnings deco engine warnings vector | |
| 2040 // | |
| 2041 // char_O_NDL_norm remaining NDL time in normal dive plan | |
| 2042 // char_O_NDL_alt remaining NDL time in alternative dive plan | |
| 2043 // int_O_TTS_norm ascent time (TTS) in normal dive plan | |
| 2044 // int_O_TTS_alt ascent time (TTS) in alternative dive plan | |
| 2045 // int_O_CNS_norm CNS value at end of normal dive plan | |
| 2046 // int_O_CNS_alt CNS value at end of alternative dive plan | |
| 2047 // | |
| 2048 // int_O_gas_need_vol calculated gas volumes needed for ascent | |
| 2049 // int_O_gas_need_pres calculated gas pressures needed for ascent | |
| 2050 // | |
| 2051 // int_O_SAC_measured measured surface air consumption (SAC) rate in l/min | |
| 2052 // | |
| 2053 // Modified: int_IO_pressure_value[] warning flags added to pressure reading 1 & 2 | |
| 2054 // int_IO_pressure_need[] pressure needs to pressure reading 1 & 2 | |
| 0 | 2055 // |
| 2056 static void calc_hauptroutine(void) | |
| 2057 { | |
| 623 | 2058 overlay unsigned short int_ppO2_min; |
| 2059 overlay unsigned short int_ppO2_max; | |
| 2060 overlay unsigned short int_ppO2_max_dil; | |
| 2061 overlay unsigned short int_ppO2_max_max; | |
| 2062 overlay float EAD; | |
| 2063 overlay float END; | |
| 2064 | |
| 2065 //============================================================================================= | |
| 2066 | |
| 2067 // | |
| 2068 //--- Setup Part --------------------------------------------------------------------------------- | |
| 2069 // | |
| 2070 | |
| 2071 // set time limit for preempting deco calculations, timer is 16 bit and increments every 1/32 ms | |
| 2072 tmr5_value = 65535 - (32 * BUDGET_PER_SECOND / INVOKES_PER_SECOND); | |
| 2073 | |
| 2074 // load timer | |
| 2075 load_tmr5(); | |
| 2076 | |
| 2077 // read command flags and set up what to do | |
| 2078 switch( char_O_deco_status & COMMAND_MASK ) | |
| 560 | 2079 { |
| 623 | 2080 |
| 2081 case INITIALIZE: | |
| 2082 case INITIALIZE_START_NORM: | |
| 2083 case INITIALIZE_START_ALT: | |
| 2084 | |
| 2085 // copy master modes to shadow registers | |
| 2086 main_status = char_O_main_status; | |
| 2087 deco_status = char_O_deco_status; | |
| 2088 | |
| 2089 // clear all command flags on the master mode to signal that the command is read | |
| 2090 char_O_deco_status &= ~COMMAND_MASK; | |
| 2091 | |
| 2092 // clear the initialization flag on the shadow copy | |
| 2093 deco_status &= ~INITIALIZE; | |
| 2094 | |
| 2095 // initialize the sequence timer | |
| 2096 sequence_timer = 0; | |
| 2097 | |
| 2098 // set the calculation phase to start with to doing the once-per-dive initialization | |
| 2099 next_planning_phase = PHASE_10_DIVE_INIT; | |
| 2100 | |
| 2101 break; | |
| 2102 | |
| 2103 | |
| 2104 case START_NORM: | |
| 2105 case START_ALT: | |
| 2106 | |
| 2107 // copy master modes to shadow registers | |
| 2108 main_status = char_O_main_status; | |
| 2109 deco_status = char_O_deco_status; | |
| 2110 | |
| 2111 // clear all command flags on the master mode to signal that the command is read | |
| 2112 char_O_deco_status &= ~COMMAND_MASK; | |
| 2113 | |
| 2114 // set the calculation phase to start with to doing the cyclic initialization | |
| 2115 next_planning_phase = PHASE_11_CYCLIC_INIT; | |
| 2116 | |
| 2117 // continue in CALCULATING | |
| 2118 | |
| 2119 | |
| 2120 case CALCULATING: | |
| 2121 | |
| 2122 // keep current calculation phase | |
| 2123 | |
| 2124 // step the sequence timer | |
| 2125 sequence_timer = (sequence_timer < INVOKES_PER_SECOND * 2 - 1) ? sequence_timer + 1 : 0; | |
| 2126 | |
| 2127 break; | |
| 560 | 2128 } |
| 2129 | |
| 582 | 2130 |
| 623 | 2131 // |
| 2132 //--- End of Setup Part ----------------------------------------------------------------------- | |
| 2133 // | |
| 2134 | |
| 2135 //============================================================================================= | |
| 2136 | |
| 2137 // | |
| 2138 //---- Calculations Part (real Tissues) ------------------------------------------------------- | |
| 2139 // | |
| 2140 | |
| 582 | 2141 |
| 604 | 2142 // target the real tissues with 2 second increments by default |
| 623 | 2143 tissue_increment = TISSUE_SELECTOR | 0; |
| 2144 | |
| 2145 | |
| 2146 // Tasks every second, if more than 1 invocation per second: on the first section of the second. | |
| 2147 // Requests for tissue "fast forward" are executed immediately. | |
| 2148 #if (INVOKES_PER_SECOND > 1) | |
| 2149 if( ( sequence_timer == 0 ) | |
| 2150 || ( sequence_timer == INVOKES_PER_SECOND ) | |
| 2151 || ( char_I_sim_advance_time > 0 ) | |
| 2152 ) | |
| 2153 #endif | |
| 584 | 2154 { |
| 623 | 2155 // acquire current environmental data |
| 2156 calc_hauptroutine_data_input(); | |
| 2157 | |
| 2158 // calculate ppO2, ppN2 and ppHe | |
| 2159 calc_alveolar_pressures(); | |
| 2160 | |
| 2161 // add decent calculation here and include trigger in above if-statement | |
| 2162 // TODO | |
| 2163 | |
| 2164 } // tasks every second, on the first section of the second | |
| 2165 | |
| 2166 | |
| 2167 // Tasks every 2 seconds, on the first section of the respective second. | |
| 2168 // Requests for tissue "fast forward" are executed immediately. | |
| 2169 if( ( sequence_timer == 0 ) | |
| 2170 || ( char_I_sim_advance_time > 0 ) | |
| 2171 ) | |
| 2172 { | |
| 2173 // Tissue and CNS updates are based on 2 seconds periods! | |
| 2174 | |
| 604 | 2175 // Set up normal tissue updating or "fast forward" updating for simulator |
| 2176 // sim+5' function and deco calculator bottom time calculation. | |
| 2177 if( char_I_sim_advance_time > 0 ) | |
| 2178 { | |
| 2179 // configure "fast forward" tissue updating | |
| 623 | 2180 tissue_increment = TISSUE_SELECTOR | char_I_sim_advance_time; |
| 2181 | |
| 2182 // clear the request | |
| 604 | 2183 char_I_sim_advance_time = 0; |
| 2184 } | |
| 2185 | |
| 584 | 2186 // calculate the real tissues |
| 2187 calc_tissues(); | |
| 2188 | |
| 604 | 2189 // update the CNS value for the real tissues |
| 2190 calc_CNS(); | |
| 2191 | |
| 2192 // calculate ceiling (at GF_high or 100%) and leading tissue supersaturation | |
| 623 | 2193 if ( char_I_deco_model ) calc_limit(GF_high); // GF factors enabled |
| 2194 else calc_limit( 1.0 ); // classic Buhlmann | |
| 2195 | |
| 2196 // convert the ceiling value to integer | |
| 604 | 2197 convert_ceiling_for_display(); |
| 2198 | |
| 623 | 2199 // convert the saturation value of the leading tissue to integer |
| 2200 convert_sat_for_display(); | |
| 2201 | |
| 2202 // convert the CNS value to integer | |
| 2203 convert_cur_CNS_for_display(); | |
| 2204 | |
| 2205 } // tasks every 2 seconds | |
| 2206 | |
| 2207 | |
| 2208 // Tasks every second, if more than 1 invocation per second: on the first section of the second. | |
| 2209 #if (INVOKES_PER_SECOND > 1) | |
| 2210 if( ( sequence_timer == 0 ) | |
| 2211 || ( sequence_timer == INVOKES_PER_SECOND ) | |
| 2212 ) | |
| 2213 #endif | |
| 582 | 2214 { |
| 623 | 2215 //---- Calculate and Export EAD and END ------------------------------------------------------ |
| 2216 | |
| 2217 // calculate EAD (Equivalent Air Depth): equivalent depth for the same N2 level with plain air | |
| 2218 EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER; | |
| 2219 | |
| 2220 // calculate END (Equivalent Narcotic Depth): here O2 is treated as narcotic, too | |
| 2221 // Source cited: The Physiology and Medicine of Diving by Peter Bennett and David Elliott, | |
| 2222 // 4th edition, 1993, W.B.Saunders Company Ltd, London. | |
| 2223 END = (real_pres_respiration - ppHe - pres_surface) * BAR_TO_METER; | |
| 2224 | |
| 2225 // export EAD | |
| 2226 float_value = EAD; convert_float_to_char(); char_O_EAD = char_value; | |
| 2227 | |
| 2228 // export END | |
| 2229 float_value = END; convert_float_to_char(); char_O_END = char_value; | |
| 2230 | |
| 2231 | |
| 2232 //---- Compute ppO2 Values in [cbar] --------------------------------------------------------- | |
| 2233 | |
| 2234 float_value = ppO2; convert_float_to_int(); int_O_breathed_ppO2 = int_value; // breathed gas | |
| 2235 #ifdef _ccr_pscr | |
| 2236 float_value = O2_ppO2; convert_float_to_int(); int_O_O2_ppO2 = int_value; // pure oxygen | |
| 2237 float_value = OC_ppO2; convert_float_to_int(); int_O_pure_ppO2 = int_value; // pure gas | |
| 2238 float_value = pSCR_ppO2; convert_float_to_int(); int_O_pSCR_ppO2 = int_value; // pSCR calculated | |
| 2239 #endif | |
| 2240 | |
| 2241 | |
| 2242 //---- Set/Reset Deco Mode -------------------------------------------------------------------- | |
| 2243 | |
| 2244 // Set the deco mode flag if: | |
| 2245 // deco mode is not set | |
| 2246 // AND breathing an OC deco gas (gas type 3) | |
| 2247 // OR breathing a gas or diluent that officially is disabled (type 0) | |
| 2248 // OR there is a deco stop and we are less deep than 1 meter below the deepest deco stop | |
| 2249 if ( ( deco_info & DECO_FLAG ) == 0 ) | |
| 2250 if ( ( char_I_current_gas_type == 3 ) | |
| 2251 || ( char_I_current_gas_type == 0 ) | |
| 2252 || ( ( char_O_deco_depth[0] > 0 ) && ( char_depth_real <= char_O_deco_depth[0] + 1 ) ) | |
| 2253 ) | |
| 2254 deco_info |= DECO_FLAG; | |
| 2255 | |
| 2256 // Clear the deco mode flag if: | |
| 2257 // deco mode is set | |
| 2258 // AND deeper than 7 meters below deepest deco stop (7 meters = 2 stop depth intervals plus 1 meter below stop) | |
| 2259 if ( ( deco_info & DECO_FLAG ) > 0 ) | |
| 2260 if ( ( char_depth_real > char_O_deco_depth[0] + 7 ) | |
| 2261 ) | |
| 2262 deco_info &= ~DECO_FLAG; | |
| 2263 | |
| 2264 | |
| 2265 //---- Compute ppO2 Warnings ------------------------------------------------------------------ | |
| 2266 | |
| 2267 // compute conditional min values | |
| 2268 #ifdef _ccr_pscr | |
| 2269 int_ppO2_min = ( main_status & MODE_LOOP ) ? (unsigned short)char_I_ppO2_min_loop : (unsigned short)char_I_ppO2_min; | |
| 2270 #else | |
| 2271 int_ppO2_min = (unsigned short)char_I_ppO2_min; | |
| 2272 #endif | |
| 2273 | |
| 2274 // compute conditional max values | |
| 2275 int_ppO2_max = ( deco_info & DECO_FLAG ) ? (unsigned short)char_I_ppO2_max_deco : (unsigned short)char_I_ppO2_max_work; | |
| 2276 | |
| 2277 // add some margin on ppO2 max to compensate for surface pressures > 1.000 mbar | |
| 2278 int_ppO2_max += ppO2_MARGIN_ON_MAX; | |
| 2279 | |
| 2280 // get biggest of char_I_ppO2_max_work / char_I_ppO2_max_deco | |
| 2281 int_ppO2_max_max = ( char_I_ppO2_max_deco > char_I_ppO2_max_work ) ? char_I_ppO2_max_deco : char_I_ppO2_max_work; | |
| 2282 | |
| 2283 #ifdef _ccr_pscr | |
| 2284 // default value for the upper diluent ppO2 warning threshold is the normal upper warning threshold | |
| 2285 int_ppO2_max_dil = int_ppO2_max; | |
| 2286 | |
| 2287 // when in CCR mode, the upper diluent warning threshold gets adjust according to the current setpoint | |
| 2288 if( (main_status & MODE_MASK) == MODE_CCR ) | |
| 2289 { | |
| 2290 overlay unsigned short max_dil; | |
| 2291 | |
| 2292 // The upper diluent ppO2 threshold is ppO2_GAP_TO_SETPOINT below the setpoint... | |
| 2293 // (the condition protects from negative numbers which would cause a wrap-around in unsigned integers) | |
| 2294 max_dil = (char_I_const_ppO2 > ppO2_GAP_TO_SETPOINT) ? (unsigned short)(char_I_const_ppO2 - ppO2_GAP_TO_SETPOINT) : 0; | |
| 2295 | |
| 2296 // ...but never above int_ppO2_max. | |
| 2297 if( max_dil < int_ppO2_max ) int_ppO2_max_dil = max_dil; | |
| 2298 | |
| 2299 // We do not need to guard int_ppO2_max_dil against becoming lower than char_I_ppO2_min because the check | |
| 2300 // against char_I_ppO2_min is done first and will then raise a low warning and inhibit further checks. | |
| 2301 } | |
| 2302 #endif | |
| 2303 | |
| 2304 // check for safe range of breathed gas | |
| 2305 if ( int_O_breathed_ppO2 <= int_ppO2_min ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
| 2306 else if ( int_O_breathed_ppO2 >= int_ppO2_max_max ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
| 2307 else if ( deco_info & DECO_FLAG ) ; // no attention generated in deco mode | |
| 2308 else if ( main_status & MODE_LOOP ) ; // no attention generated in loop modes | |
| 2309 else if ( int_O_breathed_ppO2 >= (unsigned short)char_I_ppO2_max_work ) int_O_breathed_ppO2 |= INT_FLAG_ATTENTION; | |
| 2310 | |
| 2311 #ifdef _ccr_pscr | |
| 2312 // check for safe range of pure oxygen | |
| 2313 if ( int_O_O2_ppO2 >= int_ppO2_max ) int_O_O2_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
| 2314 | |
| 2315 // check for safe range of pure diluent | |
| 2316 if ( int_O_pure_ppO2 <= (unsigned short)char_I_ppO2_min ) int_O_pure_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
| 2317 else if ( int_O_pure_ppO2 >= int_ppO2_max ) int_O_pure_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
| 2318 else if ( int_O_pure_ppO2 >= int_ppO2_max_dil ) int_O_pure_ppO2 |= INT_FLAG_ATTENTION; | |
| 2319 | |
| 2320 // check for safe range of calculated pSCR loop gas | |
| 2321 if ( int_O_pSCR_ppO2 <= int_ppO2_min ) int_O_pSCR_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
| 2322 else if ( int_O_pSCR_ppO2 >= int_ppO2_max ) int_O_pSCR_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
| 2323 #endif | |
| 2324 | |
| 2325 } // tasks every second / on the first section of the second | |
| 604 | 2326 |
| 2327 | |
| 2328 #ifdef _rx_functions | |
| 2329 | |
| 623 | 2330 // only when TR functions are enabled |
| 2331 if( main_status & TR_FUNCTIONS ) | |
| 2332 | |
| 2333 // Tasks every second, if more than 1 invocation per second: on the second section of the second. | |
| 2334 #if (INVOKES_PER_SECOND > 1) | |
| 2335 if( ( sequence_timer == 1 ) | |
| 2336 || ( sequence_timer == INVOKES_PER_SECOND + 1 ) | |
| 2337 ) | |
| 2338 #endif | |
| 604 | 2339 { |
| 623 | 2340 calc_TR_functions(); |
| 2341 } | |
| 2342 | |
| 2343 #endif // _rx_functions | |
| 2344 | |
| 2345 | |
| 2346 // | |
| 604 | 2347 //---- End of Computations for the real Tissues ----------------------------------------------- |
| 2348 // | |
| 623 | 2349 |
| 604 | 2350 //============================================================================================= |
| 623 | 2351 |
| 604 | 2352 // |
| 623 | 2353 //---- Begin of Computations for Ascent and Decompression (simulated Tissues) ----------------- |
| 2354 // | |
| 2355 | |
| 2356 // Dispatcher: select what to do based on the current calculation phase | |
| 2357 do | |
| 582 | 2358 { |
| 623 | 2359 |
| 2360 #ifdef _profiling | |
| 2361 profiling_phase = next_planning_phase; | |
| 2362 #endif | |
| 2363 | |
| 2364 switch( next_planning_phase ) | |
| 560 | 2365 { |
| 623 | 2366 |
| 2367 // | |
| 2368 //---- once-per-dive Initialization of the Deco Engine ------------------------------------ | |
| 2369 // | |
| 2370 case PHASE_10_DIVE_INIT: | |
| 2371 | |
| 2372 // initialize all output variables to defaults | |
| 2373 init_output_vars(); | |
| 2374 | |
| 2375 // safeguard input parameters that are constant during the course of the dive | |
| 2376 if( char_I_deco_distance > 20 ) char_I_deco_distance = 20; | |
| 2377 if( char_I_ascent_speed < 5 ) char_I_ascent_speed = 5; | |
| 2378 if( char_I_ascent_speed > 10 ) char_I_ascent_speed = 10; | |
| 2379 | |
| 2380 // convert input parameters to float numbers | |
| 2381 float_deco_distance = 0.01 * char_I_deco_distance; | |
| 2382 float_ascent_speed = 1.00 * char_I_ascent_speed; | |
| 582 | 2383 |
| 2384 // initialize values that will be recalculated later on periodically | |
| 623 | 2385 deco_warnings = 0; // reset all deco warnings |
| 2386 deco_info = 0; // reset all deco infos | |
| 2387 IBCD_tissue_vector = 0; // reset tissue IBCD vector | |
| 2388 NDL_tissue_start_norm = 0; // initialize the tissue to start with when calculating normal NDL time | |
| 2389 NDL_tissue_start_alt = 0; // initialize the tissue to start with when calculating alternative NDL time | |
| 2390 | |
| 2391 // enforce initialization of GF data on first cyclic initialization | |
| 2392 GF_high_last = 0; | |
| 2393 GF_low_last = 0; | |
| 2394 | |
| 2395 | |
| 2396 #ifdef _cave_mode | |
| 2397 char_I_backtrack_time = 0; //clear backtracking time (index to char_I_backtrack_depth) | |
| 2398 char_I_backtrack_depth = 0; //prime first entry with a depth of 0 meter | |
| 2399 #endif | |
| 2400 | |
| 2401 #ifdef _profiling | |
| 2402 int_O_profiling_overrun_max = 0; | |
| 2403 char_O_profiling_runs_norm = 0; | |
| 2404 char_O_profiling_runs_alt = 0; | |
| 2405 #endif | |
| 2406 | |
| 2407 | |
| 2408 // the next calculation phase will do the cyclic initialization of the deco engine if a | |
| 2409 // normal or alternative plan shall be calculated, else the calculation cycle is done. | |
| 2410 if( deco_status & PLAN_MASK ) next_planning_phase = PHASE_11_CYCLIC_INIT; | |
| 2411 else next_planning_phase = PHASE_00_DONE; | |
| 2412 | |
| 2413 break; | |
| 2414 | |
| 582 | 2415 |
| 2416 // | |
| 623 | 2417 //---- once-per-cycle Initialization of the Deco Engine------------------------------------ |
| 582 | 2418 // |
| 623 | 2419 case PHASE_11_CYCLIC_INIT: |
| 2420 | |
| 2421 // target the simulated tissues (flag bit 7 = 0) | |
| 2422 tissue_increment = 0; | |
| 2423 | |
| 2424 // clear the internal stops table | |
| 582 | 2425 clear_deco_table(); |
| 604 | 2426 |
| 560 | 2427 // initialize the simulated tissues with the current state of the real tissues |
| 604 | 2428 for( i = 0; i < NUM_COMP; i++ ) |
| 560 | 2429 { |
| 623 | 2430 sim_pres_tissue_N2[i] = real_pres_tissue_N2[i]; |
| 2431 sim_pres_tissue_He[i] = real_pres_tissue_He[i]; | |
| 582 | 2432 } |
| 2433 | |
| 623 | 2434 // initialize GF parameters if using GF model |
| 2435 if( char_I_deco_model != 0 ) | |
| 604 | 2436 { |
| 623 | 2437 // update GF parameters (GFs may have been switched between GF and aGF) |
| 2438 if( (char_I_GF_High_percentage != GF_high_last) || (char_I_GF_Low_percentage != GF_low_last) ) | |
| 604 | 2439 { |
| 623 | 2440 // store new values in integer format |
| 2441 GF_high_last = char_I_GF_High_percentage; | |
| 2442 GF_low_last = char_I_GF_Low_percentage; | |
| 2443 | |
| 2444 // store new values in float format | |
| 2445 GF_high = 0.01 * char_I_GF_High_percentage; | |
| 2446 GF_low = 0.01 * char_I_GF_Low_percentage; | |
| 2447 | |
| 2448 // reset low depth references and slopes | |
| 2449 GF_low_depth_norm = 0; | |
| 2450 GF_low_depth_alt = 0; | |
| 2451 GF_slope_norm = 0.0; | |
| 2452 GF_slope_alt = 0.0; | |
| 604 | 2453 } |
| 623 | 2454 |
| 2455 // retrieve GF parameters for current calculation cycle | |
| 2456 if( deco_status & CALC_NORM ) | |
| 560 | 2457 { |
| 623 | 2458 GF_low_depth = GF_low_depth_norm; |
| 2459 GF_slope = GF_slope_norm; | |
| 560 | 2460 } |
| 2461 else | |
| 2462 { | |
| 623 | 2463 GF_low_depth = GF_low_depth_alt; |
| 2464 GF_slope = GF_slope_alt; | |
| 560 | 2465 } |
| 604 | 2466 } |
| 2467 | |
| 623 | 2468 // initialize the simulated CNS value with the current CNS value of the real tissues |
| 2469 CNS_fraction_sim = CNS_fraction_real; | |
| 2470 | |
| 2471 // initialize the simulated depth with the current depth (in absolute pressure) | |
| 2472 sim_pres_respiration = real_pres_respiration; | |
| 2473 | |
| 2474 // compute the depth in meters where we are now | |
| 2475 float_depth_real = (sim_pres_respiration - pres_surface) * BAR_TO_METER; | |
| 2476 | |
| 2477 // convert to integer and round up to next full meter | |
| 2478 char_depth_real = (unsigned char)(float_depth_real + 0.99); | |
| 2479 | |
| 2480 // initialize depth for deco ascent calculation | |
| 2481 char_depth_sim = char_depth_real; | |
| 2482 | |
| 2483 // Lookup the gas that is currently breathed with the real tissues and set it as | |
| 2484 // the gas to be used with the simulated tissues, too. This gas will be used until | |
| 2485 // gas_find_better() is invoked and finds a better gas to switch to. | |
| 2486 gas_find_current(); | |
| 2487 | |
| 2488 // Setup the calculation ratio's for N2, He and O2 (sim_N2/He/_O2_ratio). These ratios | |
| 2489 // can be kept until a gas switch is done. Thus, if a call to gas_find_better() has | |
| 2490 // found a better gas and initiated a switch, gas_set_ratios() needs to be called again. | |
| 2491 gas_set_ratios(); | |
| 2492 | |
| 2493 // compute ppO2, ppN2 and ppHe for current depth from sim_pres_respiration | |
| 2494 calc_alveolar_pressures(); | |
| 2495 | |
| 2496 // initialize the no decompression limit (NDL) time to 240 minutes | |
| 2497 NDL_time = 240; | |
| 2498 | |
| 2499 // retrieve the tissue that had the shortest NDL time during last calculation | |
| 2500 NDL_tissue_start = ( deco_status & CALC_NORM ) ? NDL_tissue_start_norm : NDL_tissue_start_alt; | |
| 2501 | |
| 2502 // start calculating NDL time with the tissue that had the shortest NDL last time | |
| 2503 NDL_tissue = NDL_tissue_start; | |
| 2504 NDL_tissue_lead = NDL_tissue_start; | |
| 2505 | |
| 2506 // initialization for calculating the initial ascent | |
| 2507 // start with 1 minute ascent steps when calculating the initial ascent | |
| 2508 fast = 1; | |
| 2509 | |
| 2510 // initialization for calc_gas_needs_ascent() | |
| 2511 gas_needs_next_phase = GAS_NEEDS_INIT; | |
| 2512 | |
| 2513 // initialization for convert_gas_needs_to_press() | |
| 2514 gas_needs_gas_index = 0; | |
| 2515 | |
| 2516 | |
| 2517 #ifdef _profiling | |
| 2518 profiling_runs = 0; | |
| 2519 #endif | |
| 2520 | |
| 2521 // The next calculation phase will | |
| 2522 // - calculate the bottom segment if extended bottom time is configured (fTTS), | |
| 2523 // - proceed with calculating the NDL time else. | |
| 2524 if ( deco_status & DELAYED_ASCENT ) next_planning_phase = PHASE_20_EXTENDED_BOTTOM_TIME; | |
| 2525 else next_planning_phase = PHASE_30_NDL_TIME; | |
| 2526 | |
| 2527 break; | |
| 2528 | |
| 2529 | |
| 2530 // | |
| 2531 //---- extended Bottom Time --------------------------------------------------------------- | |
| 2532 // | |
| 2533 case PHASE_20_EXTENDED_BOTTOM_TIME: | |
| 2534 | |
| 2535 // program interval on simulated tissues (flag bit 7 = 0) | |
| 2536 tissue_increment = char_I_extra_time; | |
| 2537 | |
| 2538 // calculate ppO2, ppN2 and ppHe | |
| 2539 calc_alveolar_pressures(); | |
| 2540 | |
| 2541 // update the tissues | |
| 2542 calc_tissues(); | |
| 2543 | |
| 2544 // update the CNS value | |
| 2545 calc_CNS(); | |
| 2546 | |
| 2547 // the next calculation phase will calculate the NDL time | |
| 2548 next_planning_phase = PHASE_30_NDL_TIME; | |
| 604 | 2549 |
| 582 | 2550 break; |
| 2551 | |
| 623 | 2552 |
| 2553 // | |
| 2554 //---- NDL Time --------------------------------------------------------------------------- | |
| 2555 // | |
| 2556 case PHASE_30_NDL_TIME: | |
| 2557 | |
| 2558 // Calculate the remaining no decompression limit (NDL) time for the tissue NDL_tissue. | |
| 2559 // NDL_time will be updated if the NDL time found is shorter than the current NDL_time. | |
| 2560 // | |
| 2561 // In the initialization phase of the calculation cycle: | |
| 2562 // - NDL_time had been initialized to 240 (minutes), | |
| 2563 // - NDL_tissue had been initialized to the tissue with | |
| 2564 // the shortest NDL time in the last cycle. | |
| 2565 // | |
| 2566 calc_NDL_time_tissue(); | |
| 2567 | |
| 2568 // advance to next tissue, wrapping around after last tissue | |
| 2569 NDL_tissue = (NDL_tissue + 1) & (NUM_COMP - 1); | |
| 2570 | |
| 2571 // did we run out of NDL time or did we have probed all tissues? | |
| 2572 if( (NDL_time == 0) || (NDL_tissue == NDL_tissue_start) ) | |
| 2573 { | |
| 2574 // YES | |
| 2575 | |
| 2576 // set the tissue with the shortest NDL time found as | |
| 2577 // the one to start with in the next calculation cycle | |
| 2578 if( deco_status & CALC_NORM ) NDL_tissue_start_norm = NDL_tissue_lead; | |
| 2579 else NDL_tissue_start_alt = NDL_tissue_lead; | |
| 2580 | |
| 2581 // done with calculating NDL time, set next calculation phase: | |
| 2582 // - calculate return and ascent in cave mode if configured, else | |
| 2583 // - proceed with gathering the results if within NDL time, or | |
| 2584 // - proceed with the initial ascent if beyond NDL time. | |
| 2585 #ifdef _cave_mode | |
| 2586 if ( main_status & CAVE_MODE ) next_planning_phase = PHASE_40_CAVE_ASCENT; | |
| 2587 else | |
| 2588 #endif | |
| 2589 if ( NDL_time ) next_planning_phase = PHASE_70_RESULTS; | |
| 2590 else next_planning_phase = PHASE_60_DECO_ASCENT; | |
| 2591 } | |
| 2592 | |
| 2593 break; | |
| 2594 | |
| 2595 | |
| 2596 #ifdef _cave_mode | |
| 2597 // | |
| 2598 //---- Cave Mode Return/Ascent ------------------------------------------------------------ | |
| 560 | 2599 // |
| 623 | 2600 case PHASE_40_CAVE_ASCENT: |
| 2601 | |
| 2602 // TODO | |
| 2603 | |
| 2604 // the next calculation phase will gather all results | |
| 2605 next_planning_phase = PHASE_70_RESULTS; | |
| 2606 | |
| 2607 break; | |
| 2608 #endif | |
| 2609 | |
| 2610 | |
| 560 | 2611 // |
| 623 | 2612 //---- Open Water Ascent with Deco Stops -------------------------------------------------- |
| 560 | 2613 // |
| 623 | 2614 case PHASE_60_DECO_ASCENT: |
| 2615 | |
| 2616 // program 1 minute interval on simulated tissues | |
| 2617 tissue_increment = 1; | |
| 2618 | |
| 2619 // ascent to the next stop depth or the depth that is reachable within one minute of ascent | |
| 2620 // and decide if a stop is required (return value = 1/true) or not (return value = 0/false) | |
| 2621 if( find_next_stop() ) | |
| 560 | 2622 { |
| 623 | 2623 //---- stop required -------------------- |
| 2624 | |
| 2625 // check if there is a better gas to switch to | |
| 2626 if( gas_find_better() ) | |
| 2627 { | |
| 2628 // set the new calculation ratios for N2, He and O2 | |
| 2629 gas_set_ratios(); | |
| 2630 | |
| 2631 // doing extended stops? | |
| 2632 if( main_status & EXTENDED_STOPS ) | |
| 2633 { | |
| 2634 // YES - set char_depth_sim to the gas change depth | |
| 2635 char_depth_sim = sim_gas_current_depth; | |
| 2636 | |
| 2637 // - adjust absolute pressure down to the change depth | |
| 2638 sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface; | |
| 2639 } | |
| 2640 | |
| 2641 // prime the deco stop with the gas change time | |
| 2642 update_deco_table(char_I_gas_change_time); | |
| 2643 } | |
| 2644 | |
| 2645 // add one minute to an existing stop or add a new stop at char_depth_sim, | |
| 2646 // or abort stops calculation if the deco table is full | |
| 2647 if( !update_deco_table(1) ) next_planning_phase = PHASE_70_RESULTS; | |
| 560 | 2648 } |
| 2649 else | |
| 2650 { | |
| 623 | 2651 //---- no stop required ----------------- |
| 2652 | |
| 2653 // check if there is a better gas to switch to, but only: | |
| 2654 // | |
| 2655 // if extended stops are activated, | |
| 2656 // OR if in bailout mode. | |
| 2657 // | |
| 2658 // Attention: do not use a && formula over both 'if' terms, the extended stops / bailout | |
| 2659 // condition must be checked before a call to gas_find_better() is made! | |
| 2660 // | |
| 2661 if( (main_status & EXTENDED_STOPS) || (deco_status & BAILOUT_MODE) ) | |
| 2662 if( gas_find_better() ) | |
| 560 | 2663 { |
| 623 | 2664 // set the new calculation values for N2, He and O2 |
| 2665 gas_set_ratios(); | |
| 2666 | |
| 2667 // stop duration is the gas change time, a change time of 0 minutes | |
| 2668 // will set a tissue calculation interval of 2 seconds | |
| 2669 tissue_increment += char_I_gas_change_time; | |
| 2670 | |
| 2671 // set char_depth_sim to the gas change depth, but not deeper than | |
| 2672 // the depth we came from. | |
| 2673 // (char_depth_last holds the depth from before the ascent step) | |
| 2674 char_depth_sim = (sim_gas_current_depth < char_depth_last) ? sim_gas_current_depth : char_depth_last; | |
| 2675 | |
| 2676 // adjust sim_pres_respiration to the adjusted value of char_depth_sim | |
| 2677 sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface; | |
| 2678 | |
| 2679 // create a stop for the gas change in the stops table | |
| 2680 update_deco_table(char_I_gas_change_time); | |
| 560 | 2681 } |
| 2682 } | |
| 2683 | |
| 623 | 2684 //---- one minute has passed by now, update the tissues ---------------- |
| 582 | 2685 |
| 604 | 2686 // compute current ppO2, ppN2 and ppHe |
| 582 | 2687 calc_alveolar_pressures(); |
| 2688 | |
| 560 | 2689 // update the tissues |
| 582 | 2690 calc_tissues(); |
| 604 | 2691 |
| 2692 // update the CNS value | |
| 2693 calc_CNS(); | |
| 623 | 2694 |
| 2695 // finish stops calculation if the surface is reached | |
| 2696 if( char_depth_sim == 0 ) next_planning_phase = PHASE_70_RESULTS; | |
| 2697 | |
| 2698 break; | |
| 2699 | |
| 2700 | |
| 2701 /// | |
| 2702 //--- Results - Initialization ------------------------------------------------------------ | |
| 2703 // | |
| 2704 case PHASE_70_RESULTS: | |
| 2705 | |
| 2706 // The current depth is needed by calc_ascenttime(), find_NDL_gas_changes() and | |
| 2707 // calc_gas_needs_ascent(). As we don't want it to be calculated multiple times, | |
| 2708 // it is done here on stockpile. | |
| 2709 char_depth_bottom = (unsigned char)((real_pres_respiration - pres_surface) * BAR_TO_METER + 0.5); | |
| 2710 | |
| 2711 // The next calculation phase will | |
| 2712 // - publish the stops table if in normal plan mode, | |
| 2713 // - proceed with remaining results dependent on if within NDL, or | |
| 2714 // - in deco | |
| 2715 if ( deco_status & CALC_NORM ) next_planning_phase = PHASE_71_RESULTS_STOPS_TABLE; | |
| 2716 else if ( NDL_time ) next_planning_phase = PHASE_72_RESULTS_NDL; | |
| 2717 else next_planning_phase = PHASE_73_RESULTS_DECO; | |
| 2718 | |
| 2719 break; | |
| 2720 | |
| 2721 | |
| 2722 /// | |
| 2723 //--- Publish Stops Table ----------------------------------------------------------------- | |
| 2724 // | |
| 2725 case PHASE_71_RESULTS_STOPS_TABLE: | |
| 2726 | |
| 2727 // publish the stops table to the display functions | |
| 2728 publish_deco_table(); | |
| 2729 | |
| 2730 // When entering deco and the ceiling depth becomes > 0 but the | |
| 2731 // deco calculation reveals no distinct deco stop yet because | |
| 2732 // the deco obligation will vanish during the ascent, create an | |
| 2733 // artificial stop to signal that expedite surfacing ("popping | |
| 2734 // up") is not allowed anymore. | |
| 2735 if( char_O_deco_depth[0] == 0 ) // simulated ascent reveals no required stops | |
| 2736 if( int_O_ceiling > 0 ) // real tissues have a ceiling | |
| 2737 { | |
| 2738 // set a pro forma stop at the configured last stop depth | |
| 2739 char_O_deco_depth[0] = char_I_depth_last_deco; | |
| 2740 | |
| 2741 // set a stop time of 0 minutes, this will be displayed as "..'" | |
| 2742 char_O_deco_time[0] = 0; | |
| 2743 } | |
| 2744 | |
| 2745 // update deco info vector | |
| 2746 if( char_O_deco_depth[0] ) deco_info |= DECO_STOPS; // set flag for deco stops found | |
| 2747 else deco_info &= ~DECO_STOPS; // clear flag for deco stops found | |
| 2748 | |
| 2749 // The next calculation phase will publish the main results dependent on being | |
| 2750 // - within NDL, | |
| 2751 // - in deco. | |
| 2752 if ( NDL_time ) next_planning_phase = PHASE_72_RESULTS_NDL; | |
| 2753 else next_planning_phase = PHASE_73_RESULTS_DECO; | |
| 2754 | |
| 2755 break; | |
| 2756 | |
| 2757 | |
| 2758 /// | |
| 2759 //--- Results - within NDL ---------------------------------------------------------------- | |
| 2760 // | |
| 2761 case PHASE_72_RESULTS_NDL: | |
| 2762 | |
| 2763 // results to publish depend on normal or alternative plan | |
| 2764 if( deco_status & CALC_NORM ) | |
| 2765 { | |
| 2766 // output the NDL time | |
| 2767 char_O_NDL_norm = NDL_time; | |
| 2768 | |
| 2769 // clear the normal ascent time | |
| 2770 int_O_TTS_norm = 0; | |
| 2771 | |
| 2772 // as we are in no stop, CNS at end of dive is more or less the same CNS as we have right now | |
| 2773 int_O_CNS_norm = int_O_CNS_current; | |
| 2774 } | |
| 2775 else | |
| 2776 { | |
| 2777 // output the NDL time | |
| 2778 char_O_NDL_alt = NDL_time; | |
| 2779 | |
| 2780 // clear the alternative ascent time | |
| 2781 int_O_TTS_alt = 0; | |
| 2782 | |
| 2783 // as we are in no stop, CNS at end of dive is more or less the same CNS as we have right now | |
| 2784 int_O_CNS_alt = int_O_CNS_current; | |
| 2785 } | |
| 2786 | |
| 2787 // The next calculation phase will | |
| 2788 // - finish the calculation cycle if no gas needs calculation configured, else | |
| 2789 // - find gas switches when in bailout mode (we are in NDL), or | |
| 2790 // - calculate the gas needs along the ascent | |
| 2791 if ( !(main_status & CALC_VOLUME ) ) next_planning_phase = PHASE_90_FINISH; | |
| 2792 else if ( (deco_status & BAILOUT_MODE) ) next_planning_phase = PHASE_80_GAS_NEEDS_SWITCHES; | |
| 2793 else next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT; | |
| 2794 | |
| 2795 break; | |
| 2796 | |
| 2797 | |
| 2798 /// | |
| 2799 //--- Results - in Deco ------------------------------------------------------------------- | |
| 2800 // | |
| 2801 case PHASE_73_RESULTS_DECO: | |
| 2802 | |
| 2803 // calculate the ascent time | |
| 2804 calc_ascenttime(); | |
| 2805 | |
| 2806 // convert the CNS value to integer | |
| 2807 convert_sim_CNS_for_display(); | |
| 2808 | |
| 2809 // results to publish depend on normal or alternative plan | |
| 2810 if( deco_status & CALC_NORM ) | |
| 2811 { | |
| 2812 // clear the normal NDL time | |
| 2813 char_O_NDL_norm = 0; | |
| 2814 | |
| 2815 // export the ascent time | |
| 2816 int_O_TTS_norm = ascent_time; | |
| 2817 | |
| 2818 // export the integer CNS value | |
| 2819 int_O_CNS_norm = int_sim_CNS_fraction; | |
| 2820 } | |
| 2821 else | |
| 2822 { | |
| 2823 // clear the alternative NDL time | |
| 2824 char_O_NDL_alt = 0; | |
| 2825 | |
| 2826 // export the ascent time | |
| 2827 int_O_TTS_alt = ascent_time; | |
| 2828 | |
| 2829 // export the integer CNS value | |
| 2830 int_O_CNS_alt = int_sim_CNS_fraction; | |
| 2831 } | |
| 2832 | |
| 2833 // The next calculation phase will | |
| 2834 // - finish the calculation cycle if no gas needs calculation configured, else | |
| 2835 // - calculate the gas needs along the ascent | |
| 2836 if ( !(main_status & CALC_VOLUME ) ) next_planning_phase = PHASE_90_FINISH; | |
| 2837 else next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT; | |
| 2838 | |
| 2839 break; | |
| 2840 | |
| 2841 | |
| 2842 // | |
| 2843 //--- Gas Needs - Switches ---------------------------------------------------------------- | |
| 2844 // | |
| 2845 case PHASE_80_GAS_NEEDS_SWITCHES: | |
| 2846 | |
| 2847 // When in bailout mode and within NDL, find the gas switches along the ascent and put | |
| 2848 // them into the stops table. The stops table can be "polluted" by now because the table | |
| 2849 // has already been published in "clean" state before. | |
| 2850 find_NDL_gas_changes(); | |
| 2851 | |
| 2852 // the next calculation phase will calculate the gas needs along the ascent | |
| 2853 next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT; | |
| 2854 | |
| 2855 break; | |
| 2856 | |
| 2857 | |
| 2858 // | |
| 2859 //--- Gas Needs - calculate Ascent Needs using Data from Stop Table ----------------------- | |
| 2860 // | |
| 2861 case PHASE_81_GAS_NEEDS_ASCENT: | |
| 2862 | |
| 2863 // calculate the gas needs along the ascent | |
| 2864 calc_gas_needs_ascent(); | |
| 2865 | |
| 2866 // if calculation has finished, advance to next calculation phase | |
| 2867 if( gas_needs_next_phase == GAS_NEEDS_DONE ) next_planning_phase = PHASE_82_GAS_NEEDS_PRESSURES; | |
| 2868 | |
| 2869 break; | |
| 2870 | |
| 2871 | |
| 2872 // | |
| 2873 //--- Gas Needs - convert Volumes to Pressures -------------------------------------------- | |
| 2874 // | |
| 2875 case PHASE_82_GAS_NEEDS_PRESSURES: | |
| 2876 | |
| 2877 // convert required volume of the gas pointed to by gas_needs_gas_index | |
| 2878 // into the respective pressure and set the flags | |
| 2879 convert_gas_needs_to_press(); | |
| 2880 | |
| 2881 // increment index to address next gas | |
| 2882 gas_needs_gas_index++; | |
| 2883 | |
| 2884 // if all gases have been converted, advance to next calculation phase | |
| 2885 if( gas_needs_gas_index == NUM_GAS ) next_planning_phase = PHASE_90_FINISH; | |
| 2886 | |
| 2887 break; | |
| 2888 | |
| 2889 | |
| 2890 // | |
| 2891 //--- finish Calculation Cycle ------------------------------------------------------------ | |
| 2892 // | |
| 2893 case PHASE_90_FINISH: | |
| 2894 | |
| 2895 // Check if deco obligation is steady state or decreasing. | |
| 2896 // This works only when an alternative plan is enabled and if it is not a bailout plan, | |
| 2897 // thus BAILOUT_MODE must not be set while doing the alternative plan. | |
| 2898 if( (deco_status & CALC_ALT) && !(deco_status & BAILOUT_MODE) ) | |
| 2899 { | |
| 2900 if ( int_O_TTS_alt <= int_O_TTS_norm ) deco_info |= DECO_ZONE; | |
| 2901 else deco_info &= ~DECO_ZONE; | |
| 2902 } | |
| 2903 | |
| 2904 // export updated deco infos and warnings | |
| 2905 char_O_deco_info = deco_info; | |
| 2906 char_O_deco_warnings = deco_warnings; | |
| 2907 | |
| 2908 // restore command flag to indicate that deco calculation cycle has finished | |
| 2909 char_O_deco_status = deco_status; | |
| 2910 | |
| 2911 // signal end of deco calculation | |
| 2912 next_planning_phase = PHASE_00_DONE; | |
| 2913 | |
| 2914 break; | |
| 2915 | |
| 2916 } // switch | |
| 2917 | |
| 2918 // read timer 5, result will be stored in tmr5_value (in 1/32 ms) and tmr5_overflow | |
| 2919 read_tmr5(); | |
| 2920 | |
| 2921 } // sequence calculation phases while not timed out and calculation cycle is not finished | |
| 2922 while( (tmr5_overflow == 0) && ( next_planning_phase != PHASE_00_DONE ) ); | |
| 2923 | |
| 2924 // report where we are in terms of depth reached, used in deco calculator to show deco calculation progress | |
| 2925 char_O_depth_sim = char_depth_sim; | |
| 2926 | |
| 2927 | |
| 2928 #ifdef _profiling | |
| 2929 | |
| 2930 //---- Performance Measurement ------------------------------------------- | |
| 2931 | |
| 2932 // convert timer 5 readout into ms | |
| 2933 profiling_runtime = tmr5_value / 32; | |
| 2934 | |
| 2935 // actual runtime longer than target runtime? | |
| 2936 if( tmr5_overflow ) | |
| 2937 { | |
| 2938 // YES - report excess | |
| 2939 int_O_profiling_overrun = profiling_runtime; | |
| 2940 | |
| 2941 // - excess > max we had so far? | |
| 2942 if( int_O_profiling_overrun > int_O_profiling_overrun_max ) | |
| 2943 { | |
| 2944 // YES - update max | |
| 2945 int_O_profiling_overrun_max = int_O_profiling_overrun; | |
| 2946 | |
| 2947 // - store the causing phase | |
| 2948 char_O_profiling_overrun_phase = profiling_phase; | |
| 2949 } | |
| 560 | 2950 } |
| 623 | 2951 else |
| 2952 { | |
| 2953 // NO - calculate unused budget and flag it to be under-run time | |
| 2954 int_O_profiling_overrun = (2048 - profiling_runtime) | 0x8000; | |
| 2955 } | |
| 2956 | |
| 2957 // increment number of runs in current cycle | |
| 2958 profiling_runs += 1; | |
| 2959 | |
| 2960 // planning cycle completed? | |
| 2961 if( next_planning_phase == PHASE_00_DONE ) | |
| 2962 { | |
| 2963 // YES - export number of runs it took | |
| 2964 if( deco_status & COMPLETED_NORM ) char_O_profiling_runs_norm = profiling_runs; | |
| 2965 else char_O_profiling_runs_alt = profiling_runs; | |
| 2966 } | |
| 2967 | |
| 2968 #endif | |
| 2969 | |
| 2970 } | |
| 2971 | |
| 2972 | |
| 2973 ////////////////////////////////////////////////////////////////////////////// | |
| 2974 // calc_hauptroutine_data_input | |
| 2975 // | |
| 2976 // Set all C-code dive parameters from their ASM-code values. | |
| 2977 // | |
| 2978 void calc_hauptroutine_data_input(void) | |
| 2979 { | |
| 2980 overlay float IG_ratio; | |
| 2981 | |
| 2982 // safeguard and convert the surface pressure (mbar -> bar) (*) | |
| 2983 if( int_I_pres_surface < 500 ) pres_surface = 0.500; | |
| 2984 else pres_surface = 0.001 * int_I_pres_surface; | |
| 2985 | |
| 2986 // safeguard and convert the current real pressure | |
| 2987 if( int_I_pres_respiration < 500 ) real_pres_respiration = 0.500; | |
| 2988 else real_pres_respiration = 0.001 * int_I_pres_respiration; | |
| 2989 | |
| 2990 // safeguard further parameters to protect the tissue-flag and the stop table | |
| 2991 if( char_I_sim_advance_time > 127 ) char_I_sim_advance_time = 127; | |
| 2992 if( char_I_extra_time > 127 ) char_I_extra_time = 127; | |
| 2993 if( char_I_gas_change_time > 99 ) char_I_gas_change_time = 99; | |
| 2994 | |
| 2995 // calculate partial pressure of N2 in respired air at surface pressure | |
| 2996 calc_N2_equilibrium(); | |
| 2997 | |
| 2998 // get, safeguard and convert the saturation and desaturation factors | |
| 2999 get_saturation_factors(); | |
| 3000 | |
| 3001 #ifdef _ccr_pscr | |
| 3002 // compute a factor that will be used later on for pSCR ppO2 drop calculation (*) | |
| 3003 float_pSCR_factor = 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio; | |
| 3004 #endif | |
| 3005 | |
| 3006 #ifdef _helium | |
| 3007 // get the currently breathed gas ratios | |
| 3008 real_O2_ratio = 0.01 * char_I_O2_ratio; | |
| 3009 real_He_ratio = 0.01 * char_I_He_ratio; | |
| 3010 | |
| 3011 // calculate the inert gas ratio (local helper variable) | |
| 3012 IG_ratio = 1.00 - real_O2_ratio; | |
| 3013 | |
| 3014 // calculate the N2 ratio | |
| 3015 real_N2_ratio = IG_ratio - real_He_ratio; | |
| 3016 #else | |
| 3017 // get the currently breathed O2 ratio | |
| 3018 real_O2_ratio = 0.01 * char_I_O2_ratio; | |
| 3019 | |
| 3020 // set the He ratio to zero | |
| 3021 real_He_ratio = 0.0; | |
| 3022 | |
| 3023 // calculate the N2 / inert gas ratio | |
| 3024 real_N2_ratio = IG_ratio = 1.00 - real_O2_ratio; | |
| 3025 #endif // _helium | |
| 3026 | |
| 3027 #ifdef _ccr_pscr | |
| 3028 // calculate ppO2 drop in pSCR loop for real tissues | |
| 3029 real_pSCR_drop = IG_ratio * float_pSCR_factor; | |
| 3030 #endif | |
| 3031 | |
| 0 | 3032 } |
| 3033 | |
| 3034 | |
| 3035 ////////////////////////////////////////////////////////////////////////////// | |
| 604 | 3036 // Find gas changes on an NDL ascent |
| 3037 // | |
| 623 | 3038 // This function is used for finding the gas changes in an OC bailout ascent |
| 3039 // that is within NDL. | |
| 3040 // | |
| 3041 // Input: char_depth_bottom depth at which the ascent starts, in meters | |
| 3042 // | |
| 3043 // Output: gas change stops put into stops table | |
| 3044 // | |
| 3045 // Destroyed: char_depth_sim | |
| 3046 // sim_gas_current_num number of current gas | |
| 3047 // sim_gas_current_depth change depth of current gas | |
| 0 | 3048 // |
| 604 | 3049 void find_NDL_gas_changes(void) |
| 3050 { | |
| 3051 overlay unsigned char old_depth_limit; | |
| 3052 | |
| 3053 // set gas to start with | |
| 3054 gas_find_current(); | |
| 3055 | |
| 3056 // loop in ascending until reaching a depth of 3 meters, no gas switches considered thereafter | |
| 623 | 3057 for( char_depth_sim = char_depth_bottom; char_depth_sim >= 3; ) |
| 604 | 3058 { |
| 3059 // memorize the depth we came from | |
| 623 | 3060 old_depth_limit = char_depth_sim; |
| 604 | 3061 |
| 3062 // ascent - initially in steps of 10 m, then slowing down to 1 m steps to not miss a O2 gas | |
| 623 | 3063 if ( char_depth_sim > 10 ) char_depth_sim -= 10; |
| 3064 else char_depth_sim -= 1; | |
| 604 | 3065 |
| 3066 // check if there is a better gas to switch to | |
| 3067 if( gas_find_better() ) | |
| 3068 { | |
| 623 | 3069 // adjust char_depth_sim to the gas change depth, but not deeper than the depth we came from |
| 3070 char_depth_sim = (sim_gas_current_depth < old_depth_limit) ? sim_gas_current_depth : old_depth_limit; | |
| 604 | 3071 |
| 3072 // create a stop for the gas change in the stops table | |
| 3073 update_deco_table(char_I_gas_change_time); | |
| 3074 } | |
| 3075 } // for() | |
| 3076 } | |
| 3077 | |
| 3078 | |
| 3079 ////////////////////////////////////////////////////////////////////////////// | |
| 582 | 3080 // calc_tissues |
| 0 | 3081 // |
| 623 | 3082 // INPUT: ppN2 partial pressure of inspired N2 |
| 3083 // ppHe partial pressure of inspired He | |
| 3084 // tissue_increment integration time and tissue selector (real or simulated) | |
| 3085 // | |
| 3086 // MODIFIED: real_pres_tissue_N2[] tissue N2 pressures (in real tissues context) | |
| 3087 // real_pres_tissue_He[] tissue He pressures (in real tissues context) | |
| 3088 // sim_pres_tissue_N2[] tissue N2 pressures (in simulated tissues context) | |
| 3089 // sim_pres_tissue_He[] tissue He pressures (in simulated tissues context) | |
| 3090 // | |
| 3091 // OUTPUT: char_O_tissue_pres_N2[] tissue N2 pressures scaled for display purpose (in real tissues context) | |
| 3092 // char_O_tissue_pres_He[] tissue He pressures scaled for display purpose (in real tissues context) | |
| 3093 // char_O_tissue_pressure[] combined tissue pressures scaled for display purpose (in real tissue context) | |
| 582 | 3094 // |
| 3095 static void calc_tissues() | |
| 0 | 3096 { |
| 623 | 3097 overlay unsigned char period; |
| 560 | 3098 overlay float temp_tissue_N2; |
| 623 | 3099 |
| 3100 #ifdef _helium | |
| 560 | 3101 overlay float temp_tissue_He; |
| 623 | 3102 #endif |
| 582 | 3103 |
| 3104 | |
| 3105 assert( 0.00 <= ppN2 && ppN2 < 11.2 ); // 80% N2 at 130m | |
| 3106 assert( 0.00 <= ppHe && ppHe < 12.6 ); // 90% He at 130m | |
| 3107 | |
| 3108 | |
| 604 | 3109 for( ci=0; ci < NUM_COMP; ci++ ) // iterate through all compartments |
| 582 | 3110 { |
| 3111 i = tissue_increment & TIME_MASK; // extract number of minutes to do (if i > 0) | |
| 3112 // or if one 2 second period is to do (if i = 0) | |
| 3113 | |
| 3114 if( i == 0 ) // check if we shall do one 2-seconds period | |
| 560 | 3115 { |
| 623 | 3116 read_Buhlmann_times(0); // YES - program coefficients for a 2 seconds period |
| 3117 period = 1; // - set period length (in cycles) | |
| 3118 i = 1; // - and one cycle to do | |
| 560 | 3119 } |
| 582 | 3120 else if( i > 9 ) // check if we can start with 10 minutes periods |
| 560 | 3121 { |
| 623 | 3122 read_Buhlmann_times(2); // YES - program coefficients for 10 minutes periods |
| 3123 period = 10; // set period length (in cycles) to ten | |
| 560 | 3124 } |
| 623 | 3125 else // last but not lease, do 1 to 9 minutes |
| 560 | 3126 { |
| 623 | 3127 read_Buhlmann_times(1); // NO - program coefficients for 1 minute periods |
| 3128 period = 1; // - set period length (in cycles) to one | |
| 560 | 3129 } |
| 3130 | |
| 3131 do | |
| 3132 { | |
| 623 | 3133 //---- N2 -------------------------------------------------------- |
| 3134 | |
| 3135 temp_tissue = (tissue_increment & TISSUE_SELECTOR) ? real_pres_tissue_N2[ci] : sim_pres_tissue_N2[ci]; | |
| 560 | 3136 |
| 3137 temp_tissue = (ppN2 - temp_tissue) * var_N2_e; | |
| 3138 | |
| 623 | 3139 apply_saturation_factors(); |
| 3140 | |
| 3141 if( tissue_increment & TISSUE_SELECTOR ) | |
| 560 | 3142 { |
| 623 | 3143 temp_tissue_N2 = temp_tissue; |
| 3144 real_pres_tissue_N2[ci] += temp_tissue; | |
| 560 | 3145 } |
| 3146 else | |
| 3147 { | |
| 623 | 3148 sim_pres_tissue_N2[ci] += temp_tissue; |
| 560 | 3149 } |
| 3150 | |
| 623 | 3151 #ifdef _helium |
| 3152 //---- He -------------------------------------------------------- | |
| 3153 | |
| 3154 temp_tissue = (tissue_increment & TISSUE_SELECTOR) ? real_pres_tissue_He[ci] : sim_pres_tissue_He[ci]; | |
| 560 | 3155 |
| 3156 temp_tissue = (ppHe - temp_tissue) * var_He_e; | |
| 3157 | |
| 623 | 3158 apply_saturation_factors(); |
| 3159 | |
| 3160 if( tissue_increment & TISSUE_SELECTOR ) | |
| 560 | 3161 { |
| 623 | 3162 temp_tissue_He = temp_tissue; |
| 3163 real_pres_tissue_He[ci] += temp_tissue; | |
| 560 | 3164 } |
| 3165 else | |
| 3166 { | |
| 623 | 3167 sim_pres_tissue_He[ci] += temp_tissue; |
| 560 | 3168 } |
| 623 | 3169 #endif |
| 3170 | |
| 3171 //---- decrement loop counter and adjust step size --------------- | |
| 560 | 3172 |
| 3173 // decrement loop counter | |
| 3174 i -= period; | |
| 582 | 3175 |
| 560 | 3176 // check if we need to switch from 10 minute periods to 1 minute periods |
| 3177 if( (i > 0) && (period = 10) && (i < 10) ) | |
| 3178 { | |
| 582 | 3179 read_Buhlmann_times(1); // program coefficients for 1 minute periods |
| 560 | 3180 period = 1; // set period length (in cycles) to one |
| 3181 } | |
| 3182 } | |
| 3183 while( i ); | |
| 582 | 3184 |
| 3185 | |
| 560 | 3186 // have the computations been done for the "real" tissues? |
| 623 | 3187 if( tissue_increment & TISSUE_SELECTOR ) |
| 560 | 3188 { |
| 623 | 3189 |
| 3190 #ifdef _helium | |
| 3191 | |
| 560 | 3192 // net tissue balance |
| 3193 temp_tissue = temp_tissue_N2 + temp_tissue_He; | |
| 582 | 3194 |
| 623 | 3195 |
| 560 | 3196 // check tissue on-/off-gassing and IBCD with applying a threshold of +/-HYST |
| 3197 // | |
| 584 | 3198 if ( temp_tissue < -HYST ) // check if the tissue is off-gassing |
| 560 | 3199 { |
| 623 | 3200 // tag tissue as not experiencing mentionable IBCD |
| 3201 IBCD_tissue_vector &= ~(1 << ci); | |
| 560 | 3202 } |
| 3203 else if ( temp_tissue > +HYST ) // check if the tissue in on-gassing | |
| 3204 { | |
| 623 | 3205 // check for counter diffusion |
| 3206 if( ((temp_tissue_N2 > 0.0) && (temp_tissue_He < 0.0)) | |
| 604 | 3207 || ((temp_tissue_N2 < 0.0) && (temp_tissue_He > 0.0)) ) |
| 560 | 3208 { |
| 623 | 3209 // tag tissue as experiencing mentionable IBCD |
| 3210 IBCD_tissue_vector |= (1 << ci); | |
| 560 | 3211 } |
| 3212 } | |
| 3213 | |
| 623 | 3214 #endif |
| 3215 | |
| 3216 // For N2 tissue pressure display purpose: | |
| 3217 | |
| 3218 // basically keep the on-gassing / off-gassing flag from last invocation, but flip | |
| 3219 // it in case the rate exceeds a set hysteresis (actual value: see #define of HYST) | |
| 3220 char_O_tissue_pres_N2[ci] &= 128; | |
| 3221 if ( temp_tissue_N2 > +HYST ) char_O_tissue_pres_N2[ci] = 128; // set flag for tissue pressure is increasing | |
| 3222 else if ( temp_tissue_N2 < -HYST ) char_O_tissue_pres_N2[ci] = 0; // clear flag (-> tissue pressure is decreasing) | |
| 3223 | |
| 3224 // scale N2 tissue pressure such that the surface steady-state tissue loading | |
| 3225 // of [0.7902 * (1013 hPa - ppWater)] bar will give a 8, which aligns with | |
| 3226 // the 2nd scale line. | |
| 3227 temp_tissue_N2 = (8 / (0.7902 * (1.013 - ppWater))) * real_pres_tissue_N2[ci]; | |
| 3228 | |
| 3229 // limit to 127 to protect the uppermost bit which holds the sat/desat flag | |
| 3230 if (temp_tissue_N2 > 127) temp_tissue_N2 = 127; | |
| 3231 | |
| 3232 // convert to integer and combine with sat/desat flag | |
| 3233 char_O_tissue_pres_N2[ci] += (unsigned char)temp_tissue_N2; | |
| 3234 | |
| 3235 #ifdef _helium | |
| 3236 | |
| 3237 // For He tissue pressure display purpose: | |
| 3238 | |
| 3239 // basically keep the on-gassing / off-gassing flag from last invocation, but flip | |
| 3240 // it in case the rate exceeds a set hysteresis (actual value: see #define of HYST) | |
| 3241 char_O_tissue_pres_He[ci] &= 128; | |
| 3242 if ( temp_tissue_He > +HYST ) char_O_tissue_pres_He[ci] = 128; // set flag for tissue pressure is increasing | |
| 3243 else if ( temp_tissue_He < -HYST ) char_O_tissue_pres_He[ci] = 0; // clear flag (-> tissue pressure is decreasing) | |
| 3244 | |
| 3245 // scale He tissue pressure alike it is done for N2. | |
| 3246 // With no He in a tissue, the result will be 0. | |
| 3247 temp_tissue_He = (8 / (0.7902 * (1.013 - ppWater))) * real_pres_tissue_He[ci]; | |
| 3248 | |
| 3249 // limit to 127 to protect the uppermost bit which holds the sat/desat flag | |
| 3250 if (temp_tissue_He > 127) temp_tissue_He = 127; | |
| 3251 | |
| 3252 // convert to integer and combine with sat/desat flag | |
| 3253 char_O_tissue_pres_He[ci] += (unsigned char)temp_tissue_He; | |
| 3254 | |
| 3255 | |
| 3256 // For combined tissue pressure display purpose: | |
| 3257 | |
| 3258 // basically keep the on-gassing / off-gassing flag from last invocation, but flip | |
| 3259 // it in case the rate exceeds a set hysteresis (actual value: see #define of HYST) | |
| 3260 char_O_tissue_pressure[ci] &= 128; | |
| 3261 if ( temp_tissue > +HYST ) char_O_tissue_pressure[ci] = 128; // set flag for tissue pressure is increasing | |
| 3262 else if ( temp_tissue < -HYST ) char_O_tissue_pressure[ci] = 0; // clear flag (-> tissue pressure is decreasing) | |
| 3263 | |
| 3264 // add the two scaled pressures. | |
| 3265 temp_tissue = temp_tissue_N2 + temp_tissue_He; | |
| 3266 | |
| 3267 // limit to 127 to protect the uppermost bit which holds the sat/desat flag | |
| 560 | 3268 if (temp_tissue > 127) temp_tissue = 127; |
| 3269 | |
| 623 | 3270 // convert to integer and combine with sat/desat flag |
| 3271 char_O_tissue_pressure[ci] += (unsigned char)temp_tissue; | |
| 3272 | |
| 3273 #else | |
| 3274 | |
| 3275 // He tissue pressure is zero | |
| 3276 char_O_tissue_pres_He[ci] = 0; | |
| 3277 | |
| 3278 // combined tissue pressure equals N2 tissue pressure | |
| 3279 char_O_tissue_pressure[ci] = char_O_tissue_pres_N2[ci]; | |
| 3280 | |
| 3281 #endif | |
| 3282 | |
| 582 | 3283 } //if |
| 3284 | |
| 3285 } // for | |
| 0 | 3286 } |
| 3287 | |
| 623 | 3288 |
| 0 | 3289 ////////////////////////////////////////////////////////////////////////////// |
| 3290 // calc_limit | |
| 3291 // | |
| 623 | 3292 // Input: GF_parameter gradient factor to be used, negative values activate surface mode |
| 3293 // tissue_increment selector for context: real or simulated tissues | |
| 3294 // sim_pres_tissue_N2/_He tissue pressures (used in simulated tissues context) | |
| 3295 // real_pres_tissue_N2/_He tissue pressures (used in real tissues context) | |
| 3296 // | |
| 3297 // Output: lead_supersat highest supersaturation found among all tissues, 1.0 = 100% | |
| 3298 // lead_tissue number of the leading tissue (0-15) | |
| 3299 // ceiling ceiling in bar relative pressure | |
| 3300 // | |
| 3301 // Modified: deco_warnings for IBCD, micro bubbles and outside warning (only in real tissues context) | |
| 582 | 3302 // |
| 3303 static void calc_limit(PARAMETER float GF_parameter) | |
| 0 | 3304 { |
| 623 | 3305 overlay float pres_respiration_min_total = 0.0; |
| 3306 overlay unsigned char surface_mode = 0; // 0: off, 1: on | |
| 3307 | |
| 3308 | |
| 3309 // check mode | |
| 3310 if( GF_parameter < 0 ) | |
| 3311 { | |
| 3312 // activate surface mode | |
| 3313 surface_mode = 1; | |
| 3314 | |
| 3315 // normalize parameter | |
| 3316 GF_parameter = -GF_parameter; | |
| 3317 } | |
| 3318 | |
| 3319 // set leading tissue number to tissue 1 (it has the index 0) | |
| 3320 lead_tissue = 0; | |
| 604 | 3321 |
| 3322 // initialize leading tissue supersaturation value to null | |
| 623 | 3323 lead_supersat = 0.0; |
| 3324 | |
| 3325 // next code section is relevant only when invoked on the real tissues | |
| 3326 if( tissue_increment & TISSUE_SELECTOR ) | |
| 582 | 3327 { |
| 623 | 3328 // clear IBCD, micro-bubbles and outside warning flags (locked warnings will be preserved) |
| 3329 deco_warnings &= ~( DECO_WARNING_IBCD + DECO_WARNING_MBUBBLES + DECO_WARNING_OUTSIDE + DECO_ATTENTION_OUTSIDE ); | |
| 582 | 3330 } |
| 3331 | |
| 3332 // loop over all tissues | |
| 604 | 3333 for( ci = 0; ci < NUM_COMP; ci++ ) |
| 582 | 3334 { |
| 623 | 3335 overlay float pres_respiration_min_tissue; |
| 3336 | |
| 3337 | |
| 3338 // get the coefficients for tissue ci | |
| 3339 read_Buhlmann_coefficients(); | |
| 3340 | |
| 3341 #ifdef _helium | |
| 582 | 3342 |
| 3343 // get the tissue pressures | |
| 623 | 3344 // adopt_Buhlmann_coefficients needs calc_pres_tissue_N2/He when compiled for helium |
| 3345 if( tissue_increment & TISSUE_SELECTOR ) | |
| 560 | 3346 { |
| 582 | 3347 // context is real tissues |
| 623 | 3348 calc_pres_tissue_N2 = real_pres_tissue_N2[ci]; |
| 3349 calc_pres_tissue_He = real_pres_tissue_He[ci]; | |
| 560 | 3350 } |
| 3351 else | |
| 3352 { | |
| 582 | 3353 // context is simulated tissues |
| 3354 calc_pres_tissue_N2 = sim_pres_tissue_N2[ci]; | |
| 3355 calc_pres_tissue_He = sim_pres_tissue_He[ci]; | |
| 3356 } | |
| 3357 | |
| 3358 // overall tissue pressure | |
| 3359 pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He; | |
| 3360 | |
| 623 | 3361 #else |
| 3362 | |
| 3363 // get the tissue pressure | |
| 3364 pres_tissue = ( tissue_increment & TISSUE_SELECTOR ) ? real_pres_tissue_N2[ci] : sim_pres_tissue_N2[ci]; | |
| 3365 | |
| 3366 #endif | |
| 582 | 3367 |
| 604 | 3368 // adopt a and b coefficients to current N2/He ratio inside the tissue |
| 3369 adopt_Buhlmann_coefficients(); | |
| 582 | 3370 |
| 3371 // next calculations are only relevant when invoked on the real tissues | |
| 623 | 3372 if( tissue_increment & TISSUE_SELECTOR ) |
| 582 | 3373 { |
| 618 | 3374 overlay float pres_tissue_max; |
| 582 | 3375 overlay float supersat; |
| 608 | 3376 overlay float baseline_threshold; |
| 604 | 3377 |
| 623 | 3378 |
| 582 | 3379 // check if tissue is in supersaturation |
| 618 | 3380 if( pres_tissue > real_pres_respiration ) |
| 582 | 3381 { |
| 618 | 3382 // calculate maximum allowed tissue pressure at current ambient pressure |
| 623 | 3383 pres_tissue_max = real_pres_respiration / var_b + var_a; |
| 618 | 3384 |
| 3385 // calculate current supersaturation value (1.0 = 100%) of this tissue according to straight Buhlmann | |
| 3386 supersat = ( pres_tissue - real_pres_respiration ) | |
| 3387 / ( pres_tissue_max - real_pres_respiration ); | |
| 3388 | |
| 623 | 3389 // calculate supersaturation value for display purpose: 1.35 = 135% = 86 pixel |
| 3390 if( supersat <= 1.35 ) char_O_tissue_saturation[ci] = (unsigned char)(supersat * 64); | |
| 3391 else char_O_tissue_saturation[ci] = 86; | |
| 3392 | |
| 582 | 3393 // memorize highest supersaturation found |
| 3394 if( supersat > lead_supersat ) lead_supersat = supersat; | |
| 3395 | |
| 608 | 3396 // tissue-dependent baseline threshold for micro bubbles and outside warnings |
| 3397 baseline_threshold = 0.02 * ci + 1.0; | |
| 3398 | |
| 3399 // micro bubbles warning: supersaturation > baseline threshold | |
| 3400 if( supersat > baseline_threshold ) | |
| 623 | 3401 deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock); |
| 604 | 3402 |
| 608 | 3403 // outside warning: supersaturation > baseline threshold + additional 5% margin |
| 623 | 3404 if( supersat > (baseline_threshold + 0.05) ) |
| 3405 deco_warnings |= (DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock ); | |
| 3406 } | |
| 3407 else | |
| 3408 { | |
| 3409 // supersaturation is defined as zero while tissue pressure <= ambient pressure | |
| 3410 supersat = 0.0; | |
| 3411 char_O_tissue_saturation[ci] = 0; | |
| 560 | 3412 } |
| 623 | 3413 |
| 3414 // next only when in surface mode | |
| 3415 if( surface_mode ) | |
| 3416 { | |
| 3417 // tag tissue whether it is beyond the M-line limit or not | |
| 3418 if( supersat > 1.0 ) | |
| 3419 { | |
| 3420 char_O_tissue_pres_N2[ci] |= 128; | |
| 3421 #ifdef _helium | |
| 3422 char_O_tissue_pres_He[ci] |= 128; | |
| 3423 #endif | |
| 3424 char_O_tissue_pressure[ci] |= 128; | |
| 3425 } | |
| 3426 else | |
| 3427 { | |
| 3428 char_O_tissue_pres_N2[ci] &= ~128; | |
| 3429 #ifdef _helium | |
| 3430 char_O_tissue_pres_He[ci] &= ~128; | |
| 3431 #endif | |
| 3432 char_O_tissue_pressure[ci] &= ~128; | |
| 3433 } | |
| 3434 } | |
| 3435 } // real tissues | |
| 582 | 3436 |
| 618 | 3437 // calculate the minimum ambient pressure that the tissue can withstand |
| 3438 if( char_I_deco_model == 0 ) | |
| 3439 { | |
| 3440 // straight Buhlmann | |
| 623 | 3441 pres_respiration_min_tissue = (pres_tissue - var_a) * var_b; |
| 618 | 3442 } |
| 3443 else | |
| 3444 { | |
| 3445 // Buhlmann with Eric Baker's varying gradient factor correction | |
| 3446 // note: this equation [1] is the inverse of equation [2] | |
| 623 | 3447 pres_respiration_min_tissue = ( pres_tissue - (var_a * GF_parameter) ) |
| 3448 / ( 1.0 - GF_parameter + (GF_parameter / var_b ) ); | |
| 618 | 3449 } |
| 560 | 3450 |
| 3451 // check if this tissue requires a higher ambient pressure than was found to be needed up to now | |
| 623 | 3452 if( pres_respiration_min_tissue > pres_respiration_min_total ) |
| 582 | 3453 { |
| 623 | 3454 pres_respiration_min_total = pres_respiration_min_tissue; |
| 3455 lead_tissue = ci; | |
| 582 | 3456 } |
| 3457 } // for | |
| 3458 | |
| 604 | 3459 // compute ceiling for the real tissues in bar relative pressure |
| 623 | 3460 ceiling = pres_respiration_min_total - pres_surface; |
| 3461 | |
| 3462 #ifdef _helium | |
| 3463 // IBCD is checked for real tissues only | |
| 3464 if( tissue_increment & TISSUE_SELECTOR ) | |
| 560 | 3465 { |
| 604 | 3466 // check if the leading tissue is in IBCD condition |
| 623 | 3467 if( (IBCD_tissue_vector & (1 << lead_tissue)) |
| 3468 && ((real_pres_tissue_N2[lead_tissue] + real_pres_tissue_He[lead_tissue]) > real_pres_respiration) ) | |
| 582 | 3469 { |
| 623 | 3470 // leading tissue is in IBCD condition and in super-saturation, so issue a warning. |
| 3471 deco_warnings |= (DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock); | |
| 582 | 3472 } |
| 560 | 3473 } |
| 623 | 3474 #endif |
| 3475 | |
| 0 | 3476 } |
| 623 | 3477 |
| 3478 | |
| 0 | 3479 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 3480 // calc_NDL_time_tissue |
| 3481 // | |
| 3482 // calculation of the remaining no decompression limit (NDL) time for a tissue | |
| 0 | 3483 // |
| 604 | 3484 // NOTE: Erik Baker's closed formula works for Nitrox. Trimix adds a second |
| 0 | 3485 // exponential term to the M-value equation, making it impossible to |
| 623 | 3486 // invert. So we have to solve the problem with a search approach. |
| 3487 // | |
| 3488 // Input: NDL_tissue tissue for which to calculate remaining NDL time | |
| 3489 // GF_high gradient factor used when GF factors are enabled | |
| 3490 // ppN2, ppHe partial pressures of N2 and He breathed | |
| 3491 // | |
| 3492 // Modified: NDL_time shortest NDL time found so far | |
| 3493 // NDL_tissue_lead leading tissue, i.e. tissue with the shortest NDL | |
| 3494 // | |
| 3495 static void calc_NDL_time_tissue(void) | |
| 0 | 3496 { |
| 623 | 3497 overlay unsigned char NDL_time_tissue = 0; // NDL time of this tissue, starting with 0 minutes |
| 3498 overlay unsigned char step_size = 10; // step size in searching, starting with 10 minutes | |
| 3499 overlay float pres_limit; // max. tissue pressure allowed | |
| 3500 | |
| 3501 #ifdef _helium | |
| 3502 overlay float last_pres_tissue_N2; // last tissue pressure for N2 | |
| 3503 overlay float last_pres_tissue_He; // last tissue pressure for He | |
| 3504 #else | |
| 3505 overlay float last_pres_tissue; // last tissue pressure | |
| 3506 #endif | |
| 3507 | |
| 3508 | |
| 3509 // set the compartment index ci for reading the Buhlmann increments and coefficients | |
| 3510 ci = NDL_tissue; | |
| 3511 | |
| 3512 // read the tissue increments for a step size of 10 minutes | |
| 3513 read_Buhlmann_times(2); | |
| 3514 | |
| 3515 // read Buhlmann a and b coefficients for tissue ci | |
| 3516 read_Buhlmann_coefficients(); | |
| 3517 | |
| 3518 #ifdef _helium | |
| 3519 | |
| 3520 // get the current simulated tissue pressures | |
| 3521 calc_pres_tissue_N2 = last_pres_tissue_N2 = sim_pres_tissue_N2[ci]; | |
| 3522 calc_pres_tissue_He = last_pres_tissue_He = sim_pres_tissue_He[ci]; | |
| 3523 | |
| 3524 #else | |
| 3525 | |
| 3526 // get the current simulated tissue pressure | |
| 3527 pres_tissue = last_pres_tissue = sim_pres_tissue_N2[ci]; | |
| 3528 | |
| 3529 // set the a and b coefficients | |
| 3530 adopt_Buhlmann_coefficients(); | |
| 3531 | |
| 3532 #endif | |
| 3533 | |
| 3534 // simulate an increasing bottom time and check when the NDL is hit | |
| 3535 for(;;) | |
| 582 | 3536 { |
| 623 | 3537 |
| 3538 #ifdef _helium | |
| 3539 | |
| 3540 // calculate the total tissue pressure | |
| 582 | 3541 pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He; |
| 3542 | |
| 623 | 3543 // adopt a and b coefficients to current N2/He ratio inside the tissue |
| 3544 adopt_Buhlmann_coefficients(); | |
| 3545 | |
| 3546 #endif | |
| 3547 | |
| 3548 // compute the maximum tissue pressure allowed to be exposed to an | |
| 3549 // ambient pressure equaling the surface pressure | |
| 3550 if( char_I_deco_model != 0 ) | |
| 3551 { | |
| 3552 // GF model enabled, this equation [2] is the inverse of equation [1] | |
| 3553 pres_limit = (1.0 - GF_high + GF_high / var_b) * pres_surface + GF_high * var_a; | |
| 3554 } | |
| 3555 else | |
| 582 | 3556 { |
| 623 | 3557 // straight Buhlmann |
| 3558 pres_limit = pres_surface / var_b + var_a; | |
| 3559 } | |
| 3560 | |
| 3561 // is the tissue pressure higher than the maximum tissue pressure allowed? | |
| 3562 if( pres_tissue > pres_limit) | |
| 3563 { | |
| 3564 // YES - tissue is outside NDL | |
| 3565 | |
| 3566 // was the tissue outside NDL right from the start? | |
| 3567 if( NDL_time_tissue == 0 ) | |
| 582 | 3568 { |
| 623 | 3569 // YES - search can be aborted |
| 3570 | |
| 3571 // at least one tissue is outside NDL, so overall NDL time is zero | |
| 3572 NDL_time = 0; | |
| 3573 | |
| 3574 // store the number of this tissue as being the leading one | |
| 3575 NDL_tissue_lead = NDL_tissue; | |
| 3576 | |
| 3577 // done | |
| 582 | 3578 break; |
| 3579 } | |
| 3580 | |
| 623 | 3581 // when code execution passes here, the tissue has become |
| 3582 // being outside NDL after doing one or more search steps | |
| 3583 | |
| 3584 // still searching with a step size of 10 minutes? | |
| 3585 if( step_size == 10 ) | |
| 582 | 3586 { |
| 623 | 3587 // YES - retry with smaller step size |
| 3588 | |
| 3589 // go back to last NDL time | |
| 3590 NDL_time_tissue -= 10; | |
| 3591 | |
| 3592 #ifdef _helium | |
| 3593 | |
| 3594 // go back to last pressures | |
| 3595 calc_pres_tissue_N2 = last_pres_tissue_N2; | |
| 3596 calc_pres_tissue_He = last_pres_tissue_He; | |
| 3597 | |
| 3598 #else | |
| 3599 | |
| 3600 // go back to last pressure | |
| 3601 pres_tissue = last_pres_tissue; | |
| 3602 | |
| 3603 #endif | |
| 3604 | |
| 3605 // reduce step size to 1 minute | |
| 3606 step_size = 1; | |
| 3607 | |
| 3608 // read the tissue increments for a step size of 1 minute | |
| 3609 read_Buhlmann_times(1); | |
| 3610 | |
| 3611 // redo search from last pressure & time within NDL with smaller step size | |
| 582 | 3612 continue; |
| 3613 } | |
| 623 | 3614 else |
| 582 | 3615 { |
| 623 | 3616 // NO - already tried with a step size of 1 minute |
| 3617 | |
| 3618 // go back to last NDL time that was within NDL | |
| 3619 NDL_time_tissue -= 1; | |
| 3620 | |
| 3621 // is the NDL time of this tissue shorter than the overall NDL time found so far? | |
| 3622 if( NDL_time_tissue < NDL_time ) | |
| 3623 { | |
| 3624 // YES - set this tissue's NDL time as the new overall NDL time | |
| 3625 NDL_time = NDL_time_tissue; | |
| 3626 | |
| 3627 // - store the number of this tissue as being the leading one | |
| 3628 NDL_tissue_lead = NDL_tissue; | |
| 3629 } | |
| 3630 | |
| 3631 // done | |
| 3632 break; | |
| 582 | 3633 } |
| 623 | 3634 } |
| 3635 else | |
| 582 | 3636 { |
| 623 | 3637 // NO - tissue is still within NDL |
| 3638 | |
| 3639 // The search can be terminated when the NDL time of this tissue | |
| 3640 // exceeds the overall NDL time, thus when a shorter NDL time has | |
| 3641 // already been found with another tissue. | |
| 3642 if( NDL_time_tissue >= NDL_time ) break; | |
| 3643 | |
| 3644 #ifdef _helium | |
| 3645 | |
| 3646 // back-up current tissue pressures | |
| 3647 last_pres_tissue_N2 = calc_pres_tissue_N2; | |
| 3648 last_pres_tissue_He = calc_pres_tissue_He; | |
| 3649 | |
| 3650 #else | |
| 3651 | |
| 3652 // back-up current tissue pressure | |
| 3653 last_pres_tissue = pres_tissue; | |
| 3654 | |
| 3655 #endif | |
| 3656 | |
| 3657 // step forward NDL time of current tissue | |
| 3658 NDL_time_tissue += step_size; | |
| 3659 | |
| 3660 #ifdef _helium | |
| 3661 | |
| 3662 // step forward tissue pressure - N2 | |
| 3663 temp_tissue = (ppN2 - calc_pres_tissue_N2) * var_N2_e; // pressure delta breathed - tissue | |
| 3664 apply_saturation_factors(); // apply safety factor | |
| 3665 calc_pres_tissue_N2 += temp_tissue; // add pressure delta to tissue | |
| 3666 | |
| 3667 // step forward tissue pressure - He | |
| 3668 temp_tissue = (ppHe - calc_pres_tissue_He) * var_He_e; // pressure delta breathed - tissue | |
| 3669 apply_saturation_factors(); // apply safety factor | |
| 3670 calc_pres_tissue_He += temp_tissue; // add pressure delta to tissue | |
| 3671 | |
| 3672 #else | |
| 3673 | |
| 3674 // step forward tissue pressure | |
| 3675 temp_tissue = (ppN2 - pres_tissue ) * var_N2_e; // pressure delta breathed - tissue | |
| 3676 apply_saturation_factors(); // apply safety factor | |
| 3677 pres_tissue += temp_tissue; // add pressure delta to tissue | |
| 3678 | |
| 3679 #endif | |
| 3680 | |
| 582 | 3681 } |
| 623 | 3682 } |
| 0 | 3683 } |
| 3684 | |
| 604 | 3685 |
| 0 | 3686 ////////////////////////////////////////////////////////////////////////////// |
| 3687 // calc_ascenttime | |
| 3688 // | |
| 623 | 3689 // Sum up ascent from bottom to surface at char_I_ascent_speed, slowing down |
| 3690 // to 1 minute per meter for the final ascent when in deco, and all stop times. | |
| 0 | 3691 // |
| 582 | 3692 // Input: char_I_depth_last_deco |
| 604 | 3693 // char_I_ascent_speed |
| 623 | 3694 // char_depth_bottom |
| 582 | 3695 // internal_deco_depth[] |
| 604 | 3696 // internal_deco_time[] |
| 582 | 3697 // |
| 3698 // Output: ascent_time | |
| 560 | 3699 // |
| 0 | 3700 static void calc_ascenttime(void) |
| 3701 { | |
| 604 | 3702 // check if there are stops |
| 3703 if( internal_deco_depth[0] ) | |
| 560 | 3704 { |
| 623 | 3705 // YES - stops / in deco |
| 604 | 3706 |
| 3707 // check if already at last stop depth or shallower | |
| 623 | 3708 if( char_depth_bottom <= char_I_depth_last_deco) |
| 604 | 3709 { |
| 623 | 3710 // YES - final ascent part only |
| 3711 ascent_time = char_depth_bottom; | |
| 604 | 3712 } |
| 3713 else | |
| 3714 { | |
| 623 | 3715 // NO - ascent part from bottom to last stop |
| 3716 ascent_time = (char_depth_bottom - char_I_depth_last_deco) / char_I_ascent_speed + 1; | |
| 3717 | |
| 3718 // - ascent part from last stop to surface at 1 meter per minute | |
| 3719 ascent_time += char_I_depth_last_deco; | |
| 604 | 3720 } |
| 623 | 3721 |
| 3722 // add all stop times | |
| 3723 for( i=0; i < NUM_STOPS && internal_deco_depth[i]; i++ ) | |
| 3724 ascent_time += internal_deco_time[i]; | |
| 3725 | |
| 3726 // limit result to display max. | |
| 3727 if( ascent_time > 999) ascent_time = 999; | |
| 3728 | |
| 3729 // tag result as invalid if there is an overflow in the stops table | |
| 3730 if( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) ascent_time |= INT_FLAG_INVALID; | |
| 560 | 3731 } |
| 3732 else | |
| 3733 { | |
| 623 | 3734 // NO - no stops / within NDL |
| 3735 ascent_time = char_depth_bottom / char_I_ascent_speed + 1; | |
| 560 | 3736 } |
| 0 | 3737 } |
| 3738 | |
| 3739 | |
| 3740 ////////////////////////////////////////////////////////////////////////////// | |
| 3741 // clear_deco_table | |
| 3742 // | |
| 623 | 3743 // Modified: internal_deco_time[] stop durations |
| 3744 // internal_deco_depth[] stop depths | |
| 3745 // internal_deco_gas[] gases used at stops | |
| 0 | 3746 // |
| 3747 static void clear_deco_table(void) | |
| 3748 { | |
| 623 | 3749 for( i = 0; i < NUM_STOPS; ++i ) |
| 582 | 3750 { |
| 623 | 3751 internal_deco_time [i] = 0; |
| 3752 internal_deco_depth[i] = 0; | |
| 3753 internal_deco_gas[i] = 0; | |
| 582 | 3754 } |
| 3755 | |
| 560 | 3756 // clear stop table overflow warning |
| 623 | 3757 deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW; |
| 0 | 3758 } |
| 3759 | |
| 623 | 3760 |
| 0 | 3761 ////////////////////////////////////////////////////////////////////////////// |
| 3762 // update_deco_table | |
| 3763 // | |
| 623 | 3764 // Add time to a stop at char_depth_sim |
| 560 | 3765 // |
| 3766 // It is possible to create stops with a duration of 0 minutes, e.g. to | |
| 3767 // note a gas change "on the fly" while ascending. Therefore the criteria | |
| 604 | 3768 // to have reached the end of the list is depth == 0. |
| 0 | 3769 // |
| 623 | 3770 // Input: char_depth_sim stop's depth, in meters |
| 3771 // sim_gas_current_num gas used at stop, as index 1..5 or 0 for gas 6 | |
| 3772 // time_increment number of minutes to add to the stop | |
| 3773 // | |
| 3774 // Updated: internal_deco_depth[] depth (in meters) of each stop | |
| 3775 // internal_deco_time [] time (in minutes) of each stop | |
| 3776 // internal_deco_gas [] gas used (index 1-5) at each stop | |
| 560 | 3777 // |
| 3778 static unsigned char update_deco_table(PARAMETER unsigned char time_increment) | |
| 0 | 3779 { |
| 560 | 3780 overlay unsigned char x; |
| 3781 | |
| 623 | 3782 assert( char_depth_sim > 0 ); // no stop at surface |
| 560 | 3783 |
| 3784 // loop through internal deco table | |
| 604 | 3785 for( x = 0; x < NUM_STOPS; ++x ) |
| 560 | 3786 { |
| 604 | 3787 // In case the first deco stop is to be placed deeper than previously recorded |
| 3788 // stops for gas changes during the initial ascent (this may happen because the | |
| 3789 // deco stops are placed at the next deeper multiple of 3 meters instead of the | |
| 3790 // real stop's depth), relocate the deco stop to the depth of the last gas change. | |
| 3791 // The resulting combined stop's duration will be the sum of the configured gas | |
| 3792 // change time plus the duration of the deco stop itself. | |
| 623 | 3793 if( internal_deco_depth[x] && (char_depth_sim > internal_deco_depth[x]) ) |
| 3794 char_depth_sim = internal_deco_depth[x]; | |
| 604 | 3795 |
| 560 | 3796 // Is there already a stop entry for our current depth? |
| 623 | 3797 if( internal_deco_depth[x] == char_depth_sim ) |
| 560 | 3798 { |
| 3799 // Yes - increment stop time if possible | |
| 3800 // Stop time entries are limited to 99 minutes because of display constraints. | |
| 3801 if( internal_deco_time[x] < (100 - time_increment) ) | |
| 3802 { | |
| 3803 internal_deco_time[x] += time_increment; // increment stop time | |
| 3804 return 1; // return with status 'success' | |
| 3805 } | |
| 3806 } | |
| 3807 | |
| 3808 // If program flow passes here, there is either no stop entry for the current depth yet, or | |
| 3809 // the existing entry is saturated with 99 minutes. So we are looking for the next unused | |
| 3810 // table entry. | |
| 3811 if( internal_deco_depth[x] == 0 ) | |
| 3812 { | |
| 3813 internal_deco_time[x] = time_increment; // initialize entry with first stop's time, | |
| 623 | 3814 internal_deco_depth[x] = char_depth_sim; // ... depth, and |
| 3815 internal_deco_gas[x] = sim_gas_current_num; // ... gas | |
| 560 | 3816 return 1; // return with status 'success' |
| 3817 } | |
| 3818 } | |
| 3819 | |
| 3820 // If program flow passes here, all deco table entries are used up. | |
| 582 | 3821 |
| 560 | 3822 // set overflow warning |
| 623 | 3823 deco_warnings |= DECO_WARNING_STOPTABLE_OVERFLOW; |
| 582 | 3824 |
| 560 | 3825 // return with status 'failed'. |
| 3826 return 0; | |
| 0 | 3827 } |
| 3828 | |
| 3829 | |
| 3830 ////////////////////////////////////////////////////////////////////////////// | |
| 623 | 3831 // calc_desaturation_time_helper |
| 0 | 3832 // |
| 560 | 3833 // Helper function |
| 3834 // | |
| 623 | 3835 // Input: pres_actual current tissue pressure |
| 3836 // pres_target target tissue pressure | |
| 3837 // var_ht half-time of the tissue | |
| 3838 // desat_factor desaturation factor | |
| 3839 // | |
| 3840 // Output: int_time time needed by tissue to reach target pressure | |
| 3841 // | |
| 604 | 3842 static void calc_desaturation_time_helper(void) |
| 0 | 3843 { |
| 623 | 3844 // check if actual pressure is higher then target pressure |
| 3845 if( pres_actual > pres_target ) | |
| 3846 { | |
| 3847 // YES - compute remaining time | |
| 3848 | |
| 604 | 3849 overlay float pres_ratio; |
| 582 | 3850 |
| 623 | 3851 // compute pressure ratio to archive |
| 560 | 3852 pres_ratio = pres_actual / pres_target; |
| 3853 | |
| 3854 // Compute desaturation time with result rounded up to multiples of 10 minutes. | |
| 582 | 3855 // Main purpose is to avoid confusion, because the times do not clock down in |
| 3856 // one minute steps any more but get constantly re-computed according to current | |
| 3857 // ambient pressure and may therefor make steps of several minutes forwards and | |
| 604 | 3858 // backwards as ambient pressure rises/falls and N2/He ratio is being adjusted. |
| 623 | 3859 int_time = (unsigned short)( (var_ht * log(pres_ratio) / desat_factor) + 0.9 ); |
| 560 | 3860 } |
| 3861 else | |
| 623 | 3862 { |
| 3863 // NO - desaturation state reached, no remaining time | |
| 582 | 3864 int_time = 0; |
| 560 | 3865 } |
| 3866 } | |
| 3867 | |
| 623 | 3868 |
| 560 | 3869 ///////////////////////////////////////////////////////////////////////////// |
| 604 | 3870 // calc_desaturation_time |
| 3871 // | |
| 623 | 3872 // Calculates the time needed for the tissues to equilibrate with |
| 3873 // surface pressure and the no-fly / no-altitude time. | |
| 3874 // | |
| 3875 // Input: int_I_pres_surface | |
| 3876 // char_I_desaturation_multiplier | |
| 3877 // | |
| 3878 // Output: int_O_desaturation_time | |
| 3879 // int_O_nofly_time | |
| 560 | 3880 // |
| 3881 void calc_desaturation_time(void) | |
| 3882 { | |
| 623 | 3883 overlay float P_ambient_altitude; |
| 3884 | |
| 604 | 3885 assert( 800 < int_I_pres_surface && int_I_pres_surface < 1100 ); |
| 3886 assert( 0 < char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100 ); | |
| 3887 | |
| 3888 | |
| 623 | 3889 // safeguard and convert surface pressure |
| 3890 if( int_I_pres_surface < 500) pres_surface = 0.5; | |
| 3891 else pres_surface = 0.001 * int_I_pres_surface; | |
| 3892 | |
| 3893 // calculate partial pressure of N2 in respired air at surface pressure | |
| 3894 calc_N2_equilibrium(); | |
| 3895 | |
| 3896 // get, safeguard and convert the saturation and desaturation factors | |
| 3897 get_saturation_factors(); | |
| 3898 | |
| 3899 // pre-computed term for later use: 10 [Min] * 0.6931 [=log(2)] * 1 [Desat Factor] * ... | |
| 3900 desat_factor = (6.931 * SURFACE_DESAT_FACTOR) * float_desaturation_multiplier; | |
| 582 | 3901 |
| 3902 // initialize vars | |
| 560 | 3903 int_O_desaturation_time = 0; |
| 582 | 3904 int_O_nofly_time = 0; |
| 3905 | |
| 623 | 3906 // get selected target altitude |
| 3907 switch( char_I_altitude_wait ) | |
| 3908 { | |
| 3909 case 1: P_ambient_altitude = P_ambient_1000m; break; | |
| 3910 case 2: P_ambient_altitude = P_ambient_2000m; break; | |
| 3911 case 3: P_ambient_altitude = P_ambient_3000m; break; | |
| 3912 default: P_ambient_altitude = P_ambient_fly; break; | |
| 3913 } | |
| 3914 | |
| 3915 // loop over all compartments in order slowest to fastest | |
| 604 | 3916 for( ci = NUM_COMP; ci > 0; ) |
| 582 | 3917 { |
| 623 | 3918 overlay float pres_tissue_max; |
| 3919 overlay unsigned short nofly_last = ~0; | |
| 3920 overlay unsigned short nofly_N2 = 0; | |
| 3921 | |
| 3922 #ifdef _helium | |
| 3923 overlay signed char search_direction; | |
| 3924 overlay unsigned short nofly_He = 0; | |
| 3925 #endif | |
| 3926 | |
| 3927 | |
| 3928 // decrement compartment index | |
| 560 | 3929 ci -= 1; |
| 582 | 3930 |
| 623 | 3931 // get the Buhlmann halftimes and coefficients |
| 582 | 3932 read_Buhlmann_ht(); |
| 560 | 3933 read_Buhlmann_coefficients(); |
| 582 | 3934 |
| 623 | 3935 |
| 3936 // | |
| 3937 // Desaturation time | |
| 3938 // | |
| 3939 | |
| 3940 // calculate desaturation time for N2 in tissue, | |
| 3941 // desaturated state is defined as residual tissue pressure <= 1.05 x ppN2 respired | |
| 3942 | |
| 3943 // current tissue pressure above equilibrium pressure | |
| 3944 pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium; | |
| 3945 | |
| 3946 // target pressure above equilibrium pressure | |
| 3947 pres_target = 0.05 * N2_equilibrium; | |
| 3948 | |
| 3949 // half-time of the current tissue | |
| 3950 var_ht = var_N2_ht; | |
| 3951 | |
| 3952 // calculate desaturation time | |
| 3953 calc_desaturation_time_helper(); | |
| 3954 | |
| 3955 // store desaturation time if it is longer than longest found so far | |
| 3956 if( int_time > int_O_desaturation_time) int_O_desaturation_time = int_time; | |
| 3957 | |
| 3958 | |
| 3959 #ifdef _helium | |
| 3960 | |
| 3961 // calculate desaturation time for He in the tissue, | |
| 3962 // desaturated state is defined as residual tissue pressure <= 0.05 x ppN2 respired | |
| 3963 | |
| 3964 // actual tissue pressure above equilibrium: equilibrium for He is 0 bar | |
| 3965 pres_actual = real_pres_tissue_He[ci]; | |
| 3966 | |
| 3967 // target pressure above equilibrium pressure: use same target pressure as for N2 | |
| 3968 pres_target = 0.05 * N2_equilibrium; | |
| 3969 | |
| 3970 // half-time of the current tissue | |
| 3971 var_ht = var_He_ht; | |
| 3972 | |
| 3973 // calculate desaturation time | |
| 3974 calc_desaturation_time_helper(); | |
| 3975 | |
| 3976 // store desaturation time if it is longer than longest found so far | |
| 3977 if( int_time > int_O_desaturation_time) int_O_desaturation_time = int_time; | |
| 3978 | |
| 3979 #endif | |
| 3980 | |
| 3981 // | |
| 3982 // no-fly time | |
| 3983 // | |
| 582 | 3984 |
| 560 | 3985 // Target pressure for the tissue is the Buhlmann limit. We use the Buhlmann |
| 3986 // coefficients for N2 also for He because it is easier to calculate and the | |
| 3987 // N2 coefficients are more conservative than those for He, so we are on the | |
| 3988 // safe side, too. | |
| 582 | 3989 pres_tissue_max = (P_ambient_altitude/var_N2_b + var_N2_a); |
| 3990 | |
| 623 | 3991 // adjust target pressure by GF-high in case the GF model is in use, but not |
| 3992 // for the no-fly time as it's target pressure is hard to reach anyhow | |
| 3993 if( char_I_deco_model && char_I_altitude_wait ) | |
| 3994 pres_tissue_max = P_ambient_altitude + | |
| 3995 0.01 * char_I_GF_High_percentage * (pres_tissue_max - P_ambient_altitude); | |
| 3996 | |
| 3997 | |
| 3998 #ifdef _helium | |
| 3999 | |
| 4000 //---- Variant with Helium ------------------------------------------- | |
| 4001 | |
| 4002 // initialize split_N2_He in case there was a hard reboot / memory clear | |
| 604 | 4003 if( split_N2_He[ci] == 0 ) split_N2_He[ci] = 90; |
| 4004 | |
| 560 | 4005 // initialize search direction |
| 4006 search_direction = 0; | |
| 582 | 4007 |
| 560 | 4008 for(;;) |
| 4009 { | |
| 4010 // Calculate no-fly time for N2 in the tissue. | |
| 4011 // Flying is permitted when the N2 pressure fits into the assigned fraction above equilibrium. | |
| 4012 | |
| 623 | 4013 // current tissue pressure above equilibrium |
| 4014 pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium; | |
| 4015 | |
| 4016 // target pressure above equilibrium pressure, weighted by N2/He split | |
| 560 | 4017 pres_target = (split_N2_He[ci] * 0.01) * (pres_tissue_max - N2_equilibrium); |
| 4018 | |
| 623 | 4019 // half-time of the current tissue |
| 4020 var_ht = var_N2_ht; | |
| 4021 | |
| 4022 // check if desaturation to target pressure is possible at all | |
| 4023 if( pres_target < 0.0 ) | |
| 560 | 4024 { |
| 623 | 4025 // NO - set no-fly time to 288 * 10 min = 48 h |
| 4026 int_O_nofly_time = 288; | |
| 4027 break; | |
| 560 | 4028 } |
| 604 | 4029 else |
| 560 | 4030 { |
| 623 | 4031 // YES - calculate desaturation time |
| 560 | 4032 calc_desaturation_time_helper(); |
| 623 | 4033 |
| 4034 // store time found | |
| 582 | 4035 nofly_N2 = int_time; |
| 560 | 4036 } |
| 582 | 4037 |
| 623 | 4038 // calculate no-fly time for He in the tissue, |
| 4039 // flying is permitted when the He pressure fits into the assigned fraction | |
| 4040 | |
| 4041 // current tissue pressure above equilibrium: equilibrium for He is 0 bar | |
| 4042 pres_actual = real_pres_tissue_He[ci]; | |
| 4043 | |
| 4044 // target pressure above equilibrium pressure, weighted by N2/He split | |
| 4045 pres_target = ((100 - split_N2_He[ci]) * 0.01) * (pres_tissue_max - N2_equilibrium); | |
| 4046 | |
| 4047 // half-time of the current tissue | |
| 582 | 4048 var_ht = var_He_ht; |
| 4049 | |
| 623 | 4050 // calculate desaturation time |
| 560 | 4051 calc_desaturation_time_helper(); |
| 623 | 4052 |
| 4053 // store time found | |
| 582 | 4054 nofly_He = int_time; |
| 560 | 4055 |
| 4056 | |
| 4057 // Because the sum of N2 and He tissue pressures needs to fit into the Buhlmann limit for | |
| 4058 // no-fly time calculation, each gas gets assigned a fraction of the available total pressure | |
| 623 | 4059 // limit. The optimum split between the two gases can not be computed by a single formula, |
| 560 | 4060 // because this would require the inversion of a function with two exponential terms, which is |
| 4061 // not possible. We do not want to do a computational complex simulation here like it is done | |
| 4062 // in the deco calculation code (although we tackle the same base problem here), so we just let | |
| 4063 // the computer try out which split will balance the no-fly times induced by the N2 and the He | |
| 4064 // at best. | |
| 582 | 4065 |
| 560 | 4066 // first of all, skip any optimization in case the current compartment is not the leading one |
| 4067 if( (nofly_N2 <= int_O_nofly_time) && (nofly_He <= int_O_nofly_time) ) break; | |
| 4068 | |
| 4069 // check if the N2 requires more waiting time than the He | |
| 582 | 4070 if( nofly_N2 >= nofly_He ) |
| 560 | 4071 { |
| 4072 // check if the search direction has changed, which means we are beyond the | |
| 4073 // optimum now, or if we are at the upper stop limit of split_N2_He | |
| 4074 if( (search_direction < 0) || (split_N2_He[ci] == 99) ) | |
| 604 | 4075 { |
| 623 | 4076 // either the just completed iteration was more close to the optimum or the one before |
| 4077 // was, so we take the best (i.e. shortest) time of both as the final no-fly time | |
| 560 | 4078 int_O_nofly_time = (nofly_N2 < nofly_last) ? nofly_N2 : nofly_last; |
| 623 | 4079 |
| 4080 // done | |
| 560 | 4081 break; |
| 4082 } | |
| 4083 | |
| 4084 // store the no-fly time found in this iteration | |
| 582 | 4085 nofly_last = nofly_N2; |
| 4086 | |
| 623 | 4087 // increase the N2 fraction of the split |
| 560 | 4088 split_N2_He[ci] += 1; |
| 623 | 4089 |
| 4090 // set search direction towards more N2 | |
| 560 | 4091 search_direction = +1; |
| 4092 } | |
| 4093 else | |
| 4094 { | |
| 4095 // check if the search direction has changed, which means we are beyond the | |
| 4096 // optimum now, or if we are at the lower stop limit of split_N2_He | |
| 4097 if( (search_direction > 0) || (split_N2_He[ci] == 1) ) | |
| 582 | 4098 { |
| 623 | 4099 // either the just completed iteration was more close to the optimum or the one before |
| 4100 // was, so we take the best (i.e. shortest) time of both as the final no-fly time | |
| 560 | 4101 int_O_nofly_time = (nofly_He < nofly_last) ? nofly_He : nofly_last; |
| 623 | 4102 |
| 4103 // done | |
| 560 | 4104 break; |
| 4105 } | |
| 4106 | |
| 4107 // store the no-fly time found in this iteration | |
| 582 | 4108 nofly_last = nofly_He; |
| 4109 | |
| 623 | 4110 // decrease the N2 fraction of the split |
| 560 | 4111 split_N2_He[ci] -= 1; |
| 623 | 4112 |
| 4113 // set search direction towards less N2 | |
| 604 | 4114 search_direction = -1; |
| 560 | 4115 } |
| 582 | 4116 |
| 560 | 4117 } // for(;;) |
| 4118 | |
| 623 | 4119 #else |
| 4120 | |
| 4121 //---- Variant without Helium ---------------------------------------- | |
| 4122 | |
| 4123 // current tissue pressure above equilibrium | |
| 4124 pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium; | |
| 4125 | |
| 4126 // target pressure above equilibrium pressure | |
| 4127 pres_target = pres_tissue_max - N2_equilibrium; | |
| 4128 | |
| 4129 // half-time of the current tissue | |
| 4130 var_ht = var_N2_ht; | |
| 4131 | |
| 4132 // check if desaturation to target pressure is possible at all | |
| 4133 if( pres_target < 0.0 ) | |
| 4134 { | |
| 4135 // NO - set no-fly time to 288 * 10 min = 48 h | |
| 4136 int_O_nofly_time = 288; | |
| 4137 } | |
| 4138 else | |
| 4139 { | |
| 4140 // YES - calculate desaturation time | |
| 4141 calc_desaturation_time_helper(); | |
| 4142 | |
| 4143 // - extend desaturation time if this tissue needs | |
| 4144 // more time than already found to be needed | |
| 4145 if( int_time > int_O_nofly_time ) int_O_nofly_time = int_time; | |
| 4146 } | |
| 4147 | |
| 4148 #endif | |
| 4149 | |
| 560 | 4150 } // for(compartments) |
| 4151 | |
| 582 | 4152 |
| 623 | 4153 // rescale int_O_desaturation_time and int_O_nofly_time to full minutes for display purpose |
| 560 | 4154 int_O_desaturation_time *= 10; |
| 4155 int_O_nofly_time *= 10; | |
| 582 | 4156 |
| 623 | 4157 // limit int_O_desaturation_time and int_O_nofly_time to 5999 = 99 hours + 59 minutes |
| 4158 // because of display space constraints and rounding done above | |
| 560 | 4159 if( int_O_desaturation_time > 5999 ) int_O_desaturation_time = 5999; |
| 4160 if( int_O_nofly_time > 5999 ) int_O_nofly_time = 5999; | |
| 4161 | |
| 4162 | |
| 623 | 4163 // Clear the micro bubbles warning when the current gradient factor is < 100%. |
| 604 | 4164 // The current gradient factor is calculated by calc_interval() while not in diving mode. |
| 4165 // As the locked warning will stay set, this will cause the warning be be displayed in | |
| 4166 // attention color instead of warning color. | |
| 623 | 4167 if( int_O_lead_supersat < 100 ) |
| 4168 deco_warnings &= ~DECO_WARNING_MBUBBLES; | |
| 582 | 4169 |
| 560 | 4170 // clear some warnings when the desaturation time has become zero |
| 582 | 4171 if( int_O_desaturation_time == 0 ) |
| 623 | 4172 deco_warnings &= ~( DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock |
| 4173 + DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock | |
| 4174 + DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock | |
| 4175 + DECO_ATTENTION_OUTSIDE ); | |
| 0 | 4176 } |
| 4177 | |
| 623 | 4178 |
| 0 | 4179 ////////////////////////////////////////////////////////////////////////////// |
| 582 | 4180 // Calculate desaturation of the real tissues for a given time interval |
| 0 | 4181 // |
| 582 | 4182 // Caution: Works on the real tissues! |
| 4183 // If in doubt, use this function only inside a context surrounded with | |
| 4184 // push_tissues_to_vault() / pull_tissues_from_vault() ! | |
| 4185 // | |
| 623 | 4186 // Input: int_I_pres_surface surface pressure in mbar |
| 4187 // time_interval time interval in minutes, must be limited to 254 at max | |
| 4188 // | |
| 4189 // Modified: tissue pressures N2 and He pressures of the tissues | |
| 4190 // CNS_fraction_real current real CNS value | |
| 4191 // ceiling minimum allowed depth in mbar relative pressure | |
| 4192 // lead_supersat supersaturation of the leading tissue (float) | |
| 4193 // int_O_lead_supersat supersaturation of the leading tissue (integer) | |
| 560 | 4194 // |
| 582 | 4195 static void calc_interval(PARAMETER unsigned char time_interval) |
| 0 | 4196 { |
| 582 | 4197 overlay unsigned char time; |
| 4198 | |
| 4199 assert( 800 < int_I_pres_surface && int_I_pres_surface < 1100 ); | |
| 604 | 4200 assert( 100 <= char_I_saturation_multiplier && char_I_saturation_multiplier < 200 ); |
| 4201 assert( 0 < char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100 ); | |
| 4202 | |
| 4203 | |
| 623 | 4204 // safeguard and convert surface pressure |
| 4205 if( int_I_pres_surface < 500) pres_surface = 0.500; | |
| 4206 else pres_surface = 0.001 * int_I_pres_surface; | |
| 4207 | |
| 4208 // set breathed pressure to surface pressure | |
| 4209 real_pres_respiration = pres_surface; | |
| 4210 | |
| 4211 // calculate partial pressure of N2 in respired air at surface pressure | |
| 4212 calc_N2_equilibrium(); | |
| 4213 | |
| 4214 // calculate partial pressures (0.7902 is fraction of N2 in atmosphere as of Buhlmann) | |
| 4215 ppN2 = N2_equilibrium; | |
| 4216 ppHe = 0.0; | |
| 4217 | |
| 4218 // get, safeguard and convert the saturation and desaturation factors | |
| 4219 get_saturation_factors(); | |
| 4220 | |
| 4221 // adjust desaturation factor to surface mode | |
| 4222 float_desaturation_multiplier *= SURFACE_DESAT_FACTOR; | |
| 582 | 4223 |
| 4224 // Calculate the tissues: | |
| 4225 // Because calc_tissues() can calculate for 127 minutes at max, | |
| 4226 // the tissue updating may need to be done in two chunks. | |
| 4227 | |
| 4228 time = time_interval; | |
| 4229 | |
| 4230 // first chunk for the part exceeding 127 minutes | |
| 4231 if( time > 127) | |
| 560 | 4232 { |
| 582 | 4233 // do a full 127 minutes on the real tissues |
| 623 | 4234 tissue_increment = TISSUE_SELECTOR | 127; |
| 582 | 4235 calc_tissues(); |
| 4236 | |
| 623 | 4237 // determine the remaining time |
| 582 | 4238 time -= 127; |
| 560 | 4239 } |
| 4240 | |
| 623 | 4241 // program the remaining time (or full time if not exceeding 127 minutes) on the real tissues |
| 4242 tissue_increment = TISSUE_SELECTOR | time; | |
| 604 | 4243 |
| 4244 // update the N2 and He pressures in the tissues | |
| 582 | 4245 calc_tissues(); |
| 4246 | |
| 560 | 4247 |
| 4248 // Calculate CNS: | |
| 4249 // To speed up things and because on most invocations of this code char_I_dive_interval | |
| 4250 // is a multiple of 10 minutes, we loop the loop-counter down using two speeds. | |
| 4251 | |
| 582 | 4252 time = time_interval; |
| 4253 | |
| 604 | 4254 while( time ) |
| 560 | 4255 { |
| 582 | 4256 if( time > 9 ) |
| 560 | 4257 { |
| 623 | 4258 CNS_fraction_real *= 0.925874712; // half-time = 90 min -> 10 min: (1/2)^(1/9) |
| 4259 time -= 10; // fast speed looping | |
| 560 | 4260 } |
| 4261 else | |
| 4262 { | |
| 623 | 4263 CNS_fraction_real *= 0.992327946; // half-time = 90 min -> 1 min: (1/2)^(1/90) |
| 4264 time -= 1; // slow speed looping | |
| 560 | 4265 } |
| 582 | 4266 } |
| 560 | 4267 |
| 623 | 4268 // convert the CNS value to integer |
| 4269 convert_cur_CNS_for_display(); | |
| 4270 | |
| 4271 // calculate the supersaturation of the leading tissue, the | |
| 4272 // negative argument puts calc_limit() into surface mode | |
| 4273 // Attention: do not pass char_I_GF_High_percentage as an argument | |
| 4274 // here because it is not configured outside dive mode | |
| 4275 calc_limit(-1.0); | |
| 4276 | |
| 4277 // convert the saturation value of the leading tissue to integer | |
| 4278 convert_sat_for_display(); | |
| 0 | 4279 } |
| 4280 | |
| 560 | 4281 |
| 4282 ////////////////////////////////////////////////////////////////////////////// | |
| 604 | 4283 // calc_CNS |
| 560 | 4284 // |
| 623 | 4285 // Input: char_ppO2 current ppO2 [in 0.1 bars] |
| 4286 // tissue_increment time increment and tissue selector | |
| 4287 // | |
| 4288 // Modified: CNS_fraction_real accumulated CNS (real tissue context) | |
| 4289 // CNS_fraction_sim accumulated CNS (simulated tissue context) | |
| 560 | 4290 // |
| 604 | 4291 static void calc_CNS(void) |
| 560 | 4292 { |
| 604 | 4293 overlay float CNS_fraction_inc; // increment of CNS load, 0.01 = 1% |
| 623 | 4294 |
| 4295 | |
| 4296 // calculate CNS increment for 2 seconds interval | |
| 4297 if( char_ppO2 > 160 ) | |
| 4298 { | |
| 4299 // step-wise CNS increment | |
| 4300 | |
| 4301 // calculate index for increment look-up | |
| 4302 cns_i = (char_ppO2 - 161) / 5; // integer division | |
| 4303 | |
| 4304 // read coefficient (increment) | |
| 4305 read_CNS_c_coefficient(); | |
| 4306 | |
| 4307 // re-scale coefficient from storage format in [1/100000] to productive value | |
| 4308 CNS_fraction_inc = (float)var_cns_c / 100000.0; | |
| 4309 } | |
| 4310 else if( char_ppO2 > 50 ) | |
| 4311 { | |
| 4312 // range wise CNS increment approximation | |
| 4313 | |
| 4314 // calculate index for approximation coefficients look-up | |
| 4315 cns_i = (char_ppO2 - 51) / 10; // integer division | |
| 4316 | |
| 4317 // read coefficients | |
| 4318 read_CNS_ab_coefficient(); | |
| 4319 | |
| 4320 // calculate the CNS increment | |
| 4321 CNS_fraction_inc = 1.0 / (var_cns_a * char_ppO2 + var_cns_b ); | |
| 4322 } | |
| 4323 else | |
| 4324 { // no increment up to 0.5 bar ppO2 | |
| 4325 CNS_fraction_inc = 0.0; | |
| 4326 } | |
| 4327 | |
| 4328 // apply a time factor in case of minute-based interval (factor = N * 30.0) | |
| 4329 if( tissue_increment & TIME_MASK ) | |
| 4330 { | |
| 4331 CNS_fraction_inc *= (float)(tissue_increment & TIME_MASK) * 30.0; | |
| 4332 } | |
| 604 | 4333 |
| 4334 // update the CNS accumulator | |
| 623 | 4335 if ( tissue_increment & TISSUE_SELECTOR ) CNS_fraction_real += CNS_fraction_inc; // real tissues |
| 4336 else CNS_fraction_sim += CNS_fraction_inc; // simulated tissues | |
| 4337 } | |
| 4338 | |
| 4339 | |
| 4340 ////////////////////////////////////////////////////////////////////////////// | |
| 4341 // calc_due_by_depth_time_sac (Helper Function saving Code Space) | |
| 4342 // | |
| 4343 // Calculates the gas volume required for a given depth, time and usage (SAC) | |
| 4344 // rate. It uses a fixed surface pressure of 1.0 bar to deliver stable results | |
| 4345 // when used through the deco calculator. | |
| 4346 // | |
| 4347 // Input: gas_needs_float_depth depth in meters | |
| 4348 // gas_needs_float_time time in minutes | |
| 4349 // gas_needs_stop_usage gas usage in liters per minute at surface pressure | |
| 4350 // | |
| 4351 // Output: gas_needs_volume_due required gas volume in liters | |
| 4352 // | |
| 4353 static void calc_due_by_depth_time_sac(void) | |
| 4354 { | |
| 4355 gas_needs_volume_due = (gas_needs_float_depth * METER_TO_BAR + 1.0) * gas_needs_float_time * gas_needs_stop_usage; | |
| 4356 } | |
| 4357 | |
| 4358 | |
| 4359 ////////////////////////////////////////////////////////////////////////////// | |
| 4360 // calc_gas_needs_ascent | |
| 4361 // | |
| 4362 // calculates the gas needs along the ascent | |
| 4363 // | |
| 4364 // Input: char_depth_bottom depth of the bottom segment | |
| 4365 // char_I_bottom_time duration of the bottom segment | |
| 4366 // char_I_extra_time extra bottom time for fTTS / delayed ascent | |
| 4367 // float_ascent_speed ascent speed, in meters/minute | |
| 4368 // internal_deco_depth[] depth of the stops | |
| 4369 // internal_deco_time[] duration of the stops | |
| 4370 // internal_deco_gas[] gas breathed at the stops | |
| 4371 // NDL_time remaining NDL time, used to adjust speed of final ascent | |
| 4372 // char_I_SAC_work gas consumption during bottom part and initial ascent, in liters/minute | |
| 4373 // char_I_SAC_deco gas consumption during stops and following ascents, in liters/minute | |
| 4374 // char_I_gas_avail_size[] size of the tanks for gas 1-5, in liters | |
| 4375 // char_I_gas_avail_pres[] fill pressure of the tanks | |
| 4376 // | |
| 4377 // Output: gas_volume_need[] amount of gas needed, in liters | |
| 4378 // | |
| 4379 static void calc_gas_needs_ascent(void) | |
| 4380 { | |
| 4381 switch (gas_needs_next_phase) | |
| 4382 { | |
| 4383 //--------------------------------------------------------------------- | |
| 4384 | |
| 4385 case GAS_NEEDS_INIT: | |
| 4386 | |
| 4387 // set index to the first stop table entry | |
| 4388 gas_needs_stop_index = 0; | |
| 4389 | |
| 4390 // clear the gas volume needs | |
| 4391 for( i = 0; i < NUM_GAS; ++i ) gas_volume_need[i] = 0.0; | |
| 4392 | |
| 4393 #ifdef _rx_functions | |
| 4394 // only for OSTC TR model with TR functions enabled | |
| 4395 if( main_status & TR_FUNCTIONS ) | |
| 4396 { | |
| 4397 // invalidate pressure needs to pressure readings | |
| 4398 int_O_pressure_need[0] = 0 + INT_FLAG_NOT_AVAIL; | |
| 4399 int_O_pressure_need[1] = 0 + INT_FLAG_NOT_AVAIL; | |
| 4400 } | |
| 4401 #endif | |
| 4402 | |
| 4403 // terminate if in loop mode (CCR, pSCR) as there are no gas needs to calculate, | |
| 4404 // else continue with the gas needs of the bottom segment | |
| 4405 if ( deco_status & MODE_LOOP ) gas_needs_next_phase = GAS_NEEDS_DONE; | |
| 4406 else gas_needs_next_phase = GAS_NEEDS_BOTTOM_SEGMENT; | |
| 4407 | |
| 4408 break; | |
| 4409 | |
| 4410 //--------------------------------------------------------------------- | |
| 4411 | |
| 4412 case GAS_NEEDS_BOTTOM_SEGMENT: | |
| 4413 | |
| 4414 // sim_gas_current_num gas used during bottom segment (0, 1-5) | |
| 4415 // char_depth_bottom depth of the bottom segment | |
| 4416 | |
| 4417 // get the gas used during bottom segment | |
| 4418 gas_find_current(); | |
| 4419 | |
| 4420 // initialize variables | |
| 4421 gas_needs_stop_gas_last = gas_needs_stop_gas = sim_gas_current_num; | |
| 4422 | |
| 4423 // set the usage (SAC rate) to bottom usage rate for bottom part and initial ascent | |
| 4424 gas_needs_stop_usage = char_I_SAC_work; | |
| 4425 | |
| 4426 // volumes are only calculated for gases 1-5, but not the manually configured one | |
| 4427 if( gas_needs_stop_gas ) | |
| 4428 { | |
| 4429 // set the bottom depth | |
| 4430 gas_needs_float_depth = (float)char_depth_bottom; | |
| 4431 | |
| 4432 // calculate either whole bottom time or just the fTTS/bailout extra time | |
| 4433 gas_needs_float_time = ( main_status & CALCULATE_BOTTOM ) ? (float)char_I_bottom_time : (float)char_I_extra_time; | |
| 4434 | |
| 4435 // calculate gas demand | |
| 4436 calc_due_by_depth_time_sac(); | |
| 4437 | |
| 4438 // take result | |
| 4439 gas_volume_need[gas_needs_stop_gas-1] = gas_needs_volume_due; | |
| 4440 } | |
| 4441 | |
| 4442 // continue with initial ascent demand | |
| 4443 gas_needs_next_phase = GAS_NEEDS_INITIAL_ASCENT; | |
| 4444 | |
| 4445 break; | |
| 4446 | |
| 4447 | |
| 4448 //--------------------------------------------------------------------- | |
| 4449 | |
| 4450 case GAS_NEEDS_INITIAL_ASCENT: | |
| 4451 | |
| 4452 // gas_needs_stop_gas : gas from bottom segment | |
| 4453 // char_depth_bottom : depth of the bottom segment | |
| 4454 // internal_deco_depth[0]: depth of the first stop, may be 0 if no stop exists | |
| 4455 | |
| 4456 // get the data of the first stop | |
| 4457 gas_needs_stop_depth = internal_deco_depth[0]; | |
| 4458 gas_needs_stop_time = internal_deco_time[0]; | |
| 4459 | |
| 4460 // volumes are only calculated for gases 1-5, but not the manually configured one | |
| 4461 if( gas_needs_stop_gas ) | |
| 4462 { | |
| 4463 // compute distance between bottom and first stop | |
| 4464 gas_needs_float_depth = (float)char_depth_bottom - (float)gas_needs_stop_depth; | |
| 4465 | |
| 4466 // initial ascent exists only if ascent distance is > 0 | |
| 4467 if( gas_needs_float_depth > 0.0 ) | |
| 4468 { | |
| 4469 // compute ascent time | |
| 4470 gas_needs_float_time = gas_needs_float_depth / float_ascent_speed; | |
| 4471 | |
| 4472 // compute average depth between bottom and first stop | |
| 4473 gas_needs_float_depth = (float)char_depth_bottom - gas_needs_float_depth * 0.5; | |
| 4474 | |
| 4475 // calculate gas demand | |
| 4476 calc_due_by_depth_time_sac(); | |
| 4477 | |
| 4478 // add to overall demand | |
| 4479 gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due; | |
| 4480 } | |
| 4481 } | |
| 4482 | |
| 4483 // switch the usage (SAC rate) to deco usage rate | |
| 4484 // for stops, intermediate and final ascent | |
| 4485 gas_needs_stop_usage = char_I_SAC_deco; | |
| 4486 | |
| 4487 // is there a (first) stop? | |
| 4488 if( gas_needs_stop_depth ) | |
| 4489 { | |
| 4490 // YES - continue with stop demand | |
| 4491 gas_needs_next_phase = GAS_NEEDS_STOP; | |
| 4492 | |
| 4493 break; | |
| 4494 } | |
| 4495 else | |
| 4496 { | |
| 4497 // NO - add demand of a 3 minutes safety stop at 5 meters, at least for contingency... | |
| 4498 gas_needs_float_time = 3.0; | |
| 4499 gas_needs_float_depth = 5.0; | |
| 4500 | |
| 4501 // calculate gas demand | |
| 4502 calc_due_by_depth_time_sac(); | |
| 4503 | |
| 4504 // add to overall demand | |
| 4505 gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due; | |
| 4506 | |
| 4507 // calculation finished | |
| 4508 gas_needs_next_phase = GAS_NEEDS_DONE; | |
| 4509 | |
| 4510 break; | |
| 4511 } | |
| 4512 | |
| 4513 | |
| 4514 //--------------------------------------------------------------------- | |
| 4515 | |
| 4516 case GAS_NEEDS_STOP: | |
| 4517 | |
| 4518 // correct stop depth if shallower than calculated stop depth and convert to float | |
| 4519 gas_needs_float_depth = ( char_depth_bottom < gas_needs_stop_depth ) ? (float)char_depth_bottom : (float)gas_needs_stop_depth; | |
| 4520 | |
| 4521 // get the gas on this stop | |
| 4522 gas_needs_stop_gas = internal_deco_gas[gas_needs_stop_index]; | |
| 4523 | |
| 4524 // do we have a gas change? | |
| 4525 if( gas_needs_stop_gas_last && (gas_needs_stop_gas != gas_needs_stop_gas_last) ) | |
| 4526 { | |
| 4527 // YES - spend an additional char_I_gas_change_time on the old gas | |
| 4528 gas_needs_float_time = (float)char_I_gas_change_time; | |
| 4529 | |
| 4530 // calculate gas demand | |
| 4531 calc_due_by_depth_time_sac(); | |
| 4532 | |
| 4533 // add to overall demand | |
| 4534 gas_volume_need[gas_needs_stop_gas_last-1] += gas_needs_volume_due; | |
| 4535 } | |
| 4536 | |
| 4537 // calculate demand of (new) gas for the full stop duration | |
| 4538 if( gas_needs_stop_gas ) | |
| 4539 { | |
| 4540 // get the duration of the stop | |
| 4541 gas_needs_float_time = (float)gas_needs_stop_time; | |
| 4542 | |
| 4543 // calculate gas demand | |
| 4544 calc_due_by_depth_time_sac(); | |
| 4545 | |
| 4546 // add to overall demand | |
| 4547 gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due; | |
| 4548 } | |
| 4549 | |
| 4550 // Continue with the demand of the intermediate ascent to the next stop. | |
| 4551 // If there is no further stop, it will divert by itself to final ascent. | |
| 4552 gas_needs_next_phase = GAS_NEEDS_INTERMEDIATE_ASCENT; | |
| 4553 | |
| 4554 break; | |
| 4555 | |
| 4556 | |
| 4557 //--------------------------------------------------------------------- | |
| 4558 | |
| 4559 case GAS_NEEDS_INTERMEDIATE_ASCENT: | |
| 4560 | |
| 4561 // store last stop depth and last gas | |
| 4562 gas_needs_stop_depth_last = gas_needs_stop_depth; | |
| 4563 gas_needs_stop_gas_last = gas_needs_stop_gas; | |
| 4564 | |
| 4565 // check if end of stop table is reached | |
| 4566 if( gas_needs_stop_index < NUM_STOPS-1 ) | |
| 4567 { | |
| 4568 // NO - check if there is another stop entry | |
| 4569 if( internal_deco_depth[gas_needs_stop_index+1] == 0 ) | |
| 4570 { | |
| 4571 // NO - continue with final ascent demand | |
| 4572 gas_needs_next_phase = GAS_NEEDS_FINAL_ASCENT; | |
| 4573 | |
| 4574 break; | |
| 4575 } | |
| 4576 else | |
| 4577 { | |
| 4578 // YES - goto next stop entry | |
| 4579 gas_needs_stop_index++; | |
| 4580 | |
| 4581 // get the depth of the next stop entry | |
| 4582 gas_needs_stop_depth = internal_deco_depth[gas_needs_stop_index]; | |
| 4583 | |
| 4584 // get the duration of the next stop | |
| 4585 gas_needs_stop_time = internal_deco_time[gas_needs_stop_index]; | |
| 4586 } | |
| 4587 } | |
| 4588 else | |
| 4589 { | |
| 4590 // YES - end of stop table reached | |
| 4591 // We are stranded at some stop depth and do not know how many more | |
| 4592 // stops there may be in front of us and how long they may be. So as | |
| 4593 // as last resort to calculate at least something, we assume that the | |
| 4594 // rest of the ascent will be done in deco final ascent pace, i.e. at | |
| 4595 // 1 meter per minute. Because of the stop table overflow, the result | |
| 4596 // will be flagged as being invalid later on. | |
| 4597 // | |
| 4598 gas_needs_next_phase = GAS_NEEDS_FINAL_ASCENT; | |
| 4599 | |
| 4600 break; | |
| 4601 } | |
| 4602 | |
| 4603 // volumes are only calculated for gases 1-5, but not the manually configured one | |
| 4604 if( gas_needs_stop_gas_last ) | |
| 4605 { | |
| 4606 // compute distance between the two stops | |
| 4607 gas_needs_float_depth = (float)(gas_needs_stop_depth_last - gas_needs_stop_depth); | |
| 4608 | |
| 4609 // compute ascent time | |
| 4610 gas_needs_float_time = gas_needs_float_depth / float_ascent_speed; | |
| 4611 | |
| 4612 // compute average depth between the two stops | |
| 4613 gas_needs_float_depth = (float)gas_needs_stop_depth_last - gas_needs_float_depth * 0.5; | |
| 4614 | |
| 4615 // calculate gas demand | |
| 4616 calc_due_by_depth_time_sac(); | |
| 4617 | |
| 4618 // add to overall demand | |
| 4619 gas_volume_need[gas_needs_stop_gas_last-1] += gas_needs_volume_due; | |
| 4620 } | |
| 4621 | |
| 4622 // continue with calculation stop demand | |
| 4623 gas_needs_next_phase = GAS_NEEDS_STOP; | |
| 4624 | |
| 4625 break; | |
| 4626 | |
| 4627 | |
| 4628 //--------------------------------------------------------------------- | |
| 4629 | |
| 4630 case GAS_NEEDS_FINAL_ASCENT: | |
| 4631 | |
| 4632 // gas_needs_float_depth: still holds depth of the last stop | |
| 4633 // gas_needs_stop_gas : still holds gas from last stop (0 or 1-5) | |
| 4634 | |
| 4635 // volumes are only calculated for gases 1-5, but not the manually configured one | |
| 4636 if( gas_needs_stop_gas ) | |
| 4637 { | |
| 4638 // set ascent time dependent on deco status | |
| 4639 if( NDL_time ) | |
| 4640 { | |
| 4641 // within NDL - ascent with float_ascent_speed | |
| 4642 // | |
| 4643 // Remark: When calculating a bailout ascent, there may be stops | |
| 4644 // for gas changes although the dive is still within NDL | |
| 4645 // and final ascent thus does not need to be slowed down. | |
| 4646 gas_needs_float_time = gas_needs_float_depth / float_ascent_speed; | |
| 4647 } | |
| 4648 else | |
| 4649 { | |
| 4650 // in deco - reduce ascent speed to 1 meter per minute | |
| 4651 gas_needs_float_time = gas_needs_float_depth; | |
| 4652 } | |
| 4653 | |
| 4654 // set half-way depth | |
| 4655 gas_needs_float_depth *= 0.5; | |
| 4656 | |
| 4657 // calculate gas demand | |
| 4658 calc_due_by_depth_time_sac(); | |
| 4659 | |
| 4660 // add to overall demand | |
| 4661 gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due; | |
| 4662 } | |
| 4663 | |
| 4664 // calculation finished | |
| 4665 gas_needs_next_phase = GAS_NEEDS_DONE; | |
| 4666 | |
| 4667 break; | |
| 4668 | |
| 4669 } // switch | |
| 0 | 4670 } |
| 4671 | |
| 560 | 4672 |
| 0 | 4673 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 4674 // calc_TR_functions |
| 4675 // | |
| 4676 // Process Pressure Readings (OSTC TR only) | |
| 4677 // | |
| 4678 // Input: todo | |
| 4679 // | |
| 4680 // Output: todo | |
| 4681 // | |
| 4682 #ifdef _rx_functions | |
| 4683 static void calc_TR_functions(void) | |
| 560 | 4684 { |
| 623 | 4685 // pressure warnings for reading 1, but only if enabled and pressure value available |
| 4686 if( (char_I_pressure_gas[0] > 0) && !(int_IO_pressure_value[0] & INT_FLAG_NOT_AVAIL) ) | |
| 604 | 4687 { |
| 623 | 4688 overlay unsigned short pressure_value = int_IO_pressure_value[0] & ~INT_FLAG_OUTDATED; |
| 4689 | |
| 4690 if( (char_I_pressure_gas[0] < 6 ) && !(int_O_pressure_need[0] & INT_FLAG_NOT_AVAIL) ) | |
| 4691 { | |
| 4692 // not a diluent and need available: warning & attention by need | |
| 4693 if ( pressure_value <= int_O_pressure_need[0]) | |
| 4694 int_IO_pressure_value[0] |= INT_FLAG_WARNING; | |
| 4695 else if( pressure_value <= int_O_pressure_need[0] + int_O_pressure_need[0] / 2 ) | |
| 4696 int_IO_pressure_value[0] |= INT_FLAG_ATTENTION; | |
| 4697 } | |
| 4698 else | |
| 4699 { | |
| 4700 // a diluent or need not available: warning & attention by fixed thresholds | |
| 4701 if ( pressure_value <= PRESSURE_LIMIT_WARNING ) int_IO_pressure_value[0] |= INT_FLAG_WARNING; | |
| 4702 else if ( pressure_value <= PRESSURE_LIMIT_ATTENTION ) int_IO_pressure_value[0] |= INT_FLAG_ATTENTION; | |
| 4703 } | |
| 604 | 4704 } |
| 4705 | |
| 623 | 4706 // pressure warnings for reading 2, but only if enabled and pressure value available |
| 4707 if( (char_I_pressure_gas[1] > 0) && !(int_IO_pressure_value[1] & INT_FLAG_NOT_AVAIL) ) | |
| 560 | 4708 { |
| 623 | 4709 overlay unsigned short pressure_value = int_IO_pressure_value[1] & ~INT_FLAG_OUTDATED; |
| 4710 | |
| 4711 if( (char_I_pressure_gas[1] < 6 ) && !(int_O_pressure_need[1] & INT_FLAG_NOT_AVAIL) ) | |
| 560 | 4712 { |
| 623 | 4713 // not a diluent and need available: warning & attention by need |
| 4714 if ( pressure_value <= int_O_pressure_need[1]) | |
| 4715 int_IO_pressure_value[1] |= INT_FLAG_WARNING; | |
| 4716 else if ( pressure_value <= int_O_pressure_need[1] + int_O_pressure_need[1] / 2 ) | |
| 4717 int_IO_pressure_value[1] |= INT_FLAG_ATTENTION; | |
| 560 | 4718 } |
| 4719 else | |
| 4720 { | |
| 623 | 4721 // a diluent or need not available: warning & attention by fixed thresholds |
| 4722 if ( pressure_value <= PRESSURE_LIMIT_WARNING ) int_IO_pressure_value[1] |= INT_FLAG_WARNING; | |
| 4723 else if ( pressure_value <= PRESSURE_LIMIT_ATTENTION ) int_IO_pressure_value[1] |= INT_FLAG_ATTENTION; | |
| 560 | 4724 } |
| 4725 } | |
| 582 | 4726 |
| 623 | 4727 //--- SAC Calculation --------------------------------------------------------------------- |
| 4728 // | |
| 4729 // char_I_SAC_mode =0: disabled | |
| 4730 // =1: SAC from 1st reading | |
| 4731 // =2: SAC from 2nd reading | |
| 4732 // =3: SAC from higher one of both pressure drops (independent double mode) | |
| 4733 // =4: SAC (O2 usage) from 2nd reading without real_pres_respiration term | |
| 4734 | |
| 4735 // set SAC rate to not available by default | |
| 4736 int_O_SAC_measured = 0 + INT_FLAG_NOT_AVAIL; | |
| 4737 | |
| 4738 // get a copy of the current absolute pressure | |
| 4739 pres_respiration_sac = real_pres_respiration; | |
| 4740 | |
| 4741 // set threshold for SAC rate attention | |
| 4742 max_sac_rate = (deco_info & DECO_FLAG) ? char_I_SAC_deco : char_I_SAC_work; | |
| 4743 | |
| 4744 // char_I_SAC_deco / char_I_SAC_work are in l/min, max_sac_rate is in 0.1 l/min | |
| 4745 max_sac_rate *= 10; | |
| 4746 | |
| 4747 | |
| 4748 // pre-process SAC mode 3 (independent double) | |
| 4749 if( char_I_SAC_mode == 3 ) | |
| 560 | 4750 { |
| 623 | 4751 overlay unsigned char reading1_gas; |
| 4752 overlay unsigned char reading2_gas; | |
| 4753 overlay unsigned char reading1_tanksize; | |
| 4754 overlay unsigned char reading2_tanksize; | |
| 4755 overlay unsigned short reading1_press; | |
| 4756 overlay unsigned short reading2_press; | |
| 4757 overlay unsigned short reading1_drop; | |
| 4758 overlay unsigned short reading2_drop; | |
| 4759 | |
| 4760 // get gas numbers (1-10) of both readings | |
| 4761 reading1_gas = char_I_pressure_gas[0]; | |
| 4762 reading2_gas = char_I_pressure_gas[1]; | |
| 4763 | |
| 4764 // default to no SAC calculation | |
| 4765 char_I_SAC_mode = 0; | |
| 4766 | |
| 4767 // clear switch advice by default | |
| 4768 deco_info &= ~IND_DOUBLE_SWITCH_FLAG; | |
| 4769 | |
| 4770 // check if both readings are configured and available | |
| 4771 if( reading1_gas ) | |
| 4772 if( reading2_gas ) | |
| 4773 if( !(int_IO_pressure_value[0] & INT_FLAG_NOT_AVAIL) ) | |
| 4774 if( !(int_IO_pressure_value[1] & INT_FLAG_NOT_AVAIL) ) | |
| 4775 if( !(int_I_pressure_drop[0] & INT_FLAG_NOT_AVAIL) ) | |
| 4776 if( !(int_I_pressure_drop[1] & INT_FLAG_NOT_AVAIL) ) | |
| 560 | 4777 { |
| 623 | 4778 // get tank pressures, stripping flags |
| 4779 reading1_press = int_IO_pressure_value[0] & 0x0FFF; // in 0.1 bar | |
| 4780 reading2_press = int_IO_pressure_value[1] & 0x0FFF; // in 0.1 bar | |
| 4781 | |
| 4782 // get pressure drops as integers, stripping flags and shifting right | |
| 4783 // to avoid an overflow when multiplying with the tank size later on | |
| 4784 reading1_drop = (int_I_pressure_drop[0] & 0x0FFF) >> 2; | |
| 4785 reading2_drop = (int_I_pressure_drop[1] & 0x0FFF) >> 2; | |
| 4786 | |
| 4787 // get tank sizes | |
| 4788 reading1_tanksize = char_I_gas_avail_size[reading1_gas-1]; | |
| 4789 reading2_tanksize = char_I_gas_avail_size[reading2_gas-1]; | |
| 4790 | |
| 4791 // set mode to calculate SAC on the reading with the higher absolute drop | |
| 4792 char_I_SAC_mode = (reading1_drop * reading1_tanksize > reading2_drop * reading2_tanksize) ? 1 : 2; | |
| 4793 | |
| 4794 // compute switch advice if pressure (in 0.1 bar) of tank breathed from is | |
| 4795 // more than char_I_max_pres_diff (in bar) below pressure of the other tank. | |
| 4796 if( char_I_SAC_mode == 1 ) | |
| 4797 { | |
| 4798 // breathing from reading 1, switch advice if pressure on reading 1 lower than on 2 | |
| 4799 if( (reading1_press + 10*char_I_max_pres_diff) <= reading2_press ) | |
| 4800 deco_info |= IND_DOUBLE_SWITCH_FLAG; | |
| 4801 } | |
| 4802 else | |
| 4803 { | |
| 4804 // breathing from reading 2, switch advice if pressure on reading 2 lower than on 1 | |
| 4805 if( (reading2_press + 10*char_I_max_pres_diff) <= reading1_press ) | |
| 4806 deco_info |= IND_DOUBLE_SWITCH_FLAG; | |
| 4807 } | |
| 560 | 4808 } |
| 4809 } | |
| 4810 | |
| 623 | 4811 |
| 4812 // pre-process SAC mode 4 (O2 usage by reading 2) | |
| 4813 if( char_I_SAC_mode == 4 ) | |
| 4814 { | |
| 4815 // O2 usage on CCR is independent from absolute pressure | |
| 4816 pres_respiration_sac = 1.0; | |
| 4817 | |
| 4818 // O2 pressure drop is measured via reading 2 | |
| 4819 char_I_SAC_mode = 2; | |
| 4820 | |
| 4821 // reconfigure max SAC rate to O2 consumption attention threshold | |
| 4822 max_sac_rate = O2_CONSUMPTION_LIMIT_ATTENTION; | |
| 4823 } | |
| 4824 | |
| 4825 | |
| 4826 // calculate SAC - modes 1 & 2 | |
| 4827 if( (char_I_SAC_mode == 1) || (char_I_SAC_mode == 2) ) | |
| 560 | 4828 { |
| 623 | 4829 overlay unsigned char reading_index; |
| 4830 overlay unsigned char reading_gas; | |
| 4831 overlay unsigned char reading_tanksize; | |
| 4832 overlay float reading_drop; | |
| 4833 | |
| 4834 // set index: char_I_SAC_mode = 1 -> reading one, index 0 | |
| 4835 // = 2 -> two, 1 | |
| 4836 reading_index = char_I_SAC_mode - 1; | |
| 4837 | |
| 4838 // get gas number (1-10) | |
| 4839 reading_gas = char_I_pressure_gas[reading_index]; | |
| 4840 | |
| 4841 // check if reading is configured and available | |
| 4842 if( reading_gas ) | |
| 4843 if( !(int_I_pressure_drop[reading_index] & INT_FLAG_NOT_AVAIL) ) | |
| 4844 { | |
| 4845 // get tank size (in liter) | |
| 4846 reading_tanksize = char_I_gas_avail_size[reading_gas-1]; | |
| 4847 | |
| 4848 // get pressure drop as float, stripping flags (in 1/5120 bar/sec) | |
| 4849 reading_drop = (float)(int_I_pressure_drop[reading_index] & 0x0FFF); | |
| 4850 | |
| 4851 // check if pressure drop is within range | |
| 4852 if( !(int_I_pressure_drop[reading_index] & INT_FLAG_OUT_OF_RANGE) ) | |
| 4853 { | |
| 4854 // calculate SAC, 10 is factor to have result in 0.1 liter/min | |
| 4855 // 60 is factor for 60 seconds per 1 minute, | |
| 4856 // 5120 accounts for reading_drop being in 1/5120 bar/sec | |
| 4857 // 10*60/5120 = 60/512 = 15/128 | |
| 4858 float_sac = reading_drop * 15/128 * reading_tanksize / pres_respiration_sac; | |
| 4859 | |
| 4860 // limit result to 999 (99.9 liter/min) | |
| 4861 if ( float_sac >= 998.5 ) | |
| 4862 { | |
| 4863 int_O_SAC_measured = 999 + INT_FLAG_ATTENTION; | |
| 4864 } | |
| 4865 else | |
| 4866 { | |
| 4867 // convert float to integer | |
| 4868 int_O_SAC_measured = (unsigned short)(float_sac + 0.5); | |
| 4869 | |
| 4870 // set attention flag if exceeding SAC threshold, but only if pressure drop is not outdated | |
| 4871 if( !(int_I_pressure_drop[reading_index] & INT_FLAG_OUTDATED) ) | |
| 4872 if( int_O_SAC_measured >= max_sac_rate ) | |
| 4873 { | |
| 4874 int_O_SAC_measured |= INT_FLAG_ATTENTION; | |
| 4875 } | |
| 4876 } | |
| 4877 } | |
| 4878 else | |
| 4879 { | |
| 4880 // pressure drop is out of range, so SAC will be set out of range, too | |
| 4881 int_O_SAC_measured = 999 + INT_FLAG_ATTENTION; | |
| 4882 } | |
| 4883 | |
| 4884 // copy outdated flag from int_I_pressure_drop to int_O_SAC_measured | |
| 4885 if( int_I_pressure_drop[reading_index] & INT_FLAG_OUTDATED ) | |
| 4886 { | |
| 4887 int_O_SAC_measured |= INT_FLAG_OUTDATED; | |
| 4888 } | |
| 4889 } | |
| 4890 } | |
| 4891 } | |
| 4892 #endif | |
| 4893 | |
| 4894 | |
| 4895 ////////////////////////////////////////////////////////////////////////////// | |
| 4896 // convert_gas_needs_to_press | |
| 4897 // | |
| 4898 // Converts gas volumes into pressures and sets respective flags | |
| 4899 // | |
| 4900 // Input: gas_needs_gas_index index of the gas to convert (0-4) | |
| 4901 // gas_volume_need[] needed gas volume in liters | |
| 4902 // char_I_gas_avail_pres[] available gas volume in bar | |
| 4903 // char_I_gas_avail_size[] size of the tanks in liters | |
| 4904 // char_I_pressure_gas[] gas configured on reading 1/2 (TR only) | |
| 4905 // | |
| 4906 // Output: int_O_gas_need_vol[] required gas amount in liters, including flags | |
| 4907 // int_O_gas_need_pres[] required gas amount in bar, including flags | |
| 4908 // int_O_pressure_need[] required gas amount for reading 1/2 (TR only) | |
| 4909 // | |
| 4910 static void convert_gas_needs_to_press(void) | |
| 4911 { | |
| 4912 | |
| 4913 // just to make the code more readable... | |
| 4914 i = gas_needs_gas_index; | |
| 4915 | |
| 4916 if( gas_volume_need[i] >= 65534.5 ) | |
| 4917 { | |
| 4918 int_O_gas_need_vol[i] = 65535; // clip at 65535 liters | |
| 4919 int_O_gas_need_pres[i] = 999 | INT_FLAG_WARNING | INT_FLAG_HIGH; // 999 bar + warning flag + >999 flag | |
| 560 | 4920 } |
| 4921 else | |
| 4922 { | |
| 623 | 4923 overlay unsigned short int_pres_warn; |
| 4924 overlay unsigned short int_pres_attn; | |
| 4925 | |
| 4926 // set warning and attention thresholds | |
| 4927 int_pres_warn = 10.0 * (unsigned short)char_I_gas_avail_pres[i]; | |
| 4928 int_pres_attn = GAS_NEEDS_ATTENTION_THRESHOLD * int_pres_warn; | |
| 4929 | |
| 4930 // convert ascent gas volume need from float to integer [in liter] | |
| 4931 int_O_gas_need_vol[i] = (unsigned short)gas_volume_need[i]; | |
| 4932 | |
| 4933 // compute how much pressure in the tank will be needed [in bar] | |
| 4934 int_O_gas_need_pres[i] = (unsigned short)( gas_volume_need[i] / char_I_gas_avail_size[i] + 0.999 ); | |
| 4935 | |
| 4936 // limit result to 999 bar because of display constraints | |
| 4937 if( int_O_gas_need_pres[i] > 999 ) int_O_gas_need_pres[i] = 999 | INT_FLAG_HIGH; | |
| 4938 | |
| 4939 // set flags for fast evaluation by dive mode | |
| 4940 if ( int_O_gas_need_pres[i] == 0 ) int_O_gas_need_pres[i] |= INT_FLAG_ZERO; | |
| 4941 else if ( int_O_gas_need_pres[i] >= int_pres_warn ) int_O_gas_need_pres[i] |= INT_FLAG_WARNING; | |
| 4942 else if ( int_O_gas_need_pres[i] >= int_pres_attn ) int_O_gas_need_pres[i] |= INT_FLAG_ATTENTION; | |
| 560 | 4943 } |
| 4944 | |
| 623 | 4945 // set invalid flag if there is an overflow in the stops table |
| 4946 if( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_O_gas_need_pres[i] |= INT_FLAG_INVALID; | |
| 560 | 4947 |
| 604 | 4948 #ifdef _rx_functions |
| 4949 // only for OSTC TR model with TR functions enabled | |
| 623 | 4950 if( main_status & TR_FUNCTIONS ) |
| 560 | 4951 { |
| 623 | 4952 // char_I_pressure_gas[] uses gas indexes from 1-10, loop variable i runs from 0 to 4 |
| 4953 overlay unsigned char j = i+1; | |
| 4954 | |
| 4955 // check if the current gas is configured on pressure reading 1 or 2 | |
| 4956 if( (char_I_pressure_gas[0] == j) || (char_I_pressure_gas[1] == j) ) | |
| 560 | 4957 { |
| 623 | 4958 // get a copy of the required pressure in full bar |
| 4959 overlay unsigned short int_pres_need = int_O_gas_need_pres[i]; | |
| 4960 | |
| 4961 // strip all flags | |
| 4962 int_pres_need &= 1023; | |
| 4963 | |
| 4964 // limit to 400 bar and multiply by 10 to get required pressure in 0.1 bar | |
| 4965 int_pres_need = (int_pres_need > 400) ? 4000 | INT_FLAG_OUT_OF_RANGE : 10 * int_pres_need; | |
| 4966 | |
| 4967 // tag as not available if there is an overflow in the stops table | |
| 4968 if( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_pres_need |= INT_FLAG_NOT_AVAIL; | |
| 4969 | |
| 4970 // copy to reading data (in both readings the same gas could be configured) | |
| 4971 if( char_I_pressure_gas[0] == j ) int_O_pressure_need[0] = int_pres_need; | |
| 4972 if( char_I_pressure_gas[1] == j ) int_O_pressure_need[1] = int_pres_need; | |
| 4973 } | |
| 4974 } // TR functions | |
| 604 | 4975 #endif |
| 0 | 4976 } |
| 4977 | |
| 623 | 4978 |
| 4979 ////////////////////////////////////////////////////////////////////////////// | |
| 4980 // convert the real CNS value to integer | |
| 4981 // | |
| 4982 // Input CNS_fraction_real current CNS value as float | |
| 4983 // | |
| 4984 // Output: int_O_CNS_current current CNS value as integer including flags | |
| 4985 // | |
| 4986 static void convert_cur_CNS_for_display(void) | |
| 4987 { | |
| 4988 // convert to integer | |
| 4989 float_value = CNS_fraction_real; convert_float_to_int(); int_O_CNS_current = int_value; | |
| 4990 | |
| 4991 // set warning & attention flags | |
| 4992 if ( int_O_CNS_current >= CNS_WARNING_THRESHOLD ) int_O_CNS_current |= INT_FLAG_WARNING; | |
| 4993 else if ( int_O_CNS_current >= CNS_ATTENTION_THRESHOLD ) int_O_CNS_current |= INT_FLAG_ATTENTION; | |
| 4994 } | |
| 4995 | |
| 4996 | |
| 0 | 4997 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 4998 // convert the simulated CNS value to integer |
| 4999 // | |
| 5000 // Input: CNS_fraction_sim CNS value after predicted ascent in float | |
| 5001 // | |
| 5002 // Output: int_sim_CNS_fraction CNS value after predicted ascent in integer | |
| 5003 // including flags, will be routed to | |
| 5004 // int_O_{normal,alternative}_CNS_fraction | |
| 5005 // | |
| 604 | 5006 static void convert_sim_CNS_for_display(void) |
| 582 | 5007 { |
| 623 | 5008 // convert to integer |
| 5009 float_value = CNS_fraction_sim; convert_float_to_int(); int_sim_CNS_fraction = int_value; | |
| 5010 | |
| 5011 // set warning & attention flags | |
| 5012 if ( int_sim_CNS_fraction >= CNS_WARNING_THRESHOLD ) int_sim_CNS_fraction |= INT_FLAG_WARNING; | |
| 5013 else if ( int_sim_CNS_fraction >= CNS_ATTENTION_THRESHOLD ) int_sim_CNS_fraction |= INT_FLAG_ATTENTION; | |
| 604 | 5014 |
| 5015 // set invalid flag if there is an overflow in the stops table | |
| 623 | 5016 if ( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_sim_CNS_fraction |= INT_FLAG_INVALID; |
| 604 | 5017 } |
| 5018 | |
| 623 | 5019 |
| 604 | 5020 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 5021 // convert the saturation value of the leading tissue to integer |
| 5022 // | |
| 5023 // Input lead_supersat saturation of the leading tissue | |
| 5024 // lead_tissue number of the leading tissue | |
| 5025 // char_I_GF_High_percentage GF high factor | |
| 5026 // | |
| 5027 // Output: int_O_lead_supersat saturation of the leading tissue | |
| 5028 // char_O_lead_tissue number of the leading tissue | |
| 5029 // | |
| 5030 // Modified: deco_warnings deco engine warnings vector | |
| 5031 // | |
| 5032 static void convert_sat_for_display(void) | |
| 604 | 5033 { |
| 623 | 5034 // convert supersaturation of the leading tissue to int_O_lead_supersat in % (1.0 = 100%) |
| 604 | 5035 // limit to 255 because of constraints in ghostwriter code |
| 623 | 5036 if ( lead_supersat <= 0.000 ) int_O_lead_supersat = 0; |
| 5037 else if ( lead_supersat > 2.545 ) int_O_lead_supersat = 255; | |
| 5038 else int_O_lead_supersat = (unsigned short)(100 * lead_supersat + 0.5); | |
| 5039 | |
| 5040 // set warning & attention flags | |
| 5041 if( int_O_lead_supersat > 100 ) | |
| 604 | 5042 { |
| 623 | 5043 int_O_lead_supersat |= INT_FLAG_WARNING; // make GF factor shown in red |
| 5044 deco_warnings |= DECO_WARNING_OUTSIDE; // make depth shown in red | |
| 5045 } | |
| 5046 else if( (char_I_deco_model != 0) && (int_O_lead_supersat > char_I_GF_High_percentage) | |
| 5047 || (char_I_deco_model == 0) && (int_O_lead_supersat > 99 ) ) | |
| 5048 { | |
| 5049 int_O_lead_supersat |= INT_FLAG_ATTENTION; // make GF factor shown in yellow | |
| 5050 deco_warnings |= DECO_ATTENTION_OUTSIDE; // make depth shown in yellow | |
| 604 | 5051 } |
| 5052 | |
| 5053 // export also the number of the leading tissue | |
| 623 | 5054 char_O_lead_tissue = lead_tissue; |
| 604 | 5055 } |
| 5056 | |
| 623 | 5057 |
| 604 | 5058 ////////////////////////////////////////////////////////////////////////////// |
| 623 | 5059 // convert the ceiling value to integer |
| 5060 // | |
| 5061 // Input: ceiling minimum depth permitted in float | |
| 5062 // | |
| 5063 // Output: int_O_ceiling minimum depth permitted in mbar | |
| 5064 // | |
| 5065 // Modified: deco_info deco engine information vector | |
| 5066 // | |
| 604 | 5067 static void convert_ceiling_for_display(void) |
| 5068 { | |
| 5069 // Convert ceiling to int_O_ceiling in mbar relative pressure. | |
| 5070 // Round up to next 10 cm so that the ceiling disappears only | |
| 5071 // when the ceiling limit is really zero. This will coincident | |
| 5072 // with TTS switching back to NDL time. | |
| 623 | 5073 if ( ceiling <= 0.0 ) int_O_ceiling = 0; |
| 5074 else if ( ceiling > 16.0 ) int_O_ceiling = 16000; | |
| 5075 else int_O_ceiling = (unsigned short)(ceiling * 1000 + 9); | |
| 604 | 5076 |
| 5077 // set/reset ceiling flag | |
| 623 | 5078 if ( int_O_ceiling ) deco_info |= DECO_CEILING; |
| 5079 else deco_info &= ~DECO_CEILING; | |
| 0 | 5080 } |
| 5081 | |
| 623 | 5082 |
| 0 | 5083 ////////////////////////////////////////////////////////////////////////////// |
| 582 | 5084 // push_tissues_to_vault & pull_tissues_from_vault |
| 5085 // | |
| 5086 // ATTENTION: Do not use from inside the deco engine! | |
| 5087 // The vault is exclusively reserved to back-up and restore the real | |
| 5088 // tissues and related data when entering / leaving simulation mode! | |
| 5089 // | |
| 623 | 5090 // Input/Output: CNS_fraction_real current real CNS value |
| 5091 // char_O_deco_warnings deco engine warnings vector | |
| 5092 // real_pres_tissue_N2[] partial pressure of N2 in real tissues | |
| 5093 // real_pres_tissue_He[] partial pressure of He in real tissues | |
| 5094 // | |
| 5095 // Output: int_O_CNS_current current CNS value as integer including flags | |
| 5096 // | |
| 604 | 5097 static void push_tissues_to_vault(void) |
| 0 | 5098 { |
| 623 | 5099 // store the current CNS value and deco warnings |
| 5100 vault_CNS_fraction_real = CNS_fraction_real; | |
| 5101 vault_deco_warnings = char_O_deco_warnings; | |
| 5102 vault_deco_info = char_O_deco_info; | |
| 5103 | |
| 5104 // store the tissue pressures | |
| 5105 for( i = 0; i < NUM_COMP; i++ ) | |
| 582 | 5106 { |
| 623 | 5107 vault_pres_tissue_N2[i] = real_pres_tissue_N2[i]; |
| 5108 #ifdef _helium | |
| 5109 vault_pres_tissue_He[i] = real_pres_tissue_He[i]; | |
| 5110 #else | |
| 5111 vault_pres_tissue_He[i] = 0; | |
| 5112 #endif | |
| 582 | 5113 } |
| 0 | 5114 } |
| 5115 | |
| 604 | 5116 static void pull_tissues_from_vault(void) |
| 0 | 5117 { |
| 623 | 5118 // restore the CNS value and deco warnings |
| 5119 CNS_fraction_real = vault_CNS_fraction_real; | |
| 5120 char_O_deco_warnings = vault_deco_warnings; | |
| 5121 char_O_deco_info = vault_deco_info; | |
| 5122 | |
| 5123 // convert the CNS value to integer | |
| 5124 convert_cur_CNS_for_display(); | |
| 5125 | |
| 5126 // restore the tissue pressures | |
| 5127 for( i = 0; i < NUM_COMP; i++ ) | |
| 582 | 5128 { |
| 623 | 5129 real_pres_tissue_N2[i] = vault_pres_tissue_N2[i]; |
| 5130 #ifdef _helium | |
| 5131 real_pres_tissue_He[i] = vault_pres_tissue_He[i]; | |
| 5132 #else | |
| 5133 real_pres_tissue_He[i] = 0; | |
| 5134 #endif | |
| 582 | 5135 } |
| 0 | 5136 } |
| 5137 | |
| 623 | 5138 |
| 0 | 5139 ////////////////////////////////////////////////////////////////////////////// |
| 5140 // | |
| 5141 #ifndef CROSS_COMPILE | |
| 5142 void main() {} | |
| 5143 #endif |