#include <stdio.h>
#include <gtk/gtk.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);
+}
+
+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)
}
}
-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);
}
/*
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);
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),
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) {
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);
+}
projects / ext / subsurface.git / blobdiff