2017-04-27 18:24:53 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2011-08-31 01:23:59 +00:00
|
|
|
#ifndef DIVE_H
|
|
|
|
|
#define DIVE_H
|
|
|
|
|
|
2018-05-11 15:25:41 +00:00
|
|
|
// dive and dive computer related structures and helpers
|
|
|
|
|
|
2011-09-03 20:19:26 +00:00
|
|
|
#include <stdlib.h>
|
2012-11-25 19:44:27 +00:00
|
|
|
#include <stdint.h>
|
2018-01-07 10:14:46 +00:00
|
|
|
#include <stdbool.h>
|
2011-09-03 20:19:26 +00:00
|
|
|
#include <time.h>
|
2013-01-08 23:48:23 +00:00
|
|
|
#include <math.h>
|
2013-12-19 13:00:50 +00:00
|
|
|
#include <zip.h>
|
2014-02-15 06:36:49 +00:00
|
|
|
#include <sqlite3.h>
|
2014-05-06 21:08:17 +00:00
|
|
|
#include <string.h>
|
2017-02-24 07:06:48 +00:00
|
|
|
#include <sys/stat.h>
|
2015-02-12 05:46:02 +00:00
|
|
|
#include "divesite.h"
|
2011-11-05 10:39:17 +00:00
|
|
|
#include <libxml/tree.h>
|
2013-03-10 08:24:49 +00:00
|
|
|
#include <libxslt/transform.h>
|
2014-07-16 08:57:29 +00:00
|
|
|
#include <libxslt/xsltutils.h>
|
2013-02-16 01:03:42 +00:00
|
|
|
|
|
|
|
|
#include "sha1.h"
|
2014-05-10 23:42:27 +00:00
|
|
|
#include "units.h"
|
2011-09-05 20:14:53 +00:00
|
|
|
|
2013-04-01 10:51:49 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-02-13 07:35:52 +00:00
|
|
|
extern int last_xml_version;
|
|
|
|
|
|
2018-05-08 14:24:51 +00:00
|
|
|
enum divemode_t {OC, CCR, PSCR, FREEDIVE, NUM_DIVEMODE, UNDEF_COMP_TYPE}; // Flags (Open-circuit and Closed-circuit-rebreather) for setting dive computer type
|
2017-01-23 16:35:27 +00:00
|
|
|
enum cylinderuse {OC_GAS, DILUENT, OXYGEN, NOT_USED, NUM_GAS_USE}; // The different uses for cylinders
|
2014-11-16 22:11:34 +00:00
|
|
|
|
|
|
|
|
extern const char *cylinderuse_text[];
|
2018-05-17 08:04:41 +00:00
|
|
|
extern const char *divemode_text_ui[];
|
2015-01-10 23:01:15 +00:00
|
|
|
extern const char *divemode_text[];
|
2014-06-11 17:48:48 +00:00
|
|
|
|
2018-09-10 18:40:25 +00:00
|
|
|
// o2 == 0 && he == 0 -> air
|
|
|
|
|
// o2 < 0 -> invalid
|
2011-09-12 16:47:55 +00:00
|
|
|
struct gasmix {
|
2011-08-31 01:23:59 +00:00
|
|
|
fraction_t o2;
|
Start parsing gas mixes
The suunto xml is just completely crazy. What's the helium percentage
companion to "o2pct"? Would it be "hepct"? No. It's "hepct_0".
Ok, so they didn't number the first o2pct, which could be seen as sane:
that's the only mix value that should always exist. And they clearly
started their indexing with 0. So with multiple mixes, you'd then
expect "o2pct_1" and "hepct_1", right?
Wrong! Because XML people are crazy, the second O2 mix percentage is
obviously "o2pct_2". So the O2 percentages are one-based, with an
implicit one. But the He percentages are zero-based with an explicit
zero. So the second mix is "o2pct_2" and "hepct_1".
I'd like to ask what drugs Suunto people are on, but hey, it's a Finnish
company. No need to ask. Vodka explains everything. LOTS AND LOTS OF
VODKA.
In comparison, the libdivecomputer output is nice and sane, and uses a
'gasmix' node. Of course, now we have so many different XML nesting
nodes to check that I just made it an array of different noces. That
also allows me to mark the suunto case, so that we only do the "check
for crazy alcoholic xml entries" when it's a suunto file.
The "type of file" thing is probably a good idea for deciding on default
units too. Some day.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-01 20:32:52 +00:00
|
|
|
fraction_t he;
|
2011-09-12 16:47:55 +00:00
|
|
|
};
|
2018-09-10 18:40:25 +00:00
|
|
|
static const struct gasmix gasmix_invalid = { { -1 }, { -1 } };
|
|
|
|
|
static const struct gasmix gasmix_air = { { 0 }, { 0 } };
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-08-31 01:23:59 +00:00
|
|
|
volume_t size;
|
2011-09-04 03:31:18 +00:00
|
|
|
pressure_t workingpressure;
|
2014-02-28 04:09:57 +00:00
|
|
|
const char *description; /* "LP85", "AL72", "AL80", "HP100+" or whatever */
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_type_t;
|
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-09-04 03:31:18 +00:00
|
|
|
cylinder_type_t type;
|
2011-09-12 16:47:55 +00:00
|
|
|
struct gasmix gasmix;
|
2011-11-09 15:37:25 +00:00
|
|
|
pressure_t start, end, sample_start, sample_end;
|
2013-11-12 02:12:43 +00:00
|
|
|
depth_t depth;
|
2014-06-01 19:38:32 +00:00
|
|
|
bool manually_added;
|
2014-06-01 16:59:38 +00:00
|
|
|
volume_t gas_used;
|
2014-07-01 07:37:49 +00:00
|
|
|
volume_t deco_gas_used;
|
Calculate nitrogen and helium gas pressures for CCR after import from CSV
Currently the gas pressures stored in structures of pressure are
calculated using the gasmix composition of the currently selected
cylinder. But with CCR dives the default cylinder is the oxygen
cylinder (here, index 0). However, the gas pressures need to
be calculated using gasmix data from cylinder 1 (the diluent
cylinder). This patch allows setting the appropriate cylinder
for calculating the values in the structures of pressure. It
also allows for correctly calculating gas pressures for any
open circuit cylinders (e.g. bailout) that a CCR diver may
use. This is performed as follows:
1) In dive.h create an enum variable {oxygen, diluent, bailout}
2) Within the definition of cylinder_t, add a member: cylinder_use_type
This stores an enum variable, one of the above.
3) In file.c where the Poseidon CSV data are read in, assign
the appropriate enum values to each of the cylinders.
4) Within the definition of structure dive, add two members:
int oxygen_cylinder_index
int diluent_cylinder_index
This will keep the indices of the two main CCR cylinders.
5) In dive.c create a function get_cylinder_use(). This scans the
cylinders for that dive, looking for a cylinder that has a
particular cylinder_use_type and returns that cylinder index.
6) In dive.c create a function fixup_cylinder_use() that stores the
indices of the oxygen and diluent cylinders in the variables
dive->oxygen_cylinder_index and dive->diluent_cylinder_index,
making use of the function in 4) above.
7) In profile.c, modify function calculate_gas_information_new()
to use the above functions for CCR dives to find the oxygen and
diluent cylinders and to calculate partail gas pressures based
on the diluent cylinder gas mix.
This results in the correct calculation of gas partial pressures
in the case of CCR dives, displaying the correct partial pressure
graphs in the dive profile widget.
Signed-off-by: willem ferguson <willemferguson@zoology.up.ac.za>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-03 20:11:00 +00:00
|
|
|
enum cylinderuse cylinder_use;
|
2016-07-06 12:40:35 +00:00
|
|
|
bool bestmix_o2;
|
|
|
|
|
bool bestmix_he;
|
2011-09-04 03:31:18 +00:00
|
|
|
} cylinder_t;
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2011-12-24 03:41:16 +00:00
|
|
|
weight_t weight;
|
2014-02-28 04:09:57 +00:00
|
|
|
const char *description; /* "integrated", "belt", "ankle" */
|
2011-12-24 03:41:16 +00:00
|
|
|
} weightsystem_t;
|
|
|
|
|
|
2018-01-19 19:13:34 +00:00
|
|
|
struct icd_data { // This structure provides communication between function isobaric_counterdiffusion() and the calling software.
|
|
|
|
|
int dN2; // The change in fraction (permille) of nitrogen during the change
|
|
|
|
|
int dHe; // The change in fraction (permille) of helium during the change
|
|
|
|
|
};
|
|
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
extern bool isobaric_counterdiffusion(struct gasmix oldgasmix, struct gasmix newgasmix, struct icd_data *results);
|
2018-01-19 19:13:34 +00:00
|
|
|
|
2014-06-01 19:07:29 +00:00
|
|
|
/*
|
|
|
|
|
* Events are currently based straight on what libdivecomputer gives us.
|
|
|
|
|
* We need to wrap these into our own events at some point to remove some of the limitations.
|
|
|
|
|
*/
|
|
|
|
|
struct event {
|
|
|
|
|
struct event *next;
|
|
|
|
|
duration_t time;
|
2014-08-17 18:26:21 +00:00
|
|
|
int type;
|
|
|
|
|
/* This is the annoying libdivecomputer format. */
|
|
|
|
|
int flags, value;
|
|
|
|
|
/* .. and this is our "extended" data for some event types */
|
|
|
|
|
union {
|
2018-05-08 14:24:51 +00:00
|
|
|
enum divemode_t divemode; // for divemode change events
|
2014-08-17 18:26:21 +00:00
|
|
|
/*
|
|
|
|
|
* NOTE! The index may be -1, which means "unknown". In that
|
|
|
|
|
* case, the get_cylinder_index() function will give the best
|
|
|
|
|
* match with the cylinders in the dive based on gasmix.
|
|
|
|
|
*/
|
2018-04-05 10:02:25 +00:00
|
|
|
struct { // for gas switch events
|
2014-08-17 18:26:21 +00:00
|
|
|
int index;
|
|
|
|
|
struct gasmix mix;
|
|
|
|
|
} gas;
|
|
|
|
|
};
|
2014-06-01 19:07:29 +00:00
|
|
|
bool deleted;
|
|
|
|
|
char name[];
|
|
|
|
|
};
|
|
|
|
|
|
2018-08-16 22:58:30 +00:00
|
|
|
extern int event_is_gaschange(const struct event *ev);
|
2014-06-02 19:40:31 +00:00
|
|
|
|
2014-05-29 20:13:11 +00:00
|
|
|
extern int get_pressure_units(int mb, const char **units);
|
2014-02-28 23:38:42 +00:00
|
|
|
extern double get_depth_units(int mm, int *frac, const char **units);
|
2012-08-07 18:24:40 +00:00
|
|
|
extern double get_volume_units(unsigned int ml, int *frac, const char **units);
|
|
|
|
|
extern double get_temp_units(unsigned int mk, const char **units);
|
|
|
|
|
extern double get_weight_units(unsigned int grams, int *frac, const char **units);
|
2013-10-04 05:57:48 +00:00
|
|
|
extern double get_vertical_speed_units(unsigned int mms, int *frac, const char **units);
|
2011-09-21 19:12:54 +00:00
|
|
|
|
2017-03-10 06:22:31 +00:00
|
|
|
extern depth_t units_to_depth(double depth);
|
2014-08-19 16:13:55 +00:00
|
|
|
extern int units_to_sac(double volume);
|
2013-10-11 23:39:40 +00:00
|
|
|
|
2013-02-25 23:23:16 +00:00
|
|
|
/* Volume in mliter of a cylinder at pressure 'p' */
|
2018-08-23 17:18:43 +00:00
|
|
|
extern int gas_volume(const cylinder_t *cyl, pressure_t p);
|
2018-08-16 17:10:10 +00:00
|
|
|
extern double gas_compressibility_factor(struct gasmix gas, double bar);
|
|
|
|
|
extern double isothermal_pressure(struct gasmix gas, double p1, int volume1, int volume2);
|
|
|
|
|
extern double gas_density(struct gasmix gas, int pressure);
|
|
|
|
|
extern int same_gasmix(struct gasmix a, struct gasmix b);
|
2014-10-13 19:19:21 +00:00
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
static inline int get_o2(struct gasmix mix)
|
2013-03-28 16:56:32 +00:00
|
|
|
{
|
2018-08-16 17:10:10 +00:00
|
|
|
return mix.o2.permille ?: O2_IN_AIR;
|
2013-03-28 16:56:32 +00:00
|
|
|
}
|
|
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
static inline int get_he(struct gasmix mix)
|
2013-03-28 16:56:32 +00:00
|
|
|
{
|
2018-08-16 17:10:10 +00:00
|
|
|
return mix.he.permille;
|
2013-03-28 16:56:32 +00:00
|
|
|
}
|
|
|
|
|
|
2014-09-15 12:55:20 +00:00
|
|
|
struct gas_pressures {
|
|
|
|
|
double o2, n2, he;
|
|
|
|
|
};
|
|
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
extern void fill_pressures(struct gas_pressures *pressures, const double amb_pressure, struct gasmix mix, double po2, enum divemode_t dctype);
|
2014-10-13 19:19:21 +00:00
|
|
|
|
2014-05-25 16:01:16 +00:00
|
|
|
extern void sanitize_gasmix(struct gasmix *mix);
|
2018-08-16 17:10:10 +00:00
|
|
|
extern int gasmix_distance(struct gasmix a, struct gasmix b);
|
2018-08-16 22:58:30 +00:00
|
|
|
extern int find_best_gasmix_match(struct gasmix mix, const cylinder_t array[], unsigned int used);
|
2014-05-25 16:01:16 +00:00
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
extern bool gasmix_is_air(struct gasmix gasmix);
|
2014-06-01 22:25:19 +00:00
|
|
|
|
2013-01-08 23:48:23 +00:00
|
|
|
/* Linear interpolation between 'a' and 'b', when we are 'part'way into the 'whole' distance from a to b */
|
|
|
|
|
static inline int interpolate(int a, int b, int part, int whole)
|
|
|
|
|
{
|
|
|
|
|
/* It is doubtful that we actually need floating point for this, but whatever */
|
2016-08-30 03:05:20 +00:00
|
|
|
if (whole) {
|
|
|
|
|
double x = (double)a * (whole - part) + (double)b * part;
|
2018-05-18 15:46:12 +00:00
|
|
|
return (int)lrint(x / whole);
|
2016-08-30 03:05:20 +00:00
|
|
|
}
|
|
|
|
|
return (a+b)/2;
|
2013-01-08 23:48:23 +00:00
|
|
|
}
|
|
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
void get_gas_string(struct gasmix gasmix, char *text, int len);
|
|
|
|
|
const char *gasname(struct gasmix gasmix);
|
2014-06-02 03:56:29 +00:00
|
|
|
|
Try to sanely download multiple concurrent cylinder pressures
This tries to sanely handle the case of a dive computer reporting
multiple cylinder pressures concurrently.
NOTE! There are various "interesting" situations that this whole issue
brings up:
- some dive computers may report more cylinder pressures than we have
slots for.
Currently we will drop such pressures on the floor if they come for
the same sample, but if they end up being spread across multiple
samples we will end up re-using the slots with different sensor
indexes.
That kind of slot re-use may or may not end up confusing other
subsurface logic - for example, make things believe there was a
cylidner change event.
- some dive computers might send only one sample at a time, but switch
*which* sample they send on a gas switch event. If they also report
the correct sensor number, we'll now start reporting that pressure in
the second slot.
This should all be fine, and is the RightThing(tm) to do, but is
different from what we used to do when we only ever used a single
slot.
- When people actually use multiple sensors, our old save format will
start to need fixing. Right now our save format comes from the CCR
model where the second sensor was always the Oxygen sensor.
We save that pressure fine (except we save it as "o2pressure" - just
an odd historical naming artifact), but we do *not* save the actual
sensor index, because in our traditional format that was always
implicit in the data ("it's the oxygen cylinder").
so while this code hopefully makes our libdivecomputer download do the
right thing, there *will* be further fallout from having multiple
cylinder pressure sensors. We're not done yet.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-07-24 18:55:47 +00:00
|
|
|
#define MAX_SENSORS 2
|
2017-11-05 14:56:35 +00:00
|
|
|
struct sample // BASE TYPE BYTES UNITS RANGE DESCRIPTION
|
|
|
|
|
{ // --------- ----- ----- ----- -----------
|
|
|
|
|
duration_t time; // int32_t 4 seconds (0-34 yrs) elapsed dive time up to this sample
|
|
|
|
|
duration_t stoptime; // int32_t 4 seconds (0-34 yrs) time duration of next deco stop
|
|
|
|
|
duration_t ndl; // int32_t 4 seconds (-1 no val, 0-34 yrs) time duration before no-deco limit
|
|
|
|
|
duration_t tts; // int32_t 4 seconds (0-34 yrs) time duration to reach the surface
|
|
|
|
|
duration_t rbt; // int32_t 4 seconds (0-34 yrs) remaining bottom time
|
|
|
|
|
depth_t depth; // int32_t 4 mm (0-2000 km) dive depth of this sample
|
|
|
|
|
depth_t stopdepth; // int32_t 4 mm (0-2000 km) depth of next deco stop
|
2018-02-21 17:52:36 +00:00
|
|
|
temperature_t temperature; // uint32_t 4 mdegrK (0-4 MdegK) ambient temperature
|
2017-11-05 14:56:35 +00:00
|
|
|
pressure_t pressure[MAX_SENSORS]; // int32_t 4 mbar (0-2 Mbar) cylinder pressures (main and CCR o2)
|
|
|
|
|
o2pressure_t setpoint; // uint16_t 2 mbar (0-65 bar) O2 partial pressure (will be setpoint)
|
|
|
|
|
o2pressure_t o2sensor[3]; // uint16_t 6 mbar (0-65 bar) Up to 3 PO2 sensor values (rebreather)
|
|
|
|
|
bearing_t bearing; // int16_t 2 degrees (-1 no val, 0-360 deg) compass bearing
|
|
|
|
|
uint8_t sensor[MAX_SENSORS]; // uint8_t 1 sensorID (0-255) ID of cylinder pressure sensor
|
|
|
|
|
uint16_t cns; // uint16_t 1 % (0-64k %) cns% accumulated
|
|
|
|
|
uint8_t heartbeat; // uint8_t 1 beats/m (0-255) heart rate measurement
|
|
|
|
|
volume_t sac; // 4 ml/min predefined SAC
|
|
|
|
|
bool in_deco; // bool 1 y/n y/n this sample is part of deco
|
|
|
|
|
bool manually_entered; // bool 1 y/n y/n this sample was entered by the user,
|
2018-05-11 15:25:41 +00:00
|
|
|
// not calculated when planning a dive
|
2017-11-05 14:56:35 +00:00
|
|
|
}; // Total size of structure: 57 bytes, excluding padding at end
|
2011-08-31 01:23:59 +00:00
|
|
|
|
2013-11-02 01:12:42 +00:00
|
|
|
struct divetag {
|
|
|
|
|
/*
|
|
|
|
|
* The name of the divetag. If a translation is available, name contains
|
|
|
|
|
* the translated tag
|
|
|
|
|
*/
|
|
|
|
|
char *name;
|
|
|
|
|
/*
|
|
|
|
|
* If a translation is available, we write the original tag to source.
|
|
|
|
|
* This enables us to write a non-localized tag to the xml file.
|
|
|
|
|
*/
|
|
|
|
|
char *source;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct tag_entry {
|
|
|
|
|
struct divetag *tag;
|
|
|
|
|
struct tag_entry *next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* divetags are only stored once, each dive only contains
|
|
|
|
|
* a list of tag_entries which then point to the divetags
|
|
|
|
|
* in the global g_tag_list
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
extern struct tag_entry *g_tag_list;
|
|
|
|
|
|
Get rid of crazy empty tag_list element at the start
So this is totally unrelated to the git repository format, except for
the fact that I noticed it while writing the git saving code.
The subsurface divetag list handling is being stupid, and has a
initial dummy entry at the head of the list for no good reason.
I say "no good reason", because there *is* a reason for it: it allows
code to avoid the special case of empty list and adding entries to
before the first entry etc etc. But that reason is a really *bad*
reason, because it's valid only because people don't understand basic
list manipulation and pointers to pointers.
So get rid of the dummy element, and do things right instead - by
passing a *pointer* to the list, instead of the list. And then when
traversing the list and looking for a place to insert things, don't go
to the next entry - just update the "pointer to pointer" to point to
the address of the next entry. Each entry in a C linked list is no
different than the list itself, so you can use the pointer to the
pointer to the next entry as a pointer to the list.
This is a pet peeve of mine. The real beauty of pointers can never be
understood unless you understand the indirection they allow. People
who grew up with Pascal and were corrupted by that mindset are
mentally stunted. Niklaus Wirth has a lot to answer for!
But never fear. You too can overcome that mental limitation, it just
needs some brain exercise. Reading this patch may help. In particular,
contemplate the new "taglist_add_divetag()".
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-10 17:18:13 +00:00
|
|
|
struct divetag *taglist_add_tag(struct tag_entry **tag_list, const char *tag);
|
2015-05-02 19:16:03 +00:00
|
|
|
struct tag_entry *taglist_added(struct tag_entry *original_list, struct tag_entry *new_list);
|
|
|
|
|
void dump_taglist(const char *intro, struct tag_entry *tl);
|
2013-11-02 01:12:42 +00:00
|
|
|
|
|
|
|
|
/*
|
2018-04-09 08:09:34 +00:00
|
|
|
* Writes all divetags form tag_list into internally allocated buffer
|
|
|
|
|
* Function returns pointer to allocated buffer
|
|
|
|
|
* Buffer contains comma separated list of tags names or null terminated string
|
|
|
|
|
*
|
|
|
|
|
* NOTE! The returned buffer must be freed once used.
|
2013-11-02 01:12:42 +00:00
|
|
|
*/
|
2018-04-09 08:09:34 +00:00
|
|
|
char *taglist_get_tagstring(struct tag_entry *tag_list);
|
2013-11-02 01:12:42 +00:00
|
|
|
|
2014-07-10 16:39:51 +00:00
|
|
|
/* cleans up a list: removes empty tags and duplicates */
|
|
|
|
|
void taglist_cleanup(struct tag_entry **tag_list);
|
|
|
|
|
|
2013-11-02 01:12:42 +00:00
|
|
|
void taglist_init_global();
|
Get rid of crazy empty tag_list element at the start
So this is totally unrelated to the git repository format, except for
the fact that I noticed it while writing the git saving code.
The subsurface divetag list handling is being stupid, and has a
initial dummy entry at the head of the list for no good reason.
I say "no good reason", because there *is* a reason for it: it allows
code to avoid the special case of empty list and adding entries to
before the first entry etc etc. But that reason is a really *bad*
reason, because it's valid only because people don't understand basic
list manipulation and pointers to pointers.
So get rid of the dummy element, and do things right instead - by
passing a *pointer* to the list, instead of the list. And then when
traversing the list and looking for a place to insert things, don't go
to the next entry - just update the "pointer to pointer" to point to
the address of the next entry. Each entry in a C linked list is no
different than the list itself, so you can use the pointer to the
pointer to the next entry as a pointer to the list.
This is a pet peeve of mine. The real beauty of pointers can never be
understood unless you understand the indirection they allow. People
who grew up with Pascal and were corrupted by that mindset are
mentally stunted. Niklaus Wirth has a lot to answer for!
But never fear. You too can overcome that mental limitation, it just
needs some brain exercise. Reading this patch may help. In particular,
contemplate the new "taglist_add_divetag()".
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-03-10 17:18:13 +00:00
|
|
|
void taglist_free(struct tag_entry *tag_list);
|
2013-11-02 01:12:42 +00:00
|
|
|
|
2014-11-11 10:20:13 +00:00
|
|
|
bool taglist_contains(struct tag_entry *tag_list, const char *tag);
|
|
|
|
|
int count_dives_with_tag(const char *tag);
|
2014-11-13 00:01:58 +00:00
|
|
|
int count_dives_with_person(const char *person);
|
|
|
|
|
int count_dives_with_location(const char *location);
|
2014-11-13 20:35:12 +00:00
|
|
|
int count_dives_with_suit(const char *suit);
|
2014-11-11 10:20:13 +00:00
|
|
|
|
2014-11-06 18:32:48 +00:00
|
|
|
struct extra_data {
|
|
|
|
|
const char *key;
|
|
|
|
|
const char *value;
|
|
|
|
|
struct extra_data *next;
|
|
|
|
|
};
|
|
|
|
|
|
2012-11-25 19:44:27 +00:00
|
|
|
/*
|
|
|
|
|
* NOTE! The deviceid and diveid are model-specific *hashes* of
|
|
|
|
|
* whatever device identification that model may have. Different
|
|
|
|
|
* dive computers will have different identifying data, it could
|
|
|
|
|
* be a firmware number or a serial ID (in either string or in
|
|
|
|
|
* numeric format), and we do not care.
|
|
|
|
|
*
|
|
|
|
|
* The only thing we care about is that subsurface will hash
|
|
|
|
|
* that information the same way. So then you can check the ID
|
|
|
|
|
* of a dive computer by comparing the hashes for equality.
|
|
|
|
|
*
|
|
|
|
|
* A deviceid or diveid of zero is assumed to be "no ID".
|
|
|
|
|
*/
|
2012-11-24 02:51:27 +00:00
|
|
|
struct divecomputer {
|
2012-11-25 02:50:21 +00:00
|
|
|
timestamp_t when;
|
Improve profile display in planner
This patch allows the planner to save the last manually-entered
dive planner point of a dive plan. When the plan has been saved
and re-opened for edit, the time of the last-entered dive planner
point is used to ensure that dive planning continues from the same
point in the profile as was when the original dive plan was saved.
Mechanism:
1) In dive.h, create a new dc attribute dc->last_manual_time
with data type of duration_t.
2) In diveplanner.c, ensure that the last manually-entered
dive planner point is saved in dc->last_manual_time.
3) In save-xml.c, create a new XML attribute for the <divecomputer>
element, named last-manual-time. For dive plans, the element would
now look like:
<divecomputer model='planned dive' last-manual-time='31:17 min'>
4) In parse-xml.c, insert code that recognises the last-manual-time
XML attribute, reads the time value and assigns this time to
dc->last_manual_time.
5) In diveplannermodel.cpp, method DiveplannerPointModel::loadfromdive,
insert code that sets the appropriate boolean value to dp->entered
by comparing newtime (i.e. time of dp) with dc->last_manual_time.
6) Diveplannermodel.cpp also accepts profile data from normal dives in
the dive log, whether hand-entered or loaded from dive computer. It
looks like the reduction of dive points for dives with >100 points
continues to work ok.
The result is that when a dive plan is saved with manually entered
points up to e.g. 10 minutes into the dive, it can be re-opened for edit
in the dive planner and the planner re-creates the plan with manually
entered points up to 10 minutes. The rest of the points are "soft"
points, shaped by the deco calculations of the planner.
Improvements: Improve code for profile display in dive planner
This responds to #1052.
Change load-git.c and save-git.c so that the last-manual-time is
also saved in the git-format dive log.
Several stylistic changes in text for consistent C source code.
Improvement of dive planner profile display:
Do some simplification of my alterations to diveplannermodel.cpp
Two small style changes in planner.c and diveplannermodel.cpp
as requested ny @neolit123
Signed-off-by: Willem Ferguson <willemferguson@zoology.up.ac.za>
2018-01-15 12:51:47 +00:00
|
|
|
duration_t duration, surfacetime, last_manual_time;
|
2013-01-23 18:25:31 +00:00
|
|
|
depth_t maxdepth, meandepth;
|
|
|
|
|
temperature_t airtemp, watertemp;
|
|
|
|
|
pressure_t surface_pressure;
|
2018-05-08 14:24:51 +00:00
|
|
|
enum divemode_t divemode; // dive computer type: OC(default) or CCR
|
2014-06-11 17:48:48 +00:00
|
|
|
uint8_t no_o2sensors; // rebreathers: number of O2 sensors used
|
|
|
|
|
int salinity; // kg per 10000 l
|
2014-10-22 19:11:12 +00:00
|
|
|
const char *model, *serial, *fw_version;
|
2012-11-25 19:44:27 +00:00
|
|
|
uint32_t deviceid, diveid;
|
2012-11-24 02:51:27 +00:00
|
|
|
int samples, alloc_samples;
|
|
|
|
|
struct sample *sample;
|
|
|
|
|
struct event *events;
|
2014-11-06 18:32:48 +00:00
|
|
|
struct extra_data *extra_data;
|
2012-11-25 02:50:21 +00:00
|
|
|
struct divecomputer *next;
|
2012-11-24 02:51:27 +00:00
|
|
|
};
|
|
|
|
|
|
2017-02-02 14:31:52 +00:00
|
|
|
#define MAX_CYLINDERS (20)
|
2013-12-28 15:33:09 +00:00
|
|
|
#define MAX_WEIGHTSYSTEMS (6)
|
2017-06-13 22:45:18 +00:00
|
|
|
#define MAX_TANK_INFO (100)
|
2018-06-19 00:59:33 +00:00
|
|
|
#define MAX_WS_INFO (100)
|
2012-08-15 22:21:34 +00:00
|
|
|
#define W_IDX_PRIMARY 0
|
|
|
|
|
#define W_IDX_SECONDARY 1
|
Start parsing gas mixes
The suunto xml is just completely crazy. What's the helium percentage
companion to "o2pct"? Would it be "hepct"? No. It's "hepct_0".
Ok, so they didn't number the first o2pct, which could be seen as sane:
that's the only mix value that should always exist. And they clearly
started their indexing with 0. So with multiple mixes, you'd then
expect "o2pct_1" and "hepct_1", right?
Wrong! Because XML people are crazy, the second O2 mix percentage is
obviously "o2pct_2". So the O2 percentages are one-based, with an
implicit one. But the He percentages are zero-based with an explicit
zero. So the second mix is "o2pct_2" and "hepct_1".
I'd like to ask what drugs Suunto people are on, but hey, it's a Finnish
company. No need to ask. Vodka explains everything. LOTS AND LOTS OF
VODKA.
In comparison, the libdivecomputer output is nice and sane, and uses a
'gasmix' node. Of course, now we have so many different XML nesting
nodes to check that I just made it an array of different noces. That
also allows me to mark the suunto case, so that we only do the "check
for crazy alcoholic xml entries" when it's a suunto file.
The "type of file" thing is probably a good idea for deciding on default
units too. Some day.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-01 20:32:52 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef enum {
|
|
|
|
|
TF_NONE,
|
|
|
|
|
NO_TRIP,
|
|
|
|
|
IN_TRIP,
|
|
|
|
|
ASSIGNED_TRIP,
|
|
|
|
|
NUM_TRIPFLAGS
|
|
|
|
|
} tripflag_t;
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
typedef struct dive_trip
|
|
|
|
|
{
|
2012-09-20 19:30:58 +00:00
|
|
|
timestamp_t when;
|
2012-09-20 03:42:11 +00:00
|
|
|
char *location;
|
|
|
|
|
char *notes;
|
2012-11-26 02:53:15 +00:00
|
|
|
struct dive *dives;
|
2012-11-10 18:51:03 +00:00
|
|
|
int nrdives;
|
2018-07-18 06:01:25 +00:00
|
|
|
/* Used by the io-routines to mark trips that have already been written. */
|
|
|
|
|
bool saved;
|
2014-02-28 04:09:57 +00:00
|
|
|
unsigned expanded : 1, selected : 1, autogen : 1, fixup : 1;
|
2012-11-26 04:06:54 +00:00
|
|
|
struct dive_trip *next;
|
2012-09-20 03:42:11 +00:00
|
|
|
} dive_trip_t;
|
|
|
|
|
|
2012-11-26 04:06:54 +00:00
|
|
|
/* List of dive trips (sorted by date) */
|
|
|
|
|
extern dive_trip_t *dive_trip_list;
|
2014-06-02 19:56:02 +00:00
|
|
|
struct picture;
|
2011-08-31 01:23:59 +00:00
|
|
|
struct dive {
|
2011-09-11 18:36:33 +00:00
|
|
|
int number;
|
2012-08-22 05:04:24 +00:00
|
|
|
tripflag_t tripflag;
|
2012-09-20 03:42:11 +00:00
|
|
|
dive_trip_t *divetrip;
|
2012-11-26 02:53:15 +00:00
|
|
|
struct dive *next, **pprev;
|
2014-11-11 21:34:12 +00:00
|
|
|
bool selected;
|
|
|
|
|
bool hidden_by_filter;
|
2012-09-20 00:35:52 +00:00
|
|
|
timestamp_t when;
|
2015-02-11 19:22:00 +00:00
|
|
|
uint32_t dive_site_uuid;
|
2011-09-02 02:56:04 +00:00
|
|
|
char *notes;
|
2011-09-13 21:58:06 +00:00
|
|
|
char *divemaster, *buddy;
|
2011-12-07 19:58:16 +00:00
|
|
|
int rating;
|
2012-10-28 22:49:02 +00:00
|
|
|
int visibility; /* 0 - 5 star rating */
|
2011-09-04 03:31:18 +00:00
|
|
|
cylinder_t cylinder[MAX_CYLINDERS];
|
2011-12-24 03:41:16 +00:00
|
|
|
weightsystem_t weightsystem[MAX_WEIGHTSYSTEMS];
|
2012-08-14 23:07:25 +00:00
|
|
|
char *suit;
|
2012-12-11 05:18:48 +00:00
|
|
|
int sac, otu, cns, maxcns;
|
2013-02-09 00:15:18 +00:00
|
|
|
|
|
|
|
|
/* Calculated based on dive computer data */
|
2013-02-09 15:41:15 +00:00
|
|
|
temperature_t mintemp, maxtemp, watertemp, airtemp;
|
2013-02-09 14:50:53 +00:00
|
|
|
depth_t maxdepth, meandepth;
|
2013-02-09 00:15:18 +00:00
|
|
|
pressure_t surface_pressure;
|
2013-02-09 15:12:30 +00:00
|
|
|
duration_t duration;
|
2013-02-09 00:15:18 +00:00
|
|
|
int salinity; // kg per 10000 l
|
2012-11-24 02:51:27 +00:00
|
|
|
|
2014-01-07 01:30:01 +00:00
|
|
|
struct tag_entry *tag_list;
|
2012-11-24 02:51:27 +00:00
|
|
|
struct divecomputer dc;
|
2014-01-07 01:30:01 +00:00
|
|
|
int id; // unique ID for this dive
|
2014-06-02 19:56:02 +00:00
|
|
|
struct picture *picture_list;
|
2016-04-03 22:31:59 +00:00
|
|
|
unsigned char git_id[20];
|
2014-06-02 19:56:02 +00:00
|
|
|
};
|
|
|
|
|
|
2018-07-18 18:47:19 +00:00
|
|
|
extern void invalidate_dive_cache(struct dive *dive);
|
|
|
|
|
extern bool dive_cache_is_valid(const struct dive *dive);
|
2016-04-03 22:31:59 +00:00
|
|
|
|
2018-08-16 22:58:30 +00:00
|
|
|
extern int get_cylinder_idx_by_use(const struct dive *dive, enum cylinderuse cylinder_use_type);
|
2017-10-09 21:34:04 +00:00
|
|
|
extern void cylinder_renumber(struct dive *dive, int mapping[]);
|
2017-10-08 03:14:57 +00:00
|
|
|
extern int same_gasmix_cylinder(cylinder_t *cyl, int cylid, struct dive *dive, bool check_unused);
|
Calculate nitrogen and helium gas pressures for CCR after import from CSV
Currently the gas pressures stored in structures of pressure are
calculated using the gasmix composition of the currently selected
cylinder. But with CCR dives the default cylinder is the oxygen
cylinder (here, index 0). However, the gas pressures need to
be calculated using gasmix data from cylinder 1 (the diluent
cylinder). This patch allows setting the appropriate cylinder
for calculating the values in the structures of pressure. It
also allows for correctly calculating gas pressures for any
open circuit cylinders (e.g. bailout) that a CCR diver may
use. This is performed as follows:
1) In dive.h create an enum variable {oxygen, diluent, bailout}
2) Within the definition of cylinder_t, add a member: cylinder_use_type
This stores an enum variable, one of the above.
3) In file.c where the Poseidon CSV data are read in, assign
the appropriate enum values to each of the cylinders.
4) Within the definition of structure dive, add two members:
int oxygen_cylinder_index
int diluent_cylinder_index
This will keep the indices of the two main CCR cylinders.
5) In dive.c create a function get_cylinder_use(). This scans the
cylinders for that dive, looking for a cylinder that has a
particular cylinder_use_type and returns that cylinder index.
6) In dive.c create a function fixup_cylinder_use() that stores the
indices of the oxygen and diluent cylinders in the variables
dive->oxygen_cylinder_index and dive->diluent_cylinder_index,
making use of the function in 4) above.
7) In profile.c, modify function calculate_gas_information_new()
to use the above functions for CCR dives to find the oxygen and
diluent cylinders and to calculate partail gas pressures based
on the diluent cylinder gas mix.
This results in the correct calculation of gas partial pressures
in the case of CCR dives, displaying the correct partial pressure
graphs in the dive profile widget.
Signed-off-by: willem ferguson <willemferguson@zoology.up.ac.za>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2014-11-03 20:11:00 +00:00
|
|
|
|
2014-08-16 13:55:31 +00:00
|
|
|
/* when selectively copying dive information, which parts should be copied? */
|
|
|
|
|
struct dive_components {
|
2015-02-13 04:58:03 +00:00
|
|
|
unsigned int divesite : 1;
|
2014-08-16 13:55:31 +00:00
|
|
|
unsigned int notes : 1;
|
|
|
|
|
unsigned int divemaster : 1;
|
|
|
|
|
unsigned int buddy : 1;
|
|
|
|
|
unsigned int suit : 1;
|
|
|
|
|
unsigned int rating : 1;
|
|
|
|
|
unsigned int visibility : 1;
|
|
|
|
|
unsigned int tags : 1;
|
|
|
|
|
unsigned int cylinders : 1;
|
|
|
|
|
unsigned int weights : 1;
|
|
|
|
|
};
|
|
|
|
|
|
2018-08-16 22:58:30 +00:00
|
|
|
extern enum divemode_t get_current_divemode(const struct divecomputer *dc, int time, const struct event **evp, enum divemode_t *divemode);
|
|
|
|
|
extern struct event *get_next_divemodechange(const struct event **evd, bool update_pointer);
|
|
|
|
|
extern enum divemode_t get_divemode_at_time(const struct divecomputer *dc, int dtime, const struct event **ev_dmc);
|
2018-04-02 15:16:07 +00:00
|
|
|
|
2014-06-02 19:56:02 +00:00
|
|
|
/* picture list and methods related to dive picture handling */
|
|
|
|
|
struct picture {
|
|
|
|
|
char *filename;
|
2014-07-08 19:29:06 +00:00
|
|
|
offset_t offset;
|
2014-06-02 21:28:02 +00:00
|
|
|
degrees_t latitude;
|
|
|
|
|
degrees_t longitude;
|
2014-06-02 19:56:02 +00:00
|
|
|
struct picture *next;
|
2011-08-31 01:23:59 +00:00
|
|
|
};
|
|
|
|
|
|
2014-06-03 14:48:35 +00:00
|
|
|
#define FOR_EACH_PICTURE(_dive) \
|
|
|
|
|
if (_dive) \
|
|
|
|
|
for (struct picture *picture = (_dive)->picture_list; picture; picture = picture->next)
|
2014-06-02 20:07:26 +00:00
|
|
|
|
2014-10-28 10:13:07 +00:00
|
|
|
#define FOR_EACH_PICTURE_NON_PTR(_divestruct) \
|
|
|
|
|
for (struct picture *picture = (_divestruct).picture_list; picture; picture = picture->next)
|
2014-06-02 21:28:02 +00:00
|
|
|
|
|
|
|
|
extern struct picture *alloc_picture();
|
2018-08-16 22:36:51 +00:00
|
|
|
extern bool dive_check_picture_time(const struct dive *d, int shift_time, timestamp_t timestamp);
|
2017-02-21 09:00:16 +00:00
|
|
|
extern void dive_create_picture(struct dive *d, const char *filename, int shift_time, bool match_all);
|
2014-06-08 19:34:18 +00:00
|
|
|
extern void dive_add_picture(struct dive *d, struct picture *newpic);
|
2018-03-03 09:10:51 +00:00
|
|
|
extern bool dive_remove_picture(struct dive *d, const char *filename);
|
2014-06-03 07:10:39 +00:00
|
|
|
extern unsigned int dive_get_picture_count(struct dive *d);
|
2018-09-17 15:34:13 +00:00
|
|
|
extern bool picture_check_valid_time(timestamp_t timestamp, int shift_time);
|
2014-06-02 21:28:02 +00:00
|
|
|
extern void dive_set_geodata_from_picture(struct dive *d, struct picture *pic);
|
2016-03-15 20:31:59 +00:00
|
|
|
extern void picture_free(struct picture *picture);
|
2014-06-02 19:56:02 +00:00
|
|
|
|
2018-08-16 22:58:30 +00:00
|
|
|
extern bool has_gaschange_event(const struct dive *dive, const struct divecomputer *dc, int idx);
|
|
|
|
|
extern int explicit_first_cylinder(const struct dive *dive, const struct divecomputer *dc);
|
2018-08-16 22:36:51 +00:00
|
|
|
extern int get_depth_at_time(const struct divecomputer *dc, unsigned int time);
|
2014-06-02 19:56:02 +00:00
|
|
|
|
2018-08-16 22:36:51 +00:00
|
|
|
extern fraction_t best_o2(depth_t depth, const struct dive *dive);
|
|
|
|
|
extern fraction_t best_he(depth_t depth, const struct dive *dive);
|
2016-05-21 09:32:07 +00:00
|
|
|
|
2018-07-18 18:47:19 +00:00
|
|
|
extern int get_surface_pressure_in_mbar(const struct dive *dive, bool non_null);
|
|
|
|
|
extern int calculate_depth_to_mbar(int depth, pressure_t surface_pressure, int salinity);
|
2018-08-16 22:36:51 +00:00
|
|
|
extern int depth_to_mbar(int depth, const struct dive *dive);
|
|
|
|
|
extern double depth_to_bar(int depth, const struct dive *dive);
|
|
|
|
|
extern double depth_to_atm(int depth, const struct dive *dive);
|
|
|
|
|
extern int rel_mbar_to_depth(int mbar, const struct dive *dive);
|
|
|
|
|
extern int mbar_to_depth(int mbar, const struct dive *dive);
|
|
|
|
|
extern depth_t gas_mod(struct gasmix mix, pressure_t po2_limit, const struct dive *dive, int roundto);
|
|
|
|
|
extern depth_t gas_mnd(struct gasmix mix, depth_t end, const struct dive *dive, int roundto);
|
2016-07-06 12:40:31 +00:00
|
|
|
|
2012-11-11 09:36:46 +00:00
|
|
|
#define SURFACE_THRESHOLD 750 /* somewhat arbitrary: only below 75cm is it really diving */
|
|
|
|
|
|
2017-12-29 10:49:56 +00:00
|
|
|
extern bool autogroup;
|
2012-08-22 05:04:24 +00:00
|
|
|
/* random threashold: three days without diving -> new trip
|
|
|
|
|
* this works very well for people who usually dive as part of a trip and don't
|
|
|
|
|
* regularly dive at a local facility; this is why trips are an optional feature */
|
2014-02-28 04:09:57 +00:00
|
|
|
#define TRIP_THRESHOLD 3600 * 24 * 3
|
2012-08-22 05:04:24 +00:00
|
|
|
|
|
|
|
|
#define UNGROUPED_DIVE(_dive) ((_dive)->tripflag == NO_TRIP)
|
2012-09-20 03:42:11 +00:00
|
|
|
#define DIVE_IN_TRIP(_dive) ((_dive)->tripflag == IN_TRIP || (_dive)->tripflag == ASSIGNED_TRIP)
|
2012-09-07 17:12:31 +00:00
|
|
|
#define DIVE_NEEDS_TRIP(_dive) ((_dive)->tripflag == TF_NONE)
|
2012-08-22 05:04:24 +00:00
|
|
|
|
2012-11-10 18:51:03 +00:00
|
|
|
extern void add_dive_to_trip(struct dive *, dive_trip_t *);
|
|
|
|
|
|
Undo: fix multi-level undo of delete-dive and remove-dive-from-trip
The original undo-code was fundamentally broken. Not only did it leak
resources (copied trips were never freed), it also kept references
to trips or dives that could be changed by other commands. Thus,
anything more than a single undo could lead to crashes.
Two ways of fixing this were considered
1) Don't store pointers, but unique dive-ids and trip-ids.
Whereas such unique ids exist for dives, they would have to be
implemented for trips.
2) Don't free objects in the backend.
Instead, take ownership of deleted objects in the undo-object.
Thus, all references in previous undo-objects are guaranteed to
still exist (unless the objects are deleted elsewhere).
After some contemplation, the second method was chosen, because
it is significantly less intrusive. While touching the undo-objects,
clearly separate backend from ui-code, such that they can ultimately
be reused for mobile.
Note that if other parts of the code delete dives, crashes can still
be provoked. Notable examples are split/merge dives. These will have
to be fixed later. Nevertheless, the new code is a significant
improvement over the old state.
While touching the code, implement proper translation string based
on Qt's plural-feature (using %n).
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-19 12:44:27 +00:00
|
|
|
struct dive *unregister_dive(int idx);
|
2012-11-11 06:49:19 +00:00
|
|
|
extern void delete_single_dive(int idx);
|
2018-07-19 20:35:25 +00:00
|
|
|
extern int dive_get_insertion_index(struct dive *dive);
|
2012-11-11 06:49:19 +00:00
|
|
|
extern void add_single_dive(int idx, struct dive *dive);
|
|
|
|
|
|
2012-09-20 16:56:48 +00:00
|
|
|
extern void insert_trip(dive_trip_t **trip);
|
2018-07-28 19:26:59 +00:00
|
|
|
extern void insert_trip_dont_merge(dive_trip_t *trip);
|
Undo: fix multi-level undo of delete-dive and remove-dive-from-trip
The original undo-code was fundamentally broken. Not only did it leak
resources (copied trips were never freed), it also kept references
to trips or dives that could be changed by other commands. Thus,
anything more than a single undo could lead to crashes.
Two ways of fixing this were considered
1) Don't store pointers, but unique dive-ids and trip-ids.
Whereas such unique ids exist for dives, they would have to be
implemented for trips.
2) Don't free objects in the backend.
Instead, take ownership of deleted objects in the undo-object.
Thus, all references in previous undo-objects are guaranteed to
still exist (unless the objects are deleted elsewhere).
After some contemplation, the second method was chosen, because
it is significantly less intrusive. While touching the undo-objects,
clearly separate backend from ui-code, such that they can ultimately
be reused for mobile.
Note that if other parts of the code delete dives, crashes can still
be provoked. Notable examples are split/merge dives. These will have
to be fixed later. Nevertheless, the new code is a significant
improvement over the old state.
While touching the code, implement proper translation string based
on Qt's plural-feature (using %n).
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-19 12:44:27 +00:00
|
|
|
extern void unregister_trip(dive_trip_t *trip);
|
|
|
|
|
extern void free_trip(dive_trip_t *trip);
|
2011-09-07 02:07:17 +00:00
|
|
|
|
|
|
|
|
extern const struct units SI_units, IMPERIAL_units;
|
2013-01-11 01:26:10 +00:00
|
|
|
extern struct units xml_parsing_units;
|
2011-09-07 02:07:17 +00:00
|
|
|
|
2018-09-02 19:21:29 +00:00
|
|
|
extern const struct units *get_units(void);
|
2016-03-25 08:21:45 +00:00
|
|
|
extern int run_survey, verbose, quit, force_root;
|
2011-08-31 01:40:25 +00:00
|
|
|
|
|
|
|
|
struct dive_table {
|
2018-10-03 19:14:11 +00:00
|
|
|
int nr, allocated;
|
2011-08-31 01:40:25 +00:00
|
|
|
struct dive **dives;
|
|
|
|
|
};
|
|
|
|
|
|
2015-09-20 04:09:58 +00:00
|
|
|
extern struct dive_table dive_table, downloadTable;
|
2014-07-02 18:50:28 +00:00
|
|
|
extern struct dive displayed_dive;
|
2015-02-13 20:38:56 +00:00
|
|
|
extern struct dive_site displayed_dive_site;
|
2014-05-19 05:39:34 +00:00
|
|
|
extern unsigned int dc_number;
|
Undo: select dives after add, remove, merge, split dive commands
Select the proper dives after the add, remove, split and merge
dives commands on undo *and* redo. Generally, select the added
dives. For undo of add, remember the pre-addition selection.
For redo of remove, select the closest dive to the first removed
dive.
The biggest part of the commit is the signal-interface between
the dive commands and the dive-list model and dive-list view.
This is done in two steps:
1) To the DiveTripModel in batches of trips. The dive trip model
transforms the dives into indices.
2) To the DiveListView. The DiveListView has to translate the
DiveTripModel indexes to actual indexes via its QSortFilterProxy-
model.
For code-reuse, derive all divelist-changing commands from a new base-class,
which has a flag that describes whether the divelist changed. The helper
functions which add and remove dives are made members of the base class and
set the flag is a selected dive is added or removed.
To properly detect when the current dive was deleted it
became necessary to turn the current dive from an index
to a pointer, because indices are not stable.
Unfortunately, in some cases an index was expected and these
places now have to transform the dive into an index. These
should be converted in due course.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-08-03 09:35:43 +00:00
|
|
|
extern struct dive *current_dive;
|
2013-03-18 01:07:59 +00:00
|
|
|
#define current_dc (get_dive_dc(current_dive, dc_number))
|
2017-10-19 13:29:59 +00:00
|
|
|
#define displayed_dc (get_dive_dc(&displayed_dive, dc_number))
|
2011-09-11 19:53:59 +00:00
|
|
|
|
2018-07-18 18:47:19 +00:00
|
|
|
extern struct dive *get_dive(int nr);
|
|
|
|
|
extern struct dive *get_dive_from_table(int nr, struct dive_table *dt);
|
2018-08-16 22:36:51 +00:00
|
|
|
extern struct dive_site *get_dive_site_for_dive(const struct dive *dive);
|
|
|
|
|
extern const char *get_dive_country(const struct dive *dive);
|
|
|
|
|
extern const char *get_dive_location(const struct dive *dive);
|
|
|
|
|
extern unsigned int number_of_computers(const struct dive *dive);
|
2018-07-18 18:47:19 +00:00
|
|
|
extern struct divecomputer *get_dive_dc(struct dive *dive, int nr);
|
2015-09-22 19:32:27 +00:00
|
|
|
extern timestamp_t dive_endtime(const struct dive *dive);
|
|
|
|
|
|
2014-05-19 05:39:34 +00:00
|
|
|
extern void make_first_dc(void);
|
2016-03-10 02:18:58 +00:00
|
|
|
extern unsigned int count_divecomputers(void);
|
2014-06-11 20:56:33 +00:00
|
|
|
extern void delete_current_divecomputer(void);
|
2014-05-19 05:39:34 +00:00
|
|
|
|
2012-08-21 22:51:34 +00:00
|
|
|
/*
|
|
|
|
|
* Iterate over each dive, with the first parameter being the index
|
|
|
|
|
* iterator variable, and the second one being the dive one.
|
|
|
|
|
*
|
|
|
|
|
* I don't think anybody really wants the index, and we could make
|
|
|
|
|
* it local to the for-loop, but that would make us requires C99.
|
|
|
|
|
*/
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_dive(_i, _x) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for ((_i) = 0; ((_x) = get_dive(_i)) != NULL; (_i)++)
|
2012-08-21 22:51:34 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_dc(_dive, _dc) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for (_dc = &_dive->dc; _dc; _dc = _dc->next)
|
2013-02-09 00:15:18 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define for_each_gps_location(_i, _x) \
|
2014-03-05 20:19:45 +00:00
|
|
|
for ((_i) = 0; ((_x) = get_gps_location(_i, &gps_location_table)) != NULL; (_i)++)
|
2013-01-31 03:09:16 +00:00
|
|
|
|
2014-01-27 13:44:26 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-07-18 18:47:19 +00:00
|
|
|
extern struct dive *get_dive_by_uniq_id(int id);
|
|
|
|
|
extern int get_idx_by_uniq_id(int id);
|
2018-08-16 22:36:51 +00:00
|
|
|
extern bool dive_site_has_gps_location(const struct dive_site *ds);
|
|
|
|
|
extern int dive_has_gps_location(const struct dive *dive);
|
2018-07-18 18:47:19 +00:00
|
|
|
|
2014-03-07 03:27:28 +00:00
|
|
|
extern int report_error(const char *fmt, ...);
|
2018-01-26 09:40:04 +00:00
|
|
|
extern void set_error_cb(void(*cb)(char *)); // Callback takes ownership of passed string
|
2014-03-07 03:27:28 +00:00
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
extern struct dive *find_dive_including(timestamp_t when);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern bool dive_within_time_range(struct dive *dive, timestamp_t when, timestamp_t offset);
|
2015-06-25 05:38:44 +00:00
|
|
|
extern bool time_during_dive_with_offset(struct dive *dive, timestamp_t when, timestamp_t offset);
|
2013-01-31 03:09:16 +00:00
|
|
|
struct dive *find_dive_n_near(timestamp_t when, int n, timestamp_t offset);
|
2013-01-29 22:25:09 +00:00
|
|
|
|
|
|
|
|
/* Check if two dive computer entries are the exact same dive (-1=no/0=maybe/1=yes) */
|
2018-08-23 17:18:43 +00:00
|
|
|
extern int match_one_dc(const struct divecomputer *a, const struct divecomputer *b);
|
2013-01-29 22:25:09 +00:00
|
|
|
|
2011-08-31 17:20:46 +00:00
|
|
|
extern void parse_xml_init(void);
|
2014-12-08 19:26:03 +00:00
|
|
|
extern int parse_xml_buffer(const char *url, const char *buf, int size, struct dive_table *table, const char **params);
|
2012-09-18 15:33:55 +00:00
|
|
|
extern void parse_xml_exit(void);
|
2017-12-10 21:22:13 +00:00
|
|
|
extern void set_filename(const char *filename);
|
2011-08-31 01:40:25 +00:00
|
|
|
|
2014-03-14 18:26:07 +00:00
|
|
|
extern int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2014-11-15 15:34:20 +00:00
|
|
|
extern int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2014-03-14 18:26:07 +00:00
|
|
|
extern int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2014-12-20 16:19:43 +00:00
|
|
|
extern int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2015-07-12 17:46:48 +00:00
|
|
|
extern int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table);
|
2018-08-18 13:06:15 +00:00
|
|
|
extern int parse_dlf_buffer(unsigned char *buffer, size_t size, struct dive_table *table);
|
2013-03-05 05:10:39 +00:00
|
|
|
|
2018-08-18 13:06:15 +00:00
|
|
|
extern int parse_file(const char *filename, struct dive_table *table);
|
2014-03-14 17:11:26 +00:00
|
|
|
extern int save_dives(const char *filename);
|
2018-09-10 12:47:56 +00:00
|
|
|
extern int save_dives_logic(const char *filename, bool select_only, bool anonymize);
|
|
|
|
|
extern int save_dive(FILE *f, struct dive *dive, bool anonymize);
|
|
|
|
|
extern int export_dives_xslt(const char *filename, const bool selected, const int units, const char *export_xslt, bool anonymize);
|
2014-03-12 21:12:58 +00:00
|
|
|
|
2015-04-28 18:27:36 +00:00
|
|
|
struct membuffer;
|
2018-09-10 12:47:56 +00:00
|
|
|
extern void save_one_dive_to_mb(struct membuffer *b, struct dive *dive, bool anonymize);
|
2015-04-28 18:27:36 +00:00
|
|
|
|
2014-11-17 13:51:19 +00:00
|
|
|
int cylinderuse_from_text(const char *text);
|
|
|
|
|
|
2013-03-10 08:24:49 +00:00
|
|
|
|
2014-04-14 21:33:46 +00:00
|
|
|
struct user_info {
|
2018-07-07 21:26:24 +00:00
|
|
|
char *name;
|
|
|
|
|
char *email;
|
2014-04-14 21:33:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern void subsurface_user_info(struct user_info *);
|
2014-02-16 21:25:02 +00:00
|
|
|
extern int subsurface_rename(const char *path, const char *newpath);
|
2015-09-26 16:35:21 +00:00
|
|
|
extern int subsurface_dir_rename(const char *path, const char *newpath);
|
2013-12-19 13:00:50 +00:00
|
|
|
extern int subsurface_open(const char *path, int oflags, mode_t mode);
|
|
|
|
|
extern FILE *subsurface_fopen(const char *path, const char *mode);
|
|
|
|
|
extern void *subsurface_opendir(const char *path);
|
2014-11-13 17:36:08 +00:00
|
|
|
extern int subsurface_access(const char *path, int mode);
|
2017-02-24 07:06:48 +00:00
|
|
|
extern int subsurface_stat(const char* path, struct stat* buf);
|
2013-12-19 13:00:50 +00:00
|
|
|
extern struct zip *subsurface_zip_open_readonly(const char *path, int flags, int *errorp);
|
|
|
|
|
extern int subsurface_zip_close(struct zip *zip);
|
2017-11-02 23:51:33 +00:00
|
|
|
extern void subsurface_console_init(void);
|
2014-03-25 14:55:56 +00:00
|
|
|
extern void subsurface_console_exit(void);
|
2016-03-25 08:21:45 +00:00
|
|
|
extern bool subsurface_user_is_root(void);
|
2013-12-19 13:00:50 +00:00
|
|
|
|
2014-03-20 20:57:49 +00:00
|
|
|
extern timestamp_t get_times();
|
2013-11-18 13:53:05 +00:00
|
|
|
|
2013-03-10 08:24:49 +00:00
|
|
|
extern xsltStylesheetPtr get_stylesheet(const char *name);
|
2011-09-01 23:27:52 +00:00
|
|
|
|
2012-09-20 00:35:52 +00:00
|
|
|
extern timestamp_t utc_mktime(struct tm *tm);
|
|
|
|
|
extern void utc_mkdate(timestamp_t, struct tm *tm);
|
2011-09-12 20:25:05 +00:00
|
|
|
|
2011-09-12 19:56:34 +00:00
|
|
|
extern struct dive *alloc_dive(void);
|
2018-09-27 19:55:03 +00:00
|
|
|
extern void free_dive(struct dive *);
|
2015-01-09 22:35:31 +00:00
|
|
|
extern void record_dive_to_table(struct dive *dive, struct dive_table *table);
|
2011-09-12 19:56:34 +00:00
|
|
|
extern void record_dive(struct dive *dive);
|
2014-07-02 22:29:02 +00:00
|
|
|
extern void clear_dive(struct dive *dive);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern void copy_dive(const struct dive *s, struct dive *d);
|
|
|
|
|
extern void selective_copy_dive(const struct dive *s, struct dive *d, struct dive_components what, bool clear);
|
2014-07-03 20:34:27 +00:00
|
|
|
extern struct dive *clone_dive(struct dive *s);
|
2011-09-12 19:56:34 +00:00
|
|
|
|
2015-01-09 22:35:31 +00:00
|
|
|
extern void clear_table(struct dive_table *table);
|
|
|
|
|
|
2018-05-05 17:26:48 +00:00
|
|
|
extern void alloc_samples(struct divecomputer *dc, int num);
|
2018-06-20 00:20:32 +00:00
|
|
|
extern void free_samples(struct divecomputer *dc);
|
2012-11-24 02:51:27 +00:00
|
|
|
extern struct sample *prepare_sample(struct divecomputer *dc);
|
|
|
|
|
extern void finish_sample(struct divecomputer *dc);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern struct sample *add_sample(const struct sample *sample, int time, struct divecomputer *dc);
|
2017-07-26 01:33:10 +00:00
|
|
|
extern void add_sample_pressure(struct sample *sample, int sensor, int mbar);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern int legacy_format_o2pressures(const struct dive *dive, const struct divecomputer *dc);
|
2011-09-12 19:56:34 +00:00
|
|
|
|
2013-01-31 03:09:16 +00:00
|
|
|
extern void sort_table(struct dive_table *table);
|
2011-09-03 20:19:26 +00:00
|
|
|
extern struct dive *fixup_dive(struct dive *dive);
|
2014-08-04 14:36:07 +00:00
|
|
|
extern void fixup_dc_duration(struct divecomputer *dc);
|
2018-07-17 21:05:03 +00:00
|
|
|
extern int dive_getUniqID();
|
2018-08-23 17:18:43 +00:00
|
|
|
extern unsigned int dc_airtemp(const struct divecomputer *dc);
|
|
|
|
|
extern unsigned int dc_watertemp(const struct divecomputer *dc);
|
2018-07-20 18:26:06 +00:00
|
|
|
extern int split_dive_dont_insert(const struct dive *dive, struct dive **new1, struct dive **new2);
|
|
|
|
|
extern void split_dive(struct dive *);
|
|
|
|
|
extern int split_dive_at_time_dont_insert(const struct dive *dive, duration_t time, struct dive **new1, struct dive **new2);
|
2018-07-02 19:13:44 +00:00
|
|
|
extern void split_dive_at_time(struct dive *dive, duration_t time);
|
2018-07-21 16:28:33 +00:00
|
|
|
extern struct dive *merge_dives(struct dive *a, struct dive *b, int offset, bool prefer_downloaded, struct dive_trip **trip);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern struct dive *try_to_merge(struct dive *a, struct dive *b, bool prefer_downloaded);
|
2015-12-04 05:42:23 +00:00
|
|
|
extern struct event *clone_event(const struct event *src_ev);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern void copy_events(const struct divecomputer *s, struct divecomputer *d);
|
2015-04-23 22:24:02 +00:00
|
|
|
extern void free_events(struct event *ev);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern void copy_cylinders(const struct dive *s, struct dive *d, bool used_only);
|
|
|
|
|
extern void copy_samples(const struct divecomputer *s, struct divecomputer *d);
|
|
|
|
|
extern bool is_cylinder_used(const struct dive *dive, int idx);
|
|
|
|
|
extern bool is_cylinder_prot(const struct dive *dive, int idx);
|
2013-11-13 12:44:18 +00:00
|
|
|
extern void fill_default_cylinder(cylinder_t *cyl);
|
First step in cleaning up cylinder pressure sensor logic
This clarifies/changes the meaning of our "cylinderindex" entry in our
samples. It has been rather confused, because different dive computers
have done things differently, and the naming really hasn't helped.
There are two totally different - and independent - cylinder "indexes":
- the pressure sensor index, which indicates which cylinder the sensor
data is from.
- the "active cylinder" index, which indicates which cylinder we actually
breathe from.
These two values really are totally independent, and have nothing
what-so-ever to do with each other. The sensor index may well be fixed:
many dive computers only support a single pressure sensor (whether
wireless or wired), and the sensor index is thus always zero.
Other dive computers may support multiple pressure sensors, and the gas
switch event may - or may not - indicate that the sensor changed too. A
dive computer might give the sensor data for *all* cylinders it can read,
regardless of which one is the one we're actively breathing. In fact, some
dive computers might give sensor data for not just *your* cylinder, but
your buddies.
This patch renames "cylinderindex" in the samples as "sensor", making it
quite clear that it's about which sensor index the pressure data in the
sample is about.
The way we figure out which is the currently active gas is with an
explicit has change event. If a computer (like the Uemis Zurich) joins the
two concepts together, then a sensor change should also create a gas
switch event. This patch also changes the Uemis importer to do that.
Finally, it should be noted that the plot info works totally separately
from the sample data, and is about what we actually *display*, not about
the sample pressures etc. In the plot info, the "cylinderindex" does in
fact mean the currently active cylinder, and while it is initially set to
match the sensor information from the samples, we then walk the gas change
events and fix it up - and if the active cylinder differs from the sensor
cylinder, we clear the sensor data.
[Dirk Hohndel: this conflicted with some of my recent changes - I think
I merged things correctly...]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-12-31 04:00:51 +00:00
|
|
|
extern void add_gas_switch_event(struct dive *dive, struct divecomputer *dc, int time, int idx);
|
2016-03-10 02:18:58 +00:00
|
|
|
extern struct event *add_event(struct divecomputer *dc, unsigned int time, int type, int flags, int value, const char *name);
|
2014-05-22 18:40:22 +00:00
|
|
|
extern void remove_event(struct event *event);
|
2018-08-16 22:58:30 +00:00
|
|
|
extern void update_event_name(struct dive *d, struct event *event, const char *name);
|
2014-11-07 06:02:22 +00:00
|
|
|
extern void add_extra_data(struct divecomputer *dc, const char *key, const char *value);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern void per_cylinder_mean_depth(const struct dive *dive, struct divecomputer *dc, int *mean, int *duration);
|
2018-08-16 22:58:30 +00:00
|
|
|
extern int get_cylinder_index(const struct dive *dive, const struct event *ev);
|
|
|
|
|
extern struct gasmix get_gasmix_from_event(const struct dive *, const struct event *ev);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern int nr_cylinders(const struct dive *dive);
|
|
|
|
|
extern int nr_weightsystems(const struct dive *dive);
|
2011-09-23 01:02:54 +00:00
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
/* UI related protopypes */
|
|
|
|
|
|
2013-10-05 07:29:09 +00:00
|
|
|
// extern void report_error(GError* error);
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2011-10-22 15:12:30 +00:00
|
|
|
extern void add_cylinder_description(cylinder_type_t *);
|
2012-08-06 21:03:24 +00:00
|
|
|
extern void add_weightsystem_description(weightsystem_t *);
|
2011-10-25 07:29:19 +00:00
|
|
|
extern void remember_event(const char *eventname);
|
2016-04-03 22:31:59 +00:00
|
|
|
extern void invalidate_dive_cache(struct dive *dc);
|
2013-10-09 07:14:39 +00:00
|
|
|
|
|
|
|
|
#if WE_DONT_USE_THIS /* this is a missing feature in Qt - selecting which events to display */
|
|
|
|
|
extern int evn_foreach(void (*callback)(const char *, bool *, void *), void *data);
|
|
|
|
|
#endif /* WE_DONT_USE_THIS */
|
|
|
|
|
|
2013-01-31 13:07:04 +00:00
|
|
|
extern void clear_events(void);
|
2011-10-23 06:47:19 +00:00
|
|
|
|
2012-12-13 06:26:29 +00:00
|
|
|
extern void set_dc_nickname(struct dive *dive);
|
2013-10-05 07:29:09 +00:00
|
|
|
extern void set_autogroup(bool value);
|
2018-08-23 17:18:43 +00:00
|
|
|
extern int total_weight(const struct dive *);
|
2012-12-13 06:26:29 +00:00
|
|
|
|
2014-01-27 13:44:26 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-09-05 20:14:53 +00:00
|
|
|
#define DIVE_ERROR_PARSE 1
|
2013-02-13 23:03:25 +00:00
|
|
|
#define DIVE_ERROR_PLAN 2
|
2011-09-05 20:14:53 +00:00
|
|
|
|
2011-09-20 05:09:47 +00:00
|
|
|
const char *monthname(int mon);
|
|
|
|
|
|
2011-09-21 00:52:04 +00:00
|
|
|
#define UTF8_DEGREE "\xc2\xb0"
|
2013-09-25 00:07:07 +00:00
|
|
|
#define UTF8_DELTA "\xce\x94"
|
|
|
|
|
#define UTF8_UPWARDS_ARROW "\xE2\x86\x91"
|
|
|
|
|
#define UTF8_DOWNWARDS_ARROW "\xE2\x86\x93"
|
|
|
|
|
#define UTF8_AVERAGE "\xc3\xb8"
|
2011-09-21 00:52:04 +00:00
|
|
|
#define UTF8_SUBSCRIPT_2 "\xe2\x82\x82"
|
2011-12-07 19:58:16 +00:00
|
|
|
#define UTF8_WHITESTAR "\xe2\x98\x86"
|
|
|
|
|
#define UTF8_BLACKSTAR "\xe2\x98\x85"
|
2011-09-21 00:52:04 +00:00
|
|
|
|
2012-09-16 03:51:06 +00:00
|
|
|
extern const char *existing_filename;
|
2013-10-05 07:29:09 +00:00
|
|
|
extern void subsurface_command_line_init(int *, char ***);
|
|
|
|
|
extern void subsurface_command_line_exit(int *, char ***);
|
2011-12-31 16:15:59 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
#define FRACTION(n, x) ((unsigned)(n) / (x)), ((unsigned)(n) % (x))
|
2012-09-10 19:17:28 +00:00
|
|
|
|
2017-08-23 20:43:33 +00:00
|
|
|
#define DECOTIMESTEP 60 /* seconds. Unit of deco stop times */
|
|
|
|
|
|
2017-05-25 20:29:25 +00:00
|
|
|
struct deco_state {
|
|
|
|
|
double tissue_n2_sat[16];
|
|
|
|
|
double tissue_he_sat[16];
|
|
|
|
|
double tolerated_by_tissue[16];
|
|
|
|
|
double tissue_inertgas_saturation[16];
|
|
|
|
|
double buehlmann_inertgas_a[16];
|
|
|
|
|
double buehlmann_inertgas_b[16];
|
|
|
|
|
|
|
|
|
|
double max_n2_crushing_pressure[16];
|
|
|
|
|
double max_he_crushing_pressure[16];
|
|
|
|
|
|
|
|
|
|
double crushing_onset_tension[16]; // total inert gas tension in the t* moment
|
|
|
|
|
double n2_regen_radius[16]; // rs
|
|
|
|
|
double he_regen_radius[16];
|
|
|
|
|
double max_ambient_pressure; // last moment we were descending
|
|
|
|
|
|
|
|
|
|
double bottom_n2_gradient[16];
|
|
|
|
|
double bottom_he_gradient[16];
|
|
|
|
|
|
|
|
|
|
double initial_n2_gradient[16];
|
|
|
|
|
double initial_he_gradient[16];
|
2017-09-17 19:06:44 +00:00
|
|
|
pressure_t first_ceiling_pressure;
|
|
|
|
|
pressure_t max_bottom_ceiling_pressure;
|
2017-05-25 20:29:25 +00:00
|
|
|
int ci_pointing_to_guiding_tissue;
|
|
|
|
|
double gf_low_pressure_this_dive;
|
2017-11-02 20:32:28 +00:00
|
|
|
int deco_time;
|
2018-04-10 19:20:38 +00:00
|
|
|
bool icd_warning;
|
2017-05-25 20:29:25 +00:00
|
|
|
};
|
|
|
|
|
|
2018-08-16 17:10:10 +00:00
|
|
|
extern void add_segment(struct deco_state *ds, double pressure, struct gasmix gasmix, int period_in_seconds, int setpoint, enum divemode_t divemode, int sac);
|
2017-11-22 19:42:33 +00:00
|
|
|
extern void clear_deco(struct deco_state *ds, double surface_pressure);
|
|
|
|
|
extern void dump_tissues(struct deco_state *ds);
|
2017-09-19 12:38:38 +00:00
|
|
|
extern void set_gf(short gflow, short gfhigh);
|
2016-09-24 08:02:08 +00:00
|
|
|
extern void set_vpmb_conservatism(short conservatism);
|
2017-11-22 19:42:33 +00:00
|
|
|
extern void cache_deco_state(struct deco_state *source, struct deco_state **datap);
|
|
|
|
|
extern void restore_deco_state(struct deco_state *data, struct deco_state *target, bool keep_vpmb_state);
|
|
|
|
|
extern void nuclear_regeneration(struct deco_state *ds, double time);
|
|
|
|
|
extern void vpmb_start_gradient(struct deco_state *ds);
|
|
|
|
|
extern void vpmb_next_gradient(struct deco_state *ds, double deco_time, double surface_pressure);
|
|
|
|
|
extern double tissue_tolerance_calc(struct deco_state *ds, const struct dive *dive, double pressure);
|
2013-01-05 07:11:42 +00:00
|
|
|
|
2014-06-01 22:25:19 +00:00
|
|
|
/* this should be converted to use our types */
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint {
|
|
|
|
|
int time;
|
2017-03-10 12:37:54 +00:00
|
|
|
depth_t depth;
|
2016-07-06 12:40:28 +00:00
|
|
|
int cylinderid;
|
2017-03-15 21:28:36 +00:00
|
|
|
pressure_t minimum_gas;
|
2014-10-19 14:07:07 +00:00
|
|
|
int setpoint;
|
2013-10-05 07:29:09 +00:00
|
|
|
bool entered;
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint *next;
|
2018-05-08 14:24:51 +00:00
|
|
|
enum divemode_t divemode;
|
2013-01-05 20:56:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct diveplan {
|
|
|
|
|
timestamp_t when;
|
2014-02-28 04:09:57 +00:00
|
|
|
int surface_pressure; /* mbar */
|
|
|
|
|
int bottomsac; /* ml/min */
|
|
|
|
|
int decosac; /* ml/min */
|
2014-11-12 22:33:40 +00:00
|
|
|
int salinity;
|
2013-06-24 04:27:52 +00:00
|
|
|
short gflow;
|
|
|
|
|
short gfhigh;
|
2016-09-24 08:02:08 +00:00
|
|
|
short vpmb_conservatism;
|
2013-01-05 20:56:45 +00:00
|
|
|
struct divedatapoint *dp;
|
2016-11-23 10:50:50 +00:00
|
|
|
int eff_gflow, eff_gfhigh;
|
2017-10-02 09:17:10 +00:00
|
|
|
int surface_interval;
|
2013-01-05 20:56:45 +00:00
|
|
|
};
|
|
|
|
|
|
2018-05-08 14:24:51 +00:00
|
|
|
struct divedatapoint *plan_add_segment(struct diveplan *diveplan, int duration, int depth, int cylinderid, int po2, bool entered, enum divemode_t divemode);
|
2016-07-06 12:40:28 +00:00
|
|
|
struct divedatapoint *create_dp(int time_incr, int depth, int cylinderid, int po2);
|
2014-04-17 02:56:42 +00:00
|
|
|
#if DEBUG_PLAN
|
2013-06-24 01:04:35 +00:00
|
|
|
void dump_plan(struct diveplan *diveplan);
|
2014-04-17 02:56:42 +00:00
|
|
|
#endif
|
2017-08-27 20:49:41 +00:00
|
|
|
struct decostop {
|
|
|
|
|
int depth;
|
|
|
|
|
int time;
|
|
|
|
|
};
|
2017-12-28 10:26:13 +00:00
|
|
|
extern bool plan(struct deco_state *ds, struct diveplan *diveplan, struct dive *dive, int timestep, struct decostop *decostoptable, struct deco_state **cached_datap, bool is_planner, bool show_disclaimer);
|
|
|
|
|
extern void calc_crushing_pressure(struct deco_state *ds, double pressure);
|
|
|
|
|
extern void vpmb_start_gradient(struct deco_state *ds);
|
|
|
|
|
extern void clear_vpmb_state(struct deco_state *ds);
|
|
|
|
|
extern void printdecotable(struct decostop *table);
|
2013-01-05 07:11:42 +00:00
|
|
|
|
2018-08-16 22:58:30 +00:00
|
|
|
/* Since C doesn't have parameter-based overloading, two versions of get_next_event. */
|
|
|
|
|
extern const struct event *get_next_event(const struct event *event, const char *name);
|
|
|
|
|
extern struct event *get_next_event_mutable(struct event *event, const char *name);
|
2013-03-28 02:04:46 +00:00
|
|
|
|
2018-08-16 15:11:51 +00:00
|
|
|
/* Get gasmixes at increasing timestamps.
|
2018-08-16 11:35:14 +00:00
|
|
|
* In "evp", pass a pointer to a "struct event *" which is NULL-initialized on first invocation.
|
|
|
|
|
* On subsequent calls, pass the same "evp" and the "gasmix" from previous calls.
|
|
|
|
|
*/
|
2018-08-16 22:58:30 +00:00
|
|
|
extern struct gasmix get_gasmix(const struct dive *dive, const struct divecomputer *dc, int time, const struct event **evp, struct gasmix gasmix);
|
Add "get_gasmix()" helper function to iterate over gas changes
We have a few places that used to get the gasmix by looking at the
sensor index in the plot data, which really doesn't work any more.
To make it easier for those users to convert to the new world order,
this adds a "get_gasmix()" function. The gasmix function takes as its
argument the dive, the dive computer, and the time.
In addition, for good performance (to avoid looping over the event list
over and over and over again) it maintains a pointer to the next gas
switch event, and the previous gas. Those need to be initialized to
NULL by the caller, so the standard use-case pattern basically looks
like this:
struct gasmix *gasmix = NULL;
struct event *ev = NULL;
loop over samples or plot events in increasing time order: {
...
gasmix = get_gasmix(dive, dc, time, &ev, gasmix);
...
}
and then you can see what the currently breathing gas is at that time.
If for some reason you need to walk backwards in time, you can just pass
in a NULL gasmix again, which will reset the event iterator (at the cost
of now having to walk all the events again).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-07-28 17:22:17 +00:00
|
|
|
|
2018-08-16 15:11:51 +00:00
|
|
|
/* Get gasmix at a given time */
|
2018-08-16 22:58:30 +00:00
|
|
|
extern struct gasmix get_gasmix_at_time(const struct dive *dive, const struct divecomputer *dc, duration_t time);
|
2018-08-16 15:11:51 +00:00
|
|
|
|
2013-05-24 01:38:45 +00:00
|
|
|
/* these structs holds the information that
|
|
|
|
|
* describes the cylinders / weight systems.
|
|
|
|
|
* they are global variables initialized in equipment.c
|
2013-04-15 18:04:35 +00:00
|
|
|
* used to fill the combobox in the add/edit cylinder
|
|
|
|
|
* dialog
|
|
|
|
|
*/
|
|
|
|
|
|
2013-09-10 18:44:49 +00:00
|
|
|
struct tank_info_t {
|
2013-04-15 18:04:35 +00:00
|
|
|
const char *name;
|
|
|
|
|
int cuft, ml, psi, bar;
|
|
|
|
|
};
|
2017-06-13 22:45:18 +00:00
|
|
|
extern struct tank_info_t tank_info[MAX_TANK_INFO];
|
2013-05-24 01:38:45 +00:00
|
|
|
|
2013-09-10 18:44:49 +00:00
|
|
|
struct ws_info_t {
|
2013-05-24 01:38:45 +00:00
|
|
|
const char *name;
|
|
|
|
|
int grams;
|
|
|
|
|
};
|
2018-06-19 00:59:33 +00:00
|
|
|
extern struct ws_info_t ws_info[MAX_WS_INFO];
|
2013-04-15 18:04:35 +00:00
|
|
|
|
2016-04-02 18:50:17 +00:00
|
|
|
extern bool cylinder_nodata(const cylinder_t *cyl);
|
2018-08-18 10:53:48 +00:00
|
|
|
extern bool cylinder_none(const cylinder_t *cyl);
|
|
|
|
|
extern bool weightsystem_none(const weightsystem_t *ws);
|
2013-05-22 17:02:28 +00:00
|
|
|
extern void remove_cylinder(struct dive *dive, int idx);
|
|
|
|
|
extern void remove_weightsystem(struct dive *dive, int idx);
|
2014-07-04 18:40:02 +00:00
|
|
|
extern void reset_cylinders(struct dive *dive, bool track_gas);
|
2017-11-27 11:36:20 +00:00
|
|
|
#ifdef DEBUG_CYL
|
|
|
|
|
extern void dump_cylinders(struct dive *dive, bool verbose);
|
|
|
|
|
#endif
|
2013-05-22 17:02:28 +00:00
|
|
|
|
2018-03-03 09:10:51 +00:00
|
|
|
extern void set_informational_units(const char *units);
|
|
|
|
|
extern void set_git_prefs(const char *prefs);
|
2014-04-11 06:17:35 +00:00
|
|
|
|
2018-03-13 21:12:23 +00:00
|
|
|
extern char *get_dive_date_c_string(timestamp_t when);
|
2018-08-16 22:58:30 +00:00
|
|
|
extern void update_setpoint_events(const struct dive *dive, struct divecomputer *dc);
|
2018-05-11 15:25:41 +00:00
|
|
|
|
2013-04-01 10:51:49 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-01-08 06:55:47 +00:00
|
|
|
extern weight_t string_to_weight(const char *str);
|
|
|
|
|
extern depth_t string_to_depth(const char *str);
|
2014-01-09 00:49:21 +00:00
|
|
|
extern pressure_t string_to_pressure(const char *str);
|
2014-01-09 02:34:25 +00:00
|
|
|
extern volume_t string_to_volume(const char *str, pressure_t workp);
|
2014-01-09 02:43:28 +00:00
|
|
|
extern fraction_t string_to_fraction(const char *str);
|
2016-03-23 16:53:44 +00:00
|
|
|
extern void average_max_depth(struct diveplan *dive, int *avg_depth, int *max_depth);
|
2014-01-08 06:55:47 +00:00
|
|
|
|
2013-01-11 01:26:10 +00:00
|
|
|
#include "pref.h"
|
|
|
|
|
|
2014-02-11 18:14:46 +00:00
|
|
|
#endif // DIVE_H
|
![](https://secure.gravatar.com/avatar/e81491093d5916411bcadfadabe61852?d=identicon&s=36 "K. \\"pestophagous\\" Heller"){kind=small}
