Mercurial > public > hwos_code
annotate src/p2_deco.c @ 569:fea63a20c1c5
language updates
author | heinrichsweikamp |
---|---|
date | Fri, 09 Feb 2018 11:22:42 +0100 |
parents | 4ce70e3f00be |
children | b455b31ce022 |
rev | line source |
---|---|
0 | 1 // ************************************************************** |
560 | 2 // p2_deco.c REFACTORED VERSION V2.95a2 |
0 | 3 // |
4 // Created on: 12.05.2009 | |
560 | 5 // Author: heinrichs weikamp, contributions by Ralph Lembcke and others |
0 | 6 // |
7 // ************************************************************** | |
8 | |
9 ////////////////////////////////////////////////////////////////////////////// | |
10 // OSTC - diving computer code | |
11 // Copyright (C) 2011 HeinrichsWeikamp GbR | |
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 | |
15 // the Free Software Foundation, either version 3 of the License, or | |
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 | |
20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 // GNU General Public License for more details. | |
22 // | |
23 // You should have received a copy of the GNU General Public License | |
24 // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
25 // | |
26 ////////////////////////////////////////////////////////////////////////////// | |
27 | |
28 // history: | |
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 |
33 // 03/13/25 v101: CNS_fraction calculation | |
34 // 03/13/26 v101: optimization of tissue calc routines | |
35 // 07/xx/08 v102a: debug of bottom time routine | |
560 | 36 // 09/xx/08 v102d: Gradient Factor Model implementation |
0 | 37 // 10/10/08 v104: renamed to build v103 for v118 stable |
38 // 10/14/08 v104: integration of char_I_depth_last_deco for Gradient Model | |
39 // 03/31/09 v107: integration of FONT Incon24 | |
40 // 05/23/10 v109: 5 gas changes & 1 min timer | |
41 // 07/13/10 v110: cns vault added | |
42 // 12/25/10 v110: split in three files (deco.c, main.c, definitions.h) | |
43 // 2011/01/20: [jDG] Create a common file included in ASM and C code. | |
44 // 2011/01/24: [jDG] Make ascenttime an short. No more overflow! | |
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. | |
50 // 2011/04/15: [jDG] Store low_depth in 32bits (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 | |
560 | 61 // 2012/10/05: [jDG] Better gas_volumes accuracy (average depth, switch between stop). |
0 | 62 // 2013/03/05: [jDG] Should vault low_depth too. |
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 | |
0 | 72 // |
73 // | |
74 // Literature: | |
313 | 75 // Buhlmann, Albert: Tauchmedizin; 4. Auflage [2002]; |
0 | 76 // Schr"oder, Kai & Reith, Steffen; 2000; S"attigungsvorg"ange beim Tauchen, das Modell ZH-L16, Funktionsweise von Tauchcomputern; http://www.achim-und-kai.de/kai/tausim/saett_faq |
77 // Morrison, Stuart; 2000; DIY DECOMPRESSION; http://www.lizardland.co.uk/DIYDeco.html | |
78 // Balthasar, Steffen; Dekompressionstheorie I: Neo Haldane Modelle; http://www.txfreak.de/dekompressionstheorie_1.pdf | |
79 // Baker, Erik C.; Clearing Up The Confusion About "Deep Stops" | |
80 // Baker, Erik C.; Understanding M-values; http://www.txfreak.de/understanding_m-values.pdf | |
81 // | |
82 // | |
83 | |
84 // ********************* | |
85 // ** I N C L U D E S ** | |
86 // ********************* | |
87 #include <math.h> | |
88 | |
89 // *********************************************** | |
90 // ** V A R I A B L E S D E F I N I T I O N S ** | |
91 // *********************************************** | |
92 | |
93 #include "p2_definitions.h" | |
560 | 94 #define TEST_MAIN |
0 | 95 #include "shared_definitions.h" |
96 | |
560 | 97 |
98 // ambient pressure at different mountain heights | |
99 #define P_ambient_1000m 0.880 // [bar] based on 990 hPa and 20°C at sea level, 15°C at altitude | |
100 #define P_ambient_2000m 0.782 // [bar] | |
101 #define P_ambient_3000m 0.695 // [bar] | |
102 | |
103 // ambient pressure in aircraft cabin during flying - worst case according to Buhlmann | |
104 #define P_ambient_fly 0.600 // [bar], 0.600 bar is the value used by Buhlmann for his flying-after-diving calculations | |
105 // 0.735 bar is a typical cabin pressure for nowadays commercial jet aircrafts | |
106 // ----- | |
107 // 0.135 bar safety margin | |
108 | |
109 // constants and factors | |
110 #define ppWater 0.0627 // water vapor partial pressure in the lungs | |
111 #define METER_TO_BAR 0.09985 // conversion factor | |
112 #define BAR_TO_METER 10.0150 // conversion factor (1.0/METER_TO_BAR) | |
113 #define SURFACE_DESAT_FACTOR 0.7042 // surface desaturation safety factor | |
114 #define HYST 1.0E-06 // threshold for tissue graphics on-gassing / off-gassing visualization | |
115 | |
116 // thresholds | |
117 #define GF_warning_threshold 100 // threshold for GF warning (attention threshold is current GF_high) | |
118 #define CNS_warning_threshold 100 // threshold for CNS warning | |
119 #define CNS_prewarning_threshold 70 // threshold for CNS attention | |
120 #define ppO2_prewarn_threshold 120 // threshold for ppO2 attention (master warnings come through options_table.asm) | |
121 #define GAS_NEEDS_ATTENTION_THRESHOLD 0.70 // threshold for gas needs attention | |
122 | |
123 // deco engine states and modes - char_O_deco_status | |
124 #define DECO_STATUS_MASK 0x03 | |
125 #define DECO_STATUS_START 0x00 | |
126 #define DECO_STATUS_FINISHED 0x00 | |
127 #define DECO_STATUS_STOPS 0x01 | |
128 #define DECO_STATUS_ASCENT 0x02 | |
129 #define DECO_STATUS_INIT 0x03 | |
130 | |
131 #define DECO_MODE_MASK 0x0C | |
132 #define DECO_MODE_LOOP 0x04 | |
133 #define DECO_MODE_CCR 0x04 // to be used with == operator in combination with DECO_MODE_MASK only! | |
134 #define DECO_MODE_PSCR 0x08 | |
135 | |
136 #define DECO_PLAN_ALTERNATE 0x10 | |
137 #define DECO_CNS_CALCULATE 0x20 | |
138 #define DECO_VOLUME_CALCULATE 0x40 | |
139 #define DECO_ASCENT_DELAYED 0x80 | |
140 | |
141 // deco engine states and modes - char_O_main_status | |
142 //#define DECO_MODE_MASK 0x0C | |
143 //#define DECO_MODE_LOOP 0x04 | |
144 //#define DECO_MODE_CCR 0x04 // to be used with == operator in combination with DECO_MODE_MASK only! | |
145 //#define DECO_MODE_PSCR 0x08 | |
146 #define DECO_GASCHANGE_OVRD 0x10 | |
147 #define DECO_BOTTOM_CALCULATE 0x40 | |
148 | |
149 | |
150 // deco engine warnings | |
151 #define DECO_WARNING_IBCD 0x01 | |
152 #define DECO_WARNING_IBCD_lock 0x02 | |
153 #define DECO_WARNING_MBUBBLES 0x04 | |
154 #define DECO_WARNING_MBUBBLES_lock 0x08 | |
155 #define DECO_WARNING_OUTSIDE 0x10 | |
156 #define DECO_WARNING_OUTSIDE_lock 0x20 | |
157 #define DECO_WARNING_STOPTABLE_OVERFLOW 0x40 | |
158 #define DECO_FLAG 0x80 | |
159 | |
160 // flags used with integer numbers | |
161 #define INT_FLAG_INVALID 0x0400 | |
162 #define INT_FLAG_ZERO 0x0800 | |
163 #define INT_FLAG_LOW 0x1000 | |
164 #define INT_FLAG_HIGH 0x2000 | |
165 #define INT_FLAG_PREWARNING 0x4000 | |
166 #define INT_FLAG_WARNING 0x8000 | |
167 | |
168 | |
0 | 169 |
170 // ************************* | |
171 // ** P R O T O T Y P E S ** | |
172 // ************************* | |
173 | |
174 static void calc_hauptroutine(void); | |
175 static void calc_hauptroutine_data_input(void); | |
176 static void calc_hauptroutine_update_tissues(void); | |
177 static void calc_hauptroutine_calc_deco(void); | |
560 | 178 static void calc_tissue(void); |
179 static void calc_limit(void); | |
180 static void calc_nullzeit(void); | |
181 static void calc_ascenttime(void); | |
182 static void calc_dive_interval(void); | |
183 static void calc_gradient_factor(void); | |
184 static void calc_wo_deco_step_1_min(void); | |
185 static void calc_desaturation_time(void); | |
186 | |
187 static void sim_extra_time(void); | |
0 | 188 static void sim_ascent_to_first_stop(void); |
560 | 189 static void sim_limit(PARAMETER float GF_current); |
190 | |
191 static void update_startvalues(void); | |
0 | 192 static void gas_switch_set(void); |
560 | 193 static void compute_CNS_for_display(void); |
194 | |
195 static void clear_deco_table(void); | |
196 static void clear_tissue(void); | |
197 | |
198 static unsigned char gas_find_better(void); | |
0 | 199 static unsigned char calc_nextdecodepth(void); |
560 | 200 static unsigned char update_deco_table(PARAMETER unsigned char time_increment); |
201 | |
0 | 202 |
203 //---- Bank 5 parameters ----------------------------------------------------- | |
204 #ifndef UNIX | |
205 # pragma udata bank5=0x500 | |
206 #endif | |
207 | |
560 | 208 // general deco parameters |
209 | |
210 static float GF_low; // initialized from deco parameters, constant during all computations | |
211 static float GF_high; // initialized from deco parameters, constant during all computations | |
212 static float GF_delta; // initialized from deco parameters, constant during all computations | |
213 static float locked_GF_step_norm; // GF_delta / low_depth_norm in normal plan | |
214 static float locked_GF_step_alt; // GF_delta / low_depth_alt in alternative plan | |
215 | |
216 static float low_depth_norm; // Depth of deepest stop in normal plan | |
217 static float low_depth_alt; // Depth of deepest stop in alternative plan | |
218 | |
219 static float float_ascent_speed; // ascent speed from options_table (1.0 .. 10.0 m/min) | |
220 static float float_saturation_multiplier; // safety factor for on-gassing rates | |
221 static float float_desaturation_multiplier; // safety factor for off-gassing rates | |
222 static float float_deco_distance; // additional depth below stop depth for tissue, CNS and gas volume calculation | |
223 | |
224 | |
225 // real context: what we are doing now. | |
226 | |
227 static float calc_lead_tissue_limit; // minimum tolerated ambient pressure by Buhlmann model | |
228 static float CNS_fraction; // current CNS (1.00 = 100%) | |
229 | |
230 static unsigned short deco_tissue_vector; // 32 bit vector to memories all tissues that are in decompression | |
231 static unsigned short IBCD_tissue_vector; // 32 bit vector to memories all tissues that experience IBCD | |
232 | |
233 // simulation context: used to predict ascent. | |
234 | |
235 static float sim_lead_tissue_limit; // minimum tolerated ambient pressure by Buhlmann model | |
236 static float CNS_sim_norm_fraction; // CNS at end of dive in normal plan | |
237 static float CNS_sim_alt_fraction; // CNS at end of dive in alternative plan | |
238 | |
239 static unsigned char temp_depth_limit; // depth of next stop in meters, used in deco calculations | |
240 static unsigned char sim_lead_tissue_no; // Leading compartment number | |
241 static unsigned char split_N2_He[NUM_COMP]; // used for calculating the desaturation time | |
242 | |
243 | |
244 // stops table | |
245 | |
246 static unsigned char internal_deco_depth[NUM_STOPS]; // depth of the stop | |
247 static unsigned char internal_deco_time[NUM_STOPS]; // duration of the stop | |
248 static unsigned char internal_deco_gas[NUM_STOPS]; // gas used at the stop | |
249 | |
250 | |
251 // transfer variables between calc_desaturation_time() and calc_desaturation_time_helper() | |
252 | |
253 static float desat_factor; // used to cache a pre-computed factor | |
254 static float var_ht; // buffer for a half-time factor | |
255 static float pres_target; // target pressure for a compartment | |
256 static float pres_actual; // current pressure of the compartment | |
257 static unsigned short short_time; // time it takes for the compartment to reach the target pressure | |
258 | |
259 // transfer variables between gas_volumes() and gas_volumes_helper() | |
260 static float float_depth; // depth of the stop or half-way point | |
261 static float float_time; // duration of the stop or ascent phase | |
262 static float volume; // computed volume of gas | |
263 static unsigned char usage; // gas usage in l/min | |
264 | |
265 | |
266 // 44 byte free space left in this bank | |
267 | |
0 | 268 |
269 //---- Bank 6 parameters ----------------------------------------------------- | |
270 #ifndef UNIX | |
271 # pragma udata bank6=0x600 | |
272 #endif | |
273 | |
560 | 274 // indexing and sequencing |
275 | |
276 static unsigned char ci; // used as index to the Buhlmann tables | |
277 static unsigned char twosectimer = 0; // used for timing the tissue updating | |
278 static unsigned char tissue_increment; // Selector for real/simulated tissues and time increment | |
279 | |
280 | |
281 // environmental and gas data | |
282 | |
283 static float pres_respiration; // current depth in absolute pressure | |
284 static float pres_surface; // absolute pressure at the surface | |
285 static float temp_deco; // simulated current depth in abs.pressure, used for deco calculations | |
286 | |
287 static unsigned char bottom_depth; // bottom depth in meters, used by CNS and gas needs calculation | |
288 | |
289 static float O2_ratio; // real breathed gas oxygen ratio | |
290 static float N2_ratio; // real breathed gas nitrogen ratio | |
291 static float He_ratio; // real breathed gas helium ratio | |
292 | |
293 static float calc_O2_ratio; // simulated breathed gas oxygen ratio | |
294 static float calc_N2_ratio; // simulated breathed gas nitrogen ratio | |
295 static float calc_He_ratio; // simulated breathed gas helium ratio | |
296 | |
297 static float O2_ppO2; // ppO2 - calculated for pure oxygen at current depth | |
298 static float pSCR_ppO2; // ppO2 - calculated for breathed from pSCR loop | |
299 static float pure_ppO2; // ppO2 - calculated for breathed in OC mode | |
300 | |
301 static unsigned char char_actual_ppO2; // ppO2 - assumed to be breathed, as integer 100 = 1.00 bar | |
302 | |
303 static float breathed_ppO2; // partial pressure of breathed oxygen | |
304 static float ppN2; // partial pressure of breathed nitrogen | |
305 static float ppHe; // partial pressure of breathed helium | |
306 | |
307 | |
308 // Buhlmann model parameters | |
309 | |
310 static float var_N2_a; // Buhlmann a, for current N2 tissue | |
311 static float var_N2_b; // Buhlmann b, for current N2 tissue | |
312 static float var_He_a; // Buhlmann a, for current He tissue | |
313 static float var_He_b; // Buhlmann b, for current He tissue | |
314 static float var_N2_e; // exposition, for current N2 tissue | |
315 static float var_He_e; // exposition, for current He tissue | |
316 static float var_N2_ht; // half-time for current N2 tissue | |
317 static float var_He_ht; // half-time for current N2 tissue | |
318 | |
319 | |
320 // gas switch history | |
321 | |
322 static unsigned char sim_gas_first_used; // Number of first used gas, for bottom segment | |
323 static unsigned char sim_gas_last_used; // number of last used gas | |
324 static unsigned char sim_gas_last_depth; // change depth of last used gas | |
325 | |
326 | |
327 // vault to back-up & restore tissue data | |
328 | |
329 static float pres_tissue_N2_vault[NUM_COMP]; // stores the nitrogen tissue pressures | |
330 static float pres_tissue_He_vault[NUM_COMP]; // stores the helium tissue pressures | |
331 static float low_depth_norm_vault; // stores a parameter of the GF model for normal plan | |
332 static float low_depth_alt_vault; // stores a parameter of the GF model for alternative plan | |
333 static float cns_vault_float; // stores current CNS (float representation) | |
334 | |
335 static unsigned int cns_vault_int; // stores current CNS (integer representation) | |
336 static unsigned char deco_warnings_vault; // stores warnings status | |
337 | |
338 | |
339 // auxiliary variables for local data buffering | |
340 | |
341 static float N2_equilibrium; // used for N2 tissue graphics scaling | |
342 static float temp_tissue; // auxiliary variable to buffer tissue pressures | |
343 | |
344 | |
345 // 6 byte free space left in this bank | |
346 | |
0 | 347 |
348 //---- Bank 7 parameters ----------------------------------------------------- | |
349 #ifndef UNIX | |
350 # pragma udata bank7=0x700 | |
351 #endif | |
560 | 352 |
353 // Keep order and position of the variables in bank 7 as they are backed-up to & restored from EEPROM | |
354 | |
355 float pres_tissue_N2[NUM_COMP]; // 16 floats = 64 bytes | |
356 float pres_tissue_He[NUM_COMP]; // 16 floats = 64 bytes | |
357 float sim_pres_tissue_N2[NUM_COMP]; // 16 floats = 64 bytes | |
358 float sim_pres_tissue_He[NUM_COMP]; // 16 floats = 64 bytes | |
359 | |
0 | 360 |
361 //---- Bank 8 parameters ----------------------------------------------------- | |
362 #ifndef UNIX | |
363 # pragma udata overlay bank8=0x800 | |
560 | 364 |
365 static char md_pi_subst[256]; // Overlay C-code data stack here, too. | |
366 | |
367 # define C_STACK md_pi_subst | |
0 | 368 #endif |
369 | |
370 // Back to bank6 for further tmp data | |
371 #ifndef UNIX | |
372 # pragma udata bank6 | |
373 #endif | |
374 | |
375 ////////////////////////////////////////////////////////////////////////////// | |
376 ////////////////////////////////////////////////////////////////////////////// | |
377 ///////////////////////////// THE LOOKUP TABLES ////////////////////////////// | |
378 ////////////////////////////////////////////////////////////////////////////// | |
379 ////////////////////////////////////////////////////////////////////////////// | |
380 // | |
381 // End of PROM code is 17F00, So push tables on PROM top... | |
382 // | |
383 #ifndef UNIX | |
560 | 384 # pragma romdata Buhlmann_tables = 0x1DD00 // Needs to be in UPPER bank. |
0 | 385 #endif |
386 | |
560 | 387 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
|
388 // 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
|
389 // 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
|
390 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
|
391 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
|
392 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
|
393 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
|
394 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
|
395 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
|
396 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
|
397 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
|
398 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
|
399 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
|
400 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
|
401 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
|
402 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
|
403 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
|
404 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
|
405 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
|
406 }; |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
407 |
560 | 408 rom const float Buhlmann_ht[2*16] = { |
409 // Compartment half-life, in minute | |
410 //--- N2 ---- He ---------------------- | |
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
411 4.0, 1.51, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
412 8.0, 3.02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
413 12.5, 4.72, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
414 18.5, 6.99, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
415 27.0, 10.21, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
416 38.3, 14.48, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
417 54.3, 20.53, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
418 77.0, 29.11, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
419 109.0, 41.20, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
420 146.0, 55.19, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
421 187.0, 70.69, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
422 239.0, 90.34, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
423 305.0, 115.29, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
424 390.0, 147.42, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
425 498.0, 188.24, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
426 635.0, 240.03 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
427 }; |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
428 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
429 rom const float e2secs[2*16] = { |
560 | 430 // 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
|
431 //---- N2 ------------- He ------------ |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
432 5.75958E-03, 1.51848E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
433 2.88395E-03, 7.62144E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
434 1.84669E-03, 4.88315E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
435 1.24813E-03, 3.29997E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
436 8.55371E-04, 2.26041E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
437 6.03079E-04, 1.59437E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
438 4.25414E-04, 1.12479E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
439 3.00019E-04, 7.93395E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
440 2.11949E-04, 5.60641E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
441 1.58240E-04, 4.18555E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
442 1.23548E-04, 3.26795E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
443 9.66686E-05, 2.55722E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
444 7.57509E-05, 2.00387E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
445 5.92416E-05, 1.56716E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
446 4.63943E-05, 1.22734E-04, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
447 3.63850E-05, 9.62538E-05 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
448 //------------------------------------- |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
449 }; |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
450 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
451 rom const float e1min[2*16] = { |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
452 // Integration constant for 1 minute, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
453 // Ie. 1- 2^(-1/HT) |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
454 //----- N2 --------- e 1min He -------- |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
455 1.59104E-01, 3.68109E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
456 8.29960E-02, 2.05084E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
457 5.39424E-02, 1.36579E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
458 3.67742E-02, 9.44046E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
459 2.53454E-02, 6.56359E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
460 1.79351E-02, 4.67416E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
461 1.26840E-02, 3.31991E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
462 8.96152E-03, 2.35301E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
463 6.33897E-03, 1.66832E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
464 4.73633E-03, 1.24808E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
465 3.69981E-03, 9.75753E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
466 2.89600E-03, 7.64329E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
467 2.27003E-03, 5.99417E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
468 1.77572E-03, 4.69082E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
469 1.39089E-03, 3.67548E-03, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
470 1.09097E-03, 2.88359E-03 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
471 //------------------------------------- |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
472 }; |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
473 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
474 rom const float e10min[2*16] = { |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
475 // 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
|
476 // result of 1 - 2^(-10/ht) |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
477 //---- N2 -------------- He ----------- |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
478 8.23223E-01, 9.89851E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
479 5.79552E-01, 8.99258E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
480 4.25651E-01, 7.69737E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
481 3.12487E-01, 6.29027E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
482 2.26416E-01, 4.92821E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
483 1.65547E-01, 3.80407E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
484 1.19840E-01, 2.86538E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
485 8.60863E-02, 2.11886E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
486 6.16117E-02, 1.54849E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
487 4.63665E-02, 1.18026E-01, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
488 3.63881E-02, 9.34005E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
489 2.85855E-02, 7.38569E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
490 2.24698E-02, 5.83504E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
491 1.76160E-02, 4.59303E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
492 1.38222E-02, 3.61528E-02, |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
493 1.08563E-02, 2.84646E-02 |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
494 //------------------------------------- |
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
495 }; |
0 | 496 |
497 ////////////////////////////////////////////////////////////////////////////// | |
498 ////////////////////////////////////////////////////////////////////////////// | |
499 ////////////////////////////// THE SUBROUTINES /////////////////////////////// | |
500 ////////////////////////////////////////////////////////////////////////////// | |
501 ////////////////////////////////////////////////////////////////////////////// | |
502 // | |
503 // all new in v.102 | |
504 // moved from 0x0D000 to 0x0C000 in v.108 | |
505 #ifndef UNIX | |
506 # pragma code p2_deco = 0x0C000 | |
507 #endif | |
508 | |
509 ////////////////////////////////////////////////////////////////////////////// | |
510 ////////////////////////////////////////////////////////////////////////////// | |
511 /////////////////////// U T I L I T I E S ///////////////////////////////// | |
512 ////////////////////////////////////////////////////////////////////////////// | |
513 ////////////////////////////////////////////////////////////////////////////// | |
514 | |
515 ////////////////////////////////////////////////////////////////////////////// | |
516 // Bump to blue-screen when an assert is wrong | |
517 #ifdef __DEBUG | |
518 void assert_failed(PARAMETER short int line) | |
519 { | |
520 } | |
521 #endif | |
522 | |
523 ////////////////////////////////////////////////////////////////////////////// | |
524 // When calling C code from ASM context, the data stack pointer and | |
525 // frames should be reset. Bank8 is used by stack | |
526 | |
527 #ifdef CROSS_COMPILE | |
528 # define RESET_C_STACK | |
529 #else | |
530 # ifdef __DEBUG | |
531 # define RESET_C_STACK fillDataStack(); | |
532 void fillDataStack(void) | |
533 { | |
534 _asm | |
535 LFSR 1,C_STACK | |
536 MOVLW 0xCC | |
537 loop: MOVWF POSTINC1,0 | |
538 TSTFSZ FSR1L,0 | |
539 BRA loop | |
540 | |
541 LFSR 1,C_STACK | |
542 LFSR 2,C_STACK | |
543 _endasm | |
544 } | |
545 # else | |
546 # define RESET_C_STACK \ | |
547 _asm \ | |
548 LFSR 1, C_STACK \ | |
549 LFSR 2, C_STACK \ | |
550 _endasm | |
551 # endif | |
552 #endif | |
553 | |
554 ////////////////////////////////////////////////////////////////////////////// | |
555 // Fast subroutine to read timer 5. | |
560 | 556 // Note: result is in 1/32 of milliseconds (30,51757813 us/bit to be precise) |
0 | 557 static unsigned short tmr5(void) |
558 { | |
559 #ifndef CROSS_COMPILE | |
560 _asm | |
561 movff 0xf7c,PRODL // TMR5L | |
562 movff 0xf7d,PRODH // TMR5H | |
563 _endasm // result in PRODH:PRODL. | |
564 #else | |
565 return 0; | |
566 #endif | |
567 } | |
568 | |
569 ////////////////////////////////////////////////////////////////////////////// | |
560 | 570 // read Buhlmann tables A and B for compartment ci |
0 | 571 // |
560 | 572 static void read_Buhlmann_coefficients(void) |
0 | 573 { |
574 #ifndef CROSS_COMPILE | |
575 // Note: we don't use far rom pointer, because the | |
576 // 24 bits is too complex, hence we have to set | |
577 // the UPPER page ourself... | |
578 // --> Set zero if tables are moved to lower pages ! | |
579 _asm | |
580 movlw 1 | |
581 movwf TBLPTRU,0 | |
582 _endasm | |
583 #endif | |
584 | |
585 assert( ci < NUM_COMP ); | |
586 | |
587 // Use an interleaved array (AoS) to access coefficients with a | |
588 // single addressing. | |
589 { | |
560 | 590 overlay rom const float* ptr = &Buhlmann_ab[4*ci]; |
0 | 591 var_N2_a = *ptr++; |
592 var_N2_b = *ptr++; | |
593 var_He_a = *ptr++; | |
594 var_He_b = *ptr++; | |
595 } | |
596 } | |
597 | |
598 ////////////////////////////////////////////////////////////////////////////// | |
560 | 599 // read Buhlmann tables for compartment ci |
0 | 600 // If period == 0 : 2sec interval |
601 // 1 : 1 min interval | |
602 // 2 : 10 min interval. | |
560 | 603 static void read_Buhlmann_times(PARAMETER char period) |
0 | 604 { |
605 #ifndef CROSS_COMPILE | |
606 // Note: we don't use far rom pointer, because the | |
607 // 24 bits is to complex, hence we have to set | |
608 // the UPPER page ourself... | |
609 // --> Set zero if tables are moved to lower pages ! | |
610 _asm | |
611 movlw 1 | |
612 movwf TBLPTRU,0 | |
613 _endasm | |
614 #endif | |
615 | |
616 assert( ci < NUM_COMP ); | |
617 | |
618 // Integration intervals. | |
619 switch(period) | |
620 { | |
621 case 0: //---- 2 sec ----------------------------------------------------- | |
622 { | |
623 overlay rom const float* ptr = &e2secs[2*ci]; | |
624 var_N2_e = *ptr++; | |
625 var_He_e = *ptr++; | |
626 } | |
627 break; | |
628 | |
629 case 1: //---- 1 min ----------------------------------------------------- | |
630 { | |
631 overlay rom const float* ptr = &e1min[2*ci]; | |
632 var_N2_e = *ptr++; | |
633 var_He_e = *ptr++; | |
634 } | |
635 break; | |
636 | |
637 case 2: //---- 10 min ---------------------------------------------------- | |
638 { | |
639 overlay rom const float* ptr = &e10min[2*ci]; | |
640 var_N2_e = *ptr++; | |
641 var_He_e = *ptr++; | |
642 } | |
643 break; | |
644 | |
645 default: | |
646 assert(0); // Never go there... | |
647 } | |
648 } | |
649 | |
650 ////////////////////////////////////////////////////////////////////////////// | |
560 | 651 // read Buhlmann tables for compartment ci |
0 | 652 // |
560 | 653 static void read_Buhlmann_ht(void) |
0 | 654 { |
655 | |
656 #ifndef CROSS_COMPILE | |
657 // Note: we don't use far rom pointer, because the | |
658 // 24 bits is to complex, hence we have to set | |
659 // the UPPER page ourself... | |
660 // --> Set zero if tables are moved to lower pages ! | |
661 _asm | |
662 movlw 1 | |
663 movwf TBLPTRU,0 | |
664 _endasm | |
665 #endif | |
666 | |
667 assert( ci < NUM_COMP ); | |
668 { | |
560 | 669 overlay rom const float* ptr = &Buhlmann_ht[2*ci]; |
0 | 670 var_N2_ht = *ptr++; |
671 var_He_ht = *ptr++; | |
672 } | |
673 | |
674 assert( 4.0 <= var_N2_ht && var_N2_ht <= 635.0 ); | |
675 assert( 1.5099 <= var_He_ht && var_He_ht <= 240.03 ); | |
676 } | |
677 | |
678 ////////////////////////////////////////////////////////////////////////////// | |
679 // calc_nextdecodepth | |
680 // | |
681 // new in v.102 | |
682 // | |
683 // INPUT, changing during dive: | |
560 | 684 // temp_deco : current depth in absolute pressure |
0 | 685 // |
686 // INPUT, fixed during dive: | |
687 // pres_surface | |
688 // GF_delta | |
689 // GF_high | |
690 // GF_low | |
691 // char_I_depth_last_deco | |
692 // | |
560 | 693 // MODIFIED |
694 // locked_GF_step_norm/_alt : used for GF model | |
695 // low_depth_norm/_alt : used for GF model | |
0 | 696 // |
697 // OUTPUT | |
560 | 698 // temp_depth_limit : depth of next stop in meters (if RETURN == true ) |
699 // depth we can ascent to without stop (if RETURN == false) | |
700 // | |
701 // RETURN TRUE if a stop is needed. | |
0 | 702 // |
703 static unsigned char calc_nextdecodepth(void) | |
704 { | |
560 | 705 overlay unsigned char need_stop; |
706 | |
707 // compute current depth in meters | |
0 | 708 overlay float depth = (temp_deco - pres_surface) * BAR_TO_METER; |
709 | |
560 | 710 // compute depth in meters after 1 minute of ascent at float_ascent_speed (5..10 m/min) |
711 overlay float min_depth = (depth > float_ascent_speed) ? (depth - float_ascent_speed) : 0.0; | |
712 | |
713 | |
714 // allow for 200mbar of weather dependent surface pressure change | |
715 assert( depth >= -0.2 ); | |
716 | |
717 | |
718 //---- check if a stop is needed for deco reasons ---------------------------- | |
719 | |
720 // switch on deco model | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
721 if( char_I_deco_model != 0 ) |
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
722 { |
560 | 723 //---- ZH-L16 + GRADIENT FACTOR Model ------------------------------------ |
724 | |
725 overlay float locked_GF_step; | |
726 overlay float low_depth; | |
727 overlay float pres_gradient; | |
728 | |
0 | 729 overlay unsigned char first_stop = 0; |
560 | 730 |
731 | |
732 // calculate minimum depth we can ascent to in absolute pressure | |
0 | 733 sim_limit( GF_low ); |
560 | 734 |
735 // ...and convert the depth into relative pressure | |
736 pres_gradient = sim_lead_tissue_limit - pres_surface; | |
737 | |
738 // check if we can surface directly | |
739 if( pres_gradient <= 0.0 ) | |
740 { | |
741 min_depth = 0.0; // set minimum depth to 0 meters = surface | |
742 goto no_deco_stop; // done. | |
743 } | |
744 | |
745 // convert minimum depth we can ascent to from relative pressure to depth in meters | |
746 pres_gradient *= BAR_TO_METER; | |
747 | |
748 // recall low_depth dependent on current plan | |
749 low_depth = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? low_depth_alt : low_depth_norm; | |
750 | |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
751 // Store the deepest point needing a deco stop as the LOW reference for GF. |
560 | 752 // NOTE: following stops will be validated using this LOW-HIGH GF scale, |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
753 // so if we want to keep coherency, we should not validate this stop |
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
754 // yet, but apply the search to it, as for all the following stops afterward. |
560 | 755 if( pres_gradient > low_depth ) |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
756 { |
560 | 757 // update GF parameters |
758 low_depth = pres_gradient; | |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
759 locked_GF_step = GF_delta / low_depth; |
560 | 760 |
761 // store updated GF parameters dependent on current plan | |
762 if( char_O_deco_status & DECO_PLAN_ALTERNATE ) | |
763 { | |
764 low_depth_alt = low_depth; | |
765 locked_GF_step_alt = locked_GF_step; | |
766 } | |
767 else | |
768 { | |
769 low_depth_norm = low_depth; | |
770 locked_GF_step_norm = locked_GF_step; | |
771 } | |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
772 } |
560 | 773 else |
774 { | |
775 // recall locked_GF_step dependent on current plan | |
776 locked_GF_step = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? locked_GF_step_alt : locked_GF_step_norm; | |
777 } | |
778 | |
779 // invalidate this stop if we can ascent for 1 minute without going above minimum required deco depth | |
780 if( pres_gradient < min_depth ) goto no_deco_stop; | |
781 | |
782 | |
783 // if program execution passes here, we need a deco stop | |
784 | |
785 // Round to multiple of 3 meters | |
786 first_stop = 3 * (unsigned char)(0.9995 + pres_gradient * 0.333333); | |
787 | |
788 // check a constraint | |
0 | 789 assert( first_stop < 128 ); |
790 | |
560 | 791 // apply correction for the shallowest stop, use char_I_depth_last_deco (3..6 m) instead |
792 if( first_stop == 3 ) first_stop = char_I_depth_last_deco; | |
0 | 793 |
794 // We have a stop candidate. | |
795 // But maybe ascending to the next stop will diminish the constraint, | |
560 | 796 // because the GF might decrease more than the pressure gradient... |
0 | 797 while(first_stop > 0) |
798 { | |
560 | 799 // Next depth |
800 overlay unsigned char next_stop; | |
801 | |
802 // invalidate this stop if we can ascent one more minute without going above minimum required deco depth | |
803 if( first_stop <= (unsigned char)min_depth ) goto no_deco_stop; | |
804 | |
805 // compute depth of next stop | |
806 if ( first_stop <= char_I_depth_last_deco ) next_stop = 0; | |
807 else if ( first_stop == 6 ) next_stop = char_I_depth_last_deco; | |
808 else next_stop = first_stop - 3; | |
809 | |
810 // compute total pressure at the new stop candidate | |
811 pres_gradient = next_stop * METER_TO_BAR + pres_surface; | |
812 | |
813 // compute limit for the new stop candidate | |
814 if( (low_depth == 0.0) || (next_stop > low_depth) ) sim_limit( GF_low ); | |
815 else sim_limit( GF_high - next_stop * locked_GF_step ); | |
816 | |
817 // check if ascent to the next stop candidate is possible | |
818 if( sim_lead_tissue_limit >= pres_gradient ) goto deco_stop_found; // no - ascent to next_stop forbidden | |
819 | |
820 // else, validate that stop and loop... | |
0 | 821 first_stop = next_stop; |
822 } | |
823 | |
824 no_deco_stop: | |
560 | 825 need_stop = 0; // set flag for stop needed to 'no' |
826 temp_depth_limit = (unsigned char)min_depth; // report depth we can ascent to without stop | |
827 goto done; | |
0 | 828 |
342
7812ec7ef694
Fix low_depth shall be stored as a float (no rounding).
jDG
parents:
324
diff
changeset
|
829 deco_stop_found: |
560 | 830 need_stop = 1; // set flag for stop needed to 'yes' |
831 temp_depth_limit = (unsigned char)first_stop; // stop depth, in meters | |
0 | 832 |
833 done: | |
834 ; | |
835 } | |
560 | 836 else |
0 | 837 { |
560 | 838 //---- ZH-L16 model ------------------------------------------------- |
839 | |
0 | 840 overlay float pres_gradient; |
841 | |
560 | 842 |
843 // calculate minimum depth we can ascent to in absolute pressure | |
0 | 844 sim_limit(1.0); |
845 | |
560 | 846 // ...and convert the depth into relative pressure |
0 | 847 pres_gradient = sim_lead_tissue_limit - pres_surface; |
560 | 848 |
849 // check if we can surface directly | |
0 | 850 if (pres_gradient >= 0) |
851 { | |
560 | 852 // no - set flag for stop needed to 'yes' |
853 need_stop = 1; | |
854 | |
855 // convert stop depth in relative pressure to stop index | |
856 pres_gradient *= BAR_TO_METER / 3; | |
857 | |
858 // convert stop index to depth in meters, rounded to multiple of 3 meters | |
859 temp_depth_limit = 3 * (short) (pres_gradient + 0.99); | |
860 | |
861 // correct last stop to 4m/5m/6m | |
862 if( temp_depth_limit == 3 ) temp_depth_limit = char_I_depth_last_deco; | |
0 | 863 } |
864 else | |
560 | 865 { |
866 // yes - set flag for stop needed to 'no' | |
867 need_stop = 0; | |
868 | |
869 // set depth we can ascent to as 0 = surface | |
0 | 870 temp_depth_limit = 0; |
560 | 871 } |
0 | 872 } |
873 | |
560 | 874 |
875 // After the first deco stop, gas changes are only done at deco stops now! | |
876 | |
877 // check if a stop is found and there is a better gas to switch to | |
878 if( need_stop && gas_find_better() ) | |
879 { | |
880 // set the new calculation ratios for N2, He and O2 | |
881 gas_switch_set(); | |
882 | |
883 // prime the deco stop with the gas change time | |
884 update_deco_table(char_I_gas_change_time); | |
885 } | |
0 | 886 |
887 return need_stop; | |
888 } | |
889 | |
890 ////////////////////////////////////////////////////////////////////////////// | |
891 // copy_deco_table | |
892 // | |
893 // Buffer the stops, once computed, so we can continue to display them | |
894 // while computing the next set. | |
895 // | |
896 static void copy_deco_table(void) | |
897 { | |
898 // Copy depth of the first (deepest) stop, because when reversing | |
899 // order, it will be hard to find... | |
111 | 900 char_O_first_deco_depth = internal_deco_depth[0]; |
0 | 901 char_O_first_deco_time = internal_deco_time [0]; |
902 | |
903 { | |
904 overlay unsigned char x, y; | |
905 | |
906 for(x=0; x<NUM_STOPS; x++) | |
907 { | |
908 char_O_deco_depth[x] = internal_deco_depth[x]; | |
909 char_O_deco_time [x] = internal_deco_time [x]; | |
111 | 910 char_O_deco_gas [x] = internal_deco_gas [x]; |
0 | 911 } |
912 | |
913 //Now fill the char_O_deco_time_for_log array | |
914 //---- First: search the first non-null depth | |
915 for(x=(NUM_STOPS-1); x != 0; --x) | |
916 if( internal_deco_depth[x] != 0 ) break; | |
917 | |
918 //---- Second: copy to output table (in reverse order) | |
919 for(y=0; y<NUM_STOPS; y++, --x) | |
920 { | |
921 char_O_deco_time_for_log[y] = internal_deco_time [x]; | |
922 | |
923 // Stop only once the last transfer is done. | |
924 if( x == 0 ) break; | |
925 } | |
926 | |
927 //---- Third: fill table end with null | |
928 for(y++; y<NUM_STOPS; y++) | |
929 { | |
560 | 930 char_O_deco_time_for_log[y] = 0; |
0 | 931 } |
932 } | |
933 } | |
934 | |
935 ////////////////////////////////////////////////////////////////////////////// | |
560 | 936 // temp_tissue_safety |
0 | 937 // |
938 // outsourced in v.102 | |
939 // | |
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
940 // Apply safety factors for both ZH-L16 models. |
0 | 941 // |
942 static void temp_tissue_safety(void) | |
943 { | |
944 assert( 0.0 < float_desaturation_multiplier && float_desaturation_multiplier <= 1.0 ); | |
945 assert( 1.0 <= float_saturation_multiplier && float_saturation_multiplier <= 2.0 ); | |
946 | |
560 | 947 if( temp_tissue < 0.0 ) temp_tissue *= float_desaturation_multiplier; |
948 else temp_tissue *= float_saturation_multiplier; | |
0 | 949 } |
950 | |
951 ////////////////////////////////////////////////////////////////////////////// | |
952 ////////////////////////////////////////////////////////////////////////////// | |
953 // ** THE JUMP-IN CODE ** | |
954 // ** for the asm code ** | |
955 ////////////////////////////////////////////////////////////////////////////// | |
956 ////////////////////////////////////////////////////////////////////////////// | |
957 | |
958 ////////////////////////////////////////////////////////////////////////////// | |
560 | 959 // Called every second during diving. |
960 // updates tissues every second invocation. | |
0 | 961 // |
560 | 962 // Every few seconds (or slower when TTS > 16): |
963 // - updates deco table (char_O_deco_time/depth) with new values. | |
964 // - updates ascent time, | |
965 // - sets status to zero (so we can check there is new results). | |
0 | 966 // |
967 void deco_calc_hauptroutine(void) | |
968 { | |
969 RESET_C_STACK | |
970 calc_hauptroutine(); | |
971 } | |
972 | |
973 ////////////////////////////////////////////////////////////////////////////// | |
974 // Reset decompression model: | |
975 // + Set all tissues to equilibrium with Air at ambient pressure. | |
976 // + Reset last stop to 0m | |
977 // + Reset all model output. | |
978 void deco_clear_tissue(void) | |
979 { | |
980 RESET_C_STACK | |
981 clear_tissue(); | |
982 } | |
983 | |
984 ////////////////////////////////////////////////////////////////////////////// | |
985 | |
986 void deco_calc_wo_deco_step_1_min(void) | |
987 { | |
988 RESET_C_STACK | |
989 calc_wo_deco_step_1_min(); | |
560 | 990 } |
991 | |
992 ////////////////////////////////////////////////////////////////////////////// | |
993 | |
994 void deco_calc_desaturation_time(void) | |
995 { | |
996 RESET_C_STACK | |
997 calc_desaturation_time(); | |
0 | 998 } |
999 | |
1000 ////////////////////////////////////////////////////////////////////////////// | |
1001 | |
1002 void deco_calc_dive_interval(void) | |
1003 { | |
1004 RESET_C_STACK | |
1005 calc_dive_interval(); | |
1006 } | |
1007 | |
1008 ////////////////////////////////////////////////////////////////////////////// | |
560 | 1009 // deco_calc_CNS_decrease_15min |
0 | 1010 // |
560 | 1011 // new in v.101 |
0 | 1012 // |
560 | 1013 // calculates the half time of 90 minutes in 6 steps of 15 min |
1014 // (Used in sleep mode, for low battery mode). | |
0 | 1015 // |
560 | 1016 // Output: int_O_CNS_fraction |
1017 // Uses and Updates: CNS_fraction | |
1018 // | |
1019 void deco_calc_CNS_decrease_15min(void) | |
0 | 1020 { |
560 | 1021 RESET_C_STACK |
1022 | |
1023 // clock down CNS | |
1024 CNS_fraction = 0.890899 * CNS_fraction; | |
1025 | |
1026 // compute integer copy of CNS value | |
1027 compute_CNS_for_display(); | |
1028 } | |
1029 | |
1030 | |
1031 ////////////////////////////////////////////////////////////////////////////// | |
1032 // Find current gas in the list (if any) and get its change depth | |
1033 // | |
1034 // Input: char_I_current_gas : 1..5 or 6 | |
1035 // | |
1036 // Output: sim_gas_last_used : 1..6 or 0 if it is the gas set as FIRST | |
1037 // sim_gas_last_depth : change depth in meters or 0 if it is the gas set as FIRST | |
1038 // | |
1039 static void gas_find_current(void) | |
1040 { | |
1041 assert( 1 <= char_I_current_gas && char_I_current_gas <= 6 ); | |
1042 | |
1043 if( char_I_current_gas <= NUM_GAS ) // Gas 1-5 | |
0 | 1044 { |
560 | 1045 sim_gas_last_used = sim_gas_first_used = char_I_current_gas; |
1046 | |
1047 // If current gas is a deco gas get it's change depth. | |
1048 // Set change depth to 0 if the current gas is the first gas or | |
1049 // a travel/normal gas, i.e. if it can be breathed at "any" depth. | |
1050 if( char_I_deco_gas_change[sim_gas_last_used-1] ) sim_gas_last_depth = char_I_deco_gas_change[sim_gas_last_used-1]; | |
1051 else sim_gas_last_depth = 0; | |
0 | 1052 } |
1053 else | |
560 | 1054 { |
1055 sim_gas_last_used = sim_gas_first_used = 0; // Gas 6 (the manually set one) has number 0 here | |
1056 sim_gas_last_depth = 0; // handle it as a travel/normal gas | |
1057 } | |
1058 } | |
1059 | |
1060 | |
1061 ////////////////////////////////////////////////////////////////////////////// | |
1062 // Find the deco gas with the shallowest change depth beyond current depth | |
1063 // | |
1064 // INPUT temp_depth_limit : current depth in meters | |
1065 // char_I_deco_gas_change[] : change depths of the deco gases | |
1066 // sim_gas_last_depth : change depth of the currently used gas, 0 if on the gas set as FIRST | |
1067 // | |
1068 // OUTPUT sim_gas_last_depth : switch depth - only if return value is true | |
1069 // sim_gas_last_used : index of the gas (1..5) - only if return value is true | |
1070 // | |
1071 // RETURNS TRUE if a better gas is available | |
1072 // | |
1073 static unsigned char gas_find_better(void) | |
1074 { | |
1075 overlay unsigned char switch_depth = 255; | |
1076 overlay unsigned char switch_gas = 0; | |
1077 overlay unsigned char j; | |
1078 | |
1079 | |
1080 // no automatic gas changes in CCR mode and - as of now - in pSCR mode | |
1081 if( char_O_deco_status & DECO_MODE_LOOP ) return 0; | |
1082 | |
1083 // Loop over all deco gases to find the shallowest one below or at current depth. | |
1084 for(j=0; j<NUM_GAS; ++j) | |
1085 { | |
1086 // Is this the gas we are already breathing? | |
1087 // If yes, skip this gas. | |
1088 if( j+1 == sim_gas_last_used ) continue; | |
1089 | |
1090 // Is the change depth of the gas shallower than the current depth? | |
1091 // If yes, skip this gas as it is not to be used yet. | |
1092 // Remark: this check will also skip all disabled gases and the gas set | |
1093 // as 'first' because these have their change depth set to 0. | |
1094 if( temp_depth_limit > char_I_deco_gas_change[j] ) continue; | |
1095 | |
1096 // Is the change depth of the gas deeper than the change depth of the | |
1097 // gas we are currently one? | |
1098 // If yes, skip this gas as it is not better than the current one. | |
1099 // Remark: if there is more than one gas with the same change depth, | |
1100 // the last one from the list will be taken. | |
1101 if( sim_gas_last_depth && (char_I_deco_gas_change[j] > sim_gas_last_depth) ) continue; | |
1102 | |
1103 // Is the change depth of the gas shallower or equal to the change depth | |
1104 // of the best gas found so far, or is it the first better gas found? | |
1105 // If yes, we have a better gas | |
1106 if( char_I_deco_gas_change[j] <= switch_depth ) | |
1107 { | |
1108 switch_gas = j+1; // remember this gas (1..5) | |
1109 switch_depth = char_I_deco_gas_change[j]; // remember its change depth | |
1110 } | |
1111 } // continue looping through all gases to eventually find an even better gas | |
1112 | |
1113 // has a better gas been found? | |
1114 if( switch_gas ) | |
1115 { | |
1116 // yes | |
1117 sim_gas_last_used = switch_gas; // report the index of the better | |
1118 sim_gas_last_depth = switch_depth; // report its change depth | |
1119 | |
1120 assert( sim_gas_last_depth < switch_depth ); | |
1121 | |
1122 return 1; // signal a better gas was found | |
1123 } | |
1124 else | |
1125 { | |
1126 return 0; // signal no better gas was found | |
1127 } | |
0 | 1128 } |
1129 | |
1130 ////////////////////////////////////////////////////////////////////////////// | |
560 | 1131 // Set calc_N2/He/O2_ratios by sim_gas_last_used |
0 | 1132 // |
560 | 1133 // Input: sim_gas_last_used : index of gas to use |
1134 // N2_ratio, He_ratio : if gas 0 = the manually set gas is in use | |
0 | 1135 // |
560 | 1136 // Output: calc_N2_ratio, calc_He_ratio, calc_O2ratio |
0 | 1137 // |
560 | 1138 static void gas_switch_set(void) |
0 | 1139 { |
560 | 1140 assert( 0 <= sim_gas_last_used <= NUM_GAS ); |
1141 | |
1142 if( sim_gas_last_used == 0 ) // Gas6 = manually set gas. | |
1143 { | |
1144 calc_O2_ratio = O2_ratio; | |
1145 calc_He_ratio = He_ratio; | |
1146 } | |
1147 else | |
1148 { | |
1149 calc_O2_ratio = char_I_deco_O2_ratio[sim_gas_last_used-1] * 0.01; | |
1150 calc_He_ratio = char_I_deco_He_ratio[sim_gas_last_used-1] * 0.01; | |
1151 } | |
1152 | |
1153 calc_N2_ratio = 1.0 - calc_O2_ratio - calc_He_ratio; | |
1154 | |
1155 assert( 0.0 <= calc_N2_ratio && calc_N2_ratio <= 0.95 ); | |
1156 assert( 0.0 <= calc_He_ratio && calc_He_ratio <= 1.00 ); | |
1157 assert( (calc_N2_ratio + calc_He_ratio) <= 1.00 ); | |
0 | 1158 } |
1159 | |
1160 ////////////////////////////////////////////////////////////////////////////// | |
560 | 1161 // Compute ppN2 and ppHe |
0 | 1162 // |
1163 // Input: calc_N2_ratio, calc_He_ratio : simulated gas mix. | |
560 | 1164 // temp_deco : simulated respiration pressure |
1165 // float_deco_distance : safety factor | |
1166 // ppWater : water-vapor pressure inside respiratory tract | |
0 | 1167 // |
1168 // Output: ppN2, ppHe. | |
1169 // | |
1170 static void sim_alveolar_presures(void) | |
1171 { | |
560 | 1172 overlay float deco_diluent = temp_deco; |
1173 | |
1174 // read ppO2 reported from sensors or by setpoint // TODO: can be deleted | |
1175 // char_actual_ppO2 = char_I_const_ppO2; | |
1176 | |
0 | 1177 |
1178 // Take deco offset into account, but not at surface. | |
560 | 1179 // Note: this should be done on ambient pressure, hence before |
1180 // computing the diluent partial pressure... | |
1181 if( deco_diluent > pres_surface ) deco_diluent += float_deco_distance; | |
1182 | |
1183 if( char_O_deco_status & DECO_MODE_LOOP ) | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1184 { |
560 | 1185 //---- Loop mode : adjust ppN2 and ppHe for change in ppO2 due to setpoint (CCR) or drop (pSCR)------- |
1186 | |
1187 // get current setpoint (CCR) or sensor value (CCR, for pSCR see text below) as default | |
1188 overlay float const_ppO2 = char_I_const_ppO2 * 0.01; | |
1189 | |
1190 if( char_O_deco_status & DECO_MODE_PSCR ) | |
1191 { | |
1192 //---- PSCR mode : compute loop gas ---------------------------------------- | |
1193 // | |
1194 // As the ppO2 in the loop changes with water depth, we can not use the current | |
1195 // sensor value as with CCR mode, but need to compute the ppO2 for the given depth. | |
1196 // Then we continue with the CCR mode code which calculates the increases of ppN2 | |
1197 // and ppH2 due to the reduction of the ppO2 in the loop. Essentially, diving a | |
1198 // PSCR is like diving a CCR with a setpoint lower than the ambient pressure x the | |
1199 // O2 fraction of the diluent would yield... | |
1200 // | |
1201 | |
1202 // deco_diluent is 0.0 ... in bar | |
1203 // calc_O2_ratio is 0.0 ... 1 as factor | |
1204 // char_I_PSCR_drop is 0 ... 15 as % | |
1205 // char_I_PSCR_lungratio is 5 ... 20 as % | |
1206 // const_ppO2 is 0.0 ... in bar | |
1207 | |
1208 const_ppO2 = (deco_diluent * calc_O2_ratio) - (1 - calc_O2_ratio) * 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio; | |
1209 | |
1210 // capture failure condition | |
1211 if( const_ppO2 < 0.0 ) const_ppO2 = 0.0; | |
1212 } | |
1213 else | |
1214 { | |
1215 | |
1216 //---- CCR mode ------------------------------------------------------------ | |
1217 | |
1218 // Limit the setpoint to the maximum physically possible ppO2. This prevents for | |
1219 // example calculating with a setpoint of 1.3 bar in only 2 meters of depth. | |
1220 // Additionally, if limiting occurs, the ppO2 can be further reduced to account | |
1221 // for residual inert gases by the user-adjustable setting char_I_cc_max_frac_o2. | |
1222 | |
1223 if( const_ppO2 > deco_diluent ) // no ppWater subtracted here to give some margin for | |
1224 { // sensors delivering data a little bit over target | |
1225 | |
1226 const_ppO2 = 0.01 * char_I_cc_max_frac_o2 * (deco_diluent - ppWater); | |
1227 } | |
1228 } | |
1229 | |
1230 if ( const_ppO2 == 0.0 ) char_actual_ppO2 = 0; | |
1231 else if ( const_ppO2 > 2.545 ) char_actual_ppO2 = 255; | |
1232 else char_actual_ppO2 = (unsigned char)(const_ppO2*100 + 0.5); | |
1233 | |
1234 // Note: ppO2 and ratios are known outside the lungs, so there is no ppWater in the equations below: | |
0 | 1235 deco_diluent -= const_ppO2; |
560 | 1236 deco_diluent /= calc_N2_ratio + calc_He_ratio; |
527
015b7fdd90a7
BUGFIX: O2 as diluent in CCR caused wrong calculations (Deco, EAD, END) in less then 6m depth
heinrichsweikamp
parents:
522
diff
changeset
|
1237 |
560 | 1238 // capture all failure conditions, including div/0 in case diluent is pure O2 |
1239 if( (deco_diluent < 0.0) || (calc_O2_ratio > 99.5) ) | |
1240 { | |
1241 deco_diluent = 0.0; | |
1242 | |
1243 char_actual_ppO2 = (unsigned char)(temp_deco*100 + 0.5); // without float_deco_distance here as this situation | |
1244 // is likely to occur only at 6 meters or shallower | |
1245 } | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1246 } |
560 | 1247 else |
1248 { | |
1249 //---- OC mode: char_actual_ppO2 will be needed for CNS calculation later -------------------------------- | |
1250 | |
1251 overlay float ppO2 = pres_respiration * calc_O2_ratio; | |
1252 | |
1253 if ( ppO2 > 2.545 ) char_actual_ppO2 = 255; | |
1254 else char_actual_ppO2 = (unsigned char)(ppO2*100 + 0.5); | |
1255 } | |
1256 | |
1257 | |
0 | 1258 if( deco_diluent > ppWater ) |
1259 { | |
1260 ppN2 = calc_N2_ratio * (deco_diluent - ppWater); | |
1261 ppHe = calc_He_ratio * (deco_diluent - ppWater); | |
1262 } | |
1263 else | |
1264 { | |
1265 ppN2 = 0.0; | |
1266 ppHe = 0.0; | |
1267 } | |
560 | 1268 |
0 | 1269 assert( 0.0 <= ppN2 && ppN2 < 14.0 ); |
1270 assert( 0.0 <= ppHe && ppHe < 14.0 ); | |
1271 } | |
1272 | |
1273 ////////////////////////////////////////////////////////////////////////////// | |
1274 // clear_tissue | |
1275 // | |
1276 // optimized in v.101 (var_N2_a) | |
1277 // | |
1278 // preload tissues with standard pressure for the given ambient pressure. | |
1279 // Note: fixed N2_ratio for standard air. | |
1280 // | |
1281 static void clear_tissue(void) | |
1282 { | |
560 | 1283 pres_respiration = 0.001 * int_I_pres_respiration; |
1284 N2_equilibrium = 0.7902 * (pres_respiration - ppWater); | |
1285 | |
0 | 1286 for(ci=0; ci<NUM_COMP; ci++) |
1287 { | |
313 | 1288 // cycle through the 16 Buhlmann N2 tissues |
560 | 1289 pres_tissue_N2[ci] = N2_equilibrium; // initialize data for "real" tissue |
1290 char_O_tissue_N2_saturation[ci] = 11; // initialize data for tissue graphics | |
1291 | |
1292 | |
1293 // cycle through the 16 Buhlmann He tissues | |
1294 pres_tissue_He[ci] = 0.0; // initialize data for "real" tissue | |
1295 char_O_tissue_He_saturation[ci] = 0; // initialize data for tissue graphics | |
0 | 1296 } |
1297 | |
560 | 1298 clear_CNS_fraction(); |
1299 | |
0 | 1300 clear_deco_table(); |
560 | 1301 |
1302 char_O_main_status = 0; | |
1303 char_O_deco_status = 0; | |
1304 char_O_nullzeit = 0; | |
1305 char_O_gtissue_no = 0; | |
1306 char_O_deco_warnings = 0; | |
1307 | |
1308 int_O_ascenttime = 0; | |
1309 int_O_gradient_factor = 0; | |
1310 | |
1311 calc_lead_tissue_limit = 0.0; | |
0 | 1312 } |
1313 | |
1314 ////////////////////////////////////////////////////////////////////////////// | |
1315 // calc_hauptroutine | |
1316 // | |
1317 // this is the major code in dive mode calculates: | |
1318 // the tissues, | |
1319 // the bottom time, | |
1320 // and simulates the ascend with all deco stops. | |
1321 // | |
1322 // | |
1323 static void calc_hauptroutine(void) | |
1324 { | |
560 | 1325 unsigned int int_ppO2_min; |
1326 unsigned int int_ppO2_max; | |
1327 | |
1328 | |
1329 //--- set-up part -------------------------------------------------------------------------------- | |
1330 | |
1331 // twosectimer: | |
1332 // calc_hauptroutine is now invoked every second to speed up the deco planning. | |
1333 // Because the tissue and CNS calculations are based on a 2 seconds period, the | |
1334 // the following toggle-timer will be used by the respective routines to skip | |
1335 // every 2nd invocation. | |
1336 twosectimer = (twosectimer) ? 0 : 1; // toggle the toggle-timer | |
1337 | |
1338 | |
1339 // set up normal tissue updating or "fast forward" updating for simulator sim+5' function | |
1340 // and deco calculator bottom time calculation | |
1341 if( char_I_sim_advance_time > 0 ) | |
1342 { | |
1343 // configure char_I_sim_advance_time minutes of tissue updating | |
1344 tissue_increment = char_I_sim_advance_time // given number of minutes, limited to 127 | |
1345 | 128; // set flag for updating the "real" tissues & CNS | |
1346 | |
1347 char_I_sim_advance_time = 0; // clear "mailbox" | |
1348 } | |
1349 else | |
1350 { | |
1351 // configure 2 seconds of tissue updating | |
1352 tissue_increment = 0 // encoding for 2 seconds update | |
1353 | 128; // set flag for updating the "real" tissues & CNS | |
1354 } | |
1355 | |
1356 //---- calculate the real tissue's data ----------------------------------------------------------------- | |
1357 | |
1358 calc_hauptroutine_data_input(); // acquire current environment data | |
1359 | |
1360 calc_hauptroutine_update_tissues(); // update tissue pressures, also sets char_actual_ppO2 | |
1361 | |
1362 calc_CNS_fraction(); // calculate CNS% for the real tissues | |
1363 | |
1364 compute_CNS_for_display(); // compute integer copy of CNS value for display purpose | |
1365 | |
1366 calc_gradient_factor(); // compute current GF | |
1367 | |
1368 | |
1369 //---- compute ppO2 warnings ------------------------------------------------------------------------------ | |
1370 | |
1371 // compute conditional min/max values | |
1372 int_ppO2_min = (char_O_main_status & DECO_MODE_LOOP) ? (unsigned int)char_I_ppO2_min_loop : (unsigned int)char_I_ppO2_min; | |
1373 int_ppO2_max = (char_O_deco_warnings & DECO_FLAG ) ? (unsigned int)char_I_ppO2_max_deco : (unsigned int)char_I_ppO2_max; | |
1374 | |
1375 // check for safe range of pure oxygen | |
1376 if ( int_O_O2_ppO2 >= int_ppO2_max ) int_O_O2_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
1377 | |
1378 // check for safe range of breathed gas | |
1379 if ( int_O_breathed_ppO2 <= int_ppO2_min ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
1380 else if ( int_O_breathed_ppO2 >= int_ppO2_max ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
566
3febf1cd1bf4
Fix anomalie when toggling ppO2 warning levels in ccr and pscr mode.
heinrichsweikamp
parents:
560
diff
changeset
|
1381 else if ( char_O_main_status & DECO_MODE_LOOP ) ; // no attention generated in loop modes |
560 | 1382 else if ( int_O_breathed_ppO2 >= ppO2_prewarn_threshold ) int_O_breathed_ppO2 |= INT_FLAG_PREWARNING; |
1383 | |
1384 // check for safe range of pure diluent | |
1385 if ( int_O_pure_ppO2 <= (unsigned int)char_I_ppO2_min ) int_O_pure_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
1386 else if ( int_O_pure_ppO2 >= int_ppO2_max ) int_O_pure_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
1387 | |
1388 // check for safe range of calculated pSCR loop gas | |
1389 if ( int_O_pSCR_ppO2 <= int_ppO2_min ) int_O_pSCR_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW; | |
1390 else if ( int_O_pSCR_ppO2 >= int_ppO2_max ) int_O_pSCR_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH; | |
1391 | |
1392 | |
1393 //---- toggle between calculation for NDL (bottom time), deco stops and more deco stops (continue) ------ | |
1394 | |
1395 switch( char_O_deco_status & DECO_STATUS_MASK ) | |
0 | 1396 { |
560 | 1397 overlay unsigned char i; |
1398 | |
1399 case DECO_STATUS_INIT: //---- At surface: start a new dive --------------------- | |
1400 | |
1401 clear_deco_table(); | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1402 copy_deco_table(); |
560 | 1403 |
1404 | |
1405 char_I_gas_change_time = 1; // TODO: validate proper operation before enabling this options-table parameter | |
1406 | |
1407 char_I_ascent_speed = 10; // TODO: validate proper operation before enabling this options-table parameter, | |
1408 // caution: values < 10 may have an impact on the deco calculation run-times! | |
1409 | |
1410 | |
1411 float_ascent_speed = 1.00 * char_I_ascent_speed; | |
1412 float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier; | |
1413 float_saturation_multiplier = 0.01 * char_I_saturation_multiplier; | |
1414 float_deco_distance = 0.01 * char_I_deco_distance; | |
1415 | |
1416 int_O_ascenttime = 0; // reset ascent time in normal plan | |
1417 int_O_alternate_ascenttime = 0; // reset ascent time in alternative plan | |
1418 char_O_nullzeit = 0; // reset no decompression limit (NDL) in normal plan | |
1419 char_O_alternate_nullzeit = 0; // reset no decompression limit (NDL) in alternative plan | |
1420 char_O_deco_warnings = 0; // reset all deco warning flags | |
1421 deco_tissue_vector = 0; // reset tissue deco vector | |
1422 IBCD_tissue_vector = 0; // reset tissue IBCD vector | |
1423 | |
1424 int_O_desaturation_time = 65535; // tag desaturation time as invalid (it will not be computed during a dive) | |
1425 | |
1426 | |
1427 for(i=0; i<NUM_GAS; ++i) | |
1428 { | |
1429 int_O_gas_volumes[i] = 0; | |
1430 int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO; // 0 bar + flag for 0 bar | |
1431 } | |
1432 | |
1433 for(i=0; i<NUM_COMP; ++i) | |
1434 { | |
1435 split_N2_He[i] = 90; // used for calculation of no-fly time | |
1436 } | |
1437 | |
1438 | |
1439 // init CNS counters | |
1440 CNS_sim_norm_fraction = CNS_sim_alt_fraction = CNS_fraction; // the floats | |
1441 int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = int_O_CNS_fraction; // the integers | |
1442 | |
1443 | |
0 | 1444 // Values that should be reset just once for the full real dive. |
1445 // This is used to record the lowest stop for the whole dive, | |
560 | 1446 // including ACCROSS all simulated ascents. |
1447 low_depth_norm = low_depth_alt = 0.0; | |
1448 locked_GF_step_norm = locked_GF_step_alt = 0.0; | |
1449 | |
1450 | |
1451 // continue in state DECO_STATUS_START to calculate the bottom-part of the dive and the NDL | |
1452 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1453 | |
1454 // code execution continues in state DECO_STATUS_START | |
1455 | |
1456 | |
1457 case DECO_STATUS_START: //---- bottom time ------------------------------------- | |
0 | 1458 default: |
560 | 1459 |
1460 // reread the GF settings in case there was a switch between GF/aGF | |
1461 GF_low = char_I_GF_Low_percentage * 0.01; | |
1462 GF_high = char_I_GF_High_percentage * 0.01; | |
1463 GF_delta = GF_high - GF_low; | |
1464 | |
1465 // Lookup current gas and store it also as the first gas used. This gas will be used for the bottom | |
1466 // segment of the dive and for the period of delayed ascent when calculating fTTS or bailout. | |
1467 gas_find_current(); | |
1468 | |
1469 // setup the calculation ratio's calc_N2_ratio, calc_He_ratio and calc_O2_ratio | |
1470 gas_switch_set(); | |
1471 | |
1472 // calculate ppN2 and ppHe from calc_N2_ratio & calc_He_ratio | |
1473 sim_alveolar_presures(); | |
1474 | |
1475 // clear the internal(!) stops table | |
1476 clear_deco_table(); | |
1477 | |
1478 // initialize the simulated tissues with the current state of the real tissues | |
1479 update_startvalues(); | |
1480 | |
1481 // calculate the effect of extended bottom time due to delayed ascent / fTTS on current gas | |
1482 if( char_O_deco_status & DECO_ASCENT_DELAYED ) sim_extra_time(); | |
1483 | |
1484 // calculate if we are within no decompression limit (NDL) | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1485 calc_nullzeit(); |
560 | 1486 |
1487 // check which plan we are on | |
1488 if( char_O_deco_status & DECO_PLAN_ALTERNATE ) | |
1489 { | |
1490 //---- alternate dive plan -------------------------------------------------------------------- | |
1491 | |
1492 // Some NDL time left in alternate plan? | |
1493 if( char_O_alternate_nullzeit > 0 ) | |
1494 { | |
1495 // clear tank pressure needs | |
1496 if( char_O_deco_status & DECO_VOLUME_CALCULATE ) | |
1497 for(i=0; i<NUM_GAS; ++i) int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO; // 0 bar + flag for 0 bar | |
1498 | |
1499 // calculate the CNS% at the end of the dive if requested: | |
1500 // as we are in no stop, CNS at end of dive is more or less the same CNS we have now | |
1501 if( char_O_deco_status & DECO_CNS_CALCULATE ) int_O_alternate_CNS_fraction = int_O_CNS_fraction; | |
1502 | |
1503 // clear fTTS ascent time | |
1504 int_O_alternate_ascenttime = 0; | |
1505 | |
1506 // YES - computation of alternate plan completed | |
1507 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1508 } | |
1509 else | |
1510 { | |
1511 // NO - clear status bits and set status bits for | |
1512 // calculation of ascent on next invocation | |
1513 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1514 char_O_deco_status |= DECO_STATUS_ASCENT; | |
1515 } | |
1516 } | |
1517 else | |
1518 { | |
1519 //---- normal dive plan ------------------------------------------------------------------------- | |
1520 | |
1521 // Some NDL time left in normal plan? | |
1522 if( char_O_nullzeit > 0 ) | |
1523 { | |
1524 // published (erased) stops table | |
1525 copy_deco_table(); | |
1526 | |
1527 // ** commented out - char_O_deco_last_stop is not used for anything | |
1528 // | |
1529 // // set last stop to 0 (for OSTC menu animation) | |
1530 // char_O_deco_last_stop = 0; | |
1531 | |
1532 // clear tank pressure needs | |
1533 if( char_O_deco_status & DECO_VOLUME_CALCULATE ) | |
1534 for(i=0; i<NUM_GAS; ++i) int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO; // 0 bar + flag for 0 bar | |
1535 | |
1536 // calculate the CNS% at the end of the dive if requested: | |
1537 // as we are in no stop, CNS at end of dive is more or less the same CNS we have now | |
1538 if( char_O_deco_status & DECO_CNS_CALCULATE ) int_O_normal_CNS_fraction = int_O_CNS_fraction; | |
1539 | |
1540 // YES - computation of normal plan completed | |
1541 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1542 } | |
1543 else | |
1544 { | |
1545 // NO - clear status bits and set status bits for | |
1546 // calculation of ascent on next invocation | |
1547 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1548 char_O_deco_status |= DECO_STATUS_ASCENT; | |
1549 } | |
1550 } | |
1551 | |
1552 break; | |
1553 | |
1554 | |
1555 case DECO_STATUS_ASCENT: //---- Simulate ascent to first stop ------------------- | |
1556 | |
1557 // initialize depth (in abs.pressure) for ascent and deco simulation, start from current real depth | |
1558 temp_deco = pres_respiration; | |
1559 | |
1560 // calculate ascent to first stop | |
1561 sim_ascent_to_first_stop(); | |
1562 | |
1563 // calculate all further stops next time | |
1564 char_O_deco_status &= ~DECO_STATUS_MASK; // clear status bits and set status bits | |
1565 char_O_deco_status |= DECO_STATUS_STOPS; // for calculation of stops on next invocation | |
1566 | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1567 break; |
0 | 1568 |
560 | 1569 |
1570 case DECO_STATUS_STOPS: //---- Simulate stops ---------------------------------- | |
1571 | |
1572 calc_hauptroutine_calc_deco(); | |
1573 | |
1574 // If simulation is finished, do some more computations if requested | |
1575 // and restore the GF low reference so that the next ascent simulation | |
1576 // is done from the current depth: | |
1577 if( !(char_O_deco_status & DECO_STATUS_MASK) ) | |
1578 { | |
1579 // Calculate ascent time, result in int_O_ascenttime or int_O_alternate_ascenttime | |
1580 calc_ascenttime(); | |
1581 | |
1582 // the current depth is needed by calc_CNS_planning() and gas_volumes() | |
1583 bottom_depth = (unsigned char)((pres_respiration - pres_surface)*BAR_TO_METER); | |
1584 | |
1585 // if requested, calculate the CNS% at the end of the dive (including the deco stops) | |
1586 if( char_O_deco_status & DECO_CNS_CALCULATE ) calc_CNS_planning(); | |
1587 | |
1588 // if requested, calculate the required gas volumes and tank pressures at the end of the dive. | |
1589 if( char_O_deco_status & DECO_VOLUME_CALCULATE ) gas_volumes(); | |
1590 | |
1591 // some more aftermath dependent on the current plan | |
1592 if( char_O_deco_status & DECO_PLAN_ALTERNATE ) | |
1593 { | |
1594 //---- alternative plan ---------------------------------------------------- | |
1595 | |
1596 // was CNS at end of dive calculated? | |
1597 if( char_O_deco_status & DECO_CNS_CALCULATE ) | |
1598 { | |
1599 // yes - compute CNS value to display | |
1600 if ( CNS_sim_alt_fraction < 0.01 ) int_O_alternate_CNS_fraction = 0; | |
1601 else if ( CNS_sim_alt_fraction > 9.985 ) int_O_alternate_CNS_fraction = 999 + INT_FLAG_WARNING; | |
1602 else | |
1603 { | |
1604 // convert float to integer | |
1605 int_O_alternate_CNS_fraction = (unsigned short)(100 * CNS_sim_alt_fraction + 0.5); | |
1606 | |
1607 // set warning flag if CNS is >= 100% | |
1608 if( int_O_alternate_CNS_fraction >= 100 ) | |
1609 int_O_alternate_CNS_fraction |= INT_FLAG_WARNING; | |
1610 | |
1611 // set invalid flag if there is an overflow in the stops table | |
1612 if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) | |
1613 int_O_alternate_CNS_fraction |= INT_FLAG_INVALID; | |
1614 } | |
1615 } | |
1616 else | |
1617 { | |
1618 // no - invalidate value (value = 0, invalid flag set) | |
1619 int_O_alternate_CNS_fraction = INT_FLAG_INVALID; | |
1620 } | |
1621 } | |
1622 else | |
1623 { | |
1624 //---- normal plan --------------------------------------------------------- | |
1625 | |
1626 // publish the stops table | |
1627 copy_deco_table(); | |
1628 | |
1629 // was CNS at end of dive calculated? | |
1630 if( char_O_deco_status & DECO_CNS_CALCULATE ) | |
1631 { | |
1632 // yes - compute CNS value to display | |
1633 if ( CNS_sim_norm_fraction < 0.01 ) int_O_normal_CNS_fraction = 0; | |
1634 else if ( CNS_sim_norm_fraction >= 9.985 ) int_O_normal_CNS_fraction = 999 + INT_FLAG_WARNING; | |
1635 else | |
1636 { | |
1637 // convert float to integer | |
1638 int_O_normal_CNS_fraction = (unsigned short)(100 * CNS_sim_norm_fraction + 0.5); | |
1639 | |
1640 // set warning flag if CNS is >= 100% | |
1641 if( int_O_normal_CNS_fraction >= 100 ) | |
1642 int_O_normal_CNS_fraction |= INT_FLAG_WARNING; | |
1643 | |
1644 // set invalid flag if there is an overflow in the stops table | |
1645 if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) | |
1646 int_O_normal_CNS_fraction |= INT_FLAG_INVALID; | |
1647 } | |
1648 } | |
1649 else | |
1650 { | |
1651 // no - invalidate value (value = 0, invalid flag set) | |
1652 int_O_normal_CNS_fraction = INT_FLAG_INVALID; | |
1653 } | |
1654 | |
1655 } // aftermath | |
1656 } // if | |
1657 | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1658 break; |
560 | 1659 |
1660 } // switch | |
0 | 1661 } |
1662 | |
1663 ////////////////////////////////////////////////////////////////////////////// | |
1664 // calc_hauptroutine_data_input | |
1665 // | |
1666 // Reset all C-code dive parameters from their ASM-code values. | |
1667 // Detect gas change condition. | |
1668 // | |
1669 void calc_hauptroutine_data_input(void) | |
1670 { | |
560 | 1671 // get the current pressures |
1672 pres_respiration = 0.001 * int_I_pres_respiration; | |
1673 pres_surface = 0.001 * int_I_pres_surface; | |
1674 | |
1675 // get the currently breathed gas mixture | |
1676 O2_ratio = 0.01 * char_I_O2_ratio; | |
1677 He_ratio = 0.01 * char_I_He_ratio; | |
1678 | |
1679 // N2 ratios are computed within p2_deco.c from the O2 and He ratios | |
1680 N2_ratio = 1.0 - O2_ratio - He_ratio; | |
1681 | |
1682 // N2 tissue pressure at surface equilibrium, used for tissue graphics scaling | |
1683 N2_equilibrium = 0.7902 * (pres_surface - ppWater); | |
0 | 1684 } |
1685 | |
1686 ////////////////////////////////////////////////////////////////////////////// | |
1687 // | |
1688 // | |
1689 void calc_hauptroutine_update_tissues(void) | |
1690 { | |
560 | 1691 overlay float pres_diluent = pres_respiration; |
1692 | |
1693 | |
0 | 1694 assert( 0.00 <= N2_ratio && N2_ratio <= 1.00 ); |
1695 assert( 0.00 <= He_ratio && He_ratio <= 1.00 ); | |
114
109df032cc54
minor fix: assert should pass for pure helium diluant
heinrichsweikamp
parents:
111
diff
changeset
|
1696 assert( (N2_ratio + He_ratio) <= 1.00 ); |
0 | 1697 assert( 0.800 < pres_respiration && pres_respiration < 14.0 ); |
1698 | |
560 | 1699 |
1700 //---- OC, CCR and Bailout Mode Gas Calculations ------------------------------------------------------------ | |
1701 | |
1702 // calculate ppO2 of pure oxygen | |
1703 O2_ppO2 = (pres_respiration - ppWater); | |
1704 | |
1705 // capture failure condition in case pres_respiration is < ppWater (should never happen...) | |
1706 if( O2_ppO2 < 0.0 ) O2_ppO2 = 0.0; | |
1707 | |
1708 // calculate ppO2 of the pure gas (diluent) | |
1709 pure_ppO2 = O2_ppO2 * O2_ratio; | |
1710 | |
1711 | |
1712 //---- PSCR Mode Gas Calculation----------------------------------------------------------- | |
1713 | |
1714 // With flags set for PSCR we compute the ppO2 in the loop from the diluent's O2 | |
1715 // ratio and the PSCR parameters. This figure will be used in the pSCR custom view. | |
1716 // If sensors are used (char_I_const_ppO2 > 0), we will override the calculated ppO2 | |
1717 // with the sensor data. Then we continue with the CCR mode code which calculates | |
1718 // the increase of ppN2 and ppH2 due to the reduction of the ppO2 in the loop. | |
1719 // Essentially, diving a pSCR is like diving a CCR with a setpoint set lower than | |
1720 // the ambient pressure multiplied with the O2 fraction of the diluent... | |
1721 | |
1722 // calculate pSCR ppO2 | |
1723 // | |
1724 // pres_respiration is 0.0 ... in bar | |
1725 // O2_ratio is 0.0 ... 1.0 as factor | |
1726 // char_I_PSCR_drop is 0 ... 15 as % | |
1727 // char_I_PSCR_lungratio is 5 ... 20 as % | |
1728 // pSCRppO2 is 0.0 ... in bar | |
1729 | |
1730 pSCR_ppO2 = (pres_respiration * O2_ratio) - (1 - O2_ratio) * 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio; | |
1731 | |
1732 // capture failure condition if case pSCR_ppO2 becomes negative | |
1733 if( pSCR_ppO2 < 0.0 ) pSCR_ppO2 = 0.0; | |
1734 | |
1735 | |
1736 //---- Loop modes : adjust ppN2 and ppHe for change in ppO2 due to setpoint (CCR) or drop (pSCR) ------------ | |
1737 if ( char_O_main_status & DECO_MODE_LOOP ) | |
0 | 1738 { |
560 | 1739 overlay float const_ppO2; |
1740 | |
1741 // get the current sensor reading (CCR / pSCR if fitted) or the fixed setpoint (CCR) / a zero (pSCR) | |
1742 const_ppO2 = 0.01 * char_I_const_ppO2; | |
1743 | |
1744 // Limit the setpoint to the maximum physically possible ppO2. This prevents for | |
1745 // example calculating with a setpoint of 1.3 bar in only 2 meters of depth. | |
1746 // Additionally, if limiting occurs, the ppO2 can be further reduced to account | |
1747 // for residual inert gases by the user-adjustable setting char_I_cc_max_frac_o2. | |
1748 | |
1749 if( const_ppO2 > pres_respiration ) // no ppWater subtracted here to give some margin for | |
1750 { // sensors delivering data a little bit over target | |
1751 | |
1752 const_ppO2 = 0.01 * char_I_cc_max_frac_o2 * (pres_respiration - ppWater); | |
1753 } | |
1754 | |
1755 // check which kind of loop we are on | |
1756 if( char_O_main_status & DECO_MODE_PSCR ) | |
1757 { | |
1758 //---- pSCR Mode -------------------------------------------------------------------------- | |
1759 | |
1760 // check if a sensor is fitted | |
1761 if( char_I_const_ppO2 ) breathed_ppO2 = const_ppO2; // yes - derive ppO2s from (char_I_)const_ppO2 | |
1762 else breathed_ppO2 = pSCR_ppO2; // no - derive ppO2s from calculated ppO2 | |
1763 } | |
1764 else | |
1765 { | |
1766 //---- CCR Mode --------------------------------------------------------------------------- | |
1767 | |
1768 // derive breathed ppO2 from (char_I_)const_ppO2, which holds sensor reading or fixed setpoint | |
1769 breathed_ppO2 = const_ppO2; | |
1770 } | |
1771 | |
1772 // adjust diluent pressure (ppN2 + ppHe) for change in ppO2 due to setpoint (CCR) or drop (pSCR) | |
0 | 1773 pres_diluent -= const_ppO2; |
560 | 1774 pres_diluent /= N2_ratio + He_ratio; |
1775 | |
1776 // capture all failure conditions, including div/0 in case diluent is pure O2 | |
1777 if( (pres_diluent < 0.0) || (char_I_O2_ratio == 100) ) | |
1778 { | |
1779 pres_diluent = 0.0; | |
1780 breathed_ppO2 = pure_ppO2; | |
1781 } | |
1782 | |
1783 } | |
1784 else | |
1785 { //---- OC mode ----------------------------------------------------------------------------------------- | |
1786 | |
1787 // breathed ppO2 is ppO2 of pure gas | |
1788 breathed_ppO2 = pure_ppO2; | |
1789 } | |
1790 | |
1791 | |
1792 // derive char_actual_ppO2 in [cbar], used for calculating CNS% | |
1793 if ( breathed_ppO2 < 0.01 ) char_actual_ppO2 = 0; | |
1794 else if ( breathed_ppO2 >= 2.545 ) char_actual_ppO2 = 255; | |
1795 else char_actual_ppO2 = (unsigned char)(100 * breathed_ppO2 + 0.5); | |
1796 | |
1797 | |
1798 //---- export ppO2 values in [cbar] for warning generation and display purpose ------------------------------ | |
1799 | |
1800 // pure oxygen ppO2 | |
1801 if ( O2_ppO2 < 0.01 ) int_O_O2_ppO2 = 0; | |
1802 else if ( O2_ppO2 >= 9.995 ) int_O_O2_ppO2 = 999; | |
1803 else int_O_O2_ppO2 = (unsigned int)(100 * O2_ppO2 + 0.5); | |
1804 | |
1805 // pure gas ppO2 | |
1806 if ( pure_ppO2 < 0.01 ) int_O_pure_ppO2 = 0; | |
1807 else if ( pure_ppO2 >= 9.995 ) int_O_pure_ppO2 = 999; | |
1808 else int_O_pure_ppO2 = (unsigned int)(100 * pure_ppO2 + 0.5); | |
1809 | |
1810 // calculated pSCR ppO2 | |
1811 if ( pSCR_ppO2 < 0.01 ) int_O_pSCR_ppO2 = 0; | |
1812 else if ( pSCR_ppO2 >= 9.995 ) int_O_pSCR_ppO2 = 999; | |
1813 else int_O_pSCR_ppO2 = (unsigned int)(100 * pSCR_ppO2 + 0.5); | |
1814 | |
1815 // breathed ppO2 | |
1816 if ( breathed_ppO2 < 0.01 ) int_O_breathed_ppO2 = 0; | |
1817 else if ( breathed_ppO2 >= 9.995 ) int_O_breathed_ppO2 = 999; | |
1818 else int_O_breathed_ppO2 = (unsigned int)(100 * breathed_ppO2 + 0.5); | |
1819 | |
1820 | |
1821 //---- calculate ppN2, ppHe and EAD, END ------------------------------------------------------------------- | |
1822 | |
0 | 1823 if( pres_diluent > ppWater ) |
1824 { | |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1825 overlay float EAD, END; |
0 | 1826 |
287
f342853afcd9
FIX gas_volumes: shall take stops in forward order.
jdg@air
parents:
284
diff
changeset
|
1827 ppN2 = N2_ratio * (pres_diluent - ppWater); |
0 | 1828 ppHe = He_ratio * (pres_diluent - ppWater); |
1829 | |
560 | 1830 // EAD : Equivalent Air Depth. Equivalent depth for the same N2 level with plain air. |
0 | 1831 // ppN2 = 79% * (P_EAD - ppWater) |
1832 // EAD = (P_EAD - Psurface) * 10 | |
1833 // ie: EAD = (ppN2 / 0.7902 + ppWater -Psurface) * 10 | |
560 | 1834 |
0 | 1835 EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER; |
560 | 1836 |
1837 if( (EAD < 0.0) || (EAD > 245.5) ) EAD = 0.0; | |
1838 | |
0 | 1839 char_O_EAD = (unsigned char)(EAD + 0.5); |
1840 | |
560 | 1841 |
1842 // END : Equivalent Narcotic Depth. | |
1843 // Here we count O2 as narcotic too. Hence everything but helium (has a narcosis | |
1844 // factor of 0.23 btw). Hence the formula becomes: | |
0 | 1845 // END * BarPerMeter * (1.0 - 0.0) - ppWater + Psurface == Pambient - ppHe - ppWater |
1846 // ie: END = (Pambient - ppHe - Psurface) * BAR_TO_METER | |
1847 // | |
1848 // Source cited: | |
1849 // The Physiology and Medicine of Diving by Peter Bennett and David Elliott, | |
1850 // 4th edition, 1993, W.B.Saunders Company Ltd, London. | |
560 | 1851 |
0 | 1852 END = (pres_respiration - ppHe - pres_surface) * BAR_TO_METER; |
560 | 1853 |
1854 if( (END < 0.0) || (END > 245.5) ) END = 0.0; | |
1855 | |
1856 char_O_END = (unsigned char)(END + 0.5); | |
0 | 1857 } |
560 | 1858 else |
0 | 1859 { |
560 | 1860 ppN2 = ppHe = 0.0; |
1861 | |
1862 char_O_EAD = char_O_END = 0; | |
0 | 1863 } |
1864 | |
560 | 1865 |
1866 //---- calculate decompression status ---------------------------------------------------------------------- | |
1867 | |
1868 // Calculate tissues | |
1869 calc_tissue(); | |
1870 | |
1871 // Calculate limit for surface, ie. GF_high. | |
0 | 1872 calc_limit(); |
560 | 1873 |
1874 | |
1875 // Fill int_O_ceiling (in mbar) if ceiling is below the surface | |
1876 if( (calc_lead_tissue_limit - pres_surface) > 0 ) | |
1877 { | |
1878 | |
1879 // compatibility version | |
1880 int_O_ceiling = (short)((calc_lead_tissue_limit - pres_surface) * 1000); | |
1881 | |
1882 // new version | |
1883 // // Round up to next 10 cm so that the ceiling disappears on the display only when the ceiling | |
1884 // // limit is really zero. This will coincident then with TTS switching back to NDL time. | |
1885 // int_O_ceiling = (short)((calc_lead_tissue_limit - pres_surface) * 1000 + 9); | |
1886 | |
1887 | |
1888 // limit int_O_ceiling to 16000 mbar (150 m) | |
1889 if( int_O_ceiling > 16000) int_O_ceiling = 16000; | |
1890 } | |
126 | 1891 else |
560 | 1892 { |
126 | 1893 int_O_ceiling = 0; |
560 | 1894 } |
126 | 1895 |
0 | 1896 int_O_gtissue_press = (short)((pres_tissue_N2[char_O_gtissue_no] + pres_tissue_He[char_O_gtissue_no]) * 1000); |
1897 } | |
1898 | |
1899 | |
1900 ////////////////////////////////////////////////////////////////////////////// | |
1901 // Compute stops. | |
1902 // | |
1903 // Note: because this can be very long, break on 16 iterations, and set state | |
560 | 1904 // to DECO_STATUS_FINISHED when finished, or to DECO_STATUS_STOPS when |
1905 // needing to continue. | |
0 | 1906 // Note: because each iteration might be very long too (~ 66 ms in 1.84beta), |
560 | 1907 // break the loop when elapsed time exceeds 512 milliseconds. |
0 | 1908 // |
1909 void calc_hauptroutine_calc_deco(void) | |
1910 { | |
560 | 1911 overlay unsigned char loop; |
1912 | |
1913 for(loop = 0; loop < 16; ++loop) | |
1914 { | |
1915 // limit loops to 512ms, using timer 5 | |
1916 if( tmr5() & (512*32) ) break; | |
1917 | |
1918 // calc_nextdecodepth() | |
1919 // | |
1920 // INPUT temp_deco : current depth in absolute pressure | |
1921 // OUTPUT temp_depth_limit : depth of next stop in meters | |
1922 // RETURN true if a stop is needed | |
1923 // | |
1924 // The function manages gas changes by itself, including priming | |
1925 // the deco stop with the configured gas change time. | |
1926 // | |
1927 if( calc_nextdecodepth() ) | |
1928 { | |
1929 if( temp_depth_limit == 0 ) goto Surface; // this check should not bee needed as in | |
1930 // this case the RETURN value will be false | |
1931 | |
1932 //---- stop required at temp_depth_limit ------------------------------------- | |
1933 | |
1934 // convert stop depth in meters to absolute pressure | |
1935 temp_deco = temp_depth_limit * METER_TO_BAR + pres_surface; | |
1936 | |
1937 // add one minute to the current stop, or add a new stop, | |
1938 // or abort deco calculation if the deco table is full. | |
1939 if( !update_deco_table(1) ) goto Surface; | |
1940 } | |
1941 else | |
1942 { | |
1943 //---- no stop required -------------------------------------- | |
1944 | |
1945 // ascend by float_ascent_speed for 1 minute | |
1946 temp_deco -= float_ascent_speed * METER_TO_BAR; | |
1947 | |
1948 // finish deco calculation if surface is reached | |
1949 if( temp_deco <= pres_surface ) | |
1950 { | |
0 | 1951 Surface: |
560 | 1952 // set deco engine status to done (DECO_STATUS_FINISHED) |
1953 char_O_deco_status &= ~DECO_STATUS_MASK; | |
1954 | |
1955 // ** commented out - char_O_deco_last_stop is not used for anything | |
1956 // | |
1957 // // surface reached (to animate menu) | |
1958 // if( !(char_O_deco_status & DECO_PLAN_ALTERNATE)) char_O_deco_last_stop = 0; | |
1959 | |
1960 return; | |
1961 } | |
1962 } | |
1963 | |
1964 | |
1965 //---- as one minute as passed now, update the tissues ---------------------- | |
1966 | |
1967 // program 1 minute interval on simulated tissues (Flagbit 7 = 0) | |
1968 tissue_increment = 1; | |
1969 | |
1970 // compute current ppN2 and ppHe | |
1971 sim_alveolar_presures(); | |
1972 | |
1973 // update the tissues | |
1974 calc_tissue(); | |
1975 } | |
1976 | |
1977 // ** commented out - char_O_deco_last_stop is not used for anything | |
1978 // | |
1979 // // surface not reached, need more stops... store reached depth for menu animation. | |
1980 // if( !(char_O_deco_status & DECO_PLAN_ALTERNATE) ) char_O_deco_last_stop = temp_depth_limit; | |
0 | 1981 } |
1982 | |
1983 | |
1984 ////////////////////////////////////////////////////////////////////////////// | |
560 | 1985 // Simulate ascent to first deco stop. |
0 | 1986 // |
1987 // | |
560 | 1988 // Modified: temp_deco : current depth in ascent and deco simulation, in bar absolute pressure |
0 | 1989 // |
1990 void sim_ascent_to_first_stop(void) | |
1991 { | |
560 | 1992 overlay unsigned char fast = 1; // 1 = 1 minute steps, 0 = 2 seconds steps |
1993 overlay unsigned char gaschange = 0; // 1 = do a gas change, 0 = no better gas available | |
1994 | |
1995 | |
1996 //---- Loop until first deco stop or surface is reached ---------- | |
1997 for(;;) | |
1998 { | |
1999 // depth in absolute pressure we came from | |
2000 overlay float old_deco = temp_deco; | |
2001 | |
2002 // try ascending 1 full minute (fast) or 2 seconds (!fast) | |
2003 if ( fast ) temp_deco -= float_ascent_speed * METER_TO_BAR; // 1 min at float_ascent_speed ( 5 .. 10 m/min) | |
2004 else temp_deco -= (float_ascent_speed/30.0) * METER_TO_BAR; // 2 sec at float_ascent_speed (17 .. 33 cm/min) | |
2005 | |
2006 // but don't go over surface | |
2007 if( temp_deco < pres_surface ) temp_deco = pres_surface; | |
2008 | |
2009 // compute sim_lead_tissue_limit | |
2010 if ( char_I_deco_model != 0 ) sim_limit(GF_low); | |
2011 else sim_limit(1.0); | |
2012 | |
2013 // did we overshoot the first deco stop? | |
2014 if( temp_deco < sim_lead_tissue_limit ) | |
2015 { | |
2016 // YES - back to last depth below first stop | |
2017 temp_deco = old_deco; | |
2018 | |
2019 // switch to 2 seconds ascent if not yet in, else done | |
2020 if( fast ) | |
2021 { | |
2022 fast = 0; // retry with 2 seconds ascent steps | |
2023 continue; | |
2024 } | |
2025 else | |
2026 { | |
2027 break; // done... | |
2028 } | |
2029 } | |
2030 | |
2031 // If code execution passes along here, we did not overshoot the first stop. | |
2032 | |
2033 // did we reach the surface? if yes, done! | |
2034 if( temp_deco == pres_surface ) break; | |
2035 | |
2036 // depth in meters where we are now (no round-up) | |
2037 temp_depth_limit = (unsigned char)((temp_deco - pres_surface) * BAR_TO_METER); | |
2038 | |
2039 // Check if there is a better gas to switch to, but only in alternative plan mode | |
2040 // or if override is set. If yes, introduce a stop for the gas change. | |
2041 if( ((char_O_deco_status & DECO_PLAN_ALTERNATE) || (char_O_main_status & DECO_GASCHANGE_OVRD)) | |
2042 && gas_find_better() ) | |
2043 { | |
2044 // depth in meters we came from | |
2045 overlay unsigned char old_depth_limit = (unsigned char)((old_deco - pres_surface) * BAR_TO_METER); | |
2046 | |
2047 // adjust temp_depth_limit to the gas change depth, but not deeper than the depth we came from | |
2048 temp_depth_limit = (sim_gas_last_depth < old_depth_limit) ? sim_gas_last_depth : old_depth_limit; | |
2049 | |
2050 // create a stop for the gas change | |
2051 update_deco_table(char_I_gas_change_time); | |
2052 | |
2053 // set the new calculation values for N2, He and O2 | |
2054 gas_switch_set(); | |
2055 | |
2056 // signal to create a stop for the gas change and update the tissues | |
2057 gaschange = char_I_gas_change_time; | |
2058 | |
2059 // Adjust the depth for the tissue update to the stop depth. In case of fast mode, this | |
2060 // imposes that the ascent from the 'old_deco' depth to this stop took 1 minute although | |
2061 // we might have only ascended one or two meters... | |
2062 temp_deco = temp_depth_limit * METER_TO_BAR + pres_surface; | |
2063 } | |
2064 | |
2065 // Did one minute pass by and/or do we have a gas change? | |
2066 // Remark: The 2 seconds ascent iterations towards the first deco stop in !fast speed may take | |
2067 // up to 28 seconds in total - for this rough half of a minute no tissue updates will be computed. | |
2068 // Well, it could be done by setting tissue_increment = 0 in !fast condition and making calls to | |
2069 // sim_alveolar_presures() and calc_tissue() - see code commented out below. | |
2070 if( fast || gaschange ) | |
2071 { | |
2072 // program interval on simulated tissues (flag bit 7 = 0) | |
2073 tissue_increment = fast + gaschange; | |
2074 | |
2075 // clear gas change signal | |
2076 gaschange = 0; | |
2077 // } | |
2078 // else | |
2079 // { | |
2080 // // program 2 seconds interval on simulated tissues (flag bit 7 = 0) | |
2081 // tissue_increment = 0; | |
2082 // } | |
2083 // { | |
2084 // compute ppN2/ppHe for current depth from temp_deco | |
2085 sim_alveolar_presures(); | |
2086 | |
2087 // update the tissues | |
2088 calc_tissue(); | |
2089 } | |
2090 } | |
0 | 2091 } |
2092 | |
2093 ////////////////////////////////////////////////////////////////////////////// | |
560 | 2094 // Simulate extra time at the current depth. |
0 | 2095 // |
560 | 2096 // This routine is used for the futureTTS / delayed ascent feature. |
2097 // | |
0 | 2098 void sim_extra_time(void) |
2099 { | |
560 | 2100 overlay unsigned char backup = tissue_increment; // back-up tissue_increment |
2101 | |
2102 tissue_increment = char_I_extra_time; // program interval on simulated tissues (Flagbit 7 = 0) | |
2103 | |
2104 calc_tissue(); // update the tissues | |
2105 | |
2106 tissue_increment = backup; // restore tissue_increment | |
0 | 2107 } |
2108 | |
2109 ////////////////////////////////////////////////////////////////////////////// | |
2110 // calc_tissue | |
2111 // | |
2112 // optimized in v.101 | |
2113 // | |
560 | 2114 // INPUT: ppN2, ppHe, tissue_increment |
2115 // MODIFIED: pres_tissue_N2[], pres_tissue_He[] | |
2116 // OUTPUT: char_O_tissue_N2_saturation[], char_O_tissue_He_saturation[] | |
2117 // | |
2118 static void calc_tissue() | |
0 | 2119 { |
560 | 2120 overlay float temp_tissue_N2; |
2121 overlay float temp_tissue_He; | |
2122 overlay unsigned char period; | |
2123 overlay unsigned char i; | |
2124 | |
2125 | |
0 | 2126 assert( 0.00 <= ppN2 && ppN2 < 11.2 ); // 80% N2 at 130m |
2127 assert( 0.00 <= ppHe && ppHe < 12.6 ); // 90% He at 130m | |
560 | 2128 |
2129 | |
2130 for (ci=0;ci<NUM_COMP;ci++) // iterate through all compartments | |
0 | 2131 { |
560 | 2132 i = tissue_increment & 127; // extract number of minutes to do (if i > 0) |
2133 // or if one 2 second period is to do (if i = 0) | |
2134 | |
2135 if( i == 0 ) // check if we shall do one 2-seconds period | |
2136 { | |
2137 read_Buhlmann_times(0); // YES, program coefficients for a 2 seconds period | |
2138 period = 1; // set period length (in cycles) | |
2139 i = 1; // and one cycle to do | |
2140 } | |
2141 else if( i > 9 ) // check if we can start with 10 minutes periods | |
2142 { | |
2143 read_Buhlmann_times(2); // YES, program coefficients for 10 minutes periods | |
2144 period = 10; // set period length (in cycles) to ten | |
2145 } | |
2146 else // we shall do 1 to 9 minutes | |
2147 { | |
2148 read_Buhlmann_times(1); // program coefficients for 1 minute periods | |
2149 period = 1; // set period length (in cycles) to one | |
2150 } | |
2151 | |
2152 do | |
2153 { | |
2154 //---- N2 ------------------------------------------------------------------------------- | |
2155 | |
2156 temp_tissue = (tissue_increment & 128) ? pres_tissue_N2[ci] : sim_pres_tissue_N2[ci]; | |
2157 | |
2158 temp_tissue = (ppN2 - temp_tissue) * var_N2_e; | |
2159 | |
2160 temp_tissue_safety(); | |
2161 | |
2162 if( tissue_increment & 128 ) | |
2163 { | |
2164 // The temp variable takes on purpose just the tissue increment from the last loop's iteration. | |
2165 temp_tissue_N2 = temp_tissue; | |
2166 | |
2167 // Update the real tissues if either we are on the 2 seconds interval, | |
2168 // or if we shall advance the tissues on a one or several minutes basis. | |
2169 if( twosectimer || (tissue_increment & 127) ) pres_tissue_N2[ci] += temp_tissue; | |
2170 } | |
2171 else | |
2172 { | |
2173 // Updates of the sim-tissues always comes on a 1 minutes basis, | |
2174 // so we do not need to check of the 2 seconds interval. | |
2175 sim_pres_tissue_N2[ci] += temp_tissue; | |
2176 } | |
2177 | |
2178 | |
2179 //---- He ------------------------------------------------------------------------------- | |
2180 | |
2181 temp_tissue = (tissue_increment & 128) ? pres_tissue_He[ci] : sim_pres_tissue_He[ci]; | |
2182 | |
2183 temp_tissue = (ppHe - temp_tissue) * var_He_e; | |
2184 | |
2185 temp_tissue_safety(); | |
2186 | |
2187 if( tissue_increment & 128 ) | |
2188 { | |
2189 // The temp variable takes on purpose just the tissue increment from the last loop's iteration. | |
2190 temp_tissue_He = temp_tissue; | |
2191 | |
2192 // Update the real tissues if either we are on the 2 seconds interval, | |
2193 // or if we shall advance the tissues on a one or several minutes basis. | |
2194 if( twosectimer || (tissue_increment & 127) ) pres_tissue_He[ci] += temp_tissue; | |
2195 | |
2196 } | |
2197 else | |
2198 { | |
2199 // Updates of the sim-tissues always comes on a 1 minutes basis, | |
2200 // so we do not need to check of the 2 seconds interval. | |
2201 sim_pres_tissue_He[ci] += temp_tissue; | |
2202 } | |
2203 | |
2204 | |
2205 // decrement loop counter | |
2206 i -= period; | |
2207 | |
2208 // check if we need to switch from 10 minute periods to 1 minute periods | |
2209 if( (i > 0) && (period = 10) && (i < 10) ) | |
2210 { | |
2211 read_Buhlmann_times(1); // program coefficients for 1 minute periods | |
2212 period = 1; // set period length (in cycles) to one | |
2213 } | |
2214 } | |
2215 while( i ); | |
2216 | |
2217 | |
2218 // have the computations been done for the "real" tissues? | |
2219 if( (tissue_increment & 128) && (twosectimer || (tissue_increment & 127)) ) | |
2220 { | |
2221 // net tissue balance | |
2222 temp_tissue = temp_tissue_N2 + temp_tissue_He; | |
2223 | |
2224 // check tissue on-/off-gassing and IBCD with applying a threshold of +/-HYST | |
2225 // | |
2226 if ( temp_tissue < -HYST ) // Check if the tissue is off-gassing | |
2227 { | |
2228 deco_tissue_vector |= (1 << ci); // tag tissue as being in decompression | |
2229 IBCD_tissue_vector &= ~(1 << ci); // tag tissue as not experiencing mentionable IBCD | |
2230 } | |
2231 else if ( temp_tissue > +HYST ) // check if the tissue in on-gassing | |
2232 { | |
2233 deco_tissue_vector &= ~(1 << ci); // tag tissue as not being in decompression | |
2234 | |
2235 if( ((temp_tissue_N2 > 0.0) && (temp_tissue_He < 0.0)) // check for counter diffusion | |
2236 || ((temp_tissue_N2 < 0.0) && (temp_tissue_He > 0.0)) ) | |
2237 { | |
2238 IBCD_tissue_vector |= (1 << ci); // tag tissue as experiencing mentionable IBCD | |
2239 } | |
2240 } | |
2241 | |
2242 | |
2243 // keep the saturating / desaturating flags from last invocation | |
2244 char_O_tissue_N2_saturation[ci] &= 128; | |
2245 char_O_tissue_He_saturation[ci] &= 128; | |
2246 | |
2247 // flip the flags applying a hysteresis of HYST (actual value: see #define of HYST) | |
2248 if( temp_tissue_N2 > +HYST ) char_O_tissue_N2_saturation[ci] = 128; // set flag for tissue pressure is increasing | |
2249 else if( temp_tissue_N2 < -HYST ) char_O_tissue_N2_saturation[ci] = 0; // clear flag (-> tissue pressure is decreasing) | |
2250 | |
2251 if( temp_tissue_He > +HYST ) char_O_tissue_He_saturation[ci] = 128; // set flag for tissue pressure is increasing | |
2252 else if( temp_tissue_He < -HYST ) char_O_tissue_He_saturation[ci] = 0; // clear flag (-> tissue pressure is decreasing) | |
2253 | |
2254 | |
2255 // For N2 tissue display purpose: | |
2256 // Scale tissue press so that saturation in 70m on AIR gives a value of approx. 80. | |
2257 // The surface steady-state tissue loading of [0.7902 * (pres_respiration - ppWater)] bar | |
2258 // gives then a 10. If N2 is completely washed out of the tissue, result will be 0. | |
2259 // This scaling is adapted to the capabilities of the tissue graphics in the custom views. | |
2260 temp_tissue = (pres_tissue_N2[ci] / N2_equilibrium) * 10; | |
2261 | |
2262 // limit to 127 to leave space for sat/desat flag | |
2263 if (temp_tissue > 127) temp_tissue = 127; | |
2264 | |
2265 // export as integer | |
2266 char_O_tissue_N2_saturation[ci] += (unsigned char)temp_tissue; | |
2267 | |
2268 | |
2269 // For H2 tissue display purpose: | |
2270 // Scale tissue press so that saturation in 120m on TMX 10/70 gives a value of approx. 70. | |
2271 // With no He in a tissue, result will be 0. | |
2272 // This scaling is adapted to the capabilities of the tissue graphics in the custom views. | |
2273 temp_tissue = pres_tissue_He[ci] * 7.7; | |
2274 | |
2275 // limit to 127 to leave space for sat/desat flag | |
2276 if (temp_tissue > 127) temp_tissue = 127; | |
2277 | |
2278 // export as integer | |
2279 char_O_tissue_He_saturation[ci] += (unsigned char)temp_tissue; | |
2280 } | |
2281 | |
2282 }// for | |
0 | 2283 } |
2284 | |
2285 ////////////////////////////////////////////////////////////////////////////// | |
2286 // calc_limit | |
2287 // | |
2288 // New in v.111 : separated from calc_tissue(), and depends on GF value. | |
2289 // | |
2290 static void calc_limit(void) | |
2291 { | |
560 | 2292 char_O_gtissue_no = 0; |
2293 calc_lead_tissue_limit = 0.0; | |
2294 | |
2295 // clear IBCD, microbubbles and outside warning flags (locked warnings will be preserved) | |
2296 char_O_deco_warnings &= ~(DECO_WARNING_IBCD + DECO_WARNING_MBUBBLES + DECO_WARNING_OUTSIDE); | |
2297 | |
2298 | |
2299 for(ci=0; ci<NUM_COMP; ci++) | |
0 | 2300 { |
2301 overlay float N2 = pres_tissue_N2[ci]; | |
2302 overlay float He = pres_tissue_He[ci]; | |
560 | 2303 overlay float pres_tissue = N2 + He; |
2304 overlay float pres_min; | |
2305 overlay float gf; | |
2306 overlay float threshold; | |
2307 | |
2308 read_Buhlmann_coefficients(); | |
2309 var_N2_a = (var_N2_a * N2 + var_He_a * He) / pres_tissue; | |
2310 var_N2_b = (var_N2_b * N2 + var_He_b * He) / pres_tissue; | |
2311 | |
2312 // calculate minimum ambient pressure that the tissue can withstand according to straight Buhlmann | |
2313 pres_min = (pres_tissue - var_N2_a) * var_N2_b; | |
2314 | |
2315 // calculate current gf value (1.0 = 100%) of this tissue | |
2316 gf = (pres_tissue - pres_respiration) / (pres_tissue - pres_min); | |
2317 if( gf < 0.0 ) gf = 0.0; | |
2318 | |
2319 // calculate a threshold value for use below | |
2320 // ToDo: finalize the definition of the threshold | |
2321 threshold = 0.02 * ci + 0.9; | |
2322 | |
2323 // check if this tissue is likely to develop microbubbles | |
2324 // and/or if this tissue is outside the Buhlmann model | |
2325 if( ci <= 5 ) | |
2326 { | |
2327 if( gf >= threshold ) | |
2328 { | |
2329 char_O_deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock); | |
2330 | |
2331 if( gf >= 1.0 ) | |
2332 { | |
2333 char_O_deco_warnings |= (DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock); | |
2334 } | |
2335 } | |
2336 } | |
2337 else | |
2338 { | |
2339 if( gf >= 1.0 ) | |
2340 { | |
2341 char_O_deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock); | |
2342 | |
2343 if( gf >= threshold ) | |
2344 { | |
2345 char_O_deco_warnings |= (DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock); | |
2346 } | |
2347 } | |
2348 } | |
2349 | |
2350 | |
2351 // Apply the Eric Baker's varying gradient factor correction if the GF-Model is selected. | |
0 | 2352 // Note: the correction factor depends both on GF and b, |
2353 // Actual values are in the 1.5 .. 1.0 range (for a GF=30%), | |
2354 // so that can change who is the leading gas... | |
560 | 2355 // Note: Also depends of the GF. So the calculus is different for GF_low, current GF, or GF_high... |
2356 // *BUT* calc_tissue() is used to compute bottom time, hence what would happen at surface, | |
0 | 2357 // hence at GF_high. |
560 | 2358 if( char_I_deco_model != 0 ) pres_min = ( pres_tissue - var_N2_a * ( GF_high) ) * var_N2_b |
2359 / ( GF_high + var_N2_b * (1.0 - GF_high) ); | |
2360 | |
2361 // check if this tissue requires a higher ambient pressure than was found to be needed up to now | |
2362 if( pres_min > calc_lead_tissue_limit ) | |
0 | 2363 { |
560 | 2364 char_O_gtissue_no = ci; |
2365 calc_lead_tissue_limit = pres_min; | |
0 | 2366 } |
2367 } | |
560 | 2368 |
2369 // check IBCD condition | |
2370 if( !IBCD_tissue_vector ) | |
2371 { | |
2372 char_O_deco_warnings &= ~DECO_WARNING_IBCD; // no IBCD in any tissue, clear flag | |
2373 } | |
2374 else if( (IBCD_tissue_vector & (1 << char_O_gtissue_no)) | |
2375 && ((pres_tissue_N2[char_O_gtissue_no] + pres_tissue_He[char_O_gtissue_no]) > pres_respiration) ) | |
2376 { | |
2377 // leading tissue is in IBCD condition and in super-saturation, set flags. | |
2378 char_O_deco_warnings |= (DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock); | |
2379 } | |
2380 | |
566
3febf1cd1bf4
Fix anomalie when toggling ppO2 warning levels in ccr and pscr mode.
heinrichsweikamp
parents:
560
diff
changeset
|
2381 // set deco flag if we are in deco and at least one of the real tissues is off-gassing |
3febf1cd1bf4
Fix anomalie when toggling ppO2 warning levels in ccr and pscr mode.
heinrichsweikamp
parents:
560
diff
changeset
|
2382 // clear deco flag if all of the real tissues are on-gassing |
567 | 2383 if ( (char_O_nullzeit == 0) && deco_tissue_vector ) char_O_deco_warnings |= DECO_FLAG; |
566
3febf1cd1bf4
Fix anomalie when toggling ppO2 warning levels in ccr and pscr mode.
heinrichsweikamp
parents:
560
diff
changeset
|
2384 else if ( !deco_tissue_vector ) char_O_deco_warnings &= ~DECO_FLAG; |
560 | 2385 |
0 | 2386 |
2387 assert( char_O_gtissue_no < NUM_COMP ); | |
2388 assert( 0.0 <= calc_lead_tissue_limit && calc_lead_tissue_limit <= 14.0); | |
2389 } | |
2390 | |
2391 ////////////////////////////////////////////////////////////////////////////// | |
2392 // calc_nullzeit | |
2393 // | |
2394 // calculates the remaining bottom time | |
2395 // | |
2396 // NOTE: Erik Baker's closed formula works for Nitroxes. Trimix adds a second | |
2397 // exponential term to the M-value equation, making it impossible to | |
2398 // invert... So we have to make a fast-simu until we find a better way. | |
2399 // | |
2400 // Input: pres_respiration | |
560 | 2401 // Output: char_O_nullzeit / char_O_alternate_nullzeit |
0 | 2402 // |
2403 static void calc_nullzeit(void) | |
2404 { | |
560 | 2405 overlay unsigned char nullzeit = 240; |
2406 | |
2407 | |
0 | 2408 //---- Compute ppN2 and ppHe --------------------------------------------- |
2409 temp_deco = pres_respiration; | |
2410 sim_alveolar_presures(); | |
560 | 2411 |
0 | 2412 for(ci=0; ci<NUM_COMP; ci++) |
2413 { | |
2414 //---- Read A/B values and loading factor for N2 and He -------------- | |
560 | 2415 |
2416 overlay float tN2 = sim_pres_tissue_N2[ci]; | |
2417 overlay float tHe = sim_pres_tissue_He[ci]; | |
2418 | |
0 | 2419 overlay float t = tN2 + tHe; |
2420 overlay unsigned char ndl; | |
2421 overlay unsigned char period = 10; | |
2422 | |
560 | 2423 read_Buhlmann_coefficients(); |
2424 read_Buhlmann_times(2); // Starts with a 10min period. | |
0 | 2425 |
2426 //---- Simulate for that tissue -------------------------------------- | |
560 | 2427 // NOTE: No need to simulate for longer than the already found NDL. |
2428 for(ndl=0; ndl<nullzeit;) | |
0 | 2429 { |
560 | 2430 //---- Compute updated mix M-value at surface |
2431 overlay float a = (var_N2_a * tN2 + var_He_a * tHe) / t; | |
2432 overlay float b = (var_N2_b * tN2 + var_He_b * tHe) / t; | |
2433 overlay float M0 = (a + pres_surface/b); | |
2434 | |
2435 //---- Add 10min/1min to N2/He tissues | |
2436 overlay float dTN2 = (ppN2 - tN2) * var_N2_e; | |
2437 overlay float dTHe = (ppHe - tHe) * var_He_e; | |
2438 | |
2439 //---- Apply safety margin for both models | |
2440 // NDL can be computed while ascending... SO we have | |
2441 // to check if we are saturating or desaturating. | |
2442 if( dTN2 > 0.0 ) dTN2 *= float_saturation_multiplier; | |
2443 else dTN2 *= float_desaturation_multiplier; | |
2444 | |
2445 if( dTHe > 0.0 ) dTHe *= float_saturation_multiplier; | |
2446 else dTHe *= float_saturation_multiplier; | |
2447 | |
2448 // adopt M0 value when using the GF extension | |
2449 if (char_I_deco_model != 0 ) M0 = GF_high * (M0 - pres_surface) + pres_surface; | |
2450 | |
2451 //---- Simulate off-gassing while going to surface | |
0 | 2452 // TODO ! |
2453 // dTN2 -= exp( ... ascent time ... ppN2...) | |
2454 // dTHe -= exp( ... ascent time ... ppHe...) | |
2455 | |
2456 //---- Ok now, and still ok to surface after 1 or 10 minutes ? | |
2457 if( (t <= M0) && (t + dTN2 + dTHe <= M0) ) | |
2458 { | |
560 | 2459 tN2 += dTN2; // YES: apply gas loadings, |
0 | 2460 tHe += dTHe; |
560 | 2461 t = tN2 + tHe; |
2462 | |
2463 ndl += period; // increment NDL, | |
2464 | |
2465 continue; // and loop. | |
0 | 2466 } |
2467 | |
2468 //---- Should we retry with smaller steps ? | |
2469 if( period == 10 ) | |
2470 { | |
560 | 2471 read_Buhlmann_times(1); // 1min coefs. |
0 | 2472 period = 1; |
560 | 2473 |
0 | 2474 continue; |
2475 } | |
2476 | |
2477 //---- ELSE make a linear approx for the last minute | |
560 | 2478 // Useful to have a meaningful rounding of NDL. |
2479 // But ONLY if positive (negative casted to unsigned is bad). | |
2480 if( M0 > t ) ndl += (unsigned char)(0.5f + (M0-t)/(dTN2+dTHe)); | |
2481 | |
0 | 2482 break; |
2483 } | |
2484 | |
2485 // Keep the shortest NDL found | |
560 | 2486 if ( ndl < nullzeit ) nullzeit = ndl; |
0 | 2487 } |
560 | 2488 |
2489 if( char_O_deco_status & DECO_PLAN_ALTERNATE) char_O_alternate_nullzeit = nullzeit; | |
2490 else char_O_nullzeit = nullzeit; | |
0 | 2491 } |
2492 | |
2493 ////////////////////////////////////////////////////////////////////////////// | |
2494 // calc_ascenttime | |
2495 // | |
560 | 2496 // Sum up ascent from bottom to surface at float_ascent_speed, |
2497 // but 1 minute per meter for the final ascent, and all stops. | |
0 | 2498 // |
560 | 2499 // Result in int_O_ascenttime, |
2500 // or int_O_alternate_ascenttime if doing the alternative plan. | |
2501 // | |
0 | 2502 static void calc_ascenttime(void) |
2503 { | |
560 | 2504 overlay unsigned char x; |
0 | 2505 overlay unsigned short sum; |
560 | 2506 |
2507 // preset final ascent | |
2508 overlay float final = (float)char_I_depth_last_deco; | |
2509 | |
2510 // calculate depth | |
2511 overlay float ascent = (pres_respiration - pres_surface) * BAR_TO_METER; | |
2512 | |
2513 // check if we are already in final ascent | |
2514 if (ascent <= final) | |
2515 { | |
2516 // yes - all ascent is final ascent | |
2517 final = ascent; | |
2518 ascent = 0.0; | |
2519 } | |
2520 else | |
2521 { | |
2522 // no - subtract final ascent part from overall ascent | |
2523 ascent -= final; | |
2524 | |
2525 // compute time for ascent part without final ascent | |
2526 ascent /= float_ascent_speed; | |
2527 } | |
2528 | |
2529 // add 1 minute for each meter of final ascent | |
2530 ascent += final; | |
2531 | |
2532 // convert to integer | |
2533 sum = (unsigned short)(ascent + 0.5); | |
2534 | |
2535 // add all stop times | |
0 | 2536 for(x=0; x<NUM_STOPS && internal_deco_depth[x]; x++) |
2537 sum += (unsigned short)internal_deco_time[x]; | |
2538 | |
560 | 2539 // limit result to display max. |
2540 if( sum > 999) sum = 999; | |
2541 | |
2542 // tag result as invalid if there is an overflow in the stops table | |
2543 if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) sum |= INT_FLAG_INVALID; | |
2544 | |
2545 // route result to output variable | |
2546 if( char_O_deco_status & DECO_PLAN_ALTERNATE ) int_O_alternate_ascenttime = sum; | |
2547 else int_O_ascenttime = sum; | |
0 | 2548 } |
2549 | |
2550 ////////////////////////////////////////////////////////////////////////////// | |
2551 // update_startvalues | |
2552 // | |
2553 // updated in v.102 | |
2554 // | |
2555 void update_startvalues(void) | |
2556 { | |
2557 overlay unsigned char x; | |
2558 | |
2559 // Start ascent simulation with current tissue partial pressures. | |
2560 for(x=0; x<NUM_COMP; x++) | |
2561 { | |
2562 sim_pres_tissue_N2[x] = pres_tissue_N2[x]; | |
2563 sim_pres_tissue_He[x] = pres_tissue_He[x]; | |
2564 } | |
2565 | |
2566 // No leading tissue (yet) for this ascent simulation. | |
2567 sim_lead_tissue_limit = 0.0; | |
560 | 2568 sim_lead_tissue_no = 1; |
0 | 2569 } |
2570 | |
2571 ////////////////////////////////////////////////////////////////////////////// | |
2572 // sim_limit() | |
2573 // | |
2574 // New in v.111 | |
2575 // | |
560 | 2576 // Function separated from calc_tissue() to allow recomputing limit on |
0 | 2577 // different depth, because it depends on current gradient factor. |
2578 // | |
2579 static void sim_limit(PARAMETER float GF_current) | |
2580 { | |
560 | 2581 assert( 0.0 < GF_current && GF_current <= 1.0 ); |
0 | 2582 |
2583 sim_lead_tissue_limit = 0.0; | |
560 | 2584 sim_lead_tissue_no = 0; // If no one is critic, keep first tissue. |
0 | 2585 |
2586 for(ci=0; ci<NUM_COMP; ci++) | |
2587 { | |
2588 overlay float N2 = sim_pres_tissue_N2[ci]; | |
2589 overlay float He = sim_pres_tissue_He[ci]; | |
2590 overlay float p = N2 + He; | |
2591 | |
560 | 2592 read_Buhlmann_coefficients(); |
0 | 2593 var_N2_a = (var_N2_a * N2 + var_He_a * He) / p; |
2594 var_N2_b = (var_N2_b * N2 + var_He_b * He) / p; | |
2595 | |
2596 // Apply the Eric Baker's varying gradient factor correction. | |
2597 // Note: the correction factor depends both on GF and b, | |
2598 // Actual values are in the 1.5 .. 1.0 range (for a GF=30%), | |
2599 // so that can change who is the leading gas... | |
2600 // Note: Also depends of the GF_current... | |
560 | 2601 if( char_I_deco_model != 0 ) p = ( p - (var_N2_a * GF_current) ) |
2602 / ( 1.0 - GF_current + (GF_current / var_N2_b ) ); | |
2603 | |
2604 else p = (p - var_N2_a) * var_N2_b; | |
2605 | |
0 | 2606 |
2607 if( p > sim_lead_tissue_limit ) | |
2608 { | |
560 | 2609 sim_lead_tissue_no = ci; |
0 | 2610 sim_lead_tissue_limit = p; |
2611 } | |
2612 } // for ci | |
2613 | |
2614 assert( sim_lead_tissue_no < NUM_COMP ); | |
2615 assert( 0.0 <= sim_lead_tissue_limit && sim_lead_tissue_limit <= 14.0 ); | |
2616 } | |
2617 | |
2618 ////////////////////////////////////////////////////////////////////////////// | |
2619 // clear_deco_table | |
2620 // | |
2621 // | |
2622 static void clear_deco_table(void) | |
2623 { | |
2624 overlay unsigned char x; | |
2625 | |
2626 for(x=0; x<NUM_STOPS; ++x) | |
2627 { | |
2628 internal_deco_time [x] = 0; | |
2629 internal_deco_depth[x] = 0; | |
2630 } | |
560 | 2631 |
2632 // clear stop table overflow warning | |
2633 char_O_deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW; | |
0 | 2634 } |
2635 | |
2636 ////////////////////////////////////////////////////////////////////////////// | |
2637 // update_deco_table | |
2638 // | |
560 | 2639 // Add time to a stop at temp_depth_limit |
2640 // | |
2641 // It is possible to create stops with a duration of 0 minutes, e.g. to | |
2642 // note a gas change "on the fly" while ascending. Therefore the criteria | |
2643 // to have reached the end of the list needs always to be depth == 0. | |
0 | 2644 // |
560 | 2645 // Input: temp_depth_limit : stop's depth, in meters. |
2646 // sim_gas_last_used : gas used at stop, as index 1..5 or 0 for gas 6 | |
2647 // PARAMETER time_increment : number of minutes to add to the stop | |
0 | 2648 // |
560 | 2649 // Updated: internal_deco_depth[] : depth (in meters) of each stop |
2650 // internal_deco_time [] : time (in minutes) of each stop | |
2651 // internal_deco_gas [] : gas used (index 1-5) at each stop | |
2652 // | |
2653 static unsigned char update_deco_table(PARAMETER unsigned char time_increment) | |
0 | 2654 { |
560 | 2655 overlay unsigned char x; |
2656 | |
2657 assert( temp_depth_limit > 0 ); // No stop at surface... | |
2658 | |
2659 // loop through internal deco table | |
2660 for(x=0; x<NUM_STOPS; ++x) | |
2661 { | |
2662 // Make sure deco-stops are recorded in order: | |
2663 assert( !internal_deco_depth[x] || temp_depth_limit <= internal_deco_depth[x] ); | |
2664 | |
2665 // Is there already a stop entry for our current depth? | |
2666 if( internal_deco_depth[x] == temp_depth_limit ) | |
2667 { | |
2668 // Yes - increment stop time if possible | |
2669 // Stop time entries are limited to 99 minutes because of display constraints. | |
2670 // Else a limit of 254 would account because of constrains in calc_CNS_planning(). | |
2671 if( internal_deco_time[x] < (100 - time_increment) ) | |
2672 { | |
2673 internal_deco_time[x] += time_increment; // increment stop time | |
2674 return 1; // return with status 'success' | |
2675 } | |
2676 } | |
2677 | |
2678 // If program flow passes here, there is either no stop entry for the current depth yet, or | |
2679 // the existing entry is saturated with 99 minutes. So we are looking for the next unused | |
2680 // table entry. | |
2681 if( internal_deco_depth[x] == 0 ) | |
2682 { | |
2683 internal_deco_time[x] = time_increment; // initialize entry with first stop's time, | |
2684 internal_deco_depth[x] = temp_depth_limit; // ... depth, and | |
2685 internal_deco_gas[x] = sim_gas_last_used; // ... gas | |
2686 return 1; // return with status 'success' | |
2687 } | |
2688 } | |
2689 | |
2690 // If program flow passes here, all deco table entries are used up. | |
2691 | |
2692 // set overflow warning | |
2693 char_O_deco_warnings |= DECO_WARNING_STOPTABLE_OVERFLOW; | |
2694 | |
2695 | |
2696 // return with status 'failed'. | |
2697 return 0; | |
0 | 2698 } |
2699 | |
2700 ////////////////////////////////////////////////////////////////////////////// | |
2701 // calc_gradient_factor | |
2702 // | |
2703 // optimized in v.101 (var_N2_a) | |
2704 // new code in v.102 | |
2705 // | |
2706 static void calc_gradient_factor(void) | |
2707 { | |
2708 overlay float gf; | |
2709 overlay float N2 = pres_tissue_N2[char_O_gtissue_no]; | |
2710 overlay float He = pres_tissue_He[char_O_gtissue_no]; | |
2711 | |
2712 assert( char_O_gtissue_no < NUM_COMP ); | |
2713 assert( 0.800 <= pres_respiration && pres_respiration < 14.0 ); | |
2714 | |
560 | 2715 // tissue > respiration (currently off-gassing) |
2716 // GF = 0.00 when respiration == tissue, ie. dissolved gases are at equilibrium. | |
2717 // GF = 1.00 when respiration == limit. | |
0 | 2718 temp_tissue = N2 + He; |
2719 if( temp_tissue <= pres_respiration ) | |
560 | 2720 { |
0 | 2721 gf = 0.0; |
560 | 2722 int_O_gradient_factor = 0; |
2723 } | |
0 | 2724 else |
2725 { | |
2726 overlay float limit = calc_lead_tissue_limit; | |
2727 // NOTE: in GF model, calc_lead_tissue_limit include already the | |
2728 // correction due to gradient factor. To compute the actual | |
560 | 2729 // current GF, we need to (re-)compute the raw ambient-pressure |
313 | 2730 // limit from the Buhlmann model. |
0 | 2731 if( char_I_deco_model != 0 ) |
2732 { | |
2733 ci = char_O_gtissue_no; | |
560 | 2734 |
2735 read_Buhlmann_coefficients(); | |
2736 | |
0 | 2737 var_N2_a = (var_N2_a * N2 + var_He_a * He) / temp_tissue; |
2738 var_N2_b = (var_N2_b * N2 + var_He_b * He) / temp_tissue; | |
560 | 2739 |
2740 limit = (temp_tissue - var_N2_a) * var_N2_b; | |
0 | 2741 } |
2742 | |
560 | 2743 gf = (temp_tissue - pres_respiration) / (temp_tissue - limit); |
2744 | |
2745 // limit to 255 because of constraints in ghostwriter code | |
2746 if ( gf <= 0.0 ) int_O_gradient_factor = 0; | |
2747 else if( gf > 2.545 ) int_O_gradient_factor = 255 + INT_FLAG_WARNING; | |
2748 else | |
2749 { | |
2750 int_O_gradient_factor = (unsigned int)(100 * gf + 0.5); | |
2751 | |
2752 if ( int_O_gradient_factor >= GF_warning_threshold ) | |
2753 int_O_gradient_factor |= INT_FLAG_WARNING; | |
2754 | |
2755 else if ( int_O_gradient_factor >= char_I_GF_High_percentage ) | |
2756 int_O_gradient_factor |= INT_FLAG_PREWARNING; | |
2757 } | |
2758 } | |
0 | 2759 } |
2760 | |
2761 ////////////////////////////////////////////////////////////////////////////// | |
560 | 2762 // calc_desaturation_time |
0 | 2763 // |
2764 // Inputs: int_I_pres_surface, ppWater, char_I_desaturation_multiplier | |
560 | 2765 // Outputs: int_O_desaturation_time, int_O_nofly_time |
0 | 2766 // |
560 | 2767 // Helper function |
2768 // | |
2769 void calc_desaturation_time_helper(void) | |
0 | 2770 { |
560 | 2771 if( pres_actual > pres_target ) // check if actual pressure is higher then target pressure |
2772 { // YES - compute remaining time | |
2773 overlay float pres_ratio; | |
2774 | |
2775 pres_ratio = pres_actual / pres_target; | |
2776 | |
2777 // Compute desaturation time with result rounded up to multiples of 10 minutes. | |
2778 // Main purpose is to avoid confusion, because the times do not clock down in one minute steps any more | |
2779 // but get constantly re-computed according to current ambient pressure and may therefor make steps of | |
2780 // several minutes forwards and backwards as ambient pressure rises and falls. | |
2781 short_time = (unsigned short)( (var_ht * log(pres_ratio) / desat_factor) + 0.9 ); | |
2782 } | |
2783 else | |
2784 { // NO - desaturation state reached, no remaining time | |
2785 short_time = 0; | |
2786 } | |
2787 } | |
2788 | |
2789 ///////////////////////////////////////////////////////////////////////////// | |
2790 // Main function | |
2791 // | |
2792 void calc_desaturation_time(void) | |
2793 { | |
2794 assert( 800 < int_I_pres_surface && int_I_pres_surface < 1100 ); | |
2795 assert( 0 < char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100 ); | |
2796 | |
2797 | |
2798 N2_ratio = 0.7902; // fraction of N2 in respired air | |
2799 pres_surface = 0.001 * int_I_pres_surface; // surface pressure in bar | |
2800 N2_equilibrium = N2_ratio * (pres_surface - ppWater); // partial pressure of N2 in respired air | |
2801 desat_factor = 0.06931 * char_I_desaturation_multiplier * SURFACE_DESAT_FACTOR; // pre-computed term for later use: | |
2802 // 10 [Min] * 0.01 [%] * 0.6931 [ln(2)] * ... | |
2803 int_O_desaturation_time = 0; | |
2804 int_O_nofly_time = 0; | |
2805 | |
2806 | |
2807 for(ci=NUM_COMP; ci>0;) | |
0 | 2808 { |
560 | 2809 overlay float pres_tissue_max; |
2810 overlay float P_ambient_altitude; | |
2811 overlay signed char search_direction; | |
2812 overlay unsigned short nofly_N2 = 0; | |
2813 overlay unsigned short nofly_He = 0; | |
2814 overlay unsigned short nofly_last = ~0; | |
2815 | |
2816 | |
2817 ci -= 1; | |
2818 | |
2819 read_Buhlmann_ht(); | |
2820 read_Buhlmann_coefficients(); | |
2821 | |
2822 // get selected target altitude | |
2823 switch( char_I_altitude_wait ) | |
2824 { | |
2825 case 1: P_ambient_altitude = P_ambient_1000m; break; | |
2826 case 2: P_ambient_altitude = P_ambient_2000m; break; | |
2827 case 3: P_ambient_altitude = P_ambient_3000m; break; | |
2828 default: P_ambient_altitude = P_ambient_fly; break; | |
2829 } | |
2830 | |
2831 // Target pressure for the tissue is the Buhlmann limit. We use the Buhlmann | |
2832 // coefficients for N2 also for He because it is easier to calculate and the | |
2833 // N2 coefficients are more conservative than those for He, so we are on the | |
2834 // safe side, too. | |
2835 pres_tissue_max = (P_ambient_altitude/var_N2_b + var_N2_a); | |
2836 | |
2837 // Adjust target pressure in case the GF model is in use by GF-high | |
2838 if( char_I_deco_model != 0 ) | |
2839 { | |
2840 pres_tissue_max = ((pres_tissue_max - P_ambient_altitude) * char_I_GF_High_percentage * 0.01) + P_ambient_altitude; | |
2841 } | |
2842 | |
2843 | |
2844 // | |
2845 // Desaturation time | |
2846 // | |
2847 | |
2848 // N2: actual amount of tissue pressure above equilibrium. | |
2849 pres_actual = pres_tissue_N2[ci] - N2_equilibrium; | |
2850 | |
2851 // N2: half-time of the current tissue | |
2852 var_ht = var_N2_ht; | |
2853 | |
2854 // Calculate desaturation time for N2 in tissue. | |
2855 // Desaturated state is defined as residual tissue pressure <= 1.05 x ppN2 respired | |
2856 | |
2857 pres_target = 0.05 * N2_equilibrium; | |
2858 | |
2859 calc_desaturation_time_helper(); | |
2860 | |
2861 if( short_time > int_O_desaturation_time) int_O_desaturation_time = short_time; | |
2862 | |
2863 | |
2864 // He: actual amount of tissue pressure above equilibrium. | |
2865 pres_actual = pres_tissue_He[ci]; // equilibrium for He is 0 bar | |
2866 | |
2867 // He: half-time of the current tissue | |
2868 var_ht = var_He_ht; | |
2869 | |
2870 // Calculate desaturation time for He in the tissue. | |
2871 // Desaturated state is defined as residual tissue pressure <= 0.05 x ppN2 respired | |
2872 | |
2873 pres_target = 0.05 * N2_equilibrium; | |
2874 | |
2875 calc_desaturation_time_helper(); | |
2876 | |
2877 if( short_time > int_O_desaturation_time) int_O_desaturation_time = short_time; | |
2878 | |
2879 | |
2880 // | |
2881 // no-fly time | |
2882 // | |
2883 | |
2884 // initialize search direction | |
2885 search_direction = 0; | |
2886 | |
2887 for(;;) | |
2888 { | |
2889 // N2: actual amount of tissue pressure above equilibrium. | |
2890 pres_actual = pres_tissue_N2[ci] - N2_equilibrium; | |
2891 | |
2892 // N2: half-time of the current tissue | |
2893 var_ht = var_N2_ht; | |
2894 | |
2895 // Calculate no-fly time for N2 in the tissue. | |
2896 // Flying is permitted when the N2 pressure fits into the assigned fraction above equilibrium. | |
2897 | |
2898 pres_target = (split_N2_He[ci] * 0.01) * (pres_tissue_max - N2_equilibrium); | |
2899 | |
2900 if( pres_target < 0.0 ) // check if desaturation to fly target is possible | |
2901 { | |
2902 int_O_nofly_time = 288; // NO - set no-fly time to 288 * 10 min = 48 h | |
2903 break; // done for this compartment | |
2904 } | |
2905 else | |
2906 { | |
2907 calc_desaturation_time_helper(); | |
2908 nofly_N2 = short_time; | |
2909 } | |
2910 | |
2911 // He: actual amount of tissue pressure above equilibrium - equilibrium for He is 0 bar. | |
2912 pres_actual = pres_tissue_He[ci]; | |
2913 | |
2914 // He: half-time of the current tissue | |
2915 var_ht = var_He_ht; | |
2916 | |
2917 // Calculate no-fly time for He in the tissue. | |
2918 // Flying is permitted when the He pressure fits into the assigned fraction. | |
2919 | |
2920 pres_target = ((100 - split_N2_He[ci]) * 0.01) * (pres_tissue_max - N2_equilibrium); | |
2921 | |
2922 calc_desaturation_time_helper(); | |
2923 nofly_He = short_time; | |
2924 | |
2925 | |
2926 // Because the sum of N2 and He tissue pressures needs to fit into the Buhlmann limit for | |
2927 // no-fly time calculation, each gas gets assigned a fraction of the available total pressure | |
2928 // limit. The optimum split between the two gases can not be computed by a single formular, | |
2929 // because this would require the inversion of a function with two exponential terms, which is | |
2930 // not possible. We do not want to do a computational complex simulation here like it is done | |
2931 // in the deco calculation code (although we tackle the same base problem here), so we just let | |
2932 // the computer try out which split will balance the no-fly times induced by the N2 and the He | |
2933 // at best. | |
2934 | |
2935 // first of all, skip any optimization in case the current compartment is not the leading one | |
2936 if( (nofly_N2 <= int_O_nofly_time) && (nofly_He <= int_O_nofly_time) ) break; | |
2937 | |
2938 // check if the N2 requires more waiting time than the He | |
2939 if( nofly_N2 >= nofly_He ) | |
2940 { | |
2941 // check if the search direction has changed, which means we are beyond the | |
2942 // optimum now, or if we are at the upper stop limit of split_N2_He | |
2943 if( (search_direction < 0) || (split_N2_He[ci] == 99) ) | |
2944 { | |
2945 // Either the just completed iteration was more close to the optimum or the one before | |
2946 // was, so we take the best (i.e. shortest) time of both as the final no-fly time. | |
2947 int_O_nofly_time = (nofly_N2 < nofly_last) ? nofly_N2 : nofly_last; | |
2948 break; | |
2949 } | |
2950 | |
2951 // store the no-fly time found in this iteration | |
2952 nofly_last = nofly_N2; | |
2953 | |
2954 // increase the N2 fraction of the split and set search direction towards more N2 | |
2955 split_N2_He[ci] += 1; | |
2956 search_direction = +1; | |
2957 } | |
2958 else | |
2959 { | |
2960 // check if the search direction has changed, which means we are beyond the | |
2961 // optimum now, or if we are at the lower stop limit of split_N2_He | |
2962 if( (search_direction > 0) || (split_N2_He[ci] == 1) ) | |
2963 { | |
2964 // Either the just completed iteration was more close to the optimum or the one before | |
2965 // was, so we take the best (i.e. shortest) time of both as the final no-fly time. | |
2966 int_O_nofly_time = (nofly_He < nofly_last) ? nofly_He : nofly_last; | |
2967 break; | |
2968 } | |
2969 | |
2970 // store the no-fly time found in this iteration | |
2971 nofly_last = nofly_He; | |
2972 | |
2973 // decrease the N2 fraction of the split and set search direction towards less N2 | |
2974 split_N2_He[ci] -= 1; | |
2975 search_direction = -1; | |
2976 } | |
2977 | |
2978 } // for(;;) | |
2979 | |
2980 } // for(compartments) | |
2981 | |
2982 | |
2983 // Rescale int_O_desaturation_time and int_O_nofly_time to full minutes for display purpose | |
2984 int_O_desaturation_time *= 10; | |
2985 int_O_nofly_time *= 10; | |
2986 | |
2987 // Limit int_O_desaturation_time and int_O_nofly_time to 5999 = 99 hours + 59 minutes | |
2988 // because of display space constraints and rounding done above. | |
2989 if( int_O_desaturation_time > 5999 ) int_O_desaturation_time = 5999; | |
2990 if( int_O_nofly_time > 5999 ) int_O_nofly_time = 5999; | |
2991 | |
2992 | |
2993 // Clear the microbubbles warning when the current gradient factor is < GF_warning_threshold. | |
2994 // As the locked warning will stay set, this will cause the warning be be displayed in attention | |
2995 // color instead of warning color. | |
2996 if( int_O_gradient_factor < GF_warning_threshold ) char_O_deco_warnings &= ~DECO_WARNING_MBUBBLES; | |
2997 | |
2998 // clear some warnings when the desaturation time has become zero | |
2999 if( int_O_desaturation_time == 0 ) char_O_deco_warnings &= ~( DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock | |
3000 + DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock | |
3001 + DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock ); | |
3002 | |
0 | 3003 } |
3004 | |
3005 ////////////////////////////////////////////////////////////////////////////// | |
3006 // calc_wo_deco_step_1_min | |
3007 // | |
3008 // optimized in v.101 (...saturation_multiplier) | |
3009 // desaturation slowed down to 70,42% | |
3010 // | |
560 | 3011 // Input: int_I_pres_surface [mbar] |
3012 // | |
0 | 3013 static void calc_wo_deco_step_1_min(void) |
3014 { | |
560 | 3015 assert( 800 < int_I_pres_surface && int_I_pres_surface < 1100 ); |
3016 assert( 100 <= char_I_saturation_multiplier && char_I_saturation_multiplier < 200 ); | |
3017 assert( 0 < char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100 ); | |
3018 | |
3019 // setup input data for deco routines | |
0 | 3020 pres_respiration = pres_surface = int_I_pres_surface * 0.001; |
560 | 3021 |
3022 N2_ratio = 0.7902; // according to Buhlmann | |
3023 N2_equilibrium = N2_ratio * (pres_surface - ppWater); // used for N2 tissue graphics scaling | |
3024 ppN2 = N2_ratio * (pres_respiration - ppWater); | |
3025 ppHe = 0.0; | |
3026 | |
3027 float_desaturation_multiplier = char_I_desaturation_multiplier * 0.01 * SURFACE_DESAT_FACTOR; | |
0 | 3028 float_saturation_multiplier = char_I_saturation_multiplier * 0.01; |
3029 | |
560 | 3030 |
3031 // program what to do: 128 = Flag for "real" tissues, 1 = 1 minute | |
3032 tissue_increment = 128 + 1; | |
3033 | |
3034 // update the pressure in the tissues N2/He in accordance with the new ambient pressure | |
3035 calc_tissue(); | |
3036 | |
3037 // clock down CNS by a 1 minute step | |
3038 //CNS_fraction *= 0.992327946; // is done in deco_calc_CNS_decrease_15min | |
3039 | |
3040 // compute integer copy of CNS value | |
3041 //compute_CNS_for_display(); // is done in deco_calc_CNS_decrease_15min | |
3042 | |
3043 // reset deco engine start condition (probably not needed to be done here...) | |
3044 char_O_deco_status &= ~DECO_STATUS_MASK; // clear bits | |
3045 char_O_deco_status |= DECO_STATUS_INIT; // set bits | |
3046 | |
3047 // reset some more data that are not applicable in surface mode | |
3048 char_O_nullzeit = 0; | |
3049 int_O_ascenttime = 0; | |
3050 int_O_alternate_ascenttime = 0; | |
3051 clear_deco_table(); | |
3052 | |
3053 // calculate gradient factor | |
0 | 3054 calc_gradient_factor(); |
3055 } | |
3056 | |
3057 ////////////////////////////////////////////////////////////////////////////// | |
3058 // calc_dive_interval | |
3059 // | |
3060 // Prepare tissue for delay before the next dive simulation. | |
3061 // | |
560 | 3062 // Inputs: char_I_dive_interval == delay before dive (in 1 Minute steps). |
3063 // Modified: CNS_fraction, int_O_CNS_fraction | |
3064 // pres_tissue_N2/He[] | |
0 | 3065 // |
3066 // Should be protected by deco_push_tissues_to_vault(), | |
3067 // deco_pull_tissues_from_vault() | |
3068 // | |
3069 // desaturation slowed down to 70,42%. | |
3070 // | |
3071 static void calc_dive_interval(void) | |
3072 { | |
3073 overlay unsigned char t; | |
521
06e9370c6d75
CHANGE: Apply safety margin parameters to both models (GF and non-GF)
heinrichsweikamp
parents:
519
diff
changeset
|
3074 |
0 | 3075 //---- Initialize simulation parameters ---------------------------------- |
3076 pres_respiration = pres_surface = int_I_pres_surface * 0.001; | |
560 | 3077 |
3078 N2_ratio = 0.7902; // according to buehlmann | |
3079 N2_equilibrium = N2_ratio * (pres_surface - ppWater); // used for N2 tissue graphics scaling | |
3080 ppN2 = N2_ratio * (pres_respiration - ppWater); | |
3081 ppHe = 0.0; | |
3082 | |
3083 float_desaturation_multiplier = char_I_desaturation_multiplier * 0.01 * SURFACE_DESAT_FACTOR; | |
0 | 3084 float_saturation_multiplier = char_I_saturation_multiplier * 0.01; |
560 | 3085 |
0 | 3086 //---- Perform simulation ------------------------------------------------ |
560 | 3087 |
3088 // Calculate tissues: | |
3089 // Because tissue_increment is limited to 127 minutes, we have to do two passes | |
3090 // in case char_I_dive_interval is bigger than 127. | |
3091 // Ops: char_I_dive_interval must be limited to 254! | |
3092 | |
3093 t = char_I_dive_interval; | |
3094 | |
3095 if ( t == 255 ) t = 254; | |
3096 | |
3097 if ( t > 127 ) // extra pass needed? | |
3098 { | |
3099 tissue_increment = 127 // dive interval length in minutes | |
3100 | 128; // Flag to update the "real" tissues | |
3101 | |
3102 calc_tissue(); // update tissues | |
3103 | |
3104 t -= 127; // calculate remaining dive interval length | |
3105 } | |
3106 | |
3107 tissue_increment = t // dive interval length in minutes to do | |
3108 | 128; // Flag to update the "real" tissues | |
3109 calc_tissue(); // update tissues | |
3110 | |
3111 | |
3112 // Calculate CNS: | |
3113 // To speed up things and because on most invocations of this code char_I_dive_interval | |
3114 // is a multiple of 10 minutes, we loop the loop-counter down using two speeds. | |
3115 | |
3116 t = char_I_dive_interval; | |
3117 | |
3118 while ( t ) | |
3119 { | |
3120 if( t > 9 ) | |
3121 { | |
3122 CNS_fraction *= 0.925874712; // Half-time = 90min -> 10 min: (1/2)^(1/9) | |
3123 t -= 10; // fast speed looping | |
3124 } | |
3125 else | |
3126 { | |
3127 CNS_fraction *= 0.992327946; // Half-time = 90min -> 1 min: (1/2)^(1/90) | |
3128 t -= 1; // slow speed looping | |
3129 } | |
3130 } | |
3131 | |
3132 // compute integer copy of CNS value | |
3133 compute_CNS_for_display(); | |
0 | 3134 } |
3135 | |
3136 ////////////////////////////////////////////////////////////////////////////// | |
560 | 3137 // clear_CNS_fraction |
0 | 3138 // |
560 | 3139 // new in v.101 |
0 | 3140 // |
560 | 3141 void clear_CNS_fraction(void) |
0 | 3142 { |
560 | 3143 CNS_fraction = CNS_sim_norm_fraction = CNS_sim_alt_fraction = 0; |
3144 int_O_CNS_fraction = int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = 0; | |
3145 } | |
3146 | |
3147 ////////////////////////////////////////////////////////////////////////////// | |
3148 // calc_CNS_fraction | |
3149 // | |
3150 // Input: char_actual_ppO2 : current ppO2 [decibars] | |
3151 // tissue_increment : time increment and tissue selector | |
3152 // CNS_fraction : current CNS% as float before period | |
3153 // | |
3154 // Output: CNS_fraction, int_O_CNS_fraction - for the real tissues | |
3155 // CNS_sim_norm_fraction, int_O_normal_CNS_fraction - in simulation mode, normal plan | |
3156 // CNS_sim_alt_fraction, int_O_alternate_CNS_fraction - in simulation mode, alternative plan | |
3157 // | |
3158 void calc_CNS_fraction(void) | |
3159 { | |
3160 overlay float time_factor = 1.0; // default is 2sec | |
3161 overlay float CNS_fraction_temp = 0.0; | |
3162 | |
3163 assert( char_actual_ppO2 > 15 ); | |
3164 | |
3165 // All deco code is now invoked every second. But as the CNS update is based on | |
3166 // 2 seconds periods, we skip every 2nd seconds-based invocation of this function. | |
3167 // 128 = 128 (flag for "real" CNS) + 0 (2 seconds period) | |
3168 // To distribute computational load, the CNS% is calculated in "the other second" | |
3169 // than the tissues. | |
3170 if( (tissue_increment == 128) && (twosectimer) ) return; | |
3171 | |
3172 // adjust time factor if minute-based stepping is commanded, mask out flag bit | |
3173 if( tissue_increment & 127 ) time_factor = 30.0 * (float)(tissue_increment & 127); | |
3174 | |
3175 | |
33
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3176 //------------------------------------------------------------------------ |
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3177 // Don't increase CNS below 0.5 bar, but keep it steady. |
560 | 3178 if (char_actual_ppO2 < 50) |
0 | 3179 ; // no changes |
33
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3180 //------------------------------------------------------------------------ |
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3181 // Below (and including) 1.60 bar |
560 | 3182 else if (char_actual_ppO2 < 61) |
3183 CNS_fraction_temp = time_factor/(-533.07 * char_actual_ppO2 + 54000.0); | |
3184 else if (char_actual_ppO2 < 71) | |
3185 CNS_fraction_temp = time_factor/(-444.22 * char_actual_ppO2 + 48600.0); | |
3186 else if (char_actual_ppO2 < 81) | |
3187 CNS_fraction_temp = time_factor/(-355.38 * char_actual_ppO2 + 42300.0); | |
3188 else if (char_actual_ppO2 < 91) | |
3189 CNS_fraction_temp = time_factor/(-266.53 * char_actual_ppO2 + 35100.0); | |
3190 else if (char_actual_ppO2 < 111) | |
3191 CNS_fraction_temp = time_factor/(-177.69 * char_actual_ppO2 + 27000.0); | |
3192 else if (char_actual_ppO2 < 152) | |
3193 CNS_fraction_temp = time_factor/( -88.84 * char_actual_ppO2 + 17100.0); | |
3194 else if (char_actual_ppO2 < 167) | |
3195 CNS_fraction_temp = time_factor/(-222.11 * char_actual_ppO2 + 37350.0); | |
33
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3196 //------------------------------------------------------------------------ |
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3197 // Arieli et all.(2002): Modeling pulmonary and CNS O2 toxicity: |
322 | 3198 // J Appl Physiol 92: 248--256, 2002, doi:10.1152/japplphysiol.00434.2001 |
33
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3199 // Formula (A1) based on value for 1.55 and c=20 |
5d4a4fb0e8a6
Bugfix: NOAA tables for CNS are in ATA, not bar
heinrichsweikamp
parents:
0
diff
changeset
|
3200 // example calculation: Sqrt((1.7/1.55)^20)*0.000404 |
560 | 3201 else if (char_actual_ppO2 < 172) |
3202 CNS_fraction_temp = time_factor*0.00102; | |
3203 else if (char_actual_ppO2 < 177) | |
3204 CNS_fraction_temp = time_factor*0.00136; | |
3205 else if (char_actual_ppO2 < 182) | |
3206 CNS_fraction_temp = time_factor*0.00180; | |
3207 else if (char_actual_ppO2 < 187) | |
3208 CNS_fraction_temp = time_factor*0.00237; | |
3209 else if (char_actual_ppO2 < 192) | |
3210 CNS_fraction_temp = time_factor*0.00310; | |
3211 else if (char_actual_ppO2 < 198) | |
3212 CNS_fraction_temp = time_factor*0.00401; | |
3213 else if (char_actual_ppO2 < 203) | |
3214 CNS_fraction_temp = time_factor*0.00517; | |
3215 else if (char_actual_ppO2 < 233) | |
3216 CNS_fraction_temp = time_factor*0.0209; | |
0 | 3217 else |
560 | 3218 CNS_fraction_temp = time_factor*0.0482; // value for 2.5 bar, used for 2.33 bar and above |
3219 | |
3220 | |
3221 // Check from where we were called: | |
3222 // flag (bit 7) is set -> we were called from calc_hauptroutine() | |
3223 // flag (bit 7) not set -> we were called from the deco planning routines | |
3224 if ( tissue_increment & 128 ) CNS_fraction += CNS_fraction_temp; // real tissues | |
3225 else if ( char_O_deco_status & DECO_PLAN_ALTERNATE ) CNS_sim_alt_fraction += CNS_fraction_temp; // alternative plan | |
3226 else CNS_sim_norm_fraction += CNS_fraction_temp; // normal plan | |
3227 | |
0 | 3228 } |
3229 | |
3230 ////////////////////////////////////////////////////////////////////////////// | |
560 | 3231 // calc_CNS_planning |
0 | 3232 // |
3233 // Compute CNS during predicted ascent. | |
3234 // | |
3235 // Note: Needs a call to deco_push_tissues_to_vault(), | |
3236 // deco_pull_tissues_from_vault() to avoid trashing everything... | |
3237 // | |
560 | 3238 // Input: CNS_fraction, internal_deco_time[], internal_deco_depth[], internal_deco_gas[] |
3239 // Output: CNS_fraction, int_O_normal_CNS_fraction / int_O_alternate_CNS_fraction | |
0 | 3240 // |
560 | 3241 void calc_CNS_planning(void) |
0 | 3242 { |
560 | 3243 // start with CNS% we already have |
3244 if( char_O_deco_status & DECO_PLAN_ALTERNATE ) CNS_sim_alt_fraction = CNS_fraction; | |
3245 else CNS_sim_norm_fraction = CNS_fraction; | |
3246 | |
3247 | |
3248 //---- CCR mode : do the full TTS at once --------------------------------- | |
3249 | |
3250 if( ((char_O_deco_status & DECO_MODE_MASK) == DECO_MODE_CCR) ) | |
3251 { | |
3252 overlay unsigned short t; // needs 16 bits here ! | |
3253 | |
3254 // get current ppO2 from sensors or setpoint | |
3255 char_actual_ppO2 = char_I_const_ppO2; | |
3256 | |
3257 // calculate CNS% for the period of additional staying at bottom depth (fTTS / delayed ascent) | |
3258 if( char_O_deco_status & DECO_ASCENT_DELAYED) | |
3259 { | |
3260 tissue_increment = char_I_extra_time; // must be limited to 127, is limited by range of char_I_extra_time | |
3261 calc_CNS_fraction(); | |
3262 } | |
3263 | |
3264 // get the ascent time dependent on the current plan | |
3265 t = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? int_O_alternate_ascenttime : int_O_ascenttime; | |
3266 | |
3267 // start simulating CNS% in chunks of 127 minutes | |
3268 tissue_increment = 127; | |
3269 | |
3270 while( t > 127 ) | |
3271 { | |
3272 t -= 127; // tissue_increment is limited to 127 minutes because of flag in bit 7 | |
3273 calc_CNS_fraction(); // calculate CNS in chunks of full 127 minutes | |
3274 } | |
3275 | |
3276 tissue_increment = (char)t; // get the remaining minutes <= 127 | |
3277 calc_CNS_fraction(); // calculate CNS for the remaining minutes | |
3278 } | |
3279 else //---- OC mode and pSCR without sensors: have to follow all gas switches... ----- | |
0 | 3280 { |
560 | 3281 overlay float float_actual_ppO2; |
3282 overlay float abs_pres; | |
3283 | |
3284 overlay unsigned char stop_depth; | |
3285 overlay unsigned char last_gas; | |
3286 overlay unsigned char i; // stop table index | |
3287 | |
3288 | |
3289 // retrieve bottom gas: 1-5 for the configured gases or 0 for the manually set gas | |
3290 last_gas = sim_gas_last_used = sim_gas_first_used; | |
3291 | |
3292 // get the calc_N2/He/O2_ratios of the bottom gas | |
3293 gas_switch_set(); | |
3294 | |
3295 // calculate absolute pressure | |
3296 abs_pres = pres_surface + bottom_depth * METER_TO_BAR; | |
3297 | |
3298 // switch on deco mode pSCR / OC | |
3299 if( char_O_deco_status & DECO_MODE_PSCR ) | |
3300 { | |
3301 //---- pSCR calculated -------------------------------------------- | |
3302 | |
3303 // abs_pres is 0.0 ... in bar | |
3304 // calc_O2_ratio is 0.0 ... 1.0 as factor | |
3305 // char_I_PSCR_drop is 0 ... 15 as % | |
3306 // char_I_PSCR_lungratio is 5 ... 20 as % | |
3307 // float_actual_ppO2 is 0.0 ... in cbar (!) | |
3308 | |
3309 float_actual_ppO2 = (100 * abs_pres * calc_O2_ratio) | |
3310 - (1.0 - calc_O2_ratio) * char_I_PSCR_drop * char_I_PSCR_lungratio; | |
3311 } | |
3312 else | |
3313 { | |
3314 //---- OC --------------------------------------------------------- | |
3315 | |
3316 float_actual_ppO2 = abs_pres * calc_O2_ratio * 100; // in cbar (!) | |
3317 } | |
3318 | |
3319 // caution: float_actual_ppO2 is in cbar here! | |
3320 if ( float_actual_ppO2 < 0.0 ) char_actual_ppO2 = 0; | |
3321 else if ( float_actual_ppO2 > 254.5 ) char_actual_ppO2 = 255; | |
3322 else char_actual_ppO2 = (unsigned char)(float_actual_ppO2 + 0.5); | |
3323 | |
3324 | |
3325 // simulate extended bottom time (fTTS) / delay before ascent (bailout) if configured | |
3326 if( char_O_deco_status & DECO_ASCENT_DELAYED ) | |
3327 { | |
3328 tissue_increment = char_I_extra_time; // must be limited to 127, is limited by range of char_I_extra_time | |
3329 calc_CNS_fraction(); | |
3330 } | |
3331 | |
3332 | |
3333 // For simplicity reason (non-linearity of the relation between ppO2 and CNS increments), the | |
3334 // whole ascent is calculated with bottom ppO2. This errs, but it does so to the safe side. | |
3335 | |
3336 // calculate ascent time (integer division and generous round-up) | |
3337 tissue_increment = bottom_depth / char_I_ascent_speed + 1; | |
3338 | |
3339 // ** commented out - not needed when char_I_ascent_speed is limited to a | |
3340 // ** minimum of 2.something, it is indeed limited to 5. | |
3341 // | |
3342 // // limit tissue_increment to 127 minutes | |
3343 // if( tissue_increment > 127 ) tissue_increment = 127; | |
3344 | |
3345 // simulate the CNS increase | |
3346 calc_CNS_fraction(); | |
3347 | |
3348 | |
3349 //---- Stops --------------------------------------------------------- | |
3350 | |
0 | 3351 for(i=0; i<NUM_STOPS; ++i) |
3352 { | |
560 | 3353 // get the depth of the stop |
3354 stop_depth = internal_deco_depth[i]; | |
3355 | |
3356 // did we reach the last entry (depth = 0)? if yes, done | |
3357 if (stop_depth == 0) break; | |
3358 | |
3359 // get the duration of the stop and the gas breathed | |
3360 tissue_increment = internal_deco_time[i]; | |
3361 sim_gas_last_used = internal_deco_gas[i]; | |
3362 | |
3363 // do we have a gas switch? | |
3364 if( sim_gas_last_used != last_gas ) | |
0 | 3365 { |
560 | 3366 // yes - get new calc ratios |
3367 gas_switch_set(); | |
3368 | |
3369 // remember new gas as last gas | |
3370 last_gas = sim_gas_last_used; | |
3371 } | |
3372 | |
3373 // calculate absolute pressure at stop depth | |
3374 abs_pres = pres_surface + stop_depth * METER_TO_BAR; | |
3375 | |
3376 // pSCR mode | |
3377 if( char_O_deco_status & DECO_MODE_PSCR ) | |
3378 { | |
3379 // abs_pres is 0.0 ... in bar | |
3380 // calc_O2_ratio is 0.0 ... 1.0 as factor | |
3381 // char_I_PSCR_drop is 0 ... 15 as % | |
3382 // char_I_PSCR_lungratio is 5 ... 20 as % | |
3383 // float_actual_ppO2 is 0.0 ... in cbar (!) | |
3384 | |
3385 float_actual_ppO2 = (100 * abs_pres * calc_O2_ratio) | |
3386 - (1.0 - calc_O2_ratio) * char_I_PSCR_drop * char_I_PSCR_lungratio; | |
3387 } | |
3388 else // OC mode | |
3389 { | |
3390 float_actual_ppO2 = abs_pres * calc_O2_ratio * 100; // in cbar (!) | |
3391 } | |
3392 | |
3393 // caution: float_actual_ppO2 is in cbar here! | |
3394 if ( float_actual_ppO2 < 0.0 ) char_actual_ppO2 = 0; | |
3395 else if ( float_actual_ppO2 > 254.5 ) char_actual_ppO2 = 255; | |
3396 else char_actual_ppO2 = (unsigned char)(float_actual_ppO2 + 0.5); | |
3397 | |
3398 | |
3399 // ** Currently, stop times per stop entry are limited to 99 minutes in update_deco_table(), | |
3400 // ** so the following code block is not needed at times. | |
3401 // | |
3402 // // tissue_increment is limited to 127 when fed to deco_calc_CNS_fraction(), | |
3403 // // so if the stop is longer than 127 minutes (but not longer than 254 minutes!) | |
3404 // // we need to calculate the CNS in two chunks. | |
3405 // if( tissue_increment > 127) | |
3406 // { | |
3407 // tissue_increment -= 127; // subtract full 127 minutes and do the "remaining" minutes first | |
3408 // calc_CNS_fraction(); | |
3409 // tissue_increment = 127; // catch up with the previously subtracted full 127 minutes | |
3410 // } | |
3411 | |
3412 // calculate CNS% for the stop | |
3413 calc_CNS_fraction(); | |
0 | 3414 } |
3415 } | |
3416 } | |
3417 | |
560 | 3418 |
0 | 3419 ////////////////////////////////////////////////////////////////////////////// |
560 | 3420 // gas_volumes |
3421 // | |
3422 // calculates volumes and required tank fill pressures for each gas. | |
0 | 3423 // |
560 | 3424 // Input: bottom_depth depth of the bottom segment |
3425 // char_I_bottom_time duration of the bottom segment | |
3426 // char_I_extra_time extra bottom time for fTTS / delayed ascent | |
3427 // float_ascent_speed ascent speed, in meters/minute | |
3428 // sim_gas_first_used the bottom gas (1-5 for configured gases, 0 for the manual gas) | |
3429 // internal_deco_depth[] depth of the stops | |
3430 // internal_deco_time[] duration of the stops | |
3431 // internal_deco_gas[] gas breathed at the stops | |
3432 // char_I_bottom_usage gas consumption during bottom part and initial ascent, in liters/minute | |
3433 // char_I_deco_usage gas consumption during stops and following ascents, in liters/minute | |
3434 // char_I_tank_size[] size of the tanks for gas 1-5, in liters | |
3435 // char_I_tank_pres_fill[] fill pressure of the tanks | |
0 | 3436 // |
560 | 3437 // Output: int_O_gas_volumes[] amount of gas needed, in liters |
3438 // int_O_tank_pres_need[] in bar, + flags for fast evaluation by dive mode warnings: | |
3439 // 2^15: pres_need >= pres_fill | |
3440 // 2^14: pres_need >= press_fill * GAS_NEEDS_ATTENTION_THRESHOLD | |
3441 // 2^11: pres_need == 0 | |
3442 // 2^10: pres_need invalid | |
0 | 3443 // |
560 | 3444 void gas_volumes_helper(void) |
3445 { | |
3446 // Calculate the gas volume needed at a given depth, time and usage (SAC rate). | |
3447 // We use 1.0 for the surface pressure to have stable results when used through | |
3448 // the deco calculator (simulation mode). | |
3449 volume = (float_depth * METER_TO_BAR + 1.0) * float_time * usage; | |
3450 | |
3451 return; | |
3452 } | |
3453 | |
3454 void gas_volumes(void) | |
0 | 3455 { |
560 | 3456 overlay float volumes[NUM_GAS]; |
3457 | |
3458 overlay unsigned char stop_gas; | |
3459 overlay unsigned char stop_gas_last; | |
3460 overlay unsigned char stop_time; | |
3461 overlay unsigned char stop_depth; | |
3462 overlay unsigned char stop_depth_last; | |
3463 overlay unsigned char i; | |
3464 | |
3465 | |
3466 //---- initialization ---------------------------------------------------- | |
3467 | |
3468 // null the volume accumulators | |
3469 for(i=0; i<NUM_GAS; ++i) volumes[i] = 0.0; | |
3470 | |
3471 // quit for CCR and pSCR mode | |
3472 if( char_O_deco_status & DECO_MODE_LOOP ) goto done; | |
3473 | |
3474 | |
3475 //---- bottom demand ----------------------------------------------------- | |
3476 | |
3477 // sim_gas_first_used : gas used during bottom segment (0, 1-5) | |
3478 // bottom_depth: depth of the bottom segment | |
3479 | |
3480 assert(0 <= sim_gas_first_used && sim_gas_first_used <= NUM_GAS); | |
3481 | |
3482 // get the gas used during bottom segment | |
3483 stop_gas_last = stop_gas = sim_gas_first_used; | |
3484 | |
3485 // set the usage (SAC rate) to bottom usage rate for bottom part and initial ascent | |
3486 usage = char_I_bottom_usage; | |
3487 | |
3488 // volumes are only calculated for gases 1-5, but not the manually configured one | |
3489 if( stop_gas ) | |
3490 { | |
3491 // set the bottom depth | |
3492 float_depth = (float)bottom_depth; | |
3493 | |
3494 // calculate either bottom segment or just the fTTS/bailout delayed part | |
3495 if( char_O_main_status & DECO_BOTTOM_CALCULATE ) | |
3496 { | |
3497 // duration of bottom segment | |
3498 float_time = (float)char_I_bottom_time; | |
3499 } | |
3500 else | |
3501 { | |
3502 // duration of delayed ascent | |
3503 float_time = (float)char_I_extra_time; | |
3504 } | |
3505 | |
3506 // calculate gas demand | |
3507 gas_volumes_helper(); | |
3508 | |
3509 // take result | |
3510 volumes[stop_gas-1] = volume; | |
3511 } | |
3512 | |
3513 | |
3514 // initialize stop index with first stop | |
3515 i = 0; | |
3516 | |
3517 | |
3518 //---- initial ascent demand --------------------------------------------- | |
3519 | |
3520 // stop_gas : gas from bottom segment | |
3521 // bottom_depth : depth of the bottom segment in meters | |
3522 // internal_deco_depth[i=0]: depth of the first stop, may be 0 if no stop exists | |
3523 | |
3524 // get the data of the first stop | |
3525 stop_depth = internal_deco_depth[i]; | |
3526 stop_time = internal_deco_time[i]; | |
3527 | |
3528 // volumes are only calculated for gases 1-5, but not the manually configured one | |
3529 if( stop_gas ) | |
3530 { | |
3531 // compute distance between bottom and first stop | |
3532 float_depth = (float)bottom_depth - (float)stop_depth; | |
3533 | |
3534 // initial ascent exists only if ascent distance is > 0 | |
3535 if( float_depth > 0.0 ) | |
3536 { | |
3537 // compute ascent time | |
3538 float_time = float_depth / float_ascent_speed; | |
3539 | |
3540 // compute average depth between bottom and first stop | |
3541 float_depth = (float)bottom_depth - float_depth * 0.5; | |
3542 | |
3543 // calculate gas demand | |
3544 gas_volumes_helper(); | |
3545 | |
3546 // add result | |
3547 volumes[stop_gas-1] += volume; | |
3548 } | |
3549 } | |
3550 | |
3551 // switch the usage (SAC rate) to deco usage rate | |
3552 // for stops, intermediate and final ascent | |
3553 usage = char_I_deco_usage; | |
3554 | |
3555 // is there a (first) stop? if yes, goto stops processing | |
3556 if( stop_depth ) goto stops; | |
3557 | |
3558 // add demand of a 3 minutes safety stop at 5 meters, at least for contingency... | |
3559 float_time = 3.0; | |
3560 float_depth = 5.0; | |
3561 | |
3562 // calculate gas demand | |
3563 gas_volumes_helper(); | |
3564 | |
3565 // add result | |
3566 volumes[stop_gas-1] += volume; | |
3567 | |
3568 // proceed to volume conversion and pressure calculations | |
3569 goto done; | |
3570 | |
3571 | |
3572 //---- intermediate ascent demand --------------------------------------- | |
3573 inter_ascents: | |
3574 | |
3575 // store last stop depth and gas | |
3576 stop_depth_last = stop_depth; | |
3577 stop_gas_last = stop_gas; | |
3578 | |
3579 // check if we are at the end of the stops table | |
3580 if( i < NUM_STOPS-1 ) | |
3581 { | |
3582 // there are more entries - get the next stop data | |
3583 i++; | |
3584 | |
3585 // get the next stop depth | |
3586 stop_depth = internal_deco_depth[i]; | |
3587 | |
3588 // check if there is indeed another stop, | |
3589 // if not (depth = 0) treat as end of table | |
3590 if( stop_depth == 0 ) goto end_of_table; | |
3591 | |
3592 // get the next stop duration | |
3593 stop_time = internal_deco_time[i]; | |
3594 } | |
3595 else | |
3596 { | |
3597 end_of_table: | |
3598 | |
3599 // End of the stops table reached or no more stops: Split the remaining | |
3600 // ascent into an intermediate ascent and a final ascent by creating a | |
3601 // dummy stop at the usual last deco stop depth. Stop gas doesn't change. | |
3602 stop_time = 0; | |
3603 stop_depth = char_I_depth_last_deco; | |
3604 } | |
3605 | |
3606 // volumes are only calculated for gases 1-5, but not the manually configured one | |
3607 if( stop_gas_last ) | |
3608 { | |
3609 // compute distance between the two stops: | |
3610 // last stop will always be deeper than current stop | |
3611 float_depth = (float)(stop_depth_last - stop_depth); | |
3612 | |
3613 // compute ascent time | |
3614 float_time = float_depth / float_ascent_speed; | |
3615 | |
3616 // compute average depth between the two stops | |
3617 float_depth = (float)stop_depth_last - float_depth * 0.5; | |
3618 | |
3619 // calculate gas demand | |
3620 gas_volumes_helper(); | |
3621 | |
3622 // add result | |
3623 volumes[stop_gas_last-1] += volume; | |
3624 } | |
3625 | |
3626 | |
3627 //---- next stop demand ------------------------------------------------- | |
3628 stops: | |
3629 | |
3630 // convert depth of the stop | |
3631 float_depth = (float)stop_depth; | |
3632 | |
3633 // get the next gas | |
3634 stop_gas = internal_deco_gas[i]; | |
3635 | |
3636 // do we we have a gas change? | |
3637 if( stop_gas_last && (stop_gas != stop_gas_last) ) | |
3638 { | |
3639 // yes - spend an additional char_I_gas_change_time on the old gas | |
3640 float_time = (float)char_I_gas_change_time; | |
3641 | |
3642 // calculate gas demand | |
3643 gas_volumes_helper(); | |
3644 | |
3645 // add result | |
3646 volumes[stop_gas_last-1] += volume; | |
3647 } | |
3648 | |
3649 // calculate and add demand on new gas for the full stop duration | |
3650 if( stop_gas ) | |
3651 { | |
3652 // get the duration of the stop | |
3653 float_time = (float)stop_time; | |
3654 | |
3655 // calculate gas demand | |
3656 gas_volumes_helper(); | |
3657 | |
3658 // add result to last gas | |
3659 volumes[stop_gas-1] += volume; | |
3660 } | |
3661 | |
3662 // continue with the next intermediate ascent if this was not the last stop | |
3663 if( stop_depth > char_I_depth_last_deco ) goto inter_ascents; | |
3664 | |
3665 | |
3666 //---- final ascent demand ----------------------------------------------- | |
3667 final_ascent: | |
3668 | |
3669 // float_depth: depth of last stop | |
3670 // stop_gas : gas from last stop (0 or 1-5) | |
3671 | |
3672 // volumes are only calculated for gases 1-5, but not the manually configured one | |
3673 if( stop_gas ) | |
3674 { | |
3675 // set ascent time according to an ascent speed of 1 meter per minute | |
3676 float_time = float_depth; | |
3677 | |
3678 // set half-way depth | |
3679 float_depth *= 0.5; | |
3680 | |
3681 // calculate gas demand | |
3682 gas_volumes_helper(); | |
3683 | |
3684 // add result | |
3685 volumes[stop_gas-1] += volume; | |
3686 } | |
3687 | |
3688 | |
3689 //---- convert results for the assembler interface ----------------------------- | |
3690 done: | |
3691 | |
3692 for(i=0; i<NUM_GAS; ++i) | |
3693 { | |
3694 if( volumes[i] >= 65534.5 ) | |
3695 { | |
3696 int_O_gas_volumes[i] = 65535; | |
3697 int_O_tank_pres_need[i] = 999 + INT_FLAG_WARNING; // 999 bar + warning flag for > pres_fill | |
3698 } | |
3699 else | |
3700 { | |
3701 overlay unsigned short tank_pres_fill = 10.0 * (unsigned short)char_I_tank_pres_fill[i]; | |
3702 | |
3703 // No distinct rounding done here because volumes are not accurate to the single liter anyhow | |
3704 | |
3705 // convert gas volumes to integers | |
3706 int_O_gas_volumes[i] = (unsigned short)volumes[i]; | |
3707 | |
3708 // compute how much pressure in the tank will be needed [in bar] (integer-division) | |
3709 int_O_tank_pres_need[i] = (unsigned short)(int_O_gas_volumes[i] / char_I_tank_size[i]); | |
3710 | |
3711 // limit to 999 bar because of display constraints | |
3712 if( int_O_tank_pres_need[i] > 999 ) int_O_tank_pres_need[i] = 999; | |
3713 | |
3714 // set flags for fast evaluation by divemode check for warnings | |
3715 if ( int_O_tank_pres_need[i] == 0 ) | |
3716 { | |
3717 // set flag for 0 bar | |
3718 int_O_tank_pres_need[i] |= INT_FLAG_ZERO; | |
3719 } | |
3720 else if( int_O_tank_pres_need[i] >= tank_pres_fill ) | |
3721 { | |
3722 // set warning flag | |
3723 int_O_tank_pres_need[i] |= INT_FLAG_WARNING; | |
3724 | |
3725 } | |
3726 else if( int_O_tank_pres_need[i] >= tank_pres_fill * GAS_NEEDS_ATTENTION_THRESHOLD ) | |
3727 { | |
3728 // set pre-warning flag | |
3729 int_O_tank_pres_need[i] |= INT_FLAG_PREWARNING; | |
3730 } | |
3731 | |
3732 // set invalid flag if there is an overflow in the stops table | |
3733 if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) | |
3734 int_O_tank_pres_need[i] |= INT_FLAG_INVALID; | |
3735 | |
3736 } // if( volumes[i] ) | |
3737 } // for | |
0 | 3738 } |
3739 | |
3740 ////////////////////////////////////////////////////////////////////////////// | |
560 | 3741 |
3742 void compute_CNS_for_display(void) | |
0 | 3743 { |
560 | 3744 if ( CNS_fraction < 0.01 ) int_O_CNS_fraction = 0; |
3745 else if ( CNS_fraction >= 9.985 ) int_O_CNS_fraction = 999 + INT_FLAG_WARNING; | |
3746 else | |
3747 { | |
3748 // convert float to integer | |
3749 int_O_CNS_fraction = (unsigned short)(100 * CNS_fraction + 0.5); | |
3750 | |
3751 // compute warnings | |
3752 if ( int_O_CNS_fraction >= CNS_warning_threshold ) | |
3753 { | |
3754 // reset pre-warning and set main warning flag | |
3755 int_O_CNS_fraction &= ~INT_FLAG_PREWARNING; | |
3756 int_O_CNS_fraction |= INT_FLAG_WARNING; | |
3757 } | |
3758 else if ( int_O_CNS_fraction >= CNS_prewarning_threshold ) | |
3759 { | |
3760 // reset main warning but set pre-warning flag | |
3761 int_O_CNS_fraction &= ~INT_FLAG_WARNING; | |
3762 int_O_CNS_fraction |= INT_FLAG_PREWARNING; | |
3763 } | |
3764 else | |
3765 { | |
3766 // clear both warnings | |
3767 int_O_CNS_fraction &= ~(INT_FLAG_WARNING + INT_FLAG_PREWARNING); | |
3768 } | |
3769 } | |
0 | 3770 } |
3771 | |
3772 ////////////////////////////////////////////////////////////////////////////// | |
3773 | |
3774 void deco_push_tissues_to_vault(void) | |
3775 { | |
3776 overlay unsigned char x; | |
560 | 3777 |
0 | 3778 RESET_C_STACK |
3779 | |
560 | 3780 low_depth_norm_vault = low_depth_norm; |
3781 low_depth_alt_vault = low_depth_alt; | |
3782 cns_vault_float = CNS_fraction; | |
3783 cns_vault_int = int_O_CNS_fraction; | |
3784 deco_warnings_vault = char_O_deco_warnings; | |
0 | 3785 |
3786 for (x=0;x<NUM_COMP;x++) | |
3787 { | |
3788 pres_tissue_N2_vault[x] = pres_tissue_N2[x]; | |
3789 pres_tissue_He_vault[x] = pres_tissue_He[x]; | |
3790 } | |
3791 } | |
3792 | |
3793 void deco_pull_tissues_from_vault(void) | |
3794 { | |
3795 overlay unsigned char x; | |
560 | 3796 |
0 | 3797 RESET_C_STACK |
3798 | |
560 | 3799 low_depth_norm = low_depth_norm_vault; |
3800 low_depth_alt = low_depth_alt_vault; | |
3801 CNS_fraction = cns_vault_float; | |
3802 int_O_CNS_fraction = cns_vault_int; | |
3803 char_O_deco_warnings = deco_warnings_vault; | |
3804 | |
3805 locked_GF_step_norm = GF_delta / low_depth_norm; | |
3806 locked_GF_step_alt = GF_delta / low_depth_alt; | |
3807 | |
0 | 3808 for (x=0; x<NUM_COMP; x++) |
3809 { | |
3810 pres_tissue_N2[x] = pres_tissue_N2_vault[x]; | |
3811 pres_tissue_He[x] = pres_tissue_He_vault[x]; | |
3812 } | |
3813 } | |
3814 | |
3815 ////////////////////////////////////////////////////////////////////////////// | |
3816 // | |
3817 #ifndef CROSS_COMPILE | |
3818 void main() {} | |
3819 #endif |