mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-12-01 06:30:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/planner.c

1467 lines
50 KiB
C
Raw Normal View History

First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
/* planner.c
*
* code that allows us to plan future dives
*
* (c) Dirk Hohndel 2013
*/
Add some assert guard around gas finding code The code would have leaved gasidx undefined if it doesn't find a correct gas, so this asserts instead of using uninitialized variables as array index. Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-07 22:54:14 +00:00
#include <assert.h>
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
#include <unistd.h>
#include <ctype.h>
First steps towards removing glib dependencies - remove the build flags and libraries from the Makefile / Configure.mk - remove the glib types (gboolean, gchar, gint64, gint) - comment out / hack around gettext - replace the glib file helper functions - replace g_ascii_strtod - replace g_build_filename - use environment variables instead of g_get_home_dir() & g_get_user_name() - comment out GPS string parsing (uses glib utf8 macros) This needs massive cleanup, but it's a snapshot of what I have right now, in case people want to look at it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-05 07:29:09 +00:00
#include <string.h>
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
#include "dive.h"
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
#include "deco.h"
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
#include "divelist.h"
Separate Gtk related code from core logic: planner Relatively straight forward, just a handful of places where we call show_error() (a UI function) from the logic code. In the process I noticed a few places where error returns weren't dealt with correctly. Added a new planner.h files for the necessary declarations. This should make no difference to functionality. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-08 03:20:25 +00:00
#include "planner.h"
Trying to switch to Qt translation This compiles and looks about right, but it doesn't appear to work, yet. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-06 15:55:58 +00:00
#include "gettext.h"
Show translated event names in tooltip In order for this to work we need to compare against the event type instead of the event name - which makes much more sense to do, anyway. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-30 05:37:19 +00:00
#include "libdivecomputer/parser.h"
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
Planner: change timestep to 2 seconds Change the timestep used to calculate tissue pressures and ascents from 3 seconds to 2 seconds. But whats wrong with using 3 seconds? Deco stops are at 3 m (10') intervals, and our ascent rate is usually 9 m/min (30'/min), or at least multiples of 3 m/min (10'/min). Hence time to ascend from one stop to the next stop is 20s (or any factor of 60). Using 3s increments, we round our ascent interval up to 21 s, which leads to messy durations and runtimes. But what about me? I like SI units and whole decimals. Don't worry, 2s timesteps fit nicely when using 10 m/min ascent rate (18 s between stops). [Dirk Hohndel: edited the commit message to fix minute/second confusion] Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 01:01:09 +00:00
#define TIMESTEP 2 /* second */
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
#define DECOTIMESTEP 60 /* seconds. Unit of deco stop times */
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int decostoplevels_metric[] = { 0, 3000, 6000, 9000, 12000, 15000, 18000, 21000, 24000, 27000,
30000, 33000, 36000, 39000, 42000, 45000, 48000, 51000, 54000, 57000,
60000, 63000, 66000, 69000, 72000, 75000, 78000, 81000, 84000, 87000,
90000, 100000, 110000, 120000, 130000, 140000, 150000, 160000, 170000,
180000, 190000, 200000, 220000, 240000, 260000, 280000, 300000,
320000, 340000, 360000, 380000 };
int decostoplevels_imperial[] = { 0, 3048, 6096, 9144, 12192, 15240, 18288, 21336, 24384, 27432,
30480, 33528, 36576, 39624, 42672, 45720, 48768, 51816, 54864, 57912,
60960, 64008, 67056, 70104, 73152, 76200, 79248, 82296, 85344, 88392,
91440, 101600, 111760, 121920, 132080, 142240, 152400, 162560, 172720,
182880, 193040, 203200, 223520, 243840, 264160, 284480, 304800,
325120, 345440, 365760, 386080 };
Planner deco stops are at 10ft increments when measured in feet When using feet as depth unit, deco stop levels should be at 10 ft rather than 3 m increments. For shallow stops, rounding means the difference is not apparent. However, with stops deeper than 30 feet, using 3 m increments leads stops at 39ft, 49ft, ..., 98ft, etc. Apart from making plans look messy, the old behaviour makes it harder to benchmark the planner against published profiles in imperial units. This revised patch uses the help macro M_OR_FT(6, 20) to set the last stop at the correct depth. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 13:10:34 +00:00
Add GFlow/GFhigh settings in dive planner The planner interactively responds to changes to the GFlow and GFhigh in the dialog and calculates an appropriate profile. If there is a previous dive within the 48 hours prior to this dive then its saturation is correctly taken into account if the gradient factors are changed - so if they are aggressively lowered it is possible to start the dive with already an existing ceiling (simply increase the surface interval to 'fix' that). Once the plan is accepted the GF values are reset to the current preferences. This can cause the ceiling in the plot to change and the deco stops to no longer match the ceiling - but that's a logical consequence of the ability to change a temporary copy of GFlow/GFhigh during the planning process and not the actual preferences (which would be counter intuitive, I think). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 23:17:39 +00:00
double plangflow, plangfhigh;
Read planner preferences when we use them Read and use the last_stop preference in the plan function. Read the plan notes preferences and set variables (plan_verbatim, plan_display_runtime, plan_display_duration, and plan_display_transitions) in the add_plan_to_notes function. Don't read the preferences and set variables otherwise. Both plan and add_plan_to_notes functions are called on data change. Previous behaviour was: - Set variables on declaration - Reset variables in plan function (even variables that only relate to planner notes output) - Changing a preference triggered set_xxx function which sets variable, then plan function, which sets variable again. Apart from being inefficient, the previous behaviour made it difficult to track down where and when variables were set. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 12:14:10 +00:00
bool plan_verbatim, plan_display_runtime, plan_display_duration, plan_display_transitions;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
VPM-B: Calculate ceiling in deepest portion of dive The Boyle's law compensation compares the ambient pressure to a baseline value, and adjusts the theory bubble radius accordingly. Currently we use the ceiling at the last user-entered waypoint (the start of the decompression phase) as the baseline value. However, in a deep to shallow multi-level dive, decompression can start earlier, and taking a shallower ceiling leads to a more aggressive ascent. This is particularly noticeable if the user enters stops during ascent. With this commit, we take the baseline ambient pressure for Boyle's law compensation as the deeper of the: (1) Ceiling prior to ascending during a user-entered portion of the dive, and (2) Ceiling at the start of the last user-entered waypoint. This makes the calculated profile more conservative for some deep to shallow multi-level dives. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-12 02:10:54 +00:00
pressure_t first_ceiling_pressure, max_bottom_ceiling_pressure = {};
Use boyle_compensation in profile otherwise VPM-B planned profiles seem to violate the ceiling. This needs the first_stop_pressure to be available also in the profile, so I made it global in planner.c Important lesson: If you want to use deco_allowed_depth on a tissue_tolerance that comes from a VPM-B planned dive, you have to call boyles_law() before add_segment()! Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-19 21:14:00 +00:00
Disclaimer included in the printed diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 21:34:09 +00:00
const char *disclaimer;
Add simple debug function to planner This allows you to dump the diveplan structure Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 20:49:07 +00:00
#if DEBUG_PLAN
void dump_plan(struct diveplan *diveplan)
{
struct divedatapoint *dp;
struct tm tm;
if (!diveplan) {
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
printf("Diveplan NULL\n");
Add simple debug function to planner This allows you to dump the diveplan structure Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 20:49:07 +00:00
return;
}
utc_mkdate(diveplan->when, &tm);
Set a default surface pressure for dive plan and allow simplistic print This commit makes sure we have a reasonable default surface pressure (we need an input field for that). It also adjusts the debug level settings so that compiling this with make CLCFLAGS=-DDEBUG_PLAN=3 will print out an almost usable dive plan. This is of course still lacking air consumption calculations and will show deco stops that we just transit through (if the ceiling lifts far enough during the transition to an intended stop that this stop can be skipped; this sometimes happens for the first stop (haven't seen it for a later one). But it's better than nothing, I guess. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 22:05:25 +00:00
printf("\nDiveplan @ %04d-%02d-%02d %02d:%02d:%02d (surfpres %dmbar):\n",
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec,
diveplan->surface_pressure);
Add simple debug function to planner This allows you to dump the diveplan structure Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 20:49:07 +00:00
dp = diveplan->dp;
while (dp) {
Switch to the new gasmix structure in dump_plan dump_plan wasn't updated when the switch from he/o2 to gasmix was done in the planner code, this makes it compile again. Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-05 15:28:14 +00:00
printf("\t%3u:%02u: %dmm gas: %d o2 %d h2\n", FRACTION(dp->time, 60), dp->depth, get_o2(&dp->gasmix), get_he(&dp->gasmix));
Add simple debug function to planner This allows you to dump the diveplan structure Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 20:49:07 +00:00
dp = dp->next;
}
}
#endif
Planner: don't do unnecessary work on empty dive plans Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 22:40:13 +00:00
bool diveplan_empty(struct diveplan *diveplan)
{
struct divedatapoint *dp;
if (!diveplan || !diveplan->dp)
return true;
dp = diveplan->dp;
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
while (dp) {
Planner: don't do unnecessary work on empty dive plans Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 22:40:13 +00:00
if (dp->time)
return false;
dp = dp->next;
}
return true;
}
get_gas_at_time needs to always give us a valid gas Before this function was changed it was really supposed to just change a gas that was passed in in case there was an event that changed the mix - but with the new name the caller will assume that they get a valid gasmix. And promptly we had one caller that didn't initialize gas to be based on the first cylinder before calling get_gas_at_time(). Instead of adding yet one more spot that knows about the oddity of the old API I simply changed get_gas_at_time() to do what it name appears to imply and fixed the other callers not to bother to initialize the gasmix. Fixes #647 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-19 01:37:28 +00:00
/* get the gas at a certain time during the dive */
Convert get_gas_from_events to get_gas_at_time This converts the get_gas_from_events to a get_gas_at_time function that actually maps our events to what cylinder and thus gas we are breathing at that time. [Dirk Hohndel: fixed to actually use the gas that was looked up (and make things compile)] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:50 +00:00
void get_gas_at_time(struct dive *dive, struct divecomputer *dc, duration_t time, struct gasmix *gas)
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
{
get_gas_at_time needs to always give us a valid gas Before this function was changed it was really supposed to just change a gas that was passed in in case there was an event that changed the mix - but with the new name the caller will assume that they get a valid gasmix. And promptly we had one caller that didn't initialize gas to be based on the first cylinder before calling get_gas_at_time(). Instead of adding yet one more spot that knows about the oddity of the old API I simply changed get_gas_at_time() to do what it name appears to imply and fixed the other callers not to bother to initialize the gasmix. Fixes #647 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-19 01:37:28 +00:00
// we always start with the first gas, so that's our gas
// unless an event tells us otherwise
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
struct event *event = dc->events;
get_gas_at_time needs to always give us a valid gas Before this function was changed it was really supposed to just change a gas that was passed in in case there was an event that changed the mix - but with the new name the caller will assume that they get a valid gasmix. And promptly we had one caller that didn't initialize gas to be based on the first cylinder before calling get_gas_at_time(). Instead of adding yet one more spot that knows about the oddity of the old API I simply changed get_gas_at_time() to do what it name appears to imply and fixed the other callers not to bother to initialize the gasmix. Fixes #647 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-19 01:37:28 +00:00
*gas = dive->cylinder[0].gasmix;
Use more of our propper types in the planner Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:49 +00:00
while (event && event->time.seconds <= time.seconds) {
Convert get_gas_from_events to get_gas_at_time This converts the get_gas_from_events to a get_gas_at_time function that actually maps our events to what cylinder and thus gas we are breathing at that time. [Dirk Hohndel: fixed to actually use the gas that was looked up (and make things compile)] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:50 +00:00
if (!strcmp(event->name, "gaschange")) {
int cylinder_idx = get_cylinder_index(dive, event);
*gas = dive->cylinder[cylinder_idx].gasmix;
}
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
event = event->next;
}
}
Use proper types This is step one of many to use gasmix instead of int o2/he. Right now some of these changes look ridiculous because after changing a few lines we immediately go back to o2 = get_o2(gas). The reason is that I wanted to convert a hand full of functions at a time. So in this commit I only change validate_gas(), get_gas_from_events() and get_gasidx() to use a struct gasmix instead of int o2, int he. This state builds and survived some mild testing. Let's continue on top of that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 21:17:06 +00:00
int get_gasidx(struct dive *dive, struct gasmix *mix)
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
{
Make gas change events always have a cylinder index In commit df4e26c8757a ("Start sanitizing gaschange event information") back about a year and a half ago, I started sanitizing the gas switch event data, allowing gas switches to be associated with a particular cylinder index rather than just the gas mix that is switched to. But that initial step only _allowed_ a gas switch event to be associated with a particular cylinder, the primary model was still to just specify the mix. This finally takes the next step, and *always* associates a gas switch event with a particular cylinder. Instead of then looking up the cylinder by trying to match gas mixes at runtime, subsurface now looks it up when loading the dive initially as part of the dive fixup code. The switch event still has an a separate gas mix associated with it, but this patch also starts preparing for entirely relying on the gas mix in the cylinder itself, by starting to pass in not just the event but also the dive pointer to the routines that look up gas mix details. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-04-02 20:06:54 +00:00
return find_best_gasmix_match(mix, dive->cylinder, 0);
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
}
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
void interpolate_transition(struct dive *dive, duration_t t0, duration_t t1, depth_t d0, depth_t d1, const struct gasmix *gasmix, o2pressure_t po2)
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
{
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
uint32_t j;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
Use our types in interpolate_transition Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-18 18:25:00 +00:00
for (j = t0.seconds; j < t1.seconds; j++) {
int depth = interpolate(d0.mm, d1.mm, j - t0.seconds, t1.seconds - t0.seconds);
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, dive), gasmix, 1, po2.mbar, dive, prefs.bottomsac);
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
}
VPM-B: Calculate crushing pressure on descent By calculating crushing pressure after the manually entered phase, we were doing it wrong for multi-level dives. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 11:51:35 +00:00
if (d1.mm > d0.mm)
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
calc_crushing_pressure(depth_to_bar(d1.mm, &displayed_dive));
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
}
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
/* returns the tissue tolerance at the end of this (partial) dive */
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
void tissue_at_end(struct dive *dive, char **cached_datap)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
struct divecomputer *dc;
struct sample *sample, *psample;
Convert get_gas_from_events to get_gas_at_time This converts the get_gas_from_events to a get_gas_at_time function that actually maps our events to what cylinder and thus gas we are breathing at that time. [Dirk Hohndel: fixed to actually use the gas that was looked up (and make things compile)] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:50 +00:00
int i;
Use more of our propper types in the planner Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:49 +00:00
depth_t lastdepth = {};
duration_t t0 = {}, t1 = {};
Use proper types This is step one of many to use gasmix instead of int o2/he. Right now some of these changes look ridiculous because after changing a few lines we immediately go back to o2 = get_o2(gas). The reason is that I wanted to convert a hand full of functions at a time. So in this commit I only change validate_gas(), get_gas_from_events() and get_gasidx() to use a struct gasmix instead of int o2, int he. This state builds and survived some mild testing. Let's continue on top of that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 21:17:06 +00:00
struct gasmix gas;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
if (!dive)
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
return;
Add the ability to cache our deco state We kept reduing all the deco calculations, including the previous dives (if any) for each segment we add to the dive plan. This simply remembers the last stage and then just adds to that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-06 19:13:46 +00:00
if (*cached_datap) {
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
restore_deco_state(*cached_datap);
Add the ability to cache our deco state We kept reduing all the deco calculations, including the previous dives (if any) for each segment we add to the dive plan. This simply remembers the last stage and then just adds to that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-06 19:13:46 +00:00
} else {
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
init_decompression(dive);
cache_deco_state(cached_datap);
Add the ability to cache our deco state We kept reduing all the deco calculations, including the previous dives (if any) for each segment we add to the dive plan. This simply remembers the last stage and then just adds to that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-06 19:13:46 +00:00
}
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
dc = &dive->dc;
if (!dc->samples)
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
return;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
psample = sample = dc->sample;
get_gas_at_time needs to always give us a valid gas Before this function was changed it was really supposed to just change a gas that was passed in in case there was an event that changed the mix - but with the new name the caller will assume that they get a valid gasmix. And promptly we had one caller that didn't initialize gas to be based on the first cylinder before calling get_gas_at_time(). Instead of adding yet one more spot that knows about the oddity of the old API I simply changed get_gas_at_time() to do what it name appears to imply and fixed the other callers not to bother to initialize the gasmix. Fixes #647 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-19 01:37:28 +00:00
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
for (i = 0; i < dc->samples; i++, sample++) {
Use the correct setpoint in planner There is an unfortunate convention that the sample structure contains a setpoint at its end rather than during its duration which causes the expression sample[-1].setpoint in several places. This adds another one for the planner to use the correct setpoint during the manually entered leg of the dive. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-14 09:22:32 +00:00
o2pressure_t setpoint;
if (i)
setpoint = sample[-1].setpoint;
else
setpoint = sample[0].setpoint;
Use more of our propper types in the planner Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:49 +00:00
t1 = sample->time;
Convert get_gas_from_events to get_gas_at_time This converts the get_gas_from_events to a get_gas_at_time function that actually maps our events to what cylinder and thus gas we are breathing at that time. [Dirk Hohndel: fixed to actually use the gas that was looked up (and make things compile)] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:50 +00:00
get_gas_at_time(dive, dc, t0, &gas);
Fix the deco calculation in the dive planner The existing code incorrectly started all calculation at the depth at the end of the first segment. So if you went to 50m in 5min in your first segment, you incorrectly got 5 minutes at 50m (instead of a progression from 0 to 50m, over 5 minutes). This commit fixes that and now gives us planned dives that then match what is shown in the profile. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 21:54:29 +00:00
if (i > 0)
Use more of our propper types in the planner Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:49 +00:00
lastdepth = psample->depth;
VPM-B: Calculate ceiling in deepest portion of dive The Boyle's law compensation compares the ambient pressure to a baseline value, and adjusts the theory bubble radius accordingly. Currently we use the ceiling at the last user-entered waypoint (the start of the decompression phase) as the baseline value. However, in a deep to shallow multi-level dive, decompression can start earlier, and taking a shallower ceiling leads to a more aggressive ascent. This is particularly noticeable if the user enters stops during ascent. With this commit, we take the baseline ambient pressure for Boyle's law compensation as the deeper of the: (1) Ceiling prior to ascending during a user-entered portion of the dive, and (2) Ceiling at the start of the last user-entered waypoint. This makes the calculated profile more conservative for some deep to shallow multi-level dives. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-12 02:10:54 +00:00
/* The ceiling in the deeper portion of a multilevel dive is sometimes critical for the VPM-B
* Boyle's law compensation. We should check the ceiling prior to ascending during the bottom
* portion of the dive. The maximum ceiling might be reached while ascending, but testing indicates
* that it is only marginally deeper than the ceiling at the start of ascent.
* Do not set the first_ceiling_pressure variable (used for the Boyle's law compensation calculation)
* at this stage, because it would interfere with calculating the ceiling at the end of the bottom
* portion of the dive.
* Remember the value for later.
*/
if ((prefs.deco_mode == VPMB) && (lastdepth.mm > sample->depth.mm)) {
pressure_t ceiling_pressure;
nuclear_regeneration(t0.seconds);
vpmb_start_gradient();
ceiling_pressure.mbar = depth_to_mbar(deco_allowed_depth(tissue_tolerance_calc(dive,
depth_to_bar(lastdepth.mm, dive)),
dive->surface_pressure.mbar / 1000.0,
dive,
1),
dive);
if (ceiling_pressure.mbar > max_bottom_ceiling_pressure.mbar)
max_bottom_ceiling_pressure.mbar = ceiling_pressure.mbar;
}
Use the correct setpoint in planner There is an unfortunate convention that the sample structure contains a setpoint at its end rather than during its duration which causes the expression sample[-1].setpoint in several places. This adds another one for the planner to use the correct setpoint during the manually entered leg of the dive. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-14 09:22:32 +00:00
interpolate_transition(dive, t0, t1, lastdepth, sample->depth, &gas, setpoint);
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
psample = sample;
t0 = t1;
}
}
Only use a default cylinder if it is explicitly set We used to fall back to an AL80 default cylinder, but that meant that a user who doesn't want a default cylinder at all had no way to indicate that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-15 20:09:36 +00:00
/* if a default cylinder is set, use that */
Instead of a "Cylinder for planning" use a default cylinder Right now hardcoded to AL80. This way in the future we'll have a volume of gas that's available. And this makes much more sense then a random string in the description field. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-13 12:44:18 +00:00
void fill_default_cylinder(cylinder_t *cyl)
{
Only use a default cylinder if it is explicitly set We used to fall back to an AL80 default cylinder, but that meant that a user who doesn't want a default cylinder at all had no way to indicate that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-15 20:09:36 +00:00
const char *cyl_name = prefs.default_cylinder;
Use AL80 as default if no default cylinder is set Otherwise the user could get uninitialized values for newly created cylinders. Fixes #345 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-07 22:29:05 +00:00
struct tank_info_t *ti = tank_info;
Use gas_mod helper instead of local version Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-30 18:26:18 +00:00
pressure_t pO2 = {.mbar = 1600};
Use AL80 as default if no default cylinder is set Otherwise the user could get uninitialized values for newly created cylinders. Fixes #345 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-07 22:29:05 +00:00
Only use a default cylinder if it is explicitly set We used to fall back to an AL80 default cylinder, but that meant that a user who doesn't want a default cylinder at all had no way to indicate that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-15 20:09:36 +00:00
if (!cyl_name)
return;
Use AL80 as default if no default cylinder is set Otherwise the user could get uninitialized values for newly created cylinders. Fixes #345 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-07 22:29:05 +00:00
while (ti->name != NULL) {
if (strcmp(ti->name, cyl_name) == 0)
break;
ti++;
}
if (ti->name == NULL)
Only use a default cylinder if it is explicitly set We used to fall back to an AL80 default cylinder, but that meant that a user who doesn't want a default cylinder at all had no way to indicate that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-15 20:09:36 +00:00
/* didn't find it */
return;
Use AL80 as default if no default cylinder is set Otherwise the user could get uninitialized values for newly created cylinders. Fixes #345 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-07 22:29:05 +00:00
cyl->type.description = strdup(ti->name);
if (ti->ml) {
cyl->type.size.mliter = ti->ml;
cyl->type.workingpressure.mbar = ti->bar * 1000;
} else {
cyl->type.workingpressure.mbar = psi_to_mbar(ti->psi);
if (ti->psi)
cyl->type.size.mliter = cuft_to_l(ti->cuft) * 1000 / bar_to_atm(psi_to_bar(ti->psi));
Use the default cylinder if defined With this every cylinder downloaded from a divecomputer that doesn't provide cylinder data, and every cylinder manually added anywhere will default to the default cylinder that is set in the preferences. For people who most of the time dive with the same equipment (always on dive boats with AL80, or almost always diving their personal HP119) this should be a nice improvement. If you don't like this behavior, simply leave the default cylinder setting in the preferences empty. This commit also fixes the incorrect s->value call (should be s->setValue). I wonder what this did to the default filename before... Fixes #145 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-24 05:54:51 +00:00
}
Use gas_mod helper instead of local version Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-30 18:26:18 +00:00
// MOD of air
Round MOD of gas rather than truncate For the proper calculation, we need to take salinity and surface pressure into account (rather than depth = bar * 10 - 10) Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-05 22:07:39 +00:00
cyl->depth = gas_mod(&cyl->gasmix, pO2, &displayed_dive, 1);
Instead of a "Cylinder for planning" use a default cylinder Right now hardcoded to AL80. This way in the future we'll have a volume of gas that's available. And this makes much more sense then a random string in the description field. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-13 12:44:18 +00:00
}
Planner: clean up the function that tracks our gases This doesn't add gases. It just makes sure they are there. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 00:36:39 +00:00
/* make sure that the gas we are switching to is represented in our
* list of cylinders */
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
static int verify_gas_exists(struct gasmix mix_in)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
int i;
cylinder_t *cyl;
for (i = 0; i < MAX_CYLINDERS; i++) {
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
cyl = displayed_dive.cylinder + i;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
if (cylinder_nodata(cyl))
Planner: look harder to find the right gas Silly bug - while we normally fill the cylinders in a tight group with no "null" cylinders in the middle, since we copy from an existing dive and since that may end up with an odd sequence of cylinders, we need to continue looking at ALL cylinders and not stop with the first one that's empty. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-31 20:49:51 +00:00
continue;
Improve gas accounting in the panner When using gasmixes where the difference is less than 2% the planner can't caclulate casconsumptions correctly. This sets the minimum gasdifference to 1%. Fixes #795 Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-07 15:37:12 +00:00
if (gasmix_distance(&cyl->gasmix, &mix_in) < 100)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
return i;
}
Create simple non-thread-safe "gasname()" function Every single user of the get_gas_name() function wanted to just use the result to create a message or printout, and that made the interface a bit cumbersome. This adds a "gasname()" wrapper that returns a static buffer with the result in it, which is neither pretty nor thread-safe, but is a much simpler interface to work with. Our dive planning isn't multi-threaded, so nothing should care. [ This also converts a few open-coded gasname debug printouts to use the helper function, resulting in prettier printouts and less code ] Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 01:25:44 +00:00
fprintf(stderr, "this gas %s should have been on the cylinder list\nThings will fail now\n", gasname(&mix_in));
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
return -1;
}
/* calculate the new end pressure of the cylinder, based on its current end pressure and the
* latest segment. */
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
static void update_cylinder_pressure(struct dive *d, int old_depth, int new_depth, int duration, int sac, cylinder_t *cyl, bool in_deco)
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
{
volume_t gas_used;
pressure_t delta_p;
depth_t mean_depth;
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
int factor = 1000;
if (d->dc.divemode == PSCR)
factor = prefs.pscr_ratio;
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
Planner: track gas used even if we don't have a real cylinder We tracked gas used by simulating a dive with a cylinder - but for that we need a cylinder size and working pressure. If the user just enters a gas but no cylinder data (likely in order to figure out how much gas is used so that she then can pick a big enough cylinder), we didn't show any gas consumption. It kinda sucks to add another member to the cylinder structure, but this seemed far more reasonable then some other, global structure that independently tracks gas usage. This just seemed to make sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 16:59:38 +00:00
if (!cyl)
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
return;
mean_depth.mm = (old_depth + new_depth) / 2;
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
gas_used.mliter = depth_to_atm(mean_depth.mm, d) * sac / 60 * duration * factor / 1000;
Planner: track gas used even if we don't have a real cylinder We tracked gas used by simulating a dive with a cylinder - but for that we need a cylinder size and working pressure. If the user just enters a gas but no cylinder data (likely in order to figure out how much gas is used so that she then can pick a big enough cylinder), we didn't show any gas consumption. It kinda sucks to add another member to the cylinder structure, but this seemed far more reasonable then some other, global structure that independently tracks gas usage. This just seemed to make sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 16:59:38 +00:00
cyl->gas_used.mliter += gas_used.mliter;
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
if (in_deco)
cyl->deco_gas_used.mliter += gas_used.mliter;
Planner: fix typo that broke tank pressure tracking Oops, that's embarrassing. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 20:14:59 +00:00
if (cyl->type.size.mliter) {
Planner: track gas used even if we don't have a real cylinder We tracked gas used by simulating a dive with a cylinder - but for that we need a cylinder size and working pressure. If the user just enters a gas but no cylinder data (likely in order to figure out how much gas is used so that she then can pick a big enough cylinder), we didn't show any gas consumption. It kinda sucks to add another member to the cylinder structure, but this seemed far more reasonable then some other, global structure that independently tracks gas usage. This just seemed to make sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 16:59:38 +00:00
delta_p.mbar = gas_used.mliter * 1000.0 / cyl->type.size.mliter;
cyl->end.mbar -= delta_p.mbar;
}
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
/* simply overwrite the data in the displayed_dive
* return false if something goes wrong */
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
static void create_dive_from_plan(struct diveplan *diveplan, bool track_gas)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
struct divedatapoint *dp;
struct divecomputer *dc;
Make dive planner more useful for closed circuit diving Add a sample at time 0 to allow for a pO2 from the start of the dive. Remember the last pO2 so it doesn't have to be repeated (and the right thing happens for the planned part of the dive). This still doesn't allow us to change the setpoint at a certain depth (which would be analogous to being able to switch to a certain gas at a certain depth in OC plans), but with this commit it's already usable. This commit also fixes a couple of small bugs in commit b8ee3de870fa ("Dive planning for closed circuit rebreather") where a pO2 of 1.1 was hardcoded in one place, throwing off all plan calculations and integer math was used to calculate a floating point value (leading to most pO2 values actually used being 1.0). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 03:54:05 +00:00
struct sample *sample;
Switch verify_gas_exists to take gasmix argument Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:27:19 +00:00
struct gasmix oldgasmix;
Clear out old events in create_dive_from_plan Previous code where accumulating events from each iteration of the planning. This code clears the old ones before adding new ones. Fixes #595 [Dirk Hohndel: removed printf, updated comment, slightly moved the code, added parenthesis to silence warning] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 06:50:59 +00:00
struct event *ev;
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
cylinder_t *cyl;
Make dive planner more useful for closed circuit diving Add a sample at time 0 to allow for a pO2 from the start of the dive. Remember the last pO2 so it doesn't have to be repeated (and the right thing happens for the planned part of the dive). This still doesn't allow us to change the setpoint at a certain depth (which would be analogous to being able to switch to a certain gas at a certain depth in OC plans), but with this commit it's already usable. This commit also fixes a couple of small bugs in commit b8ee3de870fa ("Dive planning for closed circuit rebreather") where a pO2 of 1.1 was hardcoded in one place, throwing off all plan calculations and integer math was used to calculate a floating point value (leading to most pO2 values actually used being 1.0). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 03:54:05 +00:00
int oldpo2 = 0;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
int lasttime = 0;
Planner: correctly track gas used This part of the algorithm was off as part of it (but not all of it - crazy, I know) assumed the old semantic for gas changes where the new gas was introduced at the end of the segment and not at the beginning. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 17:02:38 +00:00
int lastdepth = 0;
Refactor dctype -> divemode ... and repair a failed rebase (sorry). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-10 23:01:15 +00:00
enum dive_comp_type type = displayed_dive.dc.divemode;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
if (!diveplan || !diveplan->dp)
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
return;
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
#if DEBUG_PLAN & 4
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
printf("in create_dive_from_plan\n");
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
dump_plan(diveplan);
#endif
Support different salinity in planner Depth is often mentioned in a length unit, but what we care about is pressure. When diving in fresh water the pressure is lower than the same depth in salt water. This adds support for using different salinities in planning. Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-12 22:33:40 +00:00
displayed_dive.salinity = diveplan->salinity;
Clear out old events in create_dive_from_plan Previous code where accumulating events from each iteration of the planning. This code clears the old ones before adding new ones. Fixes #595 [Dirk Hohndel: removed printf, updated comment, slightly moved the code, added parenthesis to silence warning] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 06:50:59 +00:00
// reset the cylinders and clear out the samples and events of the
// displayed dive so we can restart
Planner: don't set cylinder start and end pressure when adding dive Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:40:02 +00:00
reset_cylinders(&displayed_dive, track_gas);
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
dc = &displayed_dive.dc;
Planner: fix start time handling We setup the startTime for the dive plan in too many places... but never actually copied it into the planned dive. Fixes #640 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-24 16:03:56 +00:00
dc->when = displayed_dive.when = diveplan->when;
UI restructure: use displayed_dive for add dive and plan dive This gets rid of the stagingDive and stops the constant adding and removing of dives from the divelist (that was an INSANE design, seriously). When adding or planning a dive all work is now done in the dedicated displayed_dive. Add dive mostly works - when the user clicks save the dive is added to the dive list and selected. Plan dive is mostly untested. It passed trivial "start planner, save" testing so it's not entirely broken, but I'm sure there's more work to be done there. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 21:45:01 +00:00
free(dc->sample);
dc->sample = NULL;
dc->samples = 0;
dc->alloc_samples = 0;
Clear out old events in create_dive_from_plan Previous code where accumulating events from each iteration of the planning. This code clears the old ones before adding new ones. Fixes #595 [Dirk Hohndel: removed printf, updated comment, slightly moved the code, added parenthesis to silence warning] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 06:50:59 +00:00
while ((ev = dc->events)) {
dc->events = dc->events->next;
free(ev);
}
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
dp = diveplan->dp;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
cyl = &displayed_dive.cylinder[0];
Switch verify_gas_exists to take gasmix argument Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:27:19 +00:00
oldgasmix = cyl->gasmix;
Make dive planner more useful for closed circuit diving Add a sample at time 0 to allow for a pO2 from the start of the dive. Remember the last pO2 so it doesn't have to be repeated (and the right thing happens for the planned part of the dive). This still doesn't allow us to change the setpoint at a certain depth (which would be analogous to being able to switch to a certain gas at a certain depth in OC plans), but with this commit it's already usable. This commit also fixes a couple of small bugs in commit b8ee3de870fa ("Dive planning for closed circuit rebreather") where a pO2 of 1.1 was hardcoded in one place, throwing off all plan calculations and integer math was used to calculate a floating point value (leading to most pO2 values actually used being 1.0). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 03:54:05 +00:00
sample = prepare_sample(dc);
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
sample->setpoint.mbar = dp->setpoint;
Save predefined SAC When planning a dive, the gas consumption is based on a user configured SAC. Thus we should use that SAC and not try to recompute it from samples. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-16 12:49:12 +00:00
sample->sac.mliter = prefs.bottomsac;
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
oldpo2 = dp->setpoint;
Planner: don't track cylinder pressure if working pressure is 0 The pressure graph will go from 0 to negative - one could make a weak argument that this would at least tell you how much pressure you'd need in the cylinder to start with, but that's kinda lame. Fixes #615 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 06:04:30 +00:00
if (track_gas && cyl->type.workingpressure.mbar)
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
sample->cylinderpressure.mbar = cyl->end.mbar;
Mark manually entered waypoints as such With this information, when we re-plan a dive we can bring the user right back to the point where they ended - they have the waypoints in the dive pointes table and handles are shown on the right points in the profile - and the rest of the dive is once again calculated by the planning algorithm. For now this state is lost when saving the dive file as we don't add this flag in the sample to our saved files. So if we don't find any samples marked as manually added we add ALL of the samples as way points on the diveplan and the user has to manually remove the ones that were calculated. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-20 02:07:43 +00:00
sample->manually_entered = true;
Make dive planner more useful for closed circuit diving Add a sample at time 0 to allow for a pO2 from the start of the dive. Remember the last pO2 so it doesn't have to be repeated (and the right thing happens for the planned part of the dive). This still doesn't allow us to change the setpoint at a certain depth (which would be analogous to being able to switch to a certain gas at a certain depth in OC plans), but with this commit it's already usable. This commit also fixes a couple of small bugs in commit b8ee3de870fa ("Dive planning for closed circuit rebreather") where a pO2 of 1.1 was hardcoded in one place, throwing off all plan calculations and integer math was used to calculate a floating point value (leading to most pO2 values actually used being 1.0). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 03:54:05 +00:00
finish_sample(dc);
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
while (dp) {
Switch verify_gas_exists to take gasmix argument Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:27:19 +00:00
struct gasmix gasmix = dp->gasmix;
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
int po2 = dp->setpoint;
if (dp->setpoint)
type = CCR;
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
int time = dp->time;
int depth = dp->depth;
Allow special entries in diveplan for available gases An entry with no time is considered special and not considered when constructing the profile. This should allow us to add support for two different ways of adding information about available gas: changedepth 0 gasmix 0 0 gasmix @ po2 The first syntax basically says "during the ascent, switch to this gas at this depth. The second one says "switch to this gas once the pO2 allows for it" Neither of these are implemented, yet, but this commit is necessary in order for the rest of the code to ignore entries with a time field of 0. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 23:03:37 +00:00
if (time == 0) {
/* special entries that just inform the algorithm about
* additional gases that are available */
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
if (verify_gas_exists(gasmix) < 0)
Separate Gtk related code from core logic: planner Relatively straight forward, just a handful of places where we call show_error() (a UI function) from the logic code. In the process I noticed a few places where error returns weren't dealt with correctly. Added a new planner.h files for the necessary declarations. This should make no difference to functionality. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-08 03:20:25 +00:00
goto gas_error_exit;
Allow special entries in diveplan for available gases An entry with no time is considered special and not considered when constructing the profile. This should allow us to add support for two different ways of adding information about available gas: changedepth 0 gasmix 0 0 gasmix @ po2 The first syntax basically says "during the ascent, switch to this gas at this depth. The second one says "switch to this gas once the pO2 allows for it" Neither of these are implemented, yet, but this commit is necessary in order for the rest of the code to ignore entries with a time field of 0. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 23:03:37 +00:00
dp = dp->next;
continue;
}
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
Fixing SP handling in planner, adding event Fixing the SP change event and introducing a bailout scenario. I decided not to use a event showing SP=0.0 nor using a gaschange event as is in fact there is no gas change related to bailing out itself. If there is also a gaschange for the event it will be displayed anyway. Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-02 17:40:29 +00:00
/* Check for SetPoint change */
Fixing SP handling in planner, adding event Fixes bug in planner which prevents from bailing out (setpoint = 0). Also introduces events for changing setpoints in planner. It also makes the eventtype for gaschange slightly more consistent by changing it from SAMPLE_EVENT_GASCHANGE (O2 only) to SAMPLE_EVENT_GASCHANGE2 (O2/He). But Subsurface treats them both the same (the distinction comes from libdivecomputer). Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-02 17:03:26 +00:00
if (oldpo2 != po2) {
Add explicit setpoint change at t=0 when planning CCR dives As we now have the logic that there is always an explicit setpoint at t=0sec for CCR dives, also the planner should honor that. This fixes a bug that when planning a CCR dive we later add a setpoint change this influenced the ceiling _before_ the setpoint change. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-08 19:28:45 +00:00
/* this is a bad idea - we should get a different SAMPLE_EVENT type
* reserved for this in libdivecomputer... overloading SMAPLE_EVENT_PO2
* with a different meaning will only cause confusion elsewhere in the code */
add_event(dc, lasttime, SAMPLE_EVENT_PO2, 0, po2, "SP change");
Fixing SP handling in planner, adding event Fixes bug in planner which prevents from bailing out (setpoint = 0). Also introduces events for changing setpoints in planner. It also makes the eventtype for gaschange slightly more consistent by changing it from SAMPLE_EVENT_GASCHANGE (O2 only) to SAMPLE_EVENT_GASCHANGE2 (O2/He). But Subsurface treats them both the same (the distinction comes from libdivecomputer). Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-02-02 17:03:26 +00:00
oldpo2 = po2;
}
Switch verify_gas_exists to take gasmix argument Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:27:19 +00:00
/* Make sure we have the new gas, and create a gas change event */
if (gasmix_distance(&gasmix, &oldgasmix) > 0) {
Use add_gas_switch_event in instead of duplicate There is a add_gas_switch_event, so don't duplicate the code. Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-20 19:09:52 +00:00
int idx;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
if ((idx = verify_gas_exists(gasmix)) < 0)
Separate Gtk related code from core logic: planner Relatively straight forward, just a handful of places where we call show_error() (a UI function) from the logic code. In the process I noticed a few places where error returns weren't dealt with correctly. Added a new planner.h files for the necessary declarations. This should make no difference to functionality. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-08 03:20:25 +00:00
goto gas_error_exit;
Planner: correctly track gas used This part of the algorithm was off as part of it (but not all of it - crazy, I know) assumed the old semantic for gas changes where the new gas was introduced at the end of the segment and not at the beginning. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 17:02:38 +00:00
/* need to insert a first sample for the new gas */
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
add_gas_switch_event(&displayed_dive, dc, lasttime + 1, idx);
cyl = &displayed_dive.cylinder[idx];
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
sample = prepare_sample(dc);
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
sample[-1].setpoint.mbar = po2;
Planner: correctly track gas used This part of the algorithm was off as part of it (but not all of it - crazy, I know) assumed the old semantic for gas changes where the new gas was introduced at the end of the segment and not at the beginning. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 17:02:38 +00:00
sample->time.seconds = lasttime + 1;
sample->depth.mm = lastdepth;
Mark manually entered waypoints as such With this information, when we re-plan a dive we can bring the user right back to the point where they ended - they have the waypoints in the dive pointes table and handles are shown on the right points in the profile - and the rest of the dive is once again calculated by the planning algorithm. For now this state is lost when saving the dive file as we don't add this flag in the sample to our saved files. So if we don't find any samples marked as manually added we add ALL of the samples as way points on the diveplan and the user has to manually remove the ones that were calculated. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-20 02:07:43 +00:00
sample->manually_entered = dp->entered;
Save predefined SAC When planning a dive, the gas consumption is based on a user configured SAC. Thus we should use that SAC and not try to recompute it from samples. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-16 12:49:12 +00:00
sample->sac.mliter = dp->entered ? prefs.bottomsac : prefs.decosac;
Planner: don't track cylinder pressure if working pressure is 0 The pressure graph will go from 0 to negative - one could make a weak argument that this would at least tell you how much pressure you'd need in the cylinder to start with, but that's kinda lame. Fixes #615 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 06:04:30 +00:00
if (track_gas && cyl->type.workingpressure.mbar)
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
sample->cylinderpressure.mbar = cyl->sample_end.mbar;
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
finish_sample(dc);
Switch verify_gas_exists to take gasmix argument Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:27:19 +00:00
oldgasmix = gasmix;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
/* Create sample */
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
sample = prepare_sample(dc);
Make dive planner more useful for closed circuit diving Add a sample at time 0 to allow for a pO2 from the start of the dive. Remember the last pO2 so it doesn't have to be repeated (and the right thing happens for the planned part of the dive). This still doesn't allow us to change the setpoint at a certain depth (which would be analogous to being able to switch to a certain gas at a certain depth in OC plans), but with this commit it's already usable. This commit also fixes a couple of small bugs in commit b8ee3de870fa ("Dive planning for closed circuit rebreather") where a pO2 of 1.1 was hardcoded in one place, throwing off all plan calculations and integer math was used to calculate a floating point value (leading to most pO2 values actually used being 1.0). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 03:54:05 +00:00
/* set po2 at beginning of this segment */
/* and keep it valid for last sample - where it likely doesn't matter */
Assign setpoint to correct sample in planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-25 13:27:09 +00:00
sample[-1].setpoint.mbar = po2;
Set sample setpoint correctly Forward the sample set-point setting as otherwise all ascents are planned on OC. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-12-12 13:51:25 +00:00
sample->setpoint.mbar = po2;
Planner: correctly track gas used This part of the algorithm was off as part of it (but not all of it - crazy, I know) assumed the old semantic for gas changes where the new gas was introduced at the end of the segment and not at the beginning. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 17:02:38 +00:00
sample->time.seconds = lasttime = time;
sample->depth.mm = lastdepth = depth;
Mark manually entered waypoints as such With this information, when we re-plan a dive we can bring the user right back to the point where they ended - they have the waypoints in the dive pointes table and handles are shown on the right points in the profile - and the rest of the dive is once again calculated by the planning algorithm. For now this state is lost when saving the dive file as we don't add this flag in the sample to our saved files. So if we don't find any samples marked as manually added we add ALL of the samples as way points on the diveplan and the user has to manually remove the ones that were calculated. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-20 02:07:43 +00:00
sample->manually_entered = dp->entered;
Save predefined SAC When planning a dive, the gas consumption is based on a user configured SAC. Thus we should use that SAC and not try to recompute it from samples. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-16 12:49:12 +00:00
sample->sac.mliter = dp->entered ? prefs.bottomsac : prefs.decosac;
Assign setpoint to correct sample in planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-25 13:27:09 +00:00
if (track_gas && !sample[-1].setpoint.mbar) { /* Don't track gas usage for CCR legs of dive */
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
update_cylinder_pressure(&displayed_dive, sample[-1].depth.mm, depth, time - sample[-1].time.seconds,
dp->entered ? diveplan->bottomsac : diveplan->decosac, cyl, !dp->entered);
Planner: don't track cylinder pressure if working pressure is 0 The pressure graph will go from 0 to negative - one could make a weak argument that this would at least tell you how much pressure you'd need in the cylinder to start with, but that's kinda lame. Fixes #615 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 06:04:30 +00:00
if (cyl->type.workingpressure.mbar)
sample->cylinderpressure.mbar = cyl->end.mbar;
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
}
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
finish_sample(dc);
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
dp = dp->next;
}
Refactor dctype -> divemode ... and repair a failed rebase (sorry). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-10 23:01:15 +00:00
dc->divemode = type;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#if DEBUG_PLAN & 32
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
save_dive(stdout, &displayed_dive);
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#endif
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
return;
Separate Gtk related code from core logic: planner Relatively straight forward, just a handful of places where we call show_error() (a UI function) from the logic code. In the process I noticed a few places where error returns weren't dealt with correctly. Added a new planner.h files for the necessary declarations. This should make no difference to functionality. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-08 03:20:25 +00:00
gas_error_exit:
Convert other users of showError() to the new world order The "report_error()" interface is a lot simpler, although some of the C++ code uses QStrings which make them a bit annoying, especially for the varargs model. Still, even with the explicit conversion to UTF8 and "char *", the report_error() model is much nicer. This also just makes refreshDisplay() do the error reporting in the UI automatically, so a number of error paths don't even have to worry. And the multi-line model of error reporting means that it all automatically does the right thing, and reports errors for each file rather than just for the last file that failed to open. So this removes closer to a hundred lines of cruft, while being a simpler interface and doing better error reporting. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-14 18:26:07 +00:00
report_error(translate("gettextFromC", "Too many gas mixes"));
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
return;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
Planner: correctly free divedatapoints Simply setting the pointer to NULL leaks memory. And that C++ recursive two function implementation... oh boy. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-19 16:41:09 +00:00
void free_dps(struct diveplan *diveplan)
Display dive profile of the dive we plan, as we plan it As the user enters data into the entry fields, that data is validated and as soon as there is enough data we start constructing a dive profile, including the final ascent to the surface, including required deco stops, etc. This commit still has some serious issues. - when data is input that doesn't validate, we just print a warning to stdout - instead we need to change the backgroundcolor of the input field or something. - when we switch to the last dive in order to show the profile we don't actually search for the last dive - we just show the first one in the tree. This works for the default sort order but is of course wrong otherwise I'm sure there are many other bugs, but I want to push it out where it is right now for others to be able to take a look. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 06:09:12 +00:00
{
Planner: correctly free divedatapoints Simply setting the pointer to NULL leaks memory. And that C++ recursive two function implementation... oh boy. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-19 16:41:09 +00:00
if (!diveplan)
return;
struct divedatapoint *dp = diveplan->dp;
Display dive profile of the dive we plan, as we plan it As the user enters data into the entry fields, that data is validated and as soon as there is enough data we start constructing a dive profile, including the final ascent to the surface, including required deco stops, etc. This commit still has some serious issues. - when data is input that doesn't validate, we just print a warning to stdout - instead we need to change the backgroundcolor of the input field or something. - when we switch to the last dive in order to show the profile we don't actually search for the last dive - we just show the first one in the tree. This works for the default sort order but is of course wrong otherwise I'm sure there are many other bugs, but I want to push it out where it is right now for others to be able to take a look. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 06:09:12 +00:00
while (dp) {
struct divedatapoint *ndp = dp->next;
free(dp);
dp = ndp;
}
Planner: correctly free divedatapoints Simply setting the pointer to NULL leaks memory. And that C++ recursive two function implementation... oh boy. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-19 16:41:09 +00:00
diveplan->dp = NULL;
Display dive profile of the dive we plan, as we plan it As the user enters data into the entry fields, that data is validated and as soon as there is enough data we start constructing a dive profile, including the final ascent to the surface, including required deco stops, etc. This commit still has some serious issues. - when data is input that doesn't validate, we just print a warning to stdout - instead we need to change the backgroundcolor of the input field or something. - when we switch to the last dive in order to show the profile we don't actually search for the last dive - we just show the first one in the tree. This works for the default sort order but is of course wrong otherwise I'm sure there are many other bugs, but I want to push it out where it is right now for others to be able to take a look. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 06:09:12 +00:00
}
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
struct divedatapoint *create_dp(int time_incr, int depth, struct gasmix gasmix, int po2)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
struct divedatapoint *dp;
dp = malloc(sizeof(struct divedatapoint));
dp->time = time_incr;
dp->depth = depth;
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
dp->gasmix = gasmix;
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
dp->setpoint = po2;
Convert the C code to using stdbool and true/false Earlier we converted the C++ code to using true/false, and this converts the C code to using the same style. We already depended on stdbool.h in subsurfacestartup.[ch], and we build with -std=gnu99 so nobody could build subsurface without a c99 compiler. [Dirk Hohndel: small change suggested by Thiago Macieira: don't include stdbool.h for C++] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-01-15 18:54:41 +00:00
dp->entered = false;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
dp->next = NULL;
return dp;
}
void add_to_end_of_diveplan(struct diveplan *diveplan, struct divedatapoint *dp)
{
struct divedatapoint **lastdp = &diveplan->dp;
struct divedatapoint *ldp = *lastdp;
Allow special entries in diveplan for available gases An entry with no time is considered special and not considered when constructing the profile. This should allow us to add support for two different ways of adding information about available gas: changedepth 0 gasmix 0 0 gasmix @ po2 The first syntax basically says "during the ascent, switch to this gas at this depth. The second one says "switch to this gas once the pO2 allows for it" Neither of these are implemented, yet, but this commit is necessary in order for the rest of the code to ignore entries with a time field of 0. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 23:03:37 +00:00
int lasttime = 0;
Massive cleanup Mostly coding style and whitespace changes plus making lots of functions static that have no need to be extern. This also helped find a bit of code that is actually no longer used. This should have absolutely no functional impact - all changes should be purely cosmetic. But it removes a bunch of lines of code and makes the rest easier to read. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-29 21:10:46 +00:00
while (*lastdp) {
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
ldp = *lastdp;
Allow special entries in diveplan for available gases An entry with no time is considered special and not considered when constructing the profile. This should allow us to add support for two different ways of adding information about available gas: changedepth 0 gasmix 0 0 gasmix @ po2 The first syntax basically says "during the ascent, switch to this gas at this depth. The second one says "switch to this gas once the pO2 allows for it" Neither of these are implemented, yet, but this commit is necessary in order for the rest of the code to ignore entries with a time field of 0. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 23:03:37 +00:00
if (ldp->time > lasttime)
lasttime = ldp->time;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
lastdp = &(*lastdp)->next;
}
*lastdp = dp;
Make planner work again This partially reverts changes in commit 1b655d5c806b ("Correctly track gases when manually adding and then editing dives") as it turns out this did NOT help us correctly track gases (which is ironic, given the title of that commit). I didn't actually want to revert that commit as infrastructure has changed since then and this made the patches look even more incomprehensible. So we are back to tracking the "gas on which we arrive at this spot" in each dive plan node as this makes the rest of our planning so much easier - I had forgotten about the reasons why we did things this way when I made the above mentioned commit. Instead we now make sure that our available tanks are added the correct way, that such entries are ignored when planning and when drawing the editable profile, and that at the end it all gets assembled correctly. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-12 02:19:04 +00:00
if (ldp && dp->time != 0)
Allow special entries in diveplan for available gases An entry with no time is considered special and not considered when constructing the profile. This should allow us to add support for two different ways of adding information about available gas: changedepth 0 gasmix 0 0 gasmix @ po2 The first syntax basically says "during the ascent, switch to this gas at this depth. The second one says "switch to this gas once the pO2 allows for it" Neither of these are implemented, yet, but this commit is necessary in order for the rest of the code to ignore entries with a time field of 0. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 23:03:37 +00:00
dp->time += lasttime;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
struct divedatapoint *plan_add_segment(struct diveplan *diveplan, int duration, int depth, struct gasmix gasmix, int po2, bool entered)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
struct divedatapoint *dp = create_dp(duration, depth, gasmix, po2);
Distinguish between entered and calculated waypoints Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-12 15:49:42 +00:00
dp->entered = entered;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
add_to_end_of_diveplan(diveplan, dp);
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
return (dp);
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
struct gaschanges {
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int depth;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
int gasidx;
};
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
static struct gaschanges *analyze_gaslist(struct diveplan *diveplan, int *gaschangenr, int depth, int *asc_cylinder)
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
{
Use proper types This is step one of many to use gasmix instead of int o2/he. Right now some of these changes look ridiculous because after changing a few lines we immediately go back to o2 = get_o2(gas). The reason is that I wanted to convert a hand full of functions at a time. So in this commit I only change validate_gas(), get_gas_from_events() and get_gasidx() to use a struct gasmix instead of int o2, int he. This state builds and survived some mild testing. Let's continue on top of that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 21:17:06 +00:00
struct gasmix gas;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
int nr = 0;
struct gaschanges *gaschanges = NULL;
struct divedatapoint *dp = diveplan->dp;
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int best_depth = displayed_dive.cylinder[*asc_cylinder].depth.mm;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
while (dp) {
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
if (dp->time == 0) {
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
gas = dp->gasmix;
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
if (dp->depth <= depth) {
int i = 0;
nr++;
gaschanges = realloc(gaschanges, nr * sizeof(struct gaschanges));
while (i < nr - 1) {
if (dp->depth < gaschanges[i].depth) {
memmove(gaschanges + i + 1, gaschanges + i, (nr - i - 1) * sizeof(struct gaschanges));
break;
}
i++;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
}
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
gaschanges[i].depth = dp->depth;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
gaschanges[i].gasidx = get_gasidx(&displayed_dive, &gas);
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
assert(gaschanges[i].gasidx != -1);
} else {
/* is there a better mix to start deco? */
if (dp->depth < best_depth) {
best_depth = dp->depth;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
*asc_cylinder = get_gasidx(&displayed_dive, &gas);
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
}
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
}
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
}
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
dp = dp->next;
}
*gaschangenr = nr;
#if DEBUG_PLAN & 16
Create simple non-thread-safe "gasname()" function Every single user of the get_gas_name() function wanted to just use the result to create a message or printout, and that made the interface a bit cumbersome. This adds a "gasname()" wrapper that returns a static buffer with the result in it, which is neither pretty nor thread-safe, but is a much simpler interface to work with. Our dive planning isn't multi-threaded, so nothing should care. [ This also converts a few open-coded gasname debug printouts to use the helper function, resulting in prettier printouts and less code ] Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 01:25:44 +00:00
for (nr = 0; nr < *gaschangenr; nr++) {
int idx = gaschanges[nr].gasidx;
printf("gaschange nr %d: @ %5.2lfm gasidx %d (%s)\n", nr, gaschanges[nr].depth / 1000.0,
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
idx, gasname(&displayed_dive.cylinder[idx].gasmix));
Create simple non-thread-safe "gasname()" function Every single user of the get_gas_name() function wanted to just use the result to create a message or printout, and that made the interface a bit cumbersome. This adds a "gasname()" wrapper that returns a static buffer with the result in it, which is neither pretty nor thread-safe, but is a much simpler interface to work with. Our dive planning isn't multi-threaded, so nothing should care. [ This also converts a few open-coded gasname debug printouts to use the helper function, resulting in prettier printouts and less code ] Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 01:25:44 +00:00
}
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#endif
return gaschanges;
}
/* sort all the stops into one ordered list */
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
static int *sort_stops(int *dstops, int dnr, struct gaschanges *gstops, int gnr)
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
{
int i, gi, di;
int total = dnr + gnr;
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
int *stoplevels = malloc(total * sizeof(int));
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
/* no gaschanges */
if (gnr == 0) {
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
memcpy(stoplevels, dstops, dnr * sizeof(int));
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
return stoplevels;
}
i = total - 1;
gi = gnr - 1;
di = dnr - 1;
while (i >= 0) {
if (dstops[di] > gstops[gi].depth) {
stoplevels[i] = dstops[di];
di--;
} else if (dstops[di] == gstops[gi].depth) {
stoplevels[i] = dstops[di];
di--;
gi--;
} else {
stoplevels[i] = gstops[gi].depth;
gi--;
}
i--;
if (di < 0) {
while (gi >= 0)
stoplevels[i--] = gstops[gi--].depth;
break;
}
if (gi < 0) {
while (di >= 0)
stoplevels[i--] = dstops[di--];
break;
}
}
while (i >= 0)
stoplevels[i--] = 0;
#if DEBUG_PLAN & 16
int k;
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
for (k = gnr + dnr - 1; k >= 0; k--) {
printf("stoplevel[%d]: %5.2lfm\n", k, stoplevels[k] / 1000.0);
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
if (stoplevels[k] == 0)
break;
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
}
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#endif
return stoplevels;
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
}
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
static void add_plan_to_notes(struct diveplan *diveplan, struct dive *dive, bool show_disclaimer, int error)
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
{
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
const unsigned int sz_buffer = 2000000;
const unsigned int sz_temp = 100000;
char *buffer = (char *)malloc(sz_buffer);
char *temp = (char *)malloc(sz_temp);
Planner: add segment symbol to output table Add a symbol to each line of output table indicating whether a segment is an ascent, descent, constant depth (user entered) or deco stop Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2016-03-19 02:21:35 +00:00
char *deco, *segmentsymbol;
planner.c: fix 'disclaimer' pointing to stack memory In add_plan_to_notes() the 'disclaimer' is set to the temporary buffer 'buf'. By making 'buf' static, 'disclaimer' now points to a persistent buffer. Bug was reported as bad characters when printing the planner deco text. Reported-by: Stefan Fuchs <sfuchs@gmx.de> Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-11-15 17:27:57 +00:00
static char buf[1000];
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int len, lastdepth = 0, lasttime = 0, lastsetpoint = -1, newdepth = 0, lastprintdepth = 0, lastprintsetpoint = -1;
planner.c: fix missing brances warning for a 'struct gasmix' initialization, the 'permille' value from franction_t should have it's own braces. Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-23 14:38:43 +00:00
struct gasmix lastprintgasmix = {{ -1 }, { -1 }};
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
struct divedatapoint *dp = diveplan->dp;
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
bool gaschange_after = !plan_verbatim;
bool gaschange_before;
Avoid possible uninitialized memory read This looks like possibly a false positive in the Coverity scan, but we can always assume that the first point of the dive plan has been entered by the user. Coverity CID 1325285 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-02 00:45:51 +00:00
bool lastentered = true;
Deal with some uninitialized variable warnings Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-11 16:37:12 +00:00
struct divedatapoint *nextdp = NULL;
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
Read planner preferences when we use them Read and use the last_stop preference in the plan function. Read the plan notes preferences and set variables (plan_verbatim, plan_display_runtime, plan_display_duration, and plan_display_transitions) in the add_plan_to_notes function. Don't read the preferences and set variables otherwise. Both plan and add_plan_to_notes functions are called on data change. Previous behaviour was: - Set variables on declaration - Reset variables in plan function (even variables that only relate to planner notes output) - Changing a preference triggered set_xxx function which sets variable, then plan function, which sets variable again. Apart from being inefficient, the previous behaviour made it difficult to track down where and when variables were set. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 12:14:10 +00:00
plan_verbatim = prefs.verbatim_plan;
plan_display_runtime = prefs.display_runtime;
plan_display_duration = prefs.display_duration;
plan_display_transitions = prefs.display_transitions;
Planner: update disclamer Update the disclamer text to reflect which algorithm where used. [Dirk Hohndel: cleaned up coding style & replaced snprintf with strncat] Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-08 04:58:06 +00:00
if (prefs.deco_mode == VPMB) {
deco = "VPM-B";
} else {
deco = "BUHLMANN";
}
snprintf(buf, sizeof(buf), translate("gettextFromC", "DISCLAIMER / WARNING: THIS IS A NEW IMPLEMENTATION OF THE %s "
Typos This fixes two typos found by lintian. I guess a bunch of translations will need to be updated or something, I am not sure how they work so I didn't touch them. I presume in the worst case they will need to be re-translated at the next iteration -- Salvo Tomaselli "Io non mi sento obbligato a credere che lo stesso Dio che ci ha dotato di senso, ragione ed intelletto intendesse che noi ne facessimo a meno." -- Galileo Galilei http://ltworf.github.io/ltworf/ From a0e5f48349557fcccd82ba8c7555043de140835c Mon Sep 17 00:00:00 2001 From: Salvo 'LtWorf' Tomaselli <tiposchi@tiscali.it> Signed-off-by: Salvo 'LtWorf' Tomaselli <tiposchi@tiscali.it> Date: Fri, 12 Sep 2014 18:25:20 +0200 Subject: [PATCH] Fix typos reported by lintian Fixes two typos reported by lintian. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-09-12 16:29:56 +00:00
"ALGORITHM AND A DIVE PLANNER IMPLEMENTATION BASED ON THAT WHICH HAS "
Disclaimer included in the printed diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 21:34:09 +00:00
"RECEIVED ONLY A LIMITED AMOUNT OF TESTING. WE STRONGLY RECOMMEND NOT TO "
Planner: update disclamer Update the disclamer text to reflect which algorithm where used. [Dirk Hohndel: cleaned up coding style & replaced snprintf with strncat] Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-08 04:58:06 +00:00
"PLAN DIVES SIMPLY BASED ON THE RESULTS GIVEN HERE."), deco);
disclaimer = buf;
Disclaimer included in the printed diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 21:34:09 +00:00
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
if (!dp) {
free((void *)buffer);
free((void *)temp);
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
return;
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
}
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
if (error) {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, "%s",
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
translate("gettextFromC", "Decompression calculation aborted due to excessive time"));
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(buffer, sz_buffer, "<span style='color: red;'>%s </span> %s<br>",
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
translate("gettextFromC", "Warning:"), temp);
dive->notes = strdup(buffer);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
free((void *)buffer);
free((void *)temp);
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
return;
}
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len = show_disclaimer ? snprintf(buffer, sz_buffer, "<div><b>%s<b></div><br>", disclaimer) : 0;
Planner: update disclamer Update the disclamer text to reflect which algorithm where used. [Dirk Hohndel: cleaned up coding style & replaced snprintf with strncat] Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-08 04:58:06 +00:00
if (prefs.deco_mode == BUEHLMANN){
Use Bühlmann in all strings shown to the user Unify spelling of this name in strings shown to the user, as commented in mailing list. Internal coding use untouched. Signed-off-by: Salvador Cuñat <salvador.cunat@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-16 19:43:49 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "based on Bühlmann ZHL-16B with GFlow = %d and GFhigh = %d"),
Planner: update disclamer Update the disclamer text to reflect which algorithm where used. [Dirk Hohndel: cleaned up coding style & replaced snprintf with strncat] Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-08 04:58:06 +00:00
diveplan->gflow, diveplan->gfhigh);
} else if (prefs.deco_mode == VPMB){
Planner notes: Show VPM-B conservatism Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-02 11:54:13 +00:00
if (prefs.conservatism_level == 0)
snprintf(temp, sz_temp, "%s", translate("gettextFromC", "based on VPM-B at nominal conservatism"));
else
snprintf(temp, sz_temp, translate("gettextFromC", "based on VPM-B at +%d conservatism"), prefs.conservatism_level);
Planner: correct output of planner mode Previously we used strncat to output VPM mode without correctly defining the length of the string, and didn't do anything for recreational mode. This resulted in the output being junk recycled from the previous temp string. We could use strncat if the string length were defined, but using snprintf will make it simpler to include the VPM conservatism when that has been implemented. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-23 13:36:11 +00:00
} else if (prefs.deco_mode == RECREATIONAL){
Use Bühlmann in all strings shown to the user Unify spelling of this name in strings shown to the user, as commented in mailing list. Internal coding use untouched. Signed-off-by: Salvador Cuñat <salvador.cunat@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-16 19:43:49 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "recreational mode based on Bühlmann ZHL-16B with GFlow = %d and GFhigh = %d"),
Planner: correct output of planner mode Previously we used strncat to output VPM mode without correctly defining the length of the string, and didn't do anything for recreational mode. This resulted in the output being junk recycled from the previous temp string. We could use strncat if the string length were defined, but using snprintf will make it simpler to include the VPM conservatism when that has been implemented. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-23 13:36:11 +00:00
diveplan->gflow, diveplan->gfhigh);
Planner: update disclamer Update the disclamer text to reflect which algorithm where used. [Dirk Hohndel: cleaned up coding style & replaced snprintf with strncat] Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-08 04:58:06 +00:00
}
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<div><b>%s</b><br>%s</div><br>",
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
translate("gettextFromC", "Subsurface dive plan"), temp);
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
if (!plan_verbatim) {
Planner: add segment symbol to output table Add a symbol to each line of output table indicating whether a segment is an ascent, descent, constant depth (user entered) or deco stop Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2016-03-19 02:21:35 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<div><table><thead><tr><th></th><th>%s</th>",
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
translate("gettextFromC", "depth"));
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
if (plan_display_duration)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<th style='padding-left: 10px;'>%s</th>",
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
translate("gettextFromC", "duration"));
Show duration before runtime on planner notes table Switch the column order of the planner notes table so that duration is displayed before runtime. This is consistent with: - the verbatim output order, e.g. "Stay at 12.0 m for 3:00 min - runtime 32:48 on EAN50" - MultiDeco, e.g. http://www.hhssoftware.com/multideco/view_multideco.html - Planner on the Shearwater Petrel - How I have been taught to write out my dive plan in my wetnotes Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-16 11:15:46 +00:00
if (plan_display_runtime)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<th style='padding-left: 10px;'>%s</th>",
Show duration before runtime on planner notes table Switch the column order of the planner notes table so that duration is displayed before runtime. This is consistent with: - the verbatim output order, e.g. "Stay at 12.0 m for 3:00 min - runtime 32:48 on EAN50" - MultiDeco, e.g. http://www.hhssoftware.com/multideco/view_multideco.html - Planner on the Shearwater Petrel - How I have been taught to write out my dive plan in my wetnotes Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-16 11:15:46 +00:00
translate("gettextFromC", "runtime"));
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len,
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
"<th style='padding-left: 10px; float: left;'>%s</th></tr></thead><tbody style='float: left;'>",
translate("gettextFromC", "gas"));
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
}
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
do {
get_gas_at_time needs to always give us a valid gas Before this function was changed it was really supposed to just change a gas that was passed in in case there was an event that changed the mix - but with the new name the caller will assume that they get a valid gasmix. And promptly we had one caller that didn't initialize gas to be based on the first cylinder before calling get_gas_at_time(). Instead of adding yet one more spot that knows about the oddity of the old API I simply changed get_gas_at_time() to do what it name appears to imply and fixed the other callers not to bother to initialize the gasmix. Fixes #647 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-19 01:37:28 +00:00
struct gasmix gasmix, newgasmix = {};
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
const char *depth_unit;
double depthvalue;
int decimals;
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
bool isascent = (dp->depth < lastdepth);
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
nextdp = dp->next;
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
if (dp->time == 0)
continue;
Switch more functions to use gasmix type This time it's get_gas_string(). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:10:07 +00:00
gasmix = dp->gasmix;
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
depthvalue = get_depth_units(dp->depth, &decimals, &depth_unit);
Planner: more fixes for gas tracking Gas switches are now for the current segment, not for the next. We can only track gas for cylinders for which we have size / working pressure information. Print a warning for others. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 14:55:07 +00:00
/* analyze the dive points ahead */
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
while (nextdp && nextdp->time == 0)
nextdp = nextdp->next;
Remove gasmix_is_null The semantic of fo2==fhe==0 to mean "same gasmix as before" apparently is not used anywhere and gets in the way of the semantic "this is air". If there is really need for mix meaning "same as before", please use another value, e.g. one with a specific negative percentage. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-05 11:37:49 +00:00
if (nextdp)
Switch more functions to use gasmix type This time it's get_gas_string(). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 23:10:07 +00:00
newgasmix = nextdp->gasmix;
Define gaschange_before and gaschange_after a few lines earlier This is required so they work in the test for /* do we want to skip this leg as it is devoid of anything useful? */ We were already trying to use gaschange_after (and previously gaschange), but it was duplicating an existing condition (now removed). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-23 13:20:30 +00:00
gaschange_after = (nextdp && (gasmix_distance(&gasmix, &newgasmix) || dp->setpoint != nextdp->setpoint));
gaschange_before = (gasmix_distance(&lastprintgasmix, &gasmix) || lastprintsetpoint != dp->setpoint);
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
/* do we want to skip this leg as it is devoid of anything useful? */
Change add_plan_to_notes() to operated on gasmix Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 00:34:40 +00:00
if (!dp->entered &&
nextdp &&
dp->depth != lastdepth &&
Define gaschange_before and gaschange_after a few lines earlier This is required so they work in the test for /* do we want to skip this leg as it is devoid of anything useful? */ We were already trying to use gaschange_after (and previously gaschange), but it was duplicating an existing condition (now removed). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-23 13:20:30 +00:00
nextdp->depth != dp->depth &&
!gaschange_before &&
!gaschange_after)
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
continue;
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
if (dp->time - lasttime < 10 && !(gaschange_after && dp->next && dp->depth != dp->next->depth))
Planner: Show waypoints for gas changes but no double depths Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 11:00:51 +00:00
continue;
Remove unnecessary get_gasidx call Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-10 20:11:45 +00:00
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
len = strlen(buffer);
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
if (plan_verbatim) {
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* When displaying a verbatim plan, we output a waypoint for every gas change.
* Therefore, we do not need to test for difficult cases that mean we need to
* print a segment just so we don't miss a gas change. This makes the logic
* to determine whether or not to print a segment much simpler than with the
* non-verbatim plan.
*/
In diveplan differentiate between last printed depth and last depth In the decision if a dive segment should lead to a line in the diveplan, we need to differentiate between the lastdepth (the depth of the last dp to tell if we are currently stopping) and the last depth that we printed a line for (needed for gaschange lines). Without this patch, no stops without gas changes were listed anymore in the diveplan. Like the last patch for the diveplan: I hope this time I got this logic right. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-12-05 14:13:05 +00:00
if (dp->depth != lastprintdepth) {
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
if (plan_display_transitions || dp->entered || !dp->next || (gaschange_after && dp->next && dp->depth != nextdp->depth)) {
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
if (dp->setpoint)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Transition to %.*f %s in %d:%02d min - runtime %d:%02u on %s (SP = %.1fbar)"),
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
decimals, depthvalue, depth_unit,
FRACTION(dp->time - lasttime, 60),
FRACTION(dp->time, 60),
gasname(&gasmix),
(double) dp->setpoint / 1000.0);
else
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Transition to %.*f %s in %d:%02d min - runtime %d:%02u on %s"),
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
decimals, depthvalue, depth_unit,
FRACTION(dp->time - lasttime, 60),
FRACTION(dp->time, 60),
gasname(&gasmix));
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
Planner: Change 'lasttime' only if we printed something in the plan. This makes the 'segment' durations equal the runtime differences even when we don't display transitions in deco. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 21:54:33 +00:00
}
Show stops in verbatim diveplan The position of one curly brace was wrong. Bummer. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-02-03 19:37:35 +00:00
newdepth = dp->depth;
lasttime = dp->time;
Optionally strip diveplan to bare minimum There are new check-boxes to modify the look of the diveplan in the notes. The old behaviour appears with "verbatim display", others are shorter, runtimes, stoplengths and transitions being optional. Also round to full meters and minutes to remove optical clutter. To be done: Remember these setting in the config. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 14:25:58 +00:00
} else {
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
if ((nextdp && dp->depth != nextdp->depth) || gaschange_after) {
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
if (dp->setpoint)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Stay at %.*f %s for %d:%02d min - runtime %d:%02u on %s (SP = %.1fbar)"),
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
decimals, depthvalue, depth_unit,
FRACTION(dp->time - lasttime, 60),
FRACTION(dp->time, 60),
gasname(&gasmix),
(double) dp->setpoint / 1000.0);
else
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Stay at %.*f %s for %d:%02d min - runtime %d:%02u on %s"),
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
decimals, depthvalue, depth_unit,
FRACTION(dp->time - lasttime, 60),
FRACTION(dp->time, 60),
gasname(&gasmix));
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
newdepth = dp->depth;
Planner: Avoid bogus segments with 0 time Don't show a stop if we continue at this depth. This resolves a problem when there are more than two waypoints during deco at the same depth. This can happen at 6m when there is a gaschange to O2 and the last stop depth is 6m (which turns the 3m stop into another 6m stop). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 22:15:11 +00:00
lasttime = dp->time;
}
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
}
} else {
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* When not displaying the verbatim dive plan, we typically ignore ascents between deco stops,
* unless the display transitions option has been selected. We output a segment if any of the
* following conditions are met.
* 1) Display transitions is selected
* 2) The segment was manually entered
* 3) It is the last segment of the dive
* 4) The segment is not an ascent, there was a gas change at the start of the segment and the next segment
* is a change in depth (typical deco stop)
* 5) There is a gas change at the end of the segment and the last segment was entered (first calculated
* segment if it ends in a gas change)
* 6) There is a gaschange after but no ascent. This should only occur when backgas breaks option is selected
* 7) It is an ascent ending with a gas change, but is not followed by a stop. As case 5 already matches
* the first calculated ascent if it ends with a gas change, this should only occur if a travel gas is
* used for a calculated ascent, there is a subsequent gas change before the first deco stop, and zero
* time has been allowed for a gas switch.
*/
Code cleanup Make precedence of && over || explicit. Explicitly convert between char * and unsigned char *. Don't assign potentially negative return code to an unsigend variable. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-06 20:59:14 +00:00
if (plan_display_transitions || dp->entered || !dp->next ||
(nextdp && dp->depth != nextdp->depth) ||
Planner: Hide unwanted transition between deco stops If display transitions in deco isn't selected, then we shouldn't show the transition segment between two deco stops, even if there is a gas change. We should still show the ascent segment up to the first deco stop. The (gaschange_after && !isascent) condition is necessary to pick up backgas breaks. An example plan is shown below. Previously: depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   <--meaningful ascent segment 21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 0min 51min   <--unnecessary ascent segment 6m 13min 64min oxygen 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min   depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   <--meaningful ascent segment 21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 13min 64min oxygen 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min   Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 07:45:47 +00:00
(!isascent && gaschange_before && nextdp && dp->depth != nextdp->depth) ||
Planner: Add parentheses to output condition Aids reading the code, doesn't alter the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 14:30:16 +00:00
(gaschange_after && lastentered) || (gaschange_after && !isascent) ||
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
(isascent && gaschange_after && nextdp && dp->depth != nextdp->depth )) {
Planner: add segment symbol to output table Add a symbol to each line of output table indicating whether a segment is an ascent, descent, constant depth (user entered) or deco stop Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2016-03-19 02:21:35 +00:00
// Print a symbol to indicate whether segment is an ascent, descent, constant depth (user entered) or deco stop
if (isascent)
segmentsymbol = "&#10138;"; // up-right arrow for ascent
else if (dp->depth > lastdepth)
segmentsymbol = "&#10136;"; // down-right arrow for descent
else if (dp->entered)
segmentsymbol = "&#10137;"; // right arrow for entered entered segment at constant depth
else
segmentsymbol = "&#10134;"; // heavey minus sign for deco stop
len += snprintf(buffer + len, sz_buffer - len, "<tr><td style='padding-left: 10px; float: right;'>%s</td>", segmentsymbol);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "%3.0f%s"), depthvalue, depth_unit);
Planner: add segment symbol to output table Add a symbol to each line of output table indicating whether a segment is an ascent, descent, constant depth (user entered) or deco stop Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2016-03-19 02:21:35 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
if (plan_display_duration) {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "%3dmin"), (dp->time - lasttime + 30) / 60);
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
Show duration before runtime on planner notes table Switch the column order of the planner notes table so that duration is displayed before runtime. This is consistent with: - the verbatim output order, e.g. "Stay at 12.0 m for 3:00 min - runtime 32:48 on EAN50" - MultiDeco, e.g. http://www.hhssoftware.com/multideco/view_multideco.html - Planner on the Shearwater Petrel - How I have been taught to write out my dive plan in my wetnotes Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-16 11:15:46 +00:00
}
if (plan_display_runtime) {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "%3dmin"), (dp->time + 30) / 60);
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
}
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* Normally a gas change is displayed on the stopping segment, so only display a gas change at the end of
* an ascent segment if it is not followed by a stop
*/
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
if (isascent && gaschange_after && dp->next && nextdp && dp->depth != nextdp->depth) {
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
if (dp->setpoint) {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "(SP = %.1fbar)"), (double) nextdp->setpoint / 1000.0);
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s %s</b></td>", gasname(&newgasmix),
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
temp);
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
} else {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s</b></td>", gasname(&newgasmix));
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
}
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
lastprintsetpoint = nextdp->setpoint;
lastprintgasmix = newgasmix;
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
gaschange_after = false;
} else if (gaschange_before) {
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
// If a new gas has been used for this segment, now is the time to show it
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
if (dp->setpoint) {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "(SP = %.1fbar)"), (double) dp->setpoint / 1000.0);
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s %s</b></td>", gasname(&gasmix),
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
temp);
} else {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s</b></td>", gasname(&gasmix));
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
}
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
// Set variables so subsequent iterations can test against the last gas printed
Planner notes - revise logic for gasmix output The logic for when to output a gasmix in the notes table is more complicated than it seems at first. - On a descent leg, the gas is the gas used for descent - At a stop (calculated or user defined), the gas is the gas used for that stop - But on an ascent leg (if displayed), the gas is the gas that is ABOUT TO BE USED - The gas should not be repeated if it's the same gas as used on the last row of the table - Ascent legs should only be displayed if the display transitions option is selected, OR if there is a gas change without a stop (the user can now set a minimum duration for a gaschange, but zero is still allowed). The existing code tries to track what gas is being used/switched to at each waypoint, and whether the gas should be printed or postponed to the next leg. It works sometimes but not always. This patch replaces the postponed gas logic with: - Is this an ascent leg? (determines whether the applicable gas is the preceding or following leg, and whether the leg should be displayed at all if the transitions option isn't selected) - Is it an ascent with a gaschange without a stop? - Has the gas actually changed from the last output? - Will the next leg be at the same level and same gas (in which case merge them)? Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 05:04:05 +00:00
lastprintsetpoint = dp->setpoint;
lastprintgasmix = gasmix;
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
gaschange_after = false;
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
} else {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<td>&nbsp;</td>");
Optionally strip diveplan to bare minimum There are new check-boxes to modify the look of the diveplan in the notes. The old behaviour appears with "verbatim display", others are shorter, runtimes, stoplengths and transitions being optional. Also round to full meters and minutes to remove optical clutter. To be done: Remember these setting in the config. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 14:25:58 +00:00
}
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "</tr>");
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
newdepth = dp->depth;
Planner: Change 'lasttime' only if we printed something in the plan. This makes the 'segment' durations equal the runtime differences even when we don't display transitions in deco. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 21:54:33 +00:00
lasttime = dp->time;
Optionally strip diveplan to bare minimum There are new check-boxes to modify the look of the diveplan in the notes. The old behaviour appears with "verbatim display", others are shorter, runtimes, stoplengths and transitions being optional. Also round to full meters and minutes to remove optical clutter. To be done: Remember these setting in the config. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 14:25:58 +00:00
}
}
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
if (gaschange_after) {
Planner: more fixes for gas tracking Gas switches are now for the current segment, not for the next. We can only track gas for cylinders for which we have size / working pressure information. Print a warning for others. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 14:55:07 +00:00
// gas switch at this waypoint
Planner note logic and layout improved Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-03 09:38:24 +00:00
if (plan_verbatim) {
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
if (lastsetpoint >= 0) {
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
if (nextdp && nextdp->setpoint)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Switch gas to %s (SP = %.1fbar)"), gasname(&newgasmix), (double) nextdp->setpoint / 1000.0);
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
else
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "Switch gas to %s"), gasname(&newgasmix));
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
}
Refactor to use gaschage_before and gaschange_after ... for better readability. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 21:07:43 +00:00
gaschange_after = false;
Change add_plan_to_notes() to operated on gasmix Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 00:34:40 +00:00
gasmix = newgasmix;
Print gas changes at the correct lines in diveplan This is a pain. We plan with segments but the plan shows waypoints. If after a constant depth segment the gaschange (or setpoint chenge for that matter) appears, the _next_ line should get the info about the new gas (i.e. change _after_ the constant depth segment). If, however, the gas is changed after a transition, the final waypoint of the transition gets the gas printed. And all is different for a verbatim plan, where the gas change is an event rather than part of a segment. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 13:53:51 +00:00
}
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
}
In diveplan differentiate between last printed depth and last depth In the decision if a dive segment should lead to a line in the diveplan, we need to differentiate between the lastdepth (the depth of the last dp to tell if we are currently stopping) and the last depth that we printed a line for (needed for gaschange lines). Without this patch, no stops without gas changes were listed anymore in the diveplan. Like the last patch for the diveplan: I hope this time I got this logic right. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-12-05 14:13:05 +00:00
lastprintdepth = newdepth;
lastdepth = dp->depth;
Show the setpoint in the diveplan Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 11:11:17 +00:00
lastsetpoint = dp->setpoint;
Planner: Hide unwanted transition between deco stops If display transitions in deco isn't selected, then we shouldn't show the transition segment between two deco stops, even if there is a gas change. We should still show the ascent segment up to the first deco stop. The (gaschange_after && !isascent) condition is necessary to pick up backgas breaks. An example plan is shown below. Previously: depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   <--meaningful ascent segment 21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 0min 51min   <--unnecessary ascent segment 6m 13min 64min oxygen 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min   depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   <--meaningful ascent segment 21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 13min 64min oxygen 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min   Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 07:45:47 +00:00
lastentered = dp->entered;
Planner: Avoid bogus segments with 0 time Don't show a stop if we continue at this depth. This resolves a problem when there are more than two waypoints during deco at the same depth. This can happen at 6m when there is a gaschange to O2 and the last stop depth is 6m (which turns the 3m stop into another 6m stop). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-04 22:15:11 +00:00
} while ((dp = nextdp) != NULL);
Only close html tags if they were opened before The runtime html table is printed only if printing a verbatim diveplan is disabled. So the closing tags should be printed only in that case. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-11-17 10:13:08 +00:00
if (!plan_verbatim)
len += snprintf(buffer + len, sz_buffer - len, "</tbody></table></div>");
Planner: Report CNS and OTU In add_plan_to_notes(), call update_cylinder_related_info() to compute CNS and OTU data for the planned dive. Report their values in the notes. Besides CNS and OTU, update_cylinder_related_info() also recomputes the SAC, which is harmless. Note that both dive->cns and dive->maxcns need to be zeroed out for the CNS value to actually be recomputed. Signed-off-by: Gaetan Bisson <bisson@archlinux.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-15 06:03:10 +00:00
dive->cns = 0;
dive->maxcns = 0;
update_cylinder_related_info(dive);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, "%s", translate("gettextFromC", "CNS"));
len += snprintf(buffer + len, sz_buffer - len, "<div><br>%s: %i%%", temp, dive->cns);
snprintf(temp, sz_temp, "%s", translate("gettextFromC", "OTU"));
len += snprintf(buffer + len, sz_buffer - len, "<br>%s: %i</div>", temp, dive->otu);
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
Refactor dctype -> divemode ... and repair a failed rebase (sorry). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-10 23:01:15 +00:00
if (dive->dc.divemode == CCR)
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, "%s", translate("gettextFromC", "Gas consumption (CCR legs excluded):"));
Don't track gas consuption on CCR legs Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-24 13:40:59 +00:00
else
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, "%s", translate("gettextFromC", "Gas consumption:"));
len += snprintf(buffer + len, sz_buffer - len, "<div><br>%s<br>", temp);
Limit the scope of gasidx in add_plan_to_notes Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-10 20:11:46 +00:00
for (int gasidx = 0; gasidx < MAX_CYLINDERS; gasidx++) {
Planner: Show gas consumption in pressure units as well and warn if not enough reserve. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-06 19:43:53 +00:00
double volume, pressure, deco_volume, deco_pressure;
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
const char *unit, *pressure_unit;
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
char warning[1000] = "";
Planner: track gas consumption in cylinders and samples This commit is a little bigger than I usually prefer, but it's all somewhat interconnected. - we pass around the cylinders throughout the planning process and as we create the plan we calculate the gas consumption in every segment and track this both in the end pressure of the cylinder and over time in the samples - because of that we no longer try to calculate the gas consumption after being done planning; we just use what we calculated along the way - we also no longer add gases during the planning process - all gases have to come from the list of cylinders passed in (which makes sense as we should only use those gases that the user added in the UI or inherited from a the selected dive (when starting to plan with a dive already selected) With this patch I think we are close do being able to move all of the planning logic back into the planner.c code where it belongs. The one issue that still bothers me is that we are juggling so many dive structures and then keep copying content around. It seems like we should be able to reduce that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-29 21:36:14 +00:00
cylinder_t *cyl = &dive->cylinder[gasidx];
if (cylinder_none(cyl))
break;
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
Planner: track gas used even if we don't have a real cylinder We tracked gas used by simulating a dive with a cylinder - but for that we need a cylinder size and working pressure. If the user just enters a gas but no cylinder data (likely in order to figure out how much gas is used so that she then can pick a big enough cylinder), we didn't show any gas consumption. It kinda sucks to add another member to the cylinder structure, but this seemed far more reasonable then some other, global structure that independently tracks gas usage. This just seemed to make sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 16:59:38 +00:00
volume = get_volume_units(cyl->gas_used.mliter, NULL, &unit);
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
deco_volume = get_volume_units(cyl->deco_gas_used.mliter, NULL, &unit);
Planner: track gas used even if we don't have a real cylinder We tracked gas used by simulating a dive with a cylinder - but for that we need a cylinder size and working pressure. If the user just enters a gas but no cylinder data (likely in order to figure out how much gas is used so that she then can pick a big enough cylinder), we didn't show any gas consumption. It kinda sucks to add another member to the cylinder structure, but this seemed far more reasonable then some other, global structure that independently tracks gas usage. This just seemed to make sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 16:59:38 +00:00
if (cyl->type.size.mliter) {
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
deco_pressure = get_pressure_units(1000.0 * cyl->deco_gas_used.mliter / cyl->type.size.mliter, &pressure_unit);
Planner: Show gas consumption in pressure units as well and warn if not enough reserve. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-06 19:43:53 +00:00
pressure = get_pressure_units(1000.0 * cyl->gas_used.mliter / cyl->type.size.mliter, &pressure_unit);
Planner: more fixes for gas tracking Gas switches are now for the current segment, not for the next. We can only track gas for cylinders for which we have size / working pressure information. Print a warning for others. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 14:55:07 +00:00
/* Warn if the plan uses more gas than is available in a cylinder
* This only works if we have working pressure for the cylinder
* 10bar is a made up number - but it seemed silly to pretend you could breathe cylinder down to 0 */
if (cyl->end.mbar < 10000)
CSS and translation improvements to dive plan Use CSS styling to format the dive plan instead of deprecated HTML tags. Also make sure that we aren't sending HTML tags to translate() Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-22 17:28:08 +00:00
snprintf(warning, sizeof(warning), " &mdash; <span style='color: red;'>%s </span> %s",
translate("gettextFromC", "Warning:"),
translate("gettextFromC", "this is more gas than available in the specified cylinder!"));
Planner: Show gas consumption in pressure units as well and warn if not enough reserve. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-06 19:43:53 +00:00
else
if ((float) cyl->end.mbar * cyl->type.size.mliter / 1000.0 < (float) cyl->deco_gas_used.mliter)
snprintf(warning, sizeof(warning), " &mdash; <span style='color: red;'>%s </span> %s",
translate("gettextFromC", "Warning:"),
translate("gettextFromC", "not enough reserve for gas sharing on ascent!"));
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "%.0f%s/%.0f%s of %s (%.0f%s/%.0f%s in planned ascent)"), volume, unit, pressure, pressure_unit, gasname(&cyl->gasmix), deco_volume, unit, deco_pressure, pressure_unit);
Show ascent gas consumption separately in planner In the worst gase you have to provide gas for your buddy during all the ascent. So you should have the amount of gas used in ascent as a reserve. This patch makes the planner notes display that value separately. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-01 07:37:49 +00:00
} else {
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp, translate("gettextFromC", "%.0f%s (%.0f%s during planned ascent) of %s"), volume, unit, deco_volume, unit, gasname(&cyl->gasmix));
Planner: more fixes for gas tracking Gas switches are now for the current segment, not for the next. We can only track gas for cylinders for which we have size / working pressure information. Print a warning for others. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 14:55:07 +00:00
}
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "%s%s<br>", temp, warning);
Calculate the gas used during the planned dive This works on the assumption that the diver uses the deco SAC rate while on a calculated deco stop and the bottom SAC rate during the rest of the dive (including the time they move from deco stop to deco stop). This is making the planning function mostly useful for open circuit diving. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:24:17 +00:00
}
Planner: warn about high pO2 If the user entered part of the plan exceeds a pO2 of 1.6, include a warning about that in the notes. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 19:29:40 +00:00
dp = diveplan->dp;
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
if (dive->dc.divemode != CCR) {
while (dp) {
if (dp->time != 0) {
struct gas_pressures pressures;
fill_pressures(&pressures, depth_to_atm(dp->depth, dive), &dp->gasmix, 0.0, dive->dc.divemode);
if (pressures.o2 > (dp->entered ? prefs.bottompo2 : prefs.decopo2) / 1000.0) {
const char *depth_unit;
int decimals;
double depth_value = get_depth_units(dp->depth, &decimals, &depth_unit);
len = strlen(buffer);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp,
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
translate("gettextFromC", "high pO₂ value %.2f at %d:%02u with gas %s at depth %.*f %s"),
pressures.o2, FRACTION(dp->time, 60), gasname(&dp->gasmix), decimals, depth_value, depth_unit);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<span style='color: red;'>%s </span> %s<br>",
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
translate("gettextFromC", "Warning:"), temp);
} else if (pressures.o2 < 0.16) {
const char *depth_unit;
int decimals;
double depth_value = get_depth_units(dp->depth, &decimals, &depth_unit);
len = strlen(buffer);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(temp, sz_temp,
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
translate("gettextFromC", "low pO₂ value %.2f at %d:%02u with gas %s at depth %.*f %s"),
pressures.o2, FRACTION(dp->time, 60), gasname(&dp->gasmix), decimals, depth_value, depth_unit);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
len += snprintf(buffer + len, sz_buffer - len, "<span style='color: red;'>%s </span> %s<br>",
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
translate("gettextFromC", "Warning:"), temp);
}
Planner: warn about high pO2 If the user entered part of the plan exceeds a pO2 of 1.6, include a warning about that in the notes. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 19:29:40 +00:00
}
Adopt planner gas calculation to PSCR mode and include low pO2 warning [Dirk Hohndel: fixed obvious compile problem] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-01-15 22:22:12 +00:00
dp = dp->next;
Planner: warn about high pO2 If the user entered part of the plan exceeds a pO2 of 1.6, include a warning about that in the notes. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 19:29:40 +00:00
}
}
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
snprintf(buffer + len, sz_buffer - len, "</div>");
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
dive->notes = strdup(buffer);
Planner: use the heap for note buffers The default stack size on Windows per thread is 1024kb. Using the heap prevents a stack overflow in add_plan_to_notes(). The alternative is to tell the linker to use N bytes of stack: -Wl,--stack,N Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-06 22:31:13 +00:00
free((void *)buffer);
free((void *)temp);
Add diveplan to the dive notes This makes it easy to print out a dive plan - it's simply stored in the notes of the simulated dive we create. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 01:17:24 +00:00
}
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int ascent_velocity(int depth, int avg_depth, int bottom_time)
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
{
Silence warnings in planner.c Signed-off-by: Tomaz Canabrava <tomaz.canabrava@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-07 19:54:49 +00:00
(void) bottom_time;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
/* We need to make this configurable */
Planner: Implement ascend rate according to GUE standard procedures Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-26 15:29:40 +00:00
/* As an example (and possibly reasonable default) this is the Tech 1 provedure according
* to http://www.globalunderwaterexplorers.org/files/Standards_and_Procedures/SOP_Manual_Ver2.0.2.pdf */
Hook up UI elements for ascent rates to planner That provides some UI elements that were recently introduced with function of allowing the ascent rates of the planner to be configured by the user. I tried to make it work both with senisble as well as with imperial units. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-24 22:08:36 +00:00
if (depth * 4 > avg_depth * 3) {
return prefs.ascrate75;
} else {
if (depth * 2 > avg_depth) {
return prefs.ascrate50;
} else {
if (depth > 6000)
return prefs.ascratestops;
else
return prefs.ascratelast6m;
}
}
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
}
Recmode: Take safety stop into account when calculating ascent gas consumption. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-08 17:18:54 +00:00
void track_ascent_gas(int depth, cylinder_t *cylinder, int avg_depth, int bottom_time, bool safety_stop)
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
{
while (depth > 0) {
Spelling corrected Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:41:09 +00:00
int deltad = ascent_velocity(depth, avg_depth, bottom_time) * TIMESTEP;
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
if (deltad > depth)
deltad = depth;
Recmode: Fix ascent gas consumption. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-09 18:26:56 +00:00
update_cylinder_pressure(&displayed_dive, depth, depth - deltad, TIMESTEP, prefs.decosac, cylinder, true);
Be more precise about the safety-stop. There is no point in doing a stop at 5m if the last manual waypoint is shallower. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-21 17:55:28 +00:00
if (depth <= 5000 && depth >= (5000 - deltad) && safety_stop) {
Recmode: Fix ascent gas consumption. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-09 18:26:56 +00:00
update_cylinder_pressure(&displayed_dive, 5000, 5000, 180, prefs.decosac, cylinder, true);
Recmode: Take safety stop into account when calculating ascent gas consumption. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-08 17:18:54 +00:00
safety_stop = false;
}
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
depth -= deltad;
}
}
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
// Determine whether ascending to the next stop will break the ceiling. Return true if the ascent is ok, false if it isn't.
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
bool trial_ascent(int trial_depth, int stoplevel, int avg_depth, int bottom_time, struct gasmix *gasmix, int po2, double surface_pressure)
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
{
bool clear_to_ascend = true;
char *trial_cache = NULL;
VPM-B: Don't break the ceiling due to ongassing on ascent Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 14:07:22 +00:00
// For consistency with other VPM-B implementations, we should not start the ascent while the ceiling is
// deeper than the next stop (thus the offgasing during the ascent is ignored).
// However, we still need to make sure we don't break the ceiling due to on-gassing during ascent.
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
if (prefs.deco_mode == VPMB && (deco_allowed_depth(tissue_tolerance_calc(&displayed_dive,
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
depth_to_bar(stoplevel, &displayed_dive)),
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
surface_pressure, &displayed_dive, 1) > stoplevel))
VPM-B: Don't break the ceiling due to ongassing on ascent Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 14:07:22 +00:00
return false;
Compare ceiling to next stop rather than try to ascent for VPM-B For VPM-B, to stay within the reference implementation, to decide if we need to stop we check if the current ceiling is above the next stop depth rather than trying to ascent and check if we violate a ceiling. This leads to more conservative profiles. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-18 07:07:50 +00:00
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
cache_deco_state(&trial_cache);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
while (trial_depth > stoplevel) {
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int deltad = ascent_velocity(trial_depth, avg_depth, bottom_time) * TIMESTEP;
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
if (deltad > trial_depth) /* don't test against depth above surface */
deltad = trial_depth;
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(trial_depth, &displayed_dive),
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
gasmix,
TIMESTEP, po2, &displayed_dive, prefs.decosac);
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
if (deco_allowed_depth(tissue_tolerance_calc(&displayed_dive, depth_to_bar(trial_depth, &displayed_dive)),
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
surface_pressure, &displayed_dive, 1) > trial_depth - deltad) {
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
/* We should have stopped */
clear_to_ascend = false;
VPM-B: add vpm-b based deco checking. Check during the trial_ascent() if existing pressure gradient is smaller than previously calculated max gradient. If not, ascent is impossible from the vpm-b's point of view. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 21:24:20 +00:00
break;
}
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
trial_depth -= deltad;
}
restore_deco_state(trial_cache);
Fix a number of resource leaks Free memory returned from parse_mkvi_value() Free memory returned from printGPSCoords() Free memory allocated in added_list and removed_list Free memory allocated when adding suffix to dive site name Free memory allocated in cache_deco_state() Free memory allocated in build_filename() Free memory allocated in get_utf8() Free memory allocated in alloc_dive() Free memory allocated as cache but never used Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 03:24:07 +00:00
free(trial_cache);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
return clear_to_ascend;
}
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* Determine if there is enough gas for the dive. Return true if there is enough.
* Also return true if this cannot be calculated because the cylinder doesn't have
* size or a starting pressure.
*/
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
bool enough_gas(int current_cylinder)
{
cylinder_t *cyl;
cyl = &displayed_dive.cylinder[current_cylinder];
if (!cyl->start.mbar)
return true;
if (cyl->type.size.mliter)
Recmode: Allow the user to specify gas reserve. Since most regulators have an intermediate pressure of 10bar the minimum value is 10 while the max is 99. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-09 15:41:41 +00:00
return (float) (cyl->end.mbar - prefs.reserve_gas) * cyl->type.size.mliter / 1000.0 > (float) cyl->deco_gas_used.mliter;
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
else
return true;
}
Only add disclaimer and runtime table if we added deco to replanne dive As a side effect this changes the signature of plan(): Before it returned an int that was supposed to be possibly an error but we never bothered to check it. So now it's bool indicating if the planner did add stops. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-09 19:55:59 +00:00
// Work out the stops. Return value is if there were any mandatory stops.
bool plan(struct diveplan *diveplan, char **cached_datap, bool is_planner, bool show_disclaimer)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
{
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
int bottom_depth;
int bottom_gi;
int bottom_stopidx;
bool is_final_plan = true;
int deco_time;
int previous_deco_time;
char *bottom_cache = NULL;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
struct sample *sample;
More cleanup for planner.c Remove unused variables and make the ifdef'ed out debug code work again. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 00:45:00 +00:00
int po2;
Fix some signedness issues I always worry if these are worth following up on - but these seem pretty clear and obvious to me. As far as the planner is concerned, depth is unsigned. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-08 05:37:32 +00:00
int transitiontime, gi;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
int current_cylinder;
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
int stopidx;
Remove unused variables and fix signed/unsigned mismatch The depth types are unsigned for dive plan datapoints. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 20:06:21 +00:00
int depth;
Make planner work again This partially reverts changes in commit 1b655d5c806b ("Correctly track gases when manually adding and then editing dives") as it turns out this did NOT help us correctly track gases (which is ironic, given the title of that commit). I didn't actually want to revert that commit as infrastructure has changed since then and this made the patches look even more incomprehensible. So we are back to tracking the "gas on which we arrive at this spot" in each dive plan node as this makes the rest of our planning so much easier - I had forgotten about the reasons why we did things this way when I made the above mentioned commit. Instead we now make sure that our available tanks are added the correct way, that such entries are ignored when planning and when drawing the editable profile, and that at the end it all gets assembled correctly. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-12 02:19:04 +00:00
struct gaschanges *gaschanges = NULL;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
int gaschangenr;
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int *decostoplevels;
int decostoplevelcount;
Don't try to force depth to be unsigned Trying to clean up the signed vs. unsigned issues it becomes clear that forcing depth to be unsigned causes way too many problems in the code. So this commit goes the opposite direction; since we clearly aren't limited INT_MAX vs UINT_MAX, simply make more of the depth related variables signed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 16:53:44 +00:00
int *stoplevels = NULL;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
bool stopping = false;
Implement planner option to switch only at required stops When option is enabled, if a stop is not otherwise required, a gas switch will be delayed until a stop is reached. This option is ignored if the current gas is hypoxic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 12:43:20 +00:00
bool pendinggaschange = false;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
int clock, previous_point_time;
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int avg_depth, max_depth, bottom_time = 0;
int last_ascend_rate;
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
int best_first_ascend_cylinder;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
struct gasmix gas, bottom_gas;
Planner: Add backgas breaks If the corresponding checkbox is checked the planner does interrupt pure O2 deco after 12min for 6min on cylinder 0. To make this work for air I removed the gasmix_is_null logic. I guess that makes the planner feature complete for the next release. [Dirk Hohndel: trivial merge into latest master] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-02 20:07:38 +00:00
int o2time = 0;
int breaktime = -1;
Fix uninitialized variable warning Reading the code we should never be able to access breakcylinder without having initialized it first, but this seems like a really cheap fix. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-06 17:51:53 +00:00
int breakcylinder = 0;
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
int error = 0;
Only add disclaimer and runtime table if we added deco to replanne dive As a side effect this changes the signature of plan(): Before it returned an int that was supposed to be possibly an error but we never bothered to check it. So now it's bool indicating if the planner did add stops. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-09 19:55:59 +00:00
bool decodive = false;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
Planner: use the actual setting for GF low at max depth Using the default_prefs value makes no sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-10 16:08:07 +00:00
set_gf(diveplan->gflow, diveplan->gfhigh, prefs.gf_low_at_maxdepth);
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
if (!diveplan->surface_pressure)
Centralising and redefining values as integers This patch centralizes the definition for surface pressure, oxygen in air, (re)defines all such values as plain integers and adapts calculations. It eliminates 11 (!) occurrences of definitions for surface pressure and also a few for oxygen in air. It also rewrites the calculation for EAD, END and EADD using the new definitons, harmonizing it for OC and CC and fixes a bug for EADD OC calculation. And finally it removes the unneeded variable entry_ead in gtk-gui.c. Jan Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-14 22:53:38 +00:00
diveplan->surface_pressure = SURFACE_PRESSURE;
Planner: Change where we clear deco and reset gradients We should run clear_deco as early as we can. We should calculate the nuclear regeneration and start gradient after calculating tissue tolerance. We don't need to redo nuclear regeration and start gradient after that. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 11:54:22 +00:00
displayed_dive.surface_pressure.mbar = diveplan->surface_pressure;
clear_deco(displayed_dive.surface_pressure.mbar / 1000.0);
VPMB: Reset ceiling pressures at start of planned dive We do not want to remember max_bottom_ceiling_pressure from the previous planned dive - it makes the Boyle's law compensation incorrect if the previous planned dive was a deeper deep-to-shallow multi-level dive. E.g. Plan these dives (without applying this patch) with VPM-B nominal conservatism: Plan 30 m for 20 min (total run time = 28 min) Now plan 100 m for 20 min, followed by 70 m @ 23 min and 70 m at 30 min Re-plan 30 m for 20 min (total run time = 50 min) With this change, the re-planned dive run time is 28 min, as it should be. We probably don't have to reset first_ceiling_pressure too, but it's cleaner if we do. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-20 08:22:24 +00:00
max_bottom_ceiling_pressure.mbar = first_ceiling_pressure.mbar = 0;
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
create_dive_from_plan(diveplan, is_planner);
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
// Do we want deco stop array in metres or feet?
Planner deco stops are at 10ft increments when measured in feet When using feet as depth unit, deco stop levels should be at 10 ft rather than 3 m increments. For shallow stops, rounding means the difference is not apparent. However, with stops deeper than 30 feet, using 3 m increments leads stops at 39ft, 49ft, ..., 98ft, etc. Apart from making plans look messy, the old behaviour makes it harder to benchmark the planner against published profiles in imperial units. This revised patch uses the help macro M_OR_FT(6, 20) to set the last stop at the correct depth. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 13:10:34 +00:00
if (prefs.units.length == METERS ) {
Planner: use pointer to deco stop level array instead of memcpy Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 03:34:43 +00:00
decostoplevels = decostoplevels_metric;
decostoplevelcount = sizeof(decostoplevels_metric) / sizeof(int);
Read planner preferences when we use them Read and use the last_stop preference in the plan function. Read the plan notes preferences and set variables (plan_verbatim, plan_display_runtime, plan_display_duration, and plan_display_transitions) in the add_plan_to_notes function. Don't read the preferences and set variables otherwise. Both plan and add_plan_to_notes functions are called on data change. Previous behaviour was: - Set variables on declaration - Reset variables in plan function (even variables that only relate to planner notes output) - Changing a preference triggered set_xxx function which sets variable, then plan function, which sets variable again. Apart from being inefficient, the previous behaviour made it difficult to track down where and when variables were set. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 12:14:10 +00:00
} else {
Planner: use pointer to deco stop level array instead of memcpy Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 03:34:43 +00:00
decostoplevels = decostoplevels_imperial;
decostoplevelcount = sizeof(decostoplevels_imperial) / sizeof(int);
Read planner preferences when we use them Read and use the last_stop preference in the plan function. Read the plan notes preferences and set variables (plan_verbatim, plan_display_runtime, plan_display_duration, and plan_display_transitions) in the add_plan_to_notes function. Don't read the preferences and set variables otherwise. Both plan and add_plan_to_notes functions are called on data change. Previous behaviour was: - Set variables on declaration - Reset variables in plan function (even variables that only relate to planner notes output) - Changing a preference triggered set_xxx function which sets variable, then plan function, which sets variable again. Apart from being inefficient, the previous behaviour made it difficult to track down where and when variables were set. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 12:14:10 +00:00
}
Read stored planner prefs when starting. Back in 5bf23381e we started storing planner settings in prefs. We need to read those settings back when we start the planner. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-05 12:17:26 +00:00
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* If the user has selected last stop to be at 6m/20', we need to get rid of the 3m/10' stop.
* Otherwise reinstate the last stop 3m/10' stop.
*/
Planner deco stops are at 10ft increments when measured in feet When using feet as depth unit, deco stop levels should be at 10 ft rather than 3 m increments. For shallow stops, rounding means the difference is not apparent. However, with stops deeper than 30 feet, using 3 m increments leads stops at 39ft, 49ft, ..., 98ft, etc. Apart from making plans look messy, the old behaviour makes it harder to benchmark the planner against published profiles in imperial units. This revised patch uses the help macro M_OR_FT(6, 20) to set the last stop at the correct depth. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 13:10:34 +00:00
if (prefs.last_stop)
Planner: use pointer to deco stop level array instead of memcpy Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 03:34:43 +00:00
*(decostoplevels + 1) = 0;
else
*(decostoplevels + 1) = M_OR_FT(3,10);
Planner deco stops are at 10ft increments when measured in feet When using feet as depth unit, deco stop levels should be at 10 ft rather than 3 m increments. For shallow stops, rounding means the difference is not apparent. However, with stops deeper than 30 feet, using 3 m increments leads stops at 39ft, 49ft, ..., 98ft, etc. Apart from making plans look messy, the old behaviour makes it harder to benchmark the planner against published profiles in imperial units. This revised patch uses the help macro M_OR_FT(6, 20) to set the last stop at the correct depth. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 13:10:34 +00:00
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
/* Let's start at the last 'sample', i.e. the last manually entered waypoint. */
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
sample = &displayed_dive.dc.sample[displayed_dive.dc.samples - 1];
Convert get_gas_from_events to get_gas_at_time This converts the get_gas_from_events to a get_gas_at_time function that actually maps our events to what cylinder and thus gas we are breathing at that time. [Dirk Hohndel: fixed to actually use the gas that was looked up (and make things compile)] Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-17 19:16:50 +00:00
get_gas_at_time(&displayed_dive, &displayed_dive.dc, sample->time, &gas);
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
po2 = sample->setpoint.mbar;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
if ((current_cylinder = get_gasidx(&displayed_dive, &gas)) == -1) {
Create simple non-thread-safe "gasname()" function Every single user of the get_gas_name() function wanted to just use the result to create a message or printout, and that made the interface a bit cumbersome. This adds a "gasname()" wrapper that returns a static buffer with the result in it, which is neither pretty nor thread-safe, but is a much simpler interface to work with. Our dive planning isn't multi-threaded, so nothing should care. [ This also converts a few open-coded gasname debug printouts to use the helper function, resulting in prettier printouts and less code ] Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 01:25:44 +00:00
report_error(translate("gettextFromC", "Can't find gas %s"), gasname(&gas));
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
current_cylinder = 0;
}
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
depth = displayed_dive.dc.sample[displayed_dive.dc.samples - 1].depth.mm;
Only do safety stop of dive has at least max depth of 10m Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-02 08:49:24 +00:00
average_max_depth(diveplan, &avg_depth, &max_depth);
Spelling corrected Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:41:09 +00:00
last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
Only calculate deco stops in planner mode In add dive mode simply bring the diver safely back to the surface (currently with a fixed ascent rate of 30ft/min (or 9m/min)). We should make that rate configurable (for the planner as well as the dive add function). Also, the dive add function should offer to automatically include a safety stop. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-09-19 03:40:34 +00:00
Remove some safety stop code in plan() Some code in plan() left from the gtk days introduced a safety stop in the plan. It created a un-editable diveplanpoint. Fixes #349 Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-10 06:50:19 +00:00
/* if all we wanted was the dive just get us back to the surface */
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
if (!is_planner) {
Remove some safety stop code in plan() Some code in plan() left from the gtk days introduced a safety stop in the plan. It created a un-editable diveplanpoint. Fixes #349 Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-12-10 06:50:19 +00:00
transitiontime = depth / 75; /* this still needs to be made configurable */
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
plan_add_segment(diveplan, transitiontime, 0, gas, po2, false);
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
create_dive_from_plan(diveplan, is_planner);
Only add disclaimer and runtime table if we added deco to replanne dive As a side effect this changes the signature of plan(): Before it returned an int that was supposed to be possibly an error but we never bothered to check it. So now it's bool indicating if the planner did add stops. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-09 19:55:59 +00:00
return(false);
Only calculate deco stops in planner mode In add dive mode simply bring the diver safely back to the surface (currently with a fixed ascent rate of 30ft/min (or 9m/min)). We should make that rate configurable (for the planner as well as the dive add function). Also, the dive add function should offer to automatically include a safety stop. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-09-19 03:40:34 +00:00
}
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
Set a default surface pressure for dive plan and allow simplistic print This commit makes sure we have a reasonable default surface pressure (we need an input field for that). It also adjusts the debug level settings so that compiling this with make CLCFLAGS=-DDEBUG_PLAN=3 will print out an almost usable dive plan. This is of course still lacking air consumption calculations and will show deco stops that we just transit through (if the ceiling lifts far enough during the transition to an intended stop that this stop can be skipped; this sometimes happens for the first stop (haven't seen it for a later one). But it's better than nothing, I guess. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 22:05:25 +00:00
#if DEBUG_PLAN & 4
Create simple non-thread-safe "gasname()" function Every single user of the get_gas_name() function wanted to just use the result to create a message or printout, and that made the interface a bit cumbersome. This adds a "gasname()" wrapper that returns a static buffer with the result in it, which is neither pretty nor thread-safe, but is a much simpler interface to work with. Our dive planning isn't multi-threaded, so nothing should care. [ This also converts a few open-coded gasname debug printouts to use the helper function, resulting in prettier printouts and less code ] Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-02 01:25:44 +00:00
printf("gas %s\n", gasname(&gas));
Remove non-existant variable from debug statement Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 04:02:39 +00:00
printf("depth %5.2lfm \n", depth / 1000.0);
Fix gas handling in the planner The dive will start with gas 0. If things change during the planned part of the dive, this will be represented by an event. Use the last gas for the ascent. Obviously this still doesn't handle deco gases, but at least we now no longer switch back to the first gas after the planned part of the dive. This also adds quite a bit of debugging code to be able to trace what's happening in the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-08 16:52:48 +00:00
#endif
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
best_first_ascend_cylinder = current_cylinder;
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
/* Find the gases available for deco */
Don't plan gas switches when in CCR mode Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-21 10:10:19 +00:00
if (po2) { // Don't change gas in CCR mode
gaschanges = NULL;
gaschangenr = 0;
} else {
gaschanges = analyze_gaslist(diveplan, &gaschangenr, depth, &best_first_ascend_cylinder);
}
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
/* Find the first potential decostopdepth above current depth */
Planner: use pointer to deco stop level array instead of memcpy Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 03:34:43 +00:00
for (stopidx = 0; stopidx < decostoplevelcount; stopidx++)
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
if (*(decostoplevels + stopidx) >= depth)
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
break;
Don't access invalid elements with depth = 0 This is a corner case in the planner that was exposed by the recent changes to the way the dive plan reflects the gases during the dive. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-11-08 12:40:59 +00:00
if (stopidx > 0)
stopidx--;
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
/* Stoplevels are either depths of gas changes or potential deco stop depths. */
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
stoplevels = sort_stops(decostoplevels, stopidx + 1, gaschanges, gaschangenr);
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
stopidx += gaschangenr;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
/* Keep time during the ascend */
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
bottom_time = clock = previous_point_time = displayed_dive.dc.sample[displayed_dive.dc.samples - 1].time.seconds;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
gi = gaschangenr - 1;
VPM-B: add deco choice to the ui. Removed recreational mode from ui and pref and replaced it with new deco_mode enum. Added radio button ui selection. Set default deco_mode to Buehlmann algorithm. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 21:07:58 +00:00
Planner: Change where we clear deco and reset gradients We should run clear_deco as early as we can. We should calculate the nuclear regeneration and start gradient after calculating tissue tolerance. We don't need to redo nuclear regeration and start gradient after that. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 11:54:22 +00:00
/* Set tissue tolerance and initial vpmb gradient at start of ascent phase */
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
tissue_at_end(&displayed_dive, cached_datap);
Planner: Change where we clear deco and reset gradients We should run clear_deco as early as we can. We should calculate the nuclear regeneration and start gradient after calculating tissue tolerance. We don't need to redo nuclear regeration and start gradient after that. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 11:54:22 +00:00
nuclear_regeneration(clock);
vpmb_start_gradient();
VPM-B: add deco choice to the ui. Removed recreational mode from ui and pref and replaced it with new deco_mode enum. Added radio button ui selection. Set default deco_mode to Buehlmann algorithm. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 21:07:58 +00:00
if(prefs.deco_mode == RECREATIONAL) {
Only do safety stop of dive has at least max depth of 10m Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-02 08:49:24 +00:00
bool safety_stop = prefs.safetystop && max_depth >= 10000;
Recmode: Take safety stop into account when calculating ascent gas consumption. Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-08 17:18:54 +00:00
track_ascent_gas(depth, &displayed_dive.cylinder[current_cylinder], avg_depth, bottom_time, safety_stop);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
// How long can we stay at the current depth and still directly ascent to the surface?
Don't do a negative time step in recreational mode when beyond NDL In recreational mode, we keep adding time at the last depth until an ascent does violate the ceiling. Then we roll back the last added time step and record the ascent. The test for the ceiling violated was before adding the time so if it alreay failed the first time we tried to unroll a time step that was never added which resulted in a small kink in the pressure graph. This patch corrects this logic by changin a while to a do {} while. Furthermore, it removes the computation of deco state during the final ascent since that is not used anywhere later. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-12 20:03:50 +00:00
do {
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, &displayed_dive),
Don't do a negative time step in recreational mode when beyond NDL In recreational mode, we keep adding time at the last depth until an ascent does violate the ceiling. Then we roll back the last added time step and record the ascent. The test for the ceiling violated was before adding the time so if it alreay failed the first time we tried to unroll a time step that was never added which resulted in a small kink in the pressure graph. This patch corrects this logic by changin a while to a do {} while. Furthermore, it removes the computation of deco state during the final ascent since that is not used anywhere later. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-12 20:03:50 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix,
DECOTIMESTEP, po2, &displayed_dive, prefs.bottomsac);
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
update_cylinder_pressure(&displayed_dive, depth, depth, DECOTIMESTEP, prefs.bottomsac, &displayed_dive.cylinder[current_cylinder], false);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
clock += DECOTIMESTEP;
Don't do a negative time step in recreational mode when beyond NDL In recreational mode, we keep adding time at the last depth until an ascent does violate the ceiling. Then we roll back the last added time step and record the ascent. The test for the ceiling violated was before adding the time so if it alreay failed the first time we tried to unroll a time step that was never added which resulted in a small kink in the pressure graph. This patch corrects this logic by changin a while to a do {} while. Furthermore, it removes the computation of deco state during the final ascent since that is not used anywhere later. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-12 20:03:50 +00:00
} while (trial_ascent(depth, 0, avg_depth, bottom_time, &displayed_dive.cylinder[current_cylinder].gasmix,
po2, diveplan->surface_pressure / 1000.0) &&
enough_gas(current_cylinder));
// We did stay one DECOTIMESTEP too many.
// In the best of all worlds, we would roll back also the last add_segment in terms of caching deco state, but
// let's ignore that since for the eventual ascent in recreational mode, nobody looks at the ceiling anymore,
// so we don't really have to compute the deco state.
update_cylinder_pressure(&displayed_dive, depth, depth, -DECOTIMESTEP, prefs.bottomsac, &displayed_dive.cylinder[current_cylinder], false);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
clock -= DECOTIMESTEP;
Take gas consumption into account for recreational mode If there is valid gas information (cylinder size and starting pressure), also ascent before gas runs out (taking a 40bar reserve into account). Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:38:56 +00:00
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, true);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
previous_point_time = clock;
do {
/* Ascend to surface */
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
int deltad = ascent_velocity(depth, avg_depth, bottom_time) * TIMESTEP;
Spelling corrected Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:41:09 +00:00
if (ascent_velocity(depth, avg_depth, bottom_time) != last_ascend_rate) {
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
previous_point_time = clock;
Spelling corrected Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-04 16:41:09 +00:00
last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
}
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
if (depth - deltad < 0)
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
deltad = depth;
clock += TIMESTEP;
depth -= deltad;
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
if (depth <= 5000 && depth >= (5000 - deltad) && safety_stop) {
Add 3min safety stop Fixes #839 Signed-off-by: Joakim Bygdell <j.bygdell@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-04-02 09:17:57 +00:00
plan_add_segment(diveplan, clock - previous_point_time, 5000, gas, po2, false);
previous_point_time = clock;
clock += 180;
plan_add_segment(diveplan, clock - previous_point_time, 5000, gas, po2, false);
previous_point_time = clock;
safety_stop = false;
}
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
} while (depth > 0);
plan_add_segment(diveplan, clock - previous_point_time, 0, gas, po2, false);
create_dive_from_plan(diveplan, is_planner);
add_plan_to_notes(diveplan, &displayed_dive, show_disclaimer, error);
fixup_dc_duration(&displayed_dive.dc);
free(stoplevels);
free(gaschanges);
Only add disclaimer and runtime table if we added deco to replanne dive As a side effect this changes the signature of plan(): Before it returned an int that was supposed to be possibly an error but we never bothered to check it. So now it's bool indicating if the planner did add stops. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-09 19:55:59 +00:00
return(false);
Introduce recreational planner mode This adopts the planner to the needs of the recreational diver. Rather than immediately starting to ascent doing deco stops this mode, this mode stays at the last manually entered depth for the maximal time before mandantory stops appear (NDL). It does not change gas but keeps using the last used cylinder. TODO: * Grey out unused UI elements of the planner in this mode * Start ascent before gas runs out (or into reserve) * Do a 3min @ 5m safety stop. Fixes #840 Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-03-31 12:52:37 +00:00
}
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
if (best_first_ascend_cylinder != current_cylinder) {
current_cylinder = best_first_ascend_cylinder;
UI restructure: make planner act on displayed_dive Instead of constantly creating and deleting dives and messing with the dive list. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-03 20:39:06 +00:00
gas = displayed_dive.cylinder[current_cylinder].gasmix;
Make planner work again for CCR dives The latest CCR patches had rendered the planner not usable for CCR dives. This patch corrects this (and reenables the CCR set point column for segments). The problem was that a new member setpoint of struct divepoint had been introduced, but there was already po2 which had the same meaning. This patch merges the two and renames them setpoint to prevent future confusion. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-10-19 14:07:07 +00:00
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
#if DEBUG_PLAN & 16
printf("switch to gas %d (%d/%d) @ %5.2lfm\n", best_first_ascend_cylinder,
Use user entered pO2 limits for high pO2 warnings. Furthermore, replaced gasmix accessors instead of .permille directly (think: air!) Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-10 20:29:00 +00:00
(get_o2(&gas) + 5) / 10, (get_he(&gas) + 5) / 10, gaschanges[best_first_ascend_cylinder].depth / 1000.0);
Planner: start the ascend with the strongest allowed deco mix. In analyze_gaslist() we were only keeping gases that had their .depth above the current depth, i.e. where we could switch to in the future. Now we take note as well of the strongest gas that we could have already switched to and switch to it before we attempt to ascend. [Dirk Hohndel: minor whitespace and code cleanup] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-05-30 15:09:05 +00:00
#endif
}
VPM-B: vpm without CVA working. Add call of initial calculation of critical radius and start gradient, so the VPM could work. Currently without CVA, so the gradient isn't improved. Only one iteration is run. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 21:54:57 +00:00
// VPM-B or Buehlmann Deco
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
tissue_at_end(&displayed_dive, cached_datap);
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
previous_deco_time = 100000000;
deco_time = 10000000;
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
cache_deco_state(&bottom_cache); // Lets us make several iterations
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
bottom_depth = depth;
bottom_gi = gi;
bottom_gas = gas;
bottom_stopidx = stopidx;
VPM-B: Calculate first_stop_pressure before starting ascent The Boyle's law compensation depends on first_stop_pressure. To produce profiles similar to other VPM-B implementations, we should calculate it as the ceiling before starting the ascent. Commit 159c9eb2c1c19dfbf650f2b0cc28e0ef1f45c964, Compare ceiling to next stop rather than try to ascent for VPM-B, changed (VPM-B) to consider the current ceiling rather than an incremental ascent between one stop level and the next. However, the initial ascent generally steps through several stop levels, so first_stop_pressure was still not calculated as the ceiling prior to commencing the calculated ascent. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-22 04:41:53 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
//CVA
do {
is_final_plan = (prefs.deco_mode == BUEHLMANN) || (previous_deco_time - deco_time < 10); // CVA time converges
VPM-B: Add Boyles compensation to the planner. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-08-15 12:16:48 +00:00
if (deco_time != 10000000)
VPM-B: Add surface decompression time. Now, we calculate the volume of free gas not only based on the deco time but also time on the surface, needed for the full desaturation. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-08-15 12:28:44 +00:00
vpmb_next_gradient(deco_time, diveplan->surface_pressure / 1000.0);
VPM-B: Add Boyles compensation to the planner. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-08-15 12:16:48 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
previous_deco_time = deco_time;
Revert "VPM-B restore deco state before calculating next gradient" This reverts commit 3d8e5b638ad4c1fbb43f6dd5f535bf0b33a51f0b. Calculating the next gradient should be based on the tissue loading at the end of the previous iteration, so it was wrong to restore the deco state first. This has a tiny affect on the calculated profile, and makes one of the tests fail. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-04 03:42:53 +00:00
restore_deco_state(bottom_cache);
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
depth = bottom_depth;
gi = bottom_gi;
clock = previous_point_time = bottom_time;
gas = bottom_gas;
stopping = false;
decodive = false;
stopidx = bottom_stopidx;
breaktime = -1;
breakcylinder = 0;
o2time = 0;
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
first_ceiling_pressure.mbar = depth_to_mbar(deco_allowed_depth(tissue_tolerance_calc(&displayed_dive,
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
depth_to_bar(depth, &displayed_dive)),
Compute first stop pressure for each round of CVA Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-27 12:13:12 +00:00
diveplan->surface_pressure / 1000.0,
&displayed_dive,
1),
&displayed_dive);
VPM-B: Calculate ceiling in deepest portion of dive The Boyle's law compensation compares the ambient pressure to a baseline value, and adjusts the theory bubble radius accordingly. Currently we use the ceiling at the last user-entered waypoint (the start of the decompression phase) as the baseline value. However, in a deep to shallow multi-level dive, decompression can start earlier, and taking a shallower ceiling leads to a more aggressive ascent. This is particularly noticeable if the user enters stops during ascent. With this commit, we take the baseline ambient pressure for Boyle's law compensation as the deeper of the: (1) Ceiling prior to ascending during a user-entered portion of the dive, and (2) Ceiling at the start of the last user-entered waypoint. This makes the calculated profile more conservative for some deep to shallow multi-level dives. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-12 02:10:54 +00:00
if (max_bottom_ceiling_pressure.mbar > first_ceiling_pressure.mbar)
first_ceiling_pressure.mbar = max_bottom_ceiling_pressure.mbar;
Compute first stop pressure for each round of CVA Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-27 12:13:12 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
if ((current_cylinder = get_gasidx(&displayed_dive, &gas)) == -1) {
report_error(translate("gettextFromC", "Can't find gas %s"), gasname(&gas));
current_cylinder = 0;
}
VPM-B: vpm without CVA working. Add call of initial calculation of critical radius and start gradient, so the VPM could work. Currently without CVA, so the gradient isn't improved. Only one iteration is run. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 21:54:57 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
while (1) {
/* We will break out when we hit the surface */
do {
/* Ascend to next stop depth */
int deltad = ascent_velocity(depth, avg_depth, bottom_time) * TIMESTEP;
if (ascent_velocity(depth, avg_depth, bottom_time) != last_ascend_rate) {
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
previous_point_time = clock;
stopping = false;
last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
}
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
if (depth - deltad < stoplevels[stopidx])
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
deltad = depth - stoplevels[stopidx];
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, &displayed_dive),
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix,
TIMESTEP, po2, &displayed_dive, prefs.decosac);
clock += TIMESTEP;
depth -= deltad;
Revert "Clean up signedness confusion in planner.c" This reverts commit 59299f0ab34ca4d75e0b02d9a83f23ec6348e1df. Doing this oversimplified "fix" actually breaks the planner. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-03-23 15:16:33 +00:00
} while (depth > 0 && depth > stoplevels[stopidx]);
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
if (depth <= 0)
break; /* We are at the surface */
if (gi >= 0 && stoplevels[stopidx] <= gaschanges[gi].depth) {
/* We have reached a gas change.
* Record this in the dive plan */
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
Planner: Add waipoints when changing ascend rate in planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-26 19:06:48 +00:00
previous_point_time = clock;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
stopping = true;
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
/* Check we need to change cylinder.
* We might not if the cylinder was chosen by the user
* or user has selected only to switch only at required stops.
* If current gas is hypoxic, we want to switch asap */
Decrease gaschange index even if we are already breathing the new mix This fixes a bug where we would not do any gas changes at all if at the end of bottom time we were deeper than the MOD of the bottom mix. Instead we would constantly try to switch to that gas and find we are already breathing it. A test case would be a dive with air and EAN50 to more than 66m. That would have never switched to EAN50. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-03 15:29:05 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
if (current_cylinder != gaschanges[gi].gasidx) {
if (!prefs.switch_at_req_stop ||
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
!trial_ascent(depth, stoplevels[stopidx - 1], avg_depth, bottom_time,
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0) || get_o2(&displayed_dive.cylinder[current_cylinder].gasmix) < 160) {
current_cylinder = gaschanges[gi].gasidx;
gas = displayed_dive.cylinder[current_cylinder].gasmix;
#if DEBUG_PLAN & 16
printf("switch to gas %d (%d/%d) @ %5.2lfm\n", gaschanges[gi].gasidx,
(get_o2(&gas) + 5) / 10, (get_he(&gas) + 5) / 10, gaschanges[gi].depth / 1000.0);
#endif
/* Stop for the minimum duration to switch gas */
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, &displayed_dive),
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix,
prefs.min_switch_duration, po2, &displayed_dive, prefs.decosac);
clock += prefs.min_switch_duration;
Planner: Count the minimum stop time towards o2time When doing backgas breaks, count the minimum stop time towards o2time. Previously, the initial minimum stop wasn't counted, so the time of the first segment on oxygen was min_switch_duration + 12 minutes. E.g. with 1 minute minimum switch duration. Previously: depth duration runtime gas 40m 1min 1min air 40m 34min 35min 21m 2min 37min 21m 1min 38min EAN50 18m 1min 39min 15m 3min 42min 12m 4min 46min 9m 5min 51min 6m 13min 64min oxygen <--13 minutes on O2 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min Now: depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 12min 63min oxygen 6m 6min 69min air 6m 2min 71min oxygen 0m 1min 72min   Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 09:27:15 +00:00
if (prefs.doo2breaks && get_o2(&displayed_dive.cylinder[current_cylinder].gasmix) == 1000)
o2time += prefs.min_switch_duration;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
} else {
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* The user has selected the option to switch gas only at required stops.
* Remember that we are waiting to switch gas
*/
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
pendinggaschange = true;
}
}
Decrease gaschange index even if we are already breathing the new mix This fixes a bug where we would not do any gas changes at all if at the end of bottom time we were deeper than the MOD of the bottom mix. Instead we would constantly try to switch to that gas and find we are already breathing it. A test case would be a dive with air and EAN50 to more than 66m. That would have never switched to EAN50. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-03 15:29:05 +00:00
gi--;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
}
--stopidx;
/* Save the current state and try to ascend to the next stopdepth */
while (1) {
/* Check if ascending to next stop is clear, go back and wait if we hit the ceiling on the way */
Calculate ceiling only when it is needed So far, add_segment() returned a tissue tolerance (i.e. ceiling) computed just in its return statement. This tissue_tolerance needed to be dragged around until it was needed or be dropped if not needed at all. As for VPM-B, this ceiling computation is a bit expensive, this patch calls the computation function tissue_tolerance_calc() when the value is actually needed and not before. This changes the signature of some functions. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:25:28 +00:00
if (trial_ascent(depth, stoplevels[stopidx], avg_depth, bottom_time,
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0))
break; /* We did not hit the ceiling */
/* Add a minute of deco time and then try again */
decodive = true;
if (!stopping) {
/* The last segment was an ascend segment.
* Add a waypoint for start of this deco stop */
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
previous_point_time = clock;
stopping = true;
}
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* Are we waiting to switch gas?
* Occurs when the user has selected the option to switch only at required stops
*/
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
if (pendinggaschange) {
current_cylinder = gaschanges[gi + 1].gasidx;
Implement planner option to switch only at required stops When option is enabled, if a stop is not otherwise required, a gas switch will be delayed until a stop is reached. This option is ignored if the current gas is hypoxic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 12:43:20 +00:00
gas = displayed_dive.cylinder[current_cylinder].gasmix;
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#if DEBUG_PLAN & 16
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
printf("switch to gas %d (%d/%d) @ %5.2lfm\n", gaschanges[gi + 1].gasidx,
(get_o2(&gas) + 5) / 10, (get_he(&gas) + 5) / 10, gaschanges[gi + 1].depth / 1000.0);
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
#endif
Implement planner option to switch only at required stops When option is enabled, if a stop is not otherwise required, a gas switch will be delayed until a stop is reached. This option is ignored if the current gas is hypoxic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 12:43:20 +00:00
/* Stop for the minimum duration to switch gas */
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, &displayed_dive),
Implement planner option to switch only at required stops When option is enabled, if a stop is not otherwise required, a gas switch will be delayed until a stop is reached. This option is ignored if the current gas is hypoxic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 12:43:20 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix,
prefs.min_switch_duration, po2, &displayed_dive, prefs.decosac);
clock += prefs.min_switch_duration;
Planner: Count the minimum stop time towards o2time When doing backgas breaks, count the minimum stop time towards o2time. Previously, the initial minimum stop wasn't counted, so the time of the first segment on oxygen was min_switch_duration + 12 minutes. E.g. with 1 minute minimum switch duration. Previously: depth duration runtime gas 40m 1min 1min air 40m 34min 35min 21m 2min 37min 21m 1min 38min EAN50 18m 1min 39min 15m 3min 42min 12m 4min 46min 9m 5min 51min 6m 13min 64min oxygen <--13 minutes on O2 6m 6min 70min air 6m 2min 72min oxygen 0m 1min 73min Now: depth duration runtime gas 40m 1min 1min air 40m 34min 35min   21m 2min 37min   21m 1min 38min EAN50 18m 1min 39min   15m 3min 42min   12m 4min 46min   9m 5min 51min   6m 12min 63min oxygen 6m 6min 69min air 6m 2min 71min oxygen 0m 1min 72min   Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-26 09:27:15 +00:00
if (prefs.doo2breaks && get_o2(&displayed_dive.cylinder[current_cylinder].gasmix) == 1000)
o2time += prefs.min_switch_duration;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
pendinggaschange = false;
Implement planner option to switch only at required stops When option is enabled, if a stop is not otherwise required, a gas switch will be delayed until a stop is reached. This option is ignored if the current gas is hypoxic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-22 12:43:20 +00:00
}
Delete code and files that are no longer used Most of this is Gtk related, some of it is helpers that we don't need anymore. I love the diffstat. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-07 00:32:50 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
/* Deco stop should end when runtime is at a whole minute */
int this_decotimestep;
this_decotimestep = DECOTIMESTEP - clock % DECOTIMESTEP;
Planner - end deco stops at whole minutes of runtime --20cf303ddd3893b1500518e9204e Content-Type: text/plain; charset=UTF-8 Use an adjusted timestep to calculate length of deco stops, so that they always end at whole minutes of runtime. This makes for a cleaner ascent profile. <div dir="ltr">Use an adjusted timestep to calculate length of deco stops, so that they always end at whole minutes of runtime.  This makes for a cleaner ascent profile.<br></div> From 15e08450252f304fc7d46931e2aca5c991c2f3de Mon Sep 17 00:00:00 2001 From: Rick Walsh <rickmwalsh@gmail.com> Date: Sat, 20 Jun 2015 11:36:07 +1000 Subject: [PATCH 2/2] Planner - end deco stops at whole minutes of runtime Use an adjusted timestep to calculate length of deco stops, so that they always end at whole minutes of runtime. This makes for a cleaner ascent profile. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-06-20 01:40:36 +00:00
Introduce double depth_to_bar() as it leads to significant cleanup. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-31 21:39:43 +00:00
add_segment(depth_to_bar(depth, &displayed_dive),
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
&displayed_dive.cylinder[current_cylinder].gasmix,
this_decotimestep, po2, &displayed_dive, prefs.decosac);
clock += this_decotimestep;
/* Finish infinite deco */
if(clock >= 48 * 3600 && depth >= 6000) {
error = LONGDECO;
break;
}
if (prefs.doo2breaks) {
Planner: Add comments to document the code The purpose of parts of the planner code is not not always obvious. This is especially true of the conditional statements in the add_plan_to_notes function. Annotate the code with comments to explain the logic. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-27 12:06:02 +00:00
/* The backgas breaks option limits time on oxygen to 12 minutes, followed by 6 minutes on
* backgas (first defined gas). This could be customized if there were demand.
*/
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
if (get_o2(&displayed_dive.cylinder[current_cylinder].gasmix) == 1000) {
o2time += DECOTIMESTEP;
if (o2time >= 12 * 60) {
breaktime = 0;
breakcylinder = current_cylinder;
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
Planner: Add backgas breaks If the corresponding checkbox is checked the planner does interrupt pure O2 deco after 12min for 6min on cylinder 0. To make this work for air I removed the gasmix_is_null logic. I guess that makes the planner feature complete for the next release. [Dirk Hohndel: trivial merge into latest master] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-02 20:07:38 +00:00
previous_point_time = clock;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
current_cylinder = 0;
Planner: Add backgas breaks If the corresponding checkbox is checked the planner does interrupt pure O2 deco after 12min for 6min on cylinder 0. To make this work for air I removed the gasmix_is_null logic. I guess that makes the planner feature complete for the next release. [Dirk Hohndel: trivial merge into latest master] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-02 20:07:38 +00:00
gas = displayed_dive.cylinder[current_cylinder].gasmix;
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
}
} else {
if (breaktime >= 0) {
breaktime += DECOTIMESTEP;
if (breaktime >= 6 * 60) {
o2time = 0;
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
previous_point_time = clock;
current_cylinder = breakcylinder;
gas = displayed_dive.cylinder[current_cylinder].gasmix;
breaktime = -1;
}
Planner: Add backgas breaks If the corresponding checkbox is checked the planner does interrupt pure O2 deco after 12min for 6min on cylinder 0. To make this work for air I removed the gasmix_is_null logic. I guess that makes the planner feature complete for the next release. [Dirk Hohndel: trivial merge into latest master] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-02 20:07:38 +00:00
}
}
}
}
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
if (stopping) {
/* Next we will ascend again. Add a waypoint if we have spend deco time */
if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, gas, po2, false);
previous_point_time = clock;
stopping = false;
}
Improvement for various bits of the planner Rewrite of the actual planner logic. Now ascend to the next potential stop depth. There the state is cached and we try to ascend to the next stop depth. If we hit the ceiling while doing that we go back to the cached state and wait there for a minute. Then we try again. Then loop. Converted all depth related variables from unsigned int to int. During planning, in a time step the current depth can temporarily be negative and comparisons of a negative int with an unsigned it have not the result I expected ( (int) -2 < (unsigned int) 3 turns out to be false). And we don’t really need the 32nd bit that unsigned buys us for depths. Deco stops are now shown in the same table as manually entered stops in boldface (I removed the second table to save screen estate). The gas shown in the table is still misleading as it means the gas used on the segment leading up to that event. The update of the profile only works partially upon changes in the list of available gases. Treatment of various gases is basically there but needs some more love. The ascent velocity is now provided by a function that takes the current depth as argument. Currently it always returns 10m/min but that will later be variable (and hopefully user configurable). The profile is not redrawn while deco is computed (avoiding an infinite recursion). The table got a new column for the duration of a segment while the old “duration” column was renamed “Runtime” to reflect what it actually shows. Currently, only the run time but not the duration are editable. All deco gases are used from the depth where their pO2 is 1.4bar. This should become more flexible. Calculation of the pressure drop in cylinders without configured volumes is suppressed. This solves a problem with the planner crashing when saving a dive where not all cylinders had been manually given a volume. [Short rant break: Treating 0/0 as air bites back at so many places. E.g. Cylinder data is initialized with memsetting the whole structures to 0. Then later suddenly this totally unconfigured cylinder is being treated as it would contain air. Maybe at some point this was a feature. But it lead to a naughty bug which took me over an hour to resolve. We should seriously reconsider this choice and better move to 209/0 being air if changing this everywhere is not too much trouble] Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-17 08:54:55 +00:00
}
Comments added to planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-04-18 14:08:33 +00:00
VPM-B: add CVA to the deco planner. Added keeping bottom dive state and every deco's time, so we can run multiple deco simulations with different gradients until they converge to some optimal value. Some improvements on the deco time calculation may be needed. Signed-off-by: Jan Darowski <jan.darowski@gmail.com>
2015-07-03 22:13:34 +00:00
deco_time = clock - bottom_time;
} while (!is_final_plan);
Next step to using gasmix instead of o2/he This changes the divedatapoints and functions that deal with them. It changes plan_add_segment(), create_dp(), gasToStr(), and tankInUse() to consume gasmix instead of o2/he. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 22:25:19 +00:00
plan_add_segment(diveplan, clock - previous_point_time, 0, gas, po2, false);
Planner: only track gas when planning a dive When adding a dive we don't have SAC data so we should simply have the user manually enter their gas consumption. That still doesn't work, but this is one required step to get it to work. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-07-04 18:26:31 +00:00
create_dive_from_plan(diveplan, is_planner);
Bail out of deco calculation after 48h or dive time With very low values of GFhigh and setting the last stop depth to 6m it is possible to create dives that need infintie decompression time. This ends deco after 48h and replaces the dive plan with an error message. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-05 10:58:23 +00:00
add_plan_to_notes(diveplan, &displayed_dive, show_disclaimer, error);
Planner: show mean depth Almost invisible, mostly looking like an odd bug in the profile code, there was a tiny red line at depth 0 in the planned profile. Turns out that was the missing mean depth. We didn't populate enough data in the dive computer of the dive we generated from the plan (and the length of the depth line was incorrectly determined by the duration of the dive instead of the duration stored in the dive computer). Fixes #570 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-08-04 14:36:07 +00:00
fixup_dc_duration(&displayed_dive.dc);
Delete code and files that are no longer used Most of this is Gtk related, some of it is helpers that we don't need anymore. I love the diffstat. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-07 00:32:50 +00:00
Add support to planner to use additional gases during the ascent This change ended up being quite a bit bigger than expected as it uncovered a number of bugs in the existing code. The planner now handles gas changes correctly by creating (and later parsing) events in the simulated divecomputer. At the end of the dive specified in the input form the algorithm starts with the deepest interesting depth: either the first stop below our ceiling or the deepest depth at which we can change gases. It then traverses all the stop and all the gas change depth and at each stage ensures that we are allowed to ascend further before going on. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:01:15 +00:00
free(stoplevels);
free(gaschanges);
Avoid resource leak Coverity CID 1325288 Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-02 00:39:32 +00:00
free(bottom_cache);
Only add disclaimer and runtime table if we added deco to replanne dive As a side effect this changes the signature of plan(): Before it returned an int that was supposed to be possibly an error but we never bothered to check it. So now it's bool indicating if the planner did add stops. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-09 19:55:59 +00:00
return decodive;
First stab at simplistic dive planning This comes with absolutely no gui - so the plan literally needs to be compiled into Subsurface. Not exactly a feature, but this allowed me to focus on the planning part instead of spending time on tedious UI work. A new menu "Planner" with entry "Test Planner" calls into the hard-coded function in planner.c. There a simple dive plan can be constructed with calls to plan_add_segment(&diveplan, duration, depth at the end, fO2, pO2) Calling plan(&diveplan) does the deco calculations and creates deco stops that keep us below the ceiling (with the GFlow/high values currently configured). The stop levels used are defined at the top of planner.c in the stoplevels array - there is no need to do the traditional multiples of 3m or anything like that. The dive including the ascents and deco stops all the way to the surface is completed and then added as simulated dive to the end of the divelist (I guess we could automatically select it later) and can be viewed. This is crude but shows the direction we can go with this. Envision a nice UI that allows you to simply enter the segments and pick the desired stops. What is missing is the ability to give the algorithm additional gases that it can use during the deco phase - right now it simply keeps using the last gas used in the diveplan. All that said, there are clear bugs here - and sadly they seem to be in the deco calculations, as with the example given the ceiling that is calculated makes no sense. When displayed in smooth mode it has very strange jumps up and down that I wouldn't expect. For example with GF 35/75 (the default) the deco ceiling when looking at the simulated dive jumps from 16m back up to 13m around 14:10 into the dive. That seems very odd. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-05 07:11:42 +00:00
}
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
/*
* Get a value in tenths (so "10.2" == 102, "9" = 90)
*
* Return negative for errors.
*/
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
static int get_tenths(const char *begin, const char **endp)
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
{
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
char *end;
int value = strtol(begin, &end, 10);
if (begin == end)
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
return -1;
value *= 10;
/* Fraction? We only look at the first digit */
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
if (*end == '.') {
Add code to enter SAC rates for dive planning This just provides the infrastructure to enter the data, nothing is calculated, yet. This adds a new get_thousandths() helper function so we can enter information of the 'mili-' type as decimal values. So things like "14.5 l/min" or "0.75 cuft/min" are parsed correctly and converted into a ml value. In the process of implementing that I also fixed a bug introduced in commit ab7aecf16e96 ("Simplify dive planning code") which broke the get_tenth() function. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 00:54:59 +00:00
end++;
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
if (!isdigit(*end))
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
return -1;
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
value += *end - '0';
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
do {
Add code to enter SAC rates for dive planning This just provides the infrastructure to enter the data, nothing is calculated, yet. This adds a new get_thousandths() helper function so we can enter information of the 'mili-' type as decimal values. So things like "14.5 l/min" or "0.75 cuft/min" are parsed correctly and converted into a ml value. In the process of implementing that I also fixed a bug introduced in commit ab7aecf16e96 ("Simplify dive planning code") which broke the get_tenth() function. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 00:54:59 +00:00
end++;
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
} while (isdigit(*end));
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
}
Add code to enter SAC rates for dive planning This just provides the infrastructure to enter the data, nothing is calculated, yet. This adds a new get_thousandths() helper function so we can enter information of the 'mili-' type as decimal values. So things like "14.5 l/min" or "0.75 cuft/min" are parsed correctly and converted into a ml value. In the process of implementing that I also fixed a bug introduced in commit ab7aecf16e96 ("Simplify dive planning code") which broke the get_tenth() function. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-16 00:54:59 +00:00
*endp = end;
return value;
}
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
static int get_permille(const char *begin, const char **end)
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
{
int value = get_tenths(begin, end);
if (value >= 0) {
/* Allow a percentage sign */
if (**end == '%')
++*end;
}
return value;
}
Use proper types This is step one of many to use gasmix instead of int o2/he. Right now some of these changes look ridiculous because after changing a few lines we immediately go back to o2 = get_o2(gas). The reason is that I wanted to convert a hand full of functions at a time. So in this commit I only change validate_gas(), get_gas_from_events() and get_gasidx() to use a struct gasmix instead of int o2, int he. This state builds and survived some mild testing. Let's continue on top of that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 21:17:06 +00:00
int validate_gas(const char *text, struct gasmix *gas)
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
{
int o2, he;
if (!text)
return 0;
First steps towards removing glib dependencies - remove the build flags and libraries from the Makefile / Configure.mk - remove the glib types (gboolean, gchar, gint64, gint) - comment out / hack around gettext - replace the glib file helper functions - replace g_ascii_strtod - replace g_build_filename - use environment variables instead of g_get_home_dir() & g_get_user_name() - comment out GPS string parsing (uses glib utf8 macros) This needs massive cleanup, but it's a snapshot of what I have right now, in case people want to look at it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-05 07:29:09 +00:00
while (isspace(*text))
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
text++;
Simplify dive planning code This simplifies the dive planning code by: - allowing empty gas mixes (which means "pick previous gas") - avoiding unnecessary strdup/free calls (this requires us to handle "const char *" in the parsers, but that was already true from a code standpoint, just not a type one) - re-use the "plan()" function for a successful dive plan, rather than open-coding the dive plan segment handling. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 21:13:10 +00:00
if (!*text)
return 0;
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
if (!strcasecmp(text, translate("gettextFromC", "air"))) {
o2 = O2_IN_AIR;
he = 0;
text += strlen(translate("gettextFromC", "air"));
Allow "oxygen" as a gas name ...as this what comes in when the user selects this gas in the add dive/dive planner contet menu. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-05-14 21:33:48 +00:00
} else if (!strcasecmp(text, translate("gettextFromC", "oxygen"))) {
o2 = 1000;
he = 0;
text += strlen(translate("gettextFromC", "oxygen"));
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
} else if (!strncasecmp(text, translate("gettextFromC", "ean"), 3)) {
o2 = get_permille(text + 3, &text);
he = 0;
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
} else {
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
o2 = get_permille(text, &text);
he = 0;
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
if (*text == '/')
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
he = get_permille(text + 1, &text);
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
}
/* We don't want any extra crud */
First steps towards removing glib dependencies - remove the build flags and libraries from the Makefile / Configure.mk - remove the glib types (gboolean, gchar, gint64, gint) - comment out / hack around gettext - replace the glib file helper functions - replace g_ascii_strtod - replace g_build_filename - use environment variables instead of g_get_home_dir() & g_get_user_name() - comment out GPS string parsing (uses glib utf8 macros) This needs massive cleanup, but it's a snapshot of what I have right now, in case people want to look at it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-05 07:29:09 +00:00
while (isspace(*text))
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
text++;
if (*text)
return 0;
/* Validate the gas mix */
Massive automated whitespace cleanup I know everyone will hate it. Go ahead. Complain. Call me names. At least now things are consistent and reproducible. If you want changes, have your complaint come with a patch to scripts/whitespace.pl so that we can automate it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-02-28 04:09:57 +00:00
if (*text || o2 < 1 || o2 > 1000 || he < 0 || o2 + he > 1000)
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
return 0;
/* Let it rip */
Use proper types This is step one of many to use gasmix instead of int o2/he. Right now some of these changes look ridiculous because after changing a few lines we immediately go back to o2 = get_o2(gas). The reason is that I wanted to convert a hand full of functions at a time. So in this commit I only change validate_gas(), get_gas_from_events() and get_gasidx() to use a struct gasmix instead of int o2, int he. This state builds and survived some mild testing. Let's continue on top of that. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-06-01 21:17:06 +00:00
gas->o2.permille = o2;
gas->he.permille = he;
Move planner UI into planner.c There should be NO other changes in this commit - just moving the code and adjusting the includes (and adding the entry point to display-gtk.h). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-07 19:23:14 +00:00
return 1;
}
Separate Gtk related code from core logic: planner Relatively straight forward, just a handful of places where we call show_error() (a UI function) from the logic code. In the process I noticed a few places where error returns weren't dealt with correctly. Added a new planner.h files for the necessary declarations. This should make no difference to functionality. Signed-off-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-04-08 03:20:25 +00:00
int validate_po2(const char *text, int *mbar_po2)
Dive planning for closed circuit rebreather This misses a single issue to be used as a base for further discussion: The CC setpoint is used for the next segment, not the one specified for. I also have in mind to modify the existing code to use setpoints specified in mbar and plain integer instead of float values. Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-23 19:12:24 +00:00
{
int po2;
if (!text)
return 0;
po2 = get_tenths(text, &text);
if (po2 < 0)
return 0;
First steps towards removing glib dependencies - remove the build flags and libraries from the Makefile / Configure.mk - remove the glib types (gboolean, gchar, gint64, gint) - comment out / hack around gettext - replace the glib file helper functions - replace g_ascii_strtod - replace g_build_filename - use environment variables instead of g_get_home_dir() & g_get_user_name() - comment out GPS string parsing (uses glib utf8 macros) This needs massive cleanup, but it's a snapshot of what I have right now, in case people want to look at it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-05 07:29:09 +00:00
while (isspace(*text))
Dive planning for closed circuit rebreather This misses a single issue to be used as a base for further discussion: The CC setpoint is used for the next segment, not the one specified for. I also have in mind to modify the existing code to use setpoints specified in mbar and plain integer instead of float values. Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-23 19:12:24 +00:00
text++;
First steps towards removing glib dependencies - remove the build flags and libraries from the Makefile / Configure.mk - remove the glib types (gboolean, gchar, gint64, gint) - comment out / hack around gettext - replace the glib file helper functions - replace g_ascii_strtod - replace g_build_filename - use environment variables instead of g_get_home_dir() & g_get_user_name() - comment out GPS string parsing (uses glib utf8 macros) This needs massive cleanup, but it's a snapshot of what I have right now, in case people want to look at it. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-10-05 07:29:09 +00:00
while (isspace(*text))
Dive planning for closed circuit rebreather This misses a single issue to be used as a base for further discussion: The CC setpoint is used for the next segment, not the one specified for. I also have in mind to modify the existing code to use setpoints specified in mbar and plain integer instead of float values. Signed-off-by: Jan Schubert <Jan.Schubert@GMX.li> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-23 19:12:24 +00:00
text++;
if (*text)
return 0;
*mbar_po2 = po2 * 100;
return 1;
}
Reference in a new issue Copy permalink