X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=libdivecomputer.c;h=e59dd6aff7e7f9faef4e55d35ba27d8d9b648c77;hb=2cada118eb515e369ba23b85c8f3fb8c4d100aaa;hp=ab75a89e72245ed48248c34fddf267bbfae635da;hpb=d5b7f7dc06827cab8dd57d6d373a08d6be111c79;p=ext%2Fsubsurface.git diff --git a/libdivecomputer.c b/libdivecomputer.c index ab75a89..e59dd6a 100644 --- a/libdivecomputer.c +++ b/libdivecomputer.c @@ -1,43 +1,36 @@ #include -#include +#include +#include +#include #include "dive.h" +#include "divelist.h" #include "display.h" +#include "display-gtk.h" -/* libdivecomputer */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -static void error(const char *fmt, ...) +#include "libdivecomputer.h" + +/* 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; va_start(args, fmt); error = g_error_new_valist( - g_quark_from_string("divelog"), + g_quark_from_string("subsurface"), DIVE_ERROR_PARSE, fmt, args); va_end(args); - report_error(error); - g_error_free(error); + return error; } -typedef struct device_data_t { - device_type_t type; - const char *name; - device_devinfo_t devinfo; - device_clock_t clock; -} device_data_t; - static parser_status_t create_parser(device_data_t *devdata, parser_t **parser) { switch (devdata->type) { @@ -81,15 +74,23 @@ 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: @@ -103,58 +104,106 @@ static parser_status_t create_parser(device_data_t *devdata, parser_t **parser) } } -static int parse_gasmixes(parser_t *parser, int ngases) +static int parse_gasmixes(device_data_t *devdata, struct dive *dive, parser_t *parser, int ngases) { int i; for (i = 0; i < ngases; i++) { int rc; gasmix_t gasmix = {0}; + int o2, he; rc = parser_get_field(parser, FIELD_TYPE_GASMIX, i, &gasmix); if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) return rc; - printf("\n" - " %.1f\n" - " %.1f\n" - " %.1f\n" - "\n", - gasmix.helium * 100.0, - gasmix.oxygen * 100.0, - gasmix.nitrogen * 100.0); + if (i >= MAX_CYLINDERS) + continue; + + o2 = gasmix.oxygen * 1000 + 0.5; + he = gasmix.helium * 1000 + 0.5; + + /* 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; + + dive->cylinder[i].gasmix.o2.permille = o2; + dive->cylinder[i].gasmix.he.permille = he; } return PARSER_STATUS_SUCCESS; } -void -sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdata) +static void handle_event(struct dive *dive, struct sample *sample, parser_sample_value_t value) { - int i; + 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"}; + "OLF", "PO2", "airtime", "rgbm", "heading", "tissue level warning" + }; + const int nr_events = sizeof(events) / sizeof(const char *); + const char *name; + + /* + * 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; + + /* + * 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]; + + time = value.event.time; + if (sample) + time += sample->time.seconds; + + add_event(dive, time, type, value.event.flags, value.event.value, name); +} + +void +sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata) +{ + int i; + struct dive **divep = userdata; + struct dive *dive = *divep; + struct sample *sample; + + /* + * We fill in the "previous" sample - except for SAMPLE_TYPE_TIME, + * which creates a new one. + */ + sample = dive->samples ? dive->sample+dive->samples-1 : NULL; switch (type) { case SAMPLE_TYPE_TIME: - printf("\n"); - printf(" \n", value.time / 60, value.time % 60); + sample = prepare_sample(divep); + sample->time.seconds = value.time; + finish_sample(*divep); break; case SAMPLE_TYPE_DEPTH: - printf(" %.2f\n", value.depth); + sample->depth.mm = value.depth * 1000 + 0.5; break; case SAMPLE_TYPE_PRESSURE: - printf(" %.2f\n", value.pressure.tank, value.pressure.value); + sample->cylinderindex = value.pressure.tank; + sample->cylinderpressure.mbar = value.pressure.value * 1000 + 0.5; break; case SAMPLE_TYPE_TEMPERATURE: - printf(" %.2f\n", value.temperature); + sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5; break; case SAMPLE_TYPE_EVENT: - printf(" %s\n", - value.event.type, value.event.time, value.event.flags, value.event.value, events[value.event.type]); + handle_event(dive, sample, value); break; case SAMPLE_TYPE_RBT: printf(" %u\n", value.rbt); @@ -176,12 +225,49 @@ sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdat } } +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(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, NULL); + 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, @@ -192,82 +278,92 @@ static int dive_cb(const unsigned char *data, unsigned int size, 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 != PARSER_STATUS_SUCCESS) { - error("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) { - error("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) { - error("Error parsing the datetime."); + dev_info(devdata, "Error parsing the datetime"); parser_destroy (parser); return rc; } - printf("%04i-%02i-%02i %02i:%02i:%02i\n", - dt.year, dt.month, dt.day, - dt.hour, dt.minute, dt.second); + 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. - 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) { - error("Error parsing the divetime."); + dev_info(devdata, "Error parsing the divetime"); parser_destroy(parser); return rc; } - - printf("%02u:%02u\n", - divetime / 60, divetime % 60); + 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) { - error("Error parsing the maxdepth."); + dev_info(devdata, "Error parsing the maxdepth"); parser_destroy(parser); return rc; } - - printf("%.2f\n", maxdepth); + 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) { - error("Error parsing the gas mix count."); + dev_info(devdata, "Error parsing the gas mix count"); parser_destroy(parser); return rc; } - rc = parse_gasmixes(parser, ngases); + rc = parse_gasmixes(devdata, dive, parser, ngases); if (rc != PARSER_STATUS_SUCCESS) { - error("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(parser); + rc = parse_samples(devdata, &dive, parser); if (rc != PARSER_STATUS_SUCCESS) { - error("Error parsing the samples."); + dev_info(devdata, "Error parsing the samples"); parser_destroy(parser); return rc; } parser_destroy(parser); + + /* If we already saw this dive, abort. */ + if (find_dive(dive, devdata)) + return 0; + + record_dive(dive); return 1; } @@ -324,6 +420,9 @@ static device_status_t device_open(const char *devname, 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); @@ -350,88 +449,107 @@ static device_status_t device_open(const char *devname, } } -static void -event_cb (device_t *device, device_event_t event, const void *data, void *userdata) + +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: - printf("Event: progress %3.2f%% (%u/%u)\n", - 100.0 * (double) progress->current / (double) progress->maximum, - progress->current, progress->maximum); + update_progressbar(&devdata->progress, + (double) progress->current / (double) progress->maximum); 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; } } +static int import_thread_done = 0, import_thread_cancelled; + static int -cancel_cb (void *userdata) +cancel_cb(void *userdata) { - return 0; + return import_thread_cancelled; } -static void do_import(const char *computer, device_type_t type) +static const char *do_libdivecomputer_import(device_data_t *data) { - /* FIXME! Needs user input! */ - const char *devname = "/dev/ttyUSB0"; device_t *device = NULL; device_status_t rc; - device_data_t devicedata = { - .type = type, - .name = computer, - }; - rc = device_open(devname, type, &device); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Unable to open %s (%s)", computer, devname); - return; - } + import_dive_number = 0; + rc = device_open(data->devname, data->type, &device); + if (rc != DEVICE_STATUS_SUCCESS) + return "Unable to open %s (%s)"; // 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, &devicedata); + rc = device_set_events(device, events, event_cb, data); if (rc != DEVICE_STATUS_SUCCESS) { - error("Error registering the event handler."); device_close(device); - return; + return "Error registering the event handler."; } // Register the cancellation handler. - rc = device_set_cancel(device, cancel_cb, &devicedata); + rc = device_set_cancel(device, cancel_cb, data); if (rc != DEVICE_STATUS_SUCCESS) { - error("Error registering the cancellation handler."); device_close(device); - return; + return "Error registering the cancellation handler."; } - rc = import_device_data(device, &devicedata); + rc = import_device_data(device, data); if (rc != DEVICE_STATUS_SUCCESS) { - error("Dive data import error"); device_close(device); - return; + return "Dive data import error"; } device_close(device); + return NULL; +} + +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->name, data->devname); + return NULL; } /* @@ -441,10 +559,7 @@ static void do_import(const char *computer, device_type_t type) * 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[] = { +struct device_list device_list[] = { { "Suunto Solution", DEVICE_TYPE_SUUNTO_SOLUTION }, { "Suunto Eon", DEVICE_TYPE_SUUNTO_EON }, { "Suunto Vyper", DEVICE_TYPE_SUUNTO_VYPER }, @@ -459,87 +574,16 @@ struct device_list { { "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 }, { NULL } }; - -static void fill_computer_list(GtkListStore *store) -{ - 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); - } -} - -static GtkComboBox *dive_computer_selector(GtkWidget *dialog) -{ - GtkWidget *hbox, *combo_box; - GtkListStore *model; - GtkCellRenderer *renderer; - - hbox = gtk_hbox_new(FALSE, 6); - gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); - - model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); - fill_computer_list(model); - - combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); - gtk_box_pack_start(GTK_BOX(hbox), combo_box, FALSE, TRUE, 3); - - 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); - - return GTK_COMBO_BOX(combo_box); -} - -void import_dialog(GtkWidget *w, gpointer 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; - } - gtk_widget_destroy(dialog); -} -