#include <stdio.h>
-#include <gtk/gtk.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <inttypes.h>
#include "dive.h"
+#include "divelist.h"
#include "display.h"
+#include "display-gtk.h"
-/* libdivecomputer */
-#include <device.h>
-#include <suunto.h>
-#include <reefnet.h>
-#include <uwatec.h>
-#include <oceanic.h>
-#include <mares.h>
-#include <hw.h>
-#include <cressi.h>
-#include <zeagle.h>
-#include <atomics.h>
-#include <utils.h>
-
-static device_status_t device_open(const char *devname,
- device_type_t type,
- device_t **device)
-{
- switch (type) {
- case DEVICE_TYPE_SUUNTO_SOLUTION:
- return suunto_solution_device_open(device, devname);
-
- case DEVICE_TYPE_SUUNTO_EON:
- return suunto_eon_device_open(device, devname);
+#include "libdivecomputer.h"
- case DEVICE_TYPE_SUUNTO_VYPER:
- return suunto_vyper_device_open(device, devname);
+/* 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
- case DEVICE_TYPE_SUUNTO_VYPER2:
- return suunto_vyper2_device_open(device, devname);
-
- case DEVICE_TYPE_SUUNTO_D9:
- return suunto_d9_device_open(device, devname);
+static GError *error(const char *fmt, ...)
+{
+ va_list args;
+ GError *error;
- case DEVICE_TYPE_UWATEC_ALADIN:
- return uwatec_aladin_device_open(device, devname);
+ va_start(args, fmt);
+ error = g_error_new_valist(
+ g_quark_from_string("subsurface"),
+ DIVE_ERROR_PARSE, fmt, args);
+ va_end(args);
+ return error;
+}
- case DEVICE_TYPE_UWATEC_MEMOMOUSE:
- return uwatec_memomouse_device_open(device, devname);
+static dc_status_t create_parser(device_data_t *devdata, dc_parser_t **parser)
+{
+ return dc_parser_new(parser, devdata->device);
+}
- case DEVICE_TYPE_UWATEC_SMART:
- return uwatec_smart_device_open(device);
+static int parse_gasmixes(device_data_t *devdata, struct dive *dive, dc_parser_t *parser, int ngases)
+{
+ int i;
- case DEVICE_TYPE_REEFNET_SENSUS:
- return reefnet_sensus_device_open(device, devname);
+ for (i = 0; i < ngases; i++) {
+ int rc;
+ dc_gasmix_t gasmix = {0};
+ int o2, he;
- case DEVICE_TYPE_REEFNET_SENSUSPRO:
- return reefnet_sensuspro_device_open(device, devname);
+ rc = dc_parser_get_field(parser, DC_FIELD_GASMIX, i, &gasmix);
+ if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED)
+ return rc;
- case DEVICE_TYPE_REEFNET_SENSUSULTRA:
- return reefnet_sensusultra_device_open(device, devname);
+ if (i >= MAX_CYLINDERS)
+ continue;
- case DEVICE_TYPE_OCEANIC_VTPRO:
- return oceanic_vtpro_device_open(device, devname);
+ o2 = gasmix.oxygen * 1000 + 0.5;
+ he = gasmix.helium * 1000 + 0.5;
- case DEVICE_TYPE_OCEANIC_VEO250:
- return oceanic_veo250_device_open(device, devname);
+ /* Ignore bogus data - libdivecomputer does some crazy stuff */
+ if (o2 <= AIR_PERMILLE || o2 >= 1000)
+ o2 = 0;
+ if (he < 0 || he >= 800 || o2+he >= 1000)
+ he = 0;
- case DEVICE_TYPE_OCEANIC_ATOM2:
- return oceanic_atom2_device_open(device, devname);
+ dive->cylinder[i].gasmix.o2.permille = o2;
+ dive->cylinder[i].gasmix.he.permille = he;
+ }
+ return DC_STATUS_SUCCESS;
+}
- case DEVICE_TYPE_MARES_NEMO:
- return mares_nemo_device_open(device, devname);
+static void handle_event(struct dive *dive, struct sample *sample, dc_sample_value_t value)
+{
+ int type, time;
+ static const char *events[] = {
+ "none", "deco", "rbt", "ascent", "ceiling", "workload", "transmitter",
+ "violation", "bookmark", "surface", "safety stop", "gaschange",
+ "safety stop (voluntary)", "safety stop (mandatory)", "deepstop",
+ "ceiling (safety stop)", "unknown", "divetime", "maxdepth",
+ "OLF", "PO2", "airtime", "rgbm", "heading", "tissue level warning"
+ };
+ const int nr_events = sizeof(events) / sizeof(const char *);
+ const char *name;
- case DEVICE_TYPE_MARES_PUCK:
- return mares_puck_device_open(device, devname);
+ /*
+ * Just ignore surface events. They are pointless. What "surface"
+ * means depends on the dive computer (and possibly even settings
+ * in the dive computer). It does *not* necessarily mean "depth 0",
+ * so don't even turn it into that.
+ */
+ if (value.event.type == SAMPLE_EVENT_SURFACE)
+ return;
- case DEVICE_TYPE_MARES_ICONHD:
- return mares_iconhd_device_open(device, devname);
+ /*
+ * Other evens might be more interesting, but for now we just print them out.
+ */
+ type = value.event.type;
+ name = "invalid event number";
+ if (type < nr_events)
+ name = events[type];
- case DEVICE_TYPE_HW_OSTC:
- return hw_ostc_device_open(device, devname);
+ time = value.event.time;
+ if (sample)
+ time += sample->time.seconds;
- case DEVICE_TYPE_CRESSI_EDY:
- return cressi_edy_device_open(device, devname);
+ add_event(dive, time, type, value.event.flags, value.event.value, name);
+}
- case DEVICE_TYPE_ZEAGLE_N2ITION3:
- return zeagle_n2ition3_device_open(device, devname);
+void
+sample_cb(dc_sample_type_t type, dc_sample_value_t value, void *userdata)
+{
+ int i;
+ struct dive **divep = userdata;
+ struct dive *dive = *divep;
+ struct sample *sample;
- case DEVICE_TYPE_ATOMICS_COBALT:
- return atomics_cobalt_device_open(device);
+ /*
+ * We fill in the "previous" sample - except for DC_SAMPLE_TIME,
+ * which creates a new one.
+ */
+ sample = dive->samples ? dive->sample+dive->samples-1 : NULL;
+ switch (type) {
+ case DC_SAMPLE_TIME:
+ sample = prepare_sample(divep);
+ sample->time.seconds = value.time;
+ finish_sample(*divep);
+ break;
+ case DC_SAMPLE_DEPTH:
+ sample->depth.mm = value.depth * 1000 + 0.5;
+ break;
+ case DC_SAMPLE_PRESSURE:
+ sample->cylinderindex = value.pressure.tank;
+ sample->cylinderpressure.mbar = value.pressure.value * 1000 + 0.5;
+ break;
+ case DC_SAMPLE_TEMPERATURE:
+ sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5;
+ break;
+ case DC_SAMPLE_EVENT:
+ handle_event(dive, sample, value);
+ break;
+ case DC_SAMPLE_RBT:
+ printf(" <rbt>%u</rbt>\n", value.rbt);
+ break;
+ case DC_SAMPLE_HEARTBEAT:
+ printf(" <heartbeat>%u</heartbeat>\n", value.heartbeat);
+ break;
+ case DC_SAMPLE_BEARING:
+ printf(" <bearing>%u</bearing>\n", value.bearing);
+ break;
+ case DC_SAMPLE_VENDOR:
+ printf(" <vendor type=\"%u\" size=\"%u\">", value.vendor.type, value.vendor.size);
+ for (i = 0; i < value.vendor.size; ++i)
+ printf("%02X", ((unsigned char *) value.vendor.data)[i]);
+ printf("</vendor>\n");
+ break;
default:
- return DEVICE_STATUS_ERROR;
+ break;
}
}
-static void error(const char *fmt, ...)
+static void dev_info(device_data_t *devdata, const char *fmt, ...)
{
- va_list args;
- GError *error;
+ char buffer[32];
+ va_list ap;
- va_start(args, fmt);
- error = g_error_new_valist(
- g_quark_from_string("divelog"),
- DIVE_ERROR_PARSE, fmt, args);
- va_end(args);
- report_error(error);
- g_error_free(error);
+ va_start(ap, fmt);
+ vsnprintf(buffer, sizeof(buffer), fmt, ap);
+ va_end(ap);
+ update_progressbar_text(&devdata->progress, buffer);
}
-static void
-event_cb (device_t *device, device_event_t event, const void *data, void *userdata)
+static int import_dive_number = 0;
+
+static int parse_samples(device_data_t *devdata, struct dive **divep, dc_parser_t *parser)
{
+ // Parse the sample data.
+ return dc_parser_samples_foreach(parser, sample_cb, divep);
}
-static int
-cancel_cb (void *userdata)
+/*
+ * 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 void do_import(const char *computer, device_type_t type)
+static inline int year(int year)
{
- /* FIXME! Needs user input! */
- const char *devname = "/dev/ttyUSB0";
- device_t *device = NULL;
- device_status_t rc;
-
- rc = device_open(devname, type, &device);
- if (rc != DEVICE_STATUS_SUCCESS) {
- error("Unable to open %s (%s)", computer, devname);
- return;
+ 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)
+{
+ int rc;
+ dc_parser_t *parser = NULL;
+ device_data_t *devdata = userdata;
+ dc_datetime_t dt = {0};
+ struct tm tm;
+ struct dive *dive;
+
+ rc = create_parser(devdata, &parser);
+ if (rc != DC_STATUS_SUCCESS) {
+ dev_info(devdata, "Unable to create parser for %s %s", devdata->vendor, devdata->product);
+ return rc;
}
- // Register the event handler.
- int events = DEVICE_EVENT_WAITING | DEVICE_EVENT_PROGRESS | DEVICE_EVENT_DEVINFO | DEVICE_EVENT_CLOCK;
- rc = device_set_events(device, events, event_cb, NULL);
- if (rc != DEVICE_STATUS_SUCCESS) {
- error("Error registering the event handler.");
- device_close(device);
- return;
+ rc = dc_parser_set_data(parser, data, size);
+ if (rc != DC_STATUS_SUCCESS) {
+ dev_info(devdata, "Error registering the data");
+ dc_parser_destroy(parser);
+ return rc;
}
- // Register the cancellation handler.
- rc = device_set_cancel(device, cancel_cb, NULL);
- if (rc != DEVICE_STATUS_SUCCESS) {
- error("Error registering the cancellation handler.");
- device_close(device);
- return;
+ import_dive_number++;
+ dive = alloc_dive();
+ rc = dc_parser_get_datetime(parser, &dt);
+ if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+ dev_info(devdata, "Error parsing the datetime");
+ dc_parser_destroy(parser);
+ return rc;
+ }
+
+ tm.tm_year = dt.year;
+ tm.tm_mon = dt.month-1;
+ tm.tm_mday = dt.day;
+ tm.tm_hour = dt.hour;
+ tm.tm_min = dt.minute;
+ tm.tm_sec = dt.second;
+ dive->when = utc_mktime(&tm);
+
+ // Parse the divetime.
+ 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 = dc_parser_get_field (parser, DC_FIELD_DIVETIME, 0, &divetime);
+ if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+ dev_info(devdata, "Error parsing the divetime");
+ dc_parser_destroy(parser);
+ return rc;
+ }
+ dive->duration.seconds = divetime;
+
+ // Parse the maxdepth.
+ double maxdepth = 0.0;
+ rc = dc_parser_get_field(parser, DC_FIELD_MAXDEPTH, 0, &maxdepth);
+ if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+ dev_info(devdata, "Error parsing the maxdepth");
+ dc_parser_destroy(parser);
+ return rc;
+ }
+ dive->maxdepth.mm = maxdepth * 1000 + 0.5;
+
+ // Parse the gas mixes.
+ unsigned int ngases = 0;
+ rc = dc_parser_get_field(parser, DC_FIELD_GASMIX_COUNT, 0, &ngases);
+ if (rc != DC_STATUS_SUCCESS && rc != DC_STATUS_UNSUPPORTED) {
+ dev_info(devdata, "Error parsing the gas mix count");
+ dc_parser_destroy(parser);
+ return rc;
}
- error("No actual code yet for importing (%s: %s)", computer, devname);
+ rc = parse_gasmixes(devdata, dive, parser, ngases);
+ if (rc != DC_STATUS_SUCCESS) {
+ dev_info(devdata, "Error parsing the gas mix");
+ dc_parser_destroy(parser);
+ return rc;
+ }
+
+ // Initialize the sample data.
+ rc = parse_samples(devdata, &dive, parser);
+ if (rc != DC_STATUS_SUCCESS) {
+ dev_info(devdata, "Error parsing the samples");
+ dc_parser_destroy(parser);
+ return rc;
+ }
+
+ dc_parser_destroy(parser);
+
+ /* If we already saw this dive, abort. */
+ if (find_dive(dive, devdata))
+ return 0;
+
+ record_dive(dive);
+ return 1;
}
-/*
- * Taken from 'example.c' in libdivecomputer.
- *
- * I really wish there was some way to just have
- * libdivecomputer tell us what devices it supports,
- * rather than have the application have to know..
- */
-struct device_list {
- const char *name;
- device_type_t type;
-} device_list[] = {
- { "Suunto Solution", DEVICE_TYPE_SUUNTO_SOLUTION },
- { "Suunto Eon", DEVICE_TYPE_SUUNTO_EON },
- { "Suunto Vyper", DEVICE_TYPE_SUUNTO_VYPER },
- { "Suunto Vyper Air", DEVICE_TYPE_SUUNTO_VYPER2 },
- { "Suunto D9", DEVICE_TYPE_SUUNTO_D9 },
- { "Uwatec Aladin", DEVICE_TYPE_UWATEC_ALADIN },
- { "Uwatec Memo Mouse", DEVICE_TYPE_UWATEC_MEMOMOUSE },
- { "Uwatec Smart", DEVICE_TYPE_UWATEC_SMART },
- { "ReefNet Sensus", DEVICE_TYPE_REEFNET_SENSUS },
- { "ReefNet Sensus Pro", DEVICE_TYPE_REEFNET_SENSUSPRO },
- { "ReefNet Sensus Ultra",DEVICE_TYPE_REEFNET_SENSUSULTRA },
- { "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 Icon HD", DEVICE_TYPE_MARES_ICONHD },
- { "OSTC", DEVICE_TYPE_HW_OSTC },
- { "Cressi Edy", DEVICE_TYPE_CRESSI_EDY },
- { "Zeagle N2iTiON 3", DEVICE_TYPE_ZEAGLE_N2ITION3 },
- { "Atomics Cobalt", DEVICE_TYPE_ATOMICS_COBALT },
- { NULL }
-};
-
-static void fill_computer_list(GtkListStore *store)
+
+static dc_status_t import_device_data(dc_device_t *device, device_data_t *devicedata)
+{
+ return dc_device_foreach(device, dive_cb, devicedata);
+}
+
+
+static void event_cb(dc_device_t *device, dc_event_type_t event, const void *data, void *userdata)
{
- GtkTreeIter iter;
- struct device_list *list = device_list;
-
- for (list = device_list ; list->name ; list++) {
- gtk_list_store_append(store, &iter);
- gtk_list_store_set(store, &iter,
- 0, list->name,
- 1, list->type,
- -1);
+ const dc_event_progress_t *progress = data;
+ const dc_event_devinfo_t *devinfo = data;
+ const dc_event_clock_t *clock = data;
+ device_data_t *devdata = userdata;
+
+ switch (event) {
+ case DC_EVENT_WAITING:
+ dev_info(devdata, "Event: waiting for user action");
+ break;
+ case DC_EVENT_PROGRESS:
+ update_progressbar(&devdata->progress,
+ (double) progress->current / (double) progress->maximum);
+ break;
+ case DC_EVENT_DEVINFO:
+ 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 DC_EVENT_CLOCK:
+ dev_info(devdata, "Event: systime=%"PRId64", devtime=%u\n",
+ (uint64_t)clock->systime, clock->devtime);
+ break;
+ default:
+ break;
}
}
-static GtkComboBox *dive_computer_selector(GtkWidget *dialog)
+static int import_thread_done = 0, import_thread_cancelled;
+
+static int
+cancel_cb(void *userdata)
{
- GtkWidget *hbox, *combo_box;
- GtkListStore *model;
- GtkCellRenderer *renderer;
+ return import_thread_cancelled;
+}
- hbox = gtk_hbox_new(FALSE, 6);
- gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
+static const char *do_device_import(device_data_t *data)
+{
+ dc_status_t rc;
+ dc_device_t *device = data->device;
- model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
- fill_computer_list(model);
+ // Register the event handler.
+ int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK;
+ rc = dc_device_set_events(device, events, event_cb, data);
+ if (rc != DC_STATUS_SUCCESS)
+ return "Error registering the event handler.";
- combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
- gtk_box_pack_start(GTK_BOX(hbox), combo_box, FALSE, TRUE, 3);
+ // Register the cancellation handler.
+ rc = dc_device_set_cancel(device, cancel_cb, data);
+ if (rc != DC_STATUS_SUCCESS)
+ return "Error registering the cancellation handler.";
- renderer = gtk_cell_renderer_text_new();
- gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
- gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "text", 0, NULL);
+ rc = import_device_data(device, data);
+ if (rc != DC_STATUS_SUCCESS)
+ return "Dive data import error";
- return GTK_COMBO_BOX(combo_box);
+ /* All good */
+ return NULL;
}
-void import_dialog(GtkWidget *w, gpointer data)
+static const char *do_libdivecomputer_import(device_data_t *data)
{
- int result;
- GtkWidget *dialog;
- GtkComboBox *computer;
-
- dialog = gtk_dialog_new_with_buttons("Import from dive computer",
- GTK_WINDOW(main_window),
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
- GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
- NULL);
-
- computer = dive_computer_selector(dialog);
-
- gtk_widget_show_all(dialog);
- result = gtk_dialog_run(GTK_DIALOG(dialog));
- switch (result) {
- int type;
- GtkTreeIter iter;
- GtkTreeModel *model;
- const char *comp;
- case GTK_RESPONSE_ACCEPT:
- if (!gtk_combo_box_get_active_iter(computer, &iter))
- break;
- model = gtk_combo_box_get_model(computer);
- gtk_tree_model_get(model, &iter,
- 0, &comp,
- 1, &type,
- -1);
- do_import(comp, type);
- break;
- default:
- break;
+ dc_status_t rc;
+ const char *err;
+
+ import_dive_number = 0;
+ data->device = NULL;
+ data->context = NULL;
+
+ rc = dc_context_new(&data->context);
+ if (rc != DC_STATUS_SUCCESS)
+ return "Unable to create libdivecomputer context";
+
+ err = "Unable to open %s %s (%s)";
+ rc = dc_device_open(&data->device, data->context, data->descriptor, data->devname);
+ if (rc == DC_STATUS_SUCCESS) {
+ err = do_device_import(data);
+ dc_device_close(data->device);
}
- gtk_widget_destroy(dialog);
+ dc_context_free(data->context);
+ return err;
}
+static void *pthread_wrapper(void *_data)
+{
+ device_data_t *data = _data;
+ const char *err_string = do_libdivecomputer_import(data);
+ import_thread_done = 1;
+ return (void *)err_string;
+}
+
+GError *do_import(device_data_t *data)
+{
+ pthread_t pthread;
+ void *retval;
+
+ /* 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);
+ while (!import_thread_done) {
+ import_thread_cancelled = process_ui_events();
+ usleep(100000);
+ }
+ if (pthread_join(pthread, &retval) < 0)
+ retval = "Odd pthread error return";
+ if (retval)
+ return error(retval, data->vendor, data->product, data->devname);
+ return NULL;
+}
projects / ext / subsurface.git / blobdiff