/*
* Uemis water_pressure. In centibar. And when converting to
* depth, I'm just going to always use saltwater, because I
* think "true depth" is just stupid. From a diving standpoint,
* "true depth" is pretty much completely pointless, unless
* you're doing some kind of underwater surveying work.
*
* So I give water depths in "pressure depth", always assuming
* salt water. So one atmosphere per 10m.
*/
static void water_pressure(char *buffer, void *_depth)
{
depth_t *depth = _depth;
union int_or_float val;
double atm, cm;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
if (!val.fp)
break;
/* cbar to atm */
atm = (val.fp / 100) / 1.01325;
/*
* atm to cm. Why not mm? The precision just isn't
* there.
*/
cm = 100 * atm + 0.5;
if (cm > 0) {
depth->mm = 10 * (long)cm;
break;
}
default:
fprintf(stderr, "Strange water pressure '%s'\n", buffer);
}
free(buffer);
}
static void temperature(char *buffer, void *_temperature)
{
temperature_t *temperature = _temperature;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
/* Ignore zero. It means "none" */
if (!val.fp)
break;
/* Celsius */
switch (input_units.temperature) {
case KELVIN:
temperature->mkelvin = val.fp * 1000;
break;
case CELSIUS:
temperature->mkelvin = (val.fp + 273.15) * 1000 + 0.5;
break;
case FAHRENHEIT:
temperature->mkelvin = (val.fp + 459.67) * 5000/9;
break;
}
break;
default:
printf("Strange temperature reading %s\n", buffer);
}
free(buffer);
}
static void pressure(char *buffer, void *_press)
{
double mbar;
pressure_t *pressure = _press;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
/* Just ignore zero values */
if (!val.fp)
break;
switch (input_units.pressure) {
case PASCAL:
mbar = val.fp / 100;
break;
case BAR:
/* Assume mbar, but if it's really small, it's bar */
mbar = val.fp;
if (mbar < 5000)
mbar = mbar * 1000;
break;
case PSI:
mbar = val.fp * 68.95;
break;
}
if (mbar > 5 && mbar < 500000) {
pressure->mbar = mbar + 0.5;
break;
}
/* fallthrough */
default:
printf("Strange pressure reading %s\n", buffer);
}
free(buffer);
}
static void salinity(char *buffer, void *_salinity)
{
int *salinity = _salinity;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
*salinity = val.fp * 10.0 + 0.5;
break;
default:
printf("Strange salinity reading %s\n", buffer);
}
}
/* Modified julian day, yay! */
static void uemis_date_time(char *buffer, void *_when)
{
time_t *when = _when;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
*when = (val.fp - 40587) * 86400;
break;
default:
fprintf(stderr, "Strange julian date: %s", buffer);
}
free(buffer);
}
/*
* Did I mention how bat-shit crazy divinglog is? The sample
* pressures are in PSI. But the tank working pressure is in
* bar. WTF^2?
*
* Crazy stuff like this is why subsurface has everything in
* these inconvenient typed structures, and you have to say
* "pressure->mbar" to get the actual value. Exactly so that
* you can never have unit confusion.
*/
static void psi(char *buffer, void *_pressure)
{
pressure_t *pressure = _pressure;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
pressure->mbar = val.fp * 68.95 + 0.5;
break;
default:
fprintf(stderr, "Crazy Diving Log PSI reading %s\n", buffer);
}
free(buffer);
}
static void decicelsius(char *buffer, void *_temp)
{
temperature_t *temp = _temp;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
temp->mkelvin = (val.fp/10 + 273.15) * 1000 + 0.5;
break;
default:
fprintf(stderr, "Strange julian date: %s", buffer);
}
free(buffer);
}
static void centibar(char *buffer, void *_pressure)
{
pressure_t *pressure = _pressure;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
pressure->mbar = val.fp * 10 + 0.5;
break;
default:
fprintf(stderr, "Strange centibar pressure '%s'\n", buffer);
}
free(buffer);
}
static void cylindersize(char *buffer, void *_volume)
{
volume_t *volume = _volume;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
volume->mliter = val.fp * 1000 + 0.5;
break;
default:
printf("Strange volume reading %s\n", buffer);
break;
}
}
/*
* Did I mention how bat-shit crazy divinglog is? The sample
* pressures are in PSI. But the tank working pressure is in
* bar. WTF^2?
*
* Crazy stuff like this is why subsurface has everything in
* these inconvenient typed structures, and you have to say
* "pressure->mbar" to get the actual value. Exactly so that
* you can never have unit confusion.
*
* It gets worse: sometimes apparently the pressures are in
* bar, sometimes in psi. Dirk suspects that this may be a
* DivingLog Uemis importer bug, and that they are always
* supposed to be in bar, but that the importer got the
* sample importing wrong.
*
* Sadly, there's no way to really tell. So I think we just
* have to have some arbitrary cut-off point where we assume
* that smaller values mean bar.. Not good.
*/
static void psi_or_bar(char *buffer, void *_pressure)
{
pressure_t *pressure = _pressure;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
if (val.fp > 400)
pressure->mbar = psi_to_mbar(val.fp);
else
pressure->mbar = val.fp * 1000 + 0.5;
break;
default:
fprintf(stderr, "Crazy Diving Log PSI reading %s\n", buffer);
}
}
/*
* Divinglog is crazy. The temperatures are in celsius. EXCEPT
* for the sample temperatures, that are in Fahrenheit.
* WTF?
*
* Oh, and I think Diving Log *internally* probably kept them
* in celsius, because I'm seeing entries like
*
* <Temp>32.0</Temp>
*
* in there. Which is freezing, aka 0 degC. I bet the "0" is
* what Diving Log uses for "no temperature".
*
* So throw away crap like that.
*/
static void fahrenheit(char *buffer, void *_temperature)
{
temperature_t *temperature = _temperature;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
/* Floating point equality is evil, but works for small integers */
if (val.fp == 32.0)
break;
temperature->mkelvin = (val.fp + 459.67) * 5000/9;
break;
default:
fprintf(stderr, "Crazy Diving Log temperature reading %s\n", buffer);
}
free(buffer);
}
static void percent(char *buffer, void *_fraction)
{
fraction_t *fraction = _fraction;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
if (val.fp <= 100.0)
fraction->permille = val.fp * 10 + 0.5;
break;
default:
printf("Strange percentage reading %s\n", buffer);
break;
}
free(buffer);
}
static void weight(char *buffer, void *_weight)
{
weight_t *weight = _weight;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
switch (xml_parsing_units.weight) {
case KG:
weight->grams = val.fp * 1000 + 0.5;
break;
case LBS:
weight->grams = val.fp * 453.6 + 0.5;
break;
}
break;
default:
printf("Strange weight reading %s\n", buffer);
}
}
static void depth(char *buffer, void *_depth)
{
depth_t *depth = _depth;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
switch (xml_parsing_units.length) {
case METERS:
depth->mm = val.fp * 1000 + 0.5;
break;
case FEET:
depth->mm = val.fp * 304.8 + 0.5;
break;
}
break;
default:
printf("Strange depth reading %s\n", buffer);
}
}
static void temperature(char *buffer, void *_temperature)
{
temperature_t *temperature = _temperature;
union int_or_float val;
switch (integer_or_float(buffer, &val)) {
case FLOAT:
switch (xml_parsing_units.temperature) {
case KELVIN:
temperature->mkelvin = val.fp * 1000;
break;
case CELSIUS:
temperature->mkelvin = val.fp * 1000 + ZERO_C_IN_MKELVIN + 0.5;
break;
case FAHRENHEIT:
temperature->mkelvin = (val.fp + 459.67) * 5000/9;
break;
}
break;
default:
printf("Strange temperature reading %s\n", buffer);
}
}
