#include <stdio.h>
#include <pthread.h>
+#include <unistd.h>
+#include <inttypes.h>
#include "dive.h"
#include "divelist.h"
#include "libdivecomputer.h"
-static void error(const char *fmt, ...)
+/* Christ. Libdivecomputer has the worst configuration system ever. */
+#ifdef HW_FROG_H
+ #define NOT_FROG , 0
+ #define LIBDIVECOMPUTER_SUPPORTS_FROG
+#else
+ #define NOT_FROG
+#endif
+
+static GError *error(const char *fmt, ...)
{
va_list args;
GError *error;
g_quark_from_string("subsurface"),
DIVE_ERROR_PARSE, fmt, args);
va_end(args);
- report_error(error);
- g_error_free(error);
+ return error;
}
static parser_status_t create_parser(device_data_t *devdata, parser_t **parser)
case DEVICE_TYPE_OCEANIC_ATOM2:
return oceanic_atom2_parser_create(parser, devdata->devinfo.model);
+ case DEVICE_TYPE_MARES_DARWIN:
+ return mares_darwin_parser_create(parser, devdata->devinfo.model);
+
case DEVICE_TYPE_MARES_NEMO:
case DEVICE_TYPE_MARES_PUCK:
return mares_nemo_parser_create(parser, devdata->devinfo.model);
case DEVICE_TYPE_MARES_ICONHD:
- return mares_iconhd_parser_create(parser);
+ return mares_iconhd_parser_create(parser, devdata->devinfo.model);
case DEVICE_TYPE_HW_OSTC:
- return hw_ostc_parser_create(parser);
+ return hw_ostc_parser_create(parser NOT_FROG);
+
+#ifdef LIBDIVECOMPUTER_SUPPORTS_FROG
+ case DEVICE_TYPE_HW_FROG:
+ return hw_ostc_parser_create(parser, 1);
+#endif
case DEVICE_TYPE_CRESSI_EDY:
case DEVICE_TYPE_ZEAGLE_N2ITION3:
}
}
-static int parse_gasmixes(struct dive *dive, parser_t *parser, int ngases)
+static int parse_gasmixes(device_data_t *devdata, struct dive *dive, parser_t *parser, int ngases)
{
int i;
he = gasmix.helium * 1000 + 0.5;
/* Ignore bogus data - libdivecomputer does some crazy stuff */
- if (o2 < 210 || o2 >= 1000)
+ if (o2 <= AIR_PERMILLE || o2 >= 1000)
o2 = 0;
if (he < 0 || he >= 800 || o2+he >= 1000)
he = 0;
return PARSER_STATUS_SUCCESS;
}
-static void handle_event(struct dive **divep, struct sample *sample, parser_sample_value_t value)
+static void handle_event(struct dive *dive, struct sample *sample, parser_sample_value_t value)
{
int type, time;
static const char *events[] = {
if (sample)
time += sample->time.seconds;
- printf(" <event type=\"%u\" time=\"%u:%02u\" flags=\"%u\" value=\"%u\" name=\"%s\" />\n",
- type, time / 60, time % 60,
- value.event.flags, value.event.value, name);
+ add_event(dive, time, type, value.event.flags, value.event.value, name);
}
void
case SAMPLE_TYPE_TIME:
sample = prepare_sample(divep);
sample->time.seconds = value.time;
- finish_sample(*divep, sample);
+ finish_sample(*divep);
break;
case SAMPLE_TYPE_DEPTH:
sample->depth.mm = value.depth * 1000 + 0.5;
sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5;
break;
case SAMPLE_TYPE_EVENT:
- handle_event(divep, sample, value);
+ handle_event(dive, sample, value);
break;
case SAMPLE_TYPE_RBT:
printf(" <rbt>%u</rbt>\n", value.rbt);
}
}
+static void dev_info(device_data_t *devdata, const char *fmt, ...)
+{
+ char buffer[32];
+ va_list ap;
+
+ va_start(ap, fmt);
+ vsnprintf(buffer, sizeof(buffer), fmt, ap);
+ va_end(ap);
+ update_progressbar_text(&devdata->progress, buffer);
+}
+
+static int import_dive_number = 0;
-static int parse_samples(struct dive **divep, parser_t *parser)
+static int parse_samples(device_data_t *devdata, struct dive **divep, parser_t *parser)
{
// Parse the sample data.
- printf("Parsing the sample data.\n");
return parser_samples_foreach(parser, sample_cb, divep);
}
+/*
+ * Check if this dive already existed before the import
+ */
+static int find_dive(struct dive *dive, device_data_t *devdata)
+{
+ int i;
+
+ for (i = 0; i < dive_table.preexisting; i++) {
+ struct dive *old = dive_table.dives[i];
+
+ if (dive->when != old->when)
+ continue;
+ return 1;
+ }
+ return 0;
+}
+
+static inline int year(int year)
+{
+ if (year < 70)
+ return year + 2000;
+ if (year < 100)
+ return year + 1900;
+ return year;
+}
+
static int dive_cb(const unsigned char *data, unsigned int size,
const unsigned char *fingerprint, unsigned int fsize,
void *userdata)
rc = create_parser(devdata, &parser);
if (rc != PARSER_STATUS_SUCCESS) {
- fprintf(stderr, "Unable to create parser for %s", devdata->name);
+ dev_info(devdata, "Unable to create parser for %s", devdata->name);
return rc;
}
rc = parser_set_data(parser, data, size);
if (rc != PARSER_STATUS_SUCCESS) {
- fprintf(stderr, "Error registering the data.");
+ dev_info(devdata, "Error registering the data");
parser_destroy(parser);
return rc;
}
+ import_dive_number++;
dive = alloc_dive();
rc = parser_get_datetime(parser, &dt);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
- fprintf(stderr, "Error parsing the datetime.");
+ dev_info(devdata, "Error parsing the datetime");
parser_destroy (parser);
return rc;
}
dive->when = utc_mktime(&tm);
// Parse the divetime.
- printf("Parsing the divetime.\n");
+ dev_info(devdata, "Dive %d: %s %d %04d", import_dive_number,
+ monthname(tm.tm_mon), tm.tm_mday, year(tm.tm_year));
unsigned int divetime = 0;
rc = parser_get_field (parser, FIELD_TYPE_DIVETIME, 0, &divetime);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
- fprintf(stderr, "Error parsing the divetime.");
+ dev_info(devdata, "Error parsing the divetime");
parser_destroy(parser);
return rc;
}
dive->duration.seconds = divetime;
// Parse the maxdepth.
- printf("Parsing the maxdepth.\n");
double maxdepth = 0.0;
rc = parser_get_field(parser, FIELD_TYPE_MAXDEPTH, 0, &maxdepth);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
- fprintf(stderr, "Error parsing the maxdepth.");
+ dev_info(devdata, "Error parsing the maxdepth");
parser_destroy(parser);
return rc;
}
dive->maxdepth.mm = maxdepth * 1000 + 0.5;
// Parse the gas mixes.
- printf("Parsing the gas mixes.\n");
unsigned int ngases = 0;
rc = parser_get_field(parser, FIELD_TYPE_GASMIX_COUNT, 0, &ngases);
if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) {
- fprintf(stderr, "Error parsing the gas mix count.");
+ dev_info(devdata, "Error parsing the gas mix count");
parser_destroy(parser);
return rc;
}
- rc = parse_gasmixes(dive, parser, ngases);
+ rc = parse_gasmixes(devdata, dive, parser, ngases);
if (rc != PARSER_STATUS_SUCCESS) {
- fprintf(stderr, "Error parsing the gas mix.");
+ dev_info(devdata, "Error parsing the gas mix");
parser_destroy(parser);
return rc;
}
// Initialize the sample data.
- rc = parse_samples(&dive, parser);
+ rc = parse_samples(devdata, &dive, parser);
if (rc != PARSER_STATUS_SUCCESS) {
- fprintf(stderr, "Error parsing the samples.");
+ dev_info(devdata, "Error parsing the samples");
parser_destroy(parser);
return rc;
}
- record_dive(dive);
parser_destroy(parser);
+
+ /* If we already saw this dive, abort. */
+ if (find_dive(dive, devdata))
+ return 0;
+
+ record_dive(dive);
return 1;
}
case DEVICE_TYPE_OCEANIC_ATOM2:
return oceanic_atom2_device_open(device, devname);
+ case DEVICE_TYPE_MARES_DARWIN:
+ return mares_darwin_device_open(device, devname, 0); /// last parameter is model type (taken from example), 0 seems to be standard, 1 is DARWIN_AIR => Darwin Air wont work if this is fixed here?
+
case DEVICE_TYPE_MARES_NEMO:
return mares_nemo_device_open(device, devname);
}
}
+
static void event_cb(device_t *device, device_event_t event, const void *data, void *userdata)
{
- const device_progress_t *progress = (device_progress_t *) data;
- const device_devinfo_t *devinfo = (device_devinfo_t *) data;
- const device_clock_t *clock = (device_clock_t *) data;
- device_data_t *devdata = (device_data_t *) userdata;
+ const device_progress_t *progress = data;
+ const device_devinfo_t *devinfo = data;
+ const device_clock_t *clock = data;
+ device_data_t *devdata = userdata;
switch (event) {
case DEVICE_EVENT_WAITING:
- printf("Event: waiting for user action\n");
+ dev_info(devdata, "Event: waiting for user action");
break;
case DEVICE_EVENT_PROGRESS:
update_progressbar(&devdata->progress,
break;
case DEVICE_EVENT_DEVINFO:
devdata->devinfo = *devinfo;
- printf("Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)\n",
+ dev_info(devdata, "model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x)",
devinfo->model, devinfo->model,
devinfo->firmware, devinfo->firmware,
devinfo->serial, devinfo->serial);
break;
case DEVICE_EVENT_CLOCK:
devdata->clock = *clock;
- printf("Event: systime=%lld, devtime=%u\n",
- clock->systime, clock->devtime);
+ dev_info(devdata, "Event: systime=%"PRId64", devtime=%u\n",
+ (uint64_t)clock->systime, clock->devtime);
break;
default:
break;
device_t *device = NULL;
device_status_t rc;
+ import_dive_number = 0;
rc = device_open(data->devname, data->type, &device);
if (rc != DEVICE_STATUS_SUCCESS)
return "Unable to open %s (%s)";
return (void *)err_string;
}
-void do_import(device_data_t *data)
+GError *do_import(device_data_t *data)
{
pthread_t pthread;
void *retval;
- if (data->type == DEVICE_TYPE_UEMIS)
- return uemis_import();
-
/* I'm sure there is some better interface for waiting on a thread in a UI main loop */
import_thread_done = 0;
pthread_create(&pthread, NULL, pthread_wrapper, data);
if (pthread_join(pthread, &retval) < 0)
retval = "Odd pthread error return";
if (retval)
- error(retval, data->name, data->devname);
+ return error(retval, data->name, data->devname);
+ return NULL;
}
/*
{ "Oceanic VT Pro", DEVICE_TYPE_OCEANIC_VTPRO },
{ "Oceanic Veo250", DEVICE_TYPE_OCEANIC_VEO250 },
{ "Oceanic Atom 2", DEVICE_TYPE_OCEANIC_ATOM2 },
- { "Mares Nemo", DEVICE_TYPE_MARES_NEMO },
- { "Mares Puck", DEVICE_TYPE_MARES_PUCK },
+ { "Mares Darwin, M1, M2, Airlab", DEVICE_TYPE_MARES_DARWIN },
+ { "Mares Nemo, Excel, Apneist", DEVICE_TYPE_MARES_NEMO },
+ { "Mares Puck, Nemo Air, Nemo Wide", DEVICE_TYPE_MARES_PUCK },
{ "Mares Icon HD", DEVICE_TYPE_MARES_ICONHD },
{ "OSTC", DEVICE_TYPE_HW_OSTC },
+#ifdef LIBDIVECOMPUTER_SUPPORTS_FROG
+ { "OSTC Frog", DEVICE_TYPE_HW_FROG },
+#endif
{ "Cressi Edy", DEVICE_TYPE_CRESSI_EDY },
{ "Zeagle N2iTiON 3", DEVICE_TYPE_ZEAGLE_N2ITION3 },
{ "Atomics Cobalt", DEVICE_TYPE_ATOMICS_COBALT },
- { "Uemis Zurich SDA", DEVICE_TYPE_UEMIS },
{ NULL }
};
projects / ext / subsurface.git / blobdiff