#include <stdio.h>
#include <gtk/gtk.h>
+#include <pthread.h>
#include "dive.h"
+#include "divelist.h"
#include "display.h"
/* libdivecomputer */
#include <atomics.h>
#include <utils.h>
-/*
- * 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, ...)
{
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);
}
}
-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("<gasmix>\n"
- " <he>%.1f</he>\n"
- " <o2>%.1f</o2>\n"
- " <n2>%.1f</n2>\n"
- "</gasmix>\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[] = {
"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("<sample>\n");
- printf(" <time>%02u:%02u</time>\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(" <depth>%.2f</depth>\n", value.depth);
+ sample->depth.mm = value.depth * 1000 + 0.5;
break;
case SAMPLE_TYPE_PRESSURE:
- printf(" <pressure tank=\"%u\">%.2f</pressure>\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(" <temperature>%.2f</temperature>\n", value.temperature);
+ sample->temperature.mkelvin = (value.temperature + 273.15) * 1000 + 0.5;
break;
case SAMPLE_TYPE_EVENT:
printf(" <event type=\"%u\" time=\"%u\" flags=\"%u\" value=\"%u\">%s</event>\n",
}
-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,
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("<datetime>%04i-%02i-%02i %02i:%02i:%02i</datetime>\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("<divetime>%02u:%02u</divetime>\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("<maxdepth>%.2f</maxdepth>\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;
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");
}
}
+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);
}
/*
{ "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 }
};
break;
}
gtk_widget_destroy(dialog);
+
+ report_dives();
+ dive_list_update_dives();
}
projects / ext / subsurface.git / blobdiff