X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=libdivecomputer.c;h=9e5bd907ec18eb9e98281296f3644603f7ca50a4;hb=9cf8d98711dff888f5bfa8efd52ca7b8cf8bfa07;hp=7bea8e3a0ac6ce4b178e39b6358a82bb21ae1bb7;hpb=d45db9fac7b3d2ea0426a96158432f54d938f5c7;p=ext%2Fsubsurface.git diff --git a/libdivecomputer.c b/libdivecomputer.c index 7bea8e3..9e5bd90 100644 --- a/libdivecomputer.c +++ b/libdivecomputer.c @@ -1,7 +1,9 @@ #include #include +#include #include "dive.h" +#include "divelist.h" #include "display.h" /* libdivecomputer */ @@ -17,17 +19,8 @@ #include #include -/* - * I'd love to do a while-loop here for pending events, but - * that seems to screw up with the dive computer reading timing. - * - * I may need to spawn a new thread to do the computer - * reading stuff.. - */ -static int run_gtk_mainloop(void) -{ - return gtk_main_iteration_do(0); -} +/* handling uemis Zurich SDA files */ +#include "uemis.h" static void error(const char *fmt, ...) { @@ -36,7 +29,7 @@ static void error(const char *fmt, ...) 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); @@ -116,32 +109,39 @@ 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(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 < 210 || 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) +sample_cb(parser_sample_type_t type, parser_sample_value_t value, void *userdata) { int i; static const char *events[] = { @@ -150,20 +150,31 @@ sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdat "safety stop (voluntary)", "safety stop (mandatory)", "deepstop", "ceiling (safety stop)", "unknown", "divetime", "maxdepth", "OLF", "PO2", "airtime", "rgbm", "heading", "tissue level warning"}; + 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, sample); 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", @@ -190,11 +201,11 @@ sample_cb (parser_sample_type_t type, parser_sample_value_t value, void *userdat } -static int parse_samples(parser_t *parser) +static int parse_samples(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); } static int dive_cb(const unsigned char *data, unsigned int size, @@ -205,83 +216,85 @@ 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}; - - /* Christ, this is hacky */ - run_gtk_mainloop(); + 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); + fprintf(stderr, "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."); + fprintf(stderr, "Error registering the data."); parser_destroy(parser); return rc; } + dive = alloc_dive(); rc = parser_get_datetime(parser, &dt); if (rc != PARSER_STATUS_SUCCESS && rc != PARSER_STATUS_UNSUPPORTED) { - error("Error parsing the datetime."); + fprintf(stderr, "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"); 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."); + fprintf(stderr, "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."); + fprintf(stderr, "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."); + fprintf(stderr, "Error parsing the gas mix count."); parser_destroy(parser); return rc; } - rc = parse_gasmixes(parser, ngases); + rc = parse_gasmixes(dive, parser, ngases); if (rc != PARSER_STATUS_SUCCESS) { - error("Error parsing the gas mix."); + fprintf(stderr, "Error parsing the gas mix."); parser_destroy(parser); return rc; } // Initialize the sample data. - rc = parse_samples(parser); + rc = parse_samples(&dive, parser); if (rc != PARSER_STATUS_SUCCESS) { - error("Error parsing the samples."); + fprintf(stderr, "Error parsing the samples."); parser_destroy(parser); return rc; } + record_dive(dive); parser_destroy(parser); return 1; @@ -374,9 +387,6 @@ event_cb(device_t *device, device_event_t event, const void *data, void *userdat const device_clock_t *clock = (device_clock_t *) data; device_data_t *devdata = (device_data_t *) userdata; - /* Christ, this is hacky */ - run_gtk_mainloop(); - switch (event) { case DEVICE_EVENT_WAITING: printf("Event: waiting for user action\n"); @@ -402,50 +412,80 @@ event_cb(device_t *device, device_event_t event, const void *data, void *userdat } } +static int import_thread_done = 0, import_thread_cancelled; + static int cancel_cb(void *userdata) { - return run_gtk_mainloop(); + return import_thread_cancelled; } -static void do_import(device_data_t *data) +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; - rc = device_open(devname, data->type, &device); - if (rc != DEVICE_STATUS_SUCCESS) { - error("Unable to open %s (%s)", data->name, data->devname); - return; - } + 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, 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, 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, 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; +} + +static void 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 gtk main loop */ + import_thread_done = 0; + pthread_create(&pthread, NULL, pthread_wrapper, data); + while (!import_thread_done) { + while (gtk_events_pending()) { + if (gtk_main_iteration_do(0)) { + import_thread_cancelled = 1; + break; + } + } + usleep(100000); + } + if (pthread_join(pthread, &retval) < 0) + retval = "Odd pthread error return"; + if (retval) + error(retval, data->name, data->devname); } /* @@ -480,6 +520,7 @@ struct device_list { { "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 } }; @@ -565,4 +606,7 @@ void import_dialog(GtkWidget *w, gpointer data) break; } gtk_widget_destroy(dialog); + + report_dives(); + dive_list_update_dives(); }