X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=libdivecomputer.c;h=d2da5381d8bd71edb34005460e8f1a6e26bdd97c;hb=4e7161efd6738cc50c3879846b5df7d1d58c3c58;hp=b9850b38b43573f6a2eb8e05dc5d8b14149bb027;hpb=9cb60c910681b0fb3c04d22c77bcf9c2754bfa7f;p=ext%2Fsubsurface.git

diff --git a/libdivecomputer.c b/libdivecomputer.c
index b9850b3..d2da538 100644
--- a/libdivecomputer.c
+++ b/libdivecomputer.c
@@ -1,6 +1,8 @@
 #include <stdio.h>
 #include <gtk/gtk.h>
 
+#include "dive.h"
+#include "divelist.h"
 #include "display.h"
 
 /* libdivecomputer */
@@ -16,6 +18,305 @@
 #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);
+}
+
+static void error(const char *fmt, ...)
+{
+	va_list args;
+	GError *error;
+
+	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);
+}
+
+typedef struct device_data_t {
+	device_type_t type;
+	const char *name, *devname;
+	GtkWidget *progressbar;
+	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) {
+	case DEVICE_TYPE_SUUNTO_SOLUTION:
+		return suunto_solution_parser_create(parser);
+
+	case DEVICE_TYPE_SUUNTO_EON:
+		return suunto_eon_parser_create(parser, 0);
+
+	case DEVICE_TYPE_SUUNTO_VYPER:
+		if (devdata->devinfo.model == 0x01)
+			return suunto_eon_parser_create(parser, 1);
+		return suunto_vyper_parser_create(parser);
+
+	case DEVICE_TYPE_SUUNTO_VYPER2:
+	case DEVICE_TYPE_SUUNTO_D9:
+		return suunto_d9_parser_create(parser, devdata->devinfo.model);
+
+	case DEVICE_TYPE_UWATEC_ALADIN:
+	case DEVICE_TYPE_UWATEC_MEMOMOUSE:
+		return uwatec_memomouse_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
+
+	case DEVICE_TYPE_UWATEC_SMART:
+		return uwatec_smart_parser_create(parser, devdata->devinfo.model, devdata->clock.devtime, devdata->clock.systime);
+
+	case DEVICE_TYPE_REEFNET_SENSUS:
+		return reefnet_sensus_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
+
+	case DEVICE_TYPE_REEFNET_SENSUSPRO:
+		return reefnet_sensuspro_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
+
+	case DEVICE_TYPE_REEFNET_SENSUSULTRA:
+		return reefnet_sensusultra_parser_create(parser, devdata->clock.devtime, devdata->clock.systime);
+
+	case DEVICE_TYPE_OCEANIC_VTPRO:
+		return oceanic_vtpro_parser_create(parser);
+
+	case DEVICE_TYPE_OCEANIC_VEO250:
+		return oceanic_veo250_parser_create(parser, devdata->devinfo.model);
+
+	case DEVICE_TYPE_OCEANIC_ATOM2:
+		return oceanic_atom2_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);
+
+	case DEVICE_TYPE_HW_OSTC:
+		return hw_ostc_parser_create(parser);
+
+	case DEVICE_TYPE_CRESSI_EDY:
+	case DEVICE_TYPE_ZEAGLE_N2ITION3:
+		return cressi_edy_parser_create(parser, devdata->devinfo.model);
+
+	case DEVICE_TYPE_ATOMICS_COBALT:
+		return atomics_cobalt_parser_create(parser);
+
+	default:
+		return PARSER_STATUS_ERROR;
+	}
+}
+
+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;
+
+		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)
+{
+	int i;
+	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"};
+	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:
+		sample = prepare_sample(divep);
+		sample->time.seconds = value.time;
+		finish_sample(*divep, sample);
+		break;
+	case SAMPLE_TYPE_DEPTH:
+		sample->depth.mm = value.depth * 1000 + 0.5;
+		break;
+	case SAMPLE_TYPE_PRESSURE:
+		sample->cylinderindex = value.pressure.tank;
+		sample->cylinderpressure.mbar = value.pressure.value * 1000 + 0.5;
+		break;
+	case SAMPLE_TYPE_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",
+			value.event.type, value.event.time, value.event.flags, value.event.value, events[value.event.type]);
+		break;
+	case SAMPLE_TYPE_RBT:
+		printf("   <rbt>%u</rbt>\n", value.rbt);
+		break;
+	case SAMPLE_TYPE_HEARTBEAT:
+		printf("   <heartbeat>%u</heartbeat>\n", value.heartbeat);
+		break;
+	case SAMPLE_TYPE_BEARING:
+		printf("   <bearing>%u</bearing>\n", value.bearing);
+		break;
+	case SAMPLE_TYPE_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:
+		break;
+	}
+}
+
+
+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, divep);
+}
+
+static int dive_cb(const unsigned char *data, unsigned int size,
+	const unsigned char *fingerprint, unsigned int fsize,
+	void *userdata)
+{
+	int rc;
+	parser_t *parser = NULL;
+	device_data_t *devdata = userdata;
+	dc_datetime_t dt = {0};
+	struct tm tm;
+	struct dive *dive;
+
+	/* Christ, this is hacky */
+	run_gtk_mainloop();
+
+	rc = create_parser(devdata, &parser);
+	if (rc != PARSER_STATUS_SUCCESS) {
+		error("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.");
+		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.");
+		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.
+	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.");
+		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) {
+		error("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) {
+		error("Error parsing the gas mix count.");
+		parser_destroy(parser);
+		return rc;
+	}
+
+	rc = parse_gasmixes(dive, parser, ngases);
+	if (rc != PARSER_STATUS_SUCCESS) {
+		error("Error parsing the gas mix.");
+		parser_destroy(parser);
+		return rc;
+	}
+
+	// Initialize the sample data.
+	rc = parse_samples(&dive, parser);
+	if (rc != PARSER_STATUS_SUCCESS) {
+		error("Error parsing the samples.");
+		parser_destroy(parser);
+		return rc;
+	}
+	record_dive(dive);
+
+	parser_destroy(parser);
+	return 1;
+}
+
+
+static device_status_t import_device_data(device_t *device, device_data_t *devicedata)
+{
+	return device_foreach(device, dive_cb, devicedata);
+}
+
 static device_status_t device_open(const char *devname,
 	device_type_t type,
 	device_t **device)
@@ -89,17 +390,86 @@ static device_status_t device_open(const char *devname,
 	}
 }
 
-static void do_import(const char *computer, device_type_t type)
+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;
+
+	/* Christ, this is hacky */
+	run_gtk_mainloop();
+
+	switch (event) {
+	case DEVICE_EVENT_WAITING:
+		printf("Event: waiting for user action\n");
+		break;
+	case DEVICE_EVENT_PROGRESS:
+		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(devdata->progressbar),
+			(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",
+			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);
+		break;
+	default:
+		break;
+	}
+}
+
+static int
+cancel_cb(void *userdata)
+{
+	return run_gtk_mainloop();
+}
+
+static void do_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, type, &device);
-	printf("rc=%d\n", rc);
-	if (rc != DEVICE_STATUS_SUCCESS)
+	rc = device_open(devname, data->type, &device);
+	if (rc != DEVICE_STATUS_SUCCESS) {
+		error("Unable to open %s (%s)", data->name, data->devname);
+		return;
+	}
+
+	// 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;
+	}
+
+	// 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;
+	}
+
+	rc = import_device_data(device, data);
+	if (rc != DEVICE_STATUS_SUCCESS) {
+		error("Dive data import error");
+		device_close(device);
+		return;
+	}
+
+	device_close(device);
 }
 
 /*
@@ -158,7 +528,7 @@ static GtkComboBox *dive_computer_selector(GtkWidget *dialog)
 	GtkCellRenderer *renderer;
 
 	hbox = gtk_hbox_new(FALSE, 6);
-	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
+	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 3);
 
 	model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
 	fill_computer_list(model);
@@ -176,8 +546,11 @@ static GtkComboBox *dive_computer_selector(GtkWidget *dialog)
 void import_dialog(GtkWidget *w, gpointer data)
 {
 	int result;
-	GtkWidget *dialog;
+	GtkWidget *dialog, *hbox;
 	GtkComboBox *computer;
+	device_data_t devicedata = {
+		.devname = "/dev/ttyUSB0",
+	};
 
 	dialog = gtk_dialog_new_with_buttons("Import from dive computer",
 		GTK_WINDOW(main_window),
@@ -188,6 +561,11 @@ void import_dialog(GtkWidget *w, gpointer data)
 
 	computer = dive_computer_selector(dialog);
 
+	hbox = gtk_hbox_new(FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, TRUE, 3);
+	devicedata.progressbar = gtk_progress_bar_new();
+	gtk_container_add(GTK_CONTAINER(hbox), devicedata.progressbar);
+
 	gtk_widget_show_all(dialog);
 	result = gtk_dialog_run(GTK_DIALOG(dialog));
 	switch (result) {
@@ -203,11 +581,15 @@ void import_dialog(GtkWidget *w, gpointer data)
 			0, &comp,
 			1, &type,
 			-1);
-		do_import(comp, type);
+		devicedata.type = type;
+		devicedata.name = comp;
+		do_import(&devicedata);
 		break;
 	default:
 		break;
 	}
 	gtk_widget_destroy(dialog);
-}
 
+	report_dives();
+	dive_list_update_dives(dive_list);
+}