71cf0a5c69
Merge upstream libdivecomputer changes from Jef Driesen. The most notable one is how libdivecomputer no longer sends the GASCHANGE events, but uses DC_SAMPLE_GASMIX instead. We still turn it into a SAMPLE_EVENT_GASCHANGE2 event internally in subsurface, since we want all the normal event handling to trigger. * 'master' of git://git.libdivecomputer.org/libdivecomputer: (21 commits) Document the date/time functions Document the public api with man pages Add support for the Cressi Drake Detect overwritten dive profiles Ignore tank pressure if no sensor is attached Add support for the tank field Add support for the salinity field Use the sample interval from the settings Update the Aqualung i750TC parser Toggle the DTR line during setup Implement the read function Add doxygen documentation to the build system Add support for the Aqualung i750TC Fix the Windows version resource build Force the dive mode to gauge Add support for the dive mode Report the initial gas mix on the first sample Remove the deprecated gas change events Add support for the Hollis DG02. Add support for the Oceanic F10. ...
320 lines
8.3 KiB
C
320 lines
8.3 KiB
C
/*
|
|
* libdivecomputer
|
|
*
|
|
* Copyright (C) 2008 Jef Driesen
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301 USA
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
#include <libdivecomputer/suunto.h>
|
|
#include <libdivecomputer/reefnet.h>
|
|
#include <libdivecomputer/uwatec.h>
|
|
#include <libdivecomputer/oceanic.h>
|
|
#include <libdivecomputer/mares.h>
|
|
#include <libdivecomputer/hw.h>
|
|
#include <libdivecomputer/cressi.h>
|
|
#include <libdivecomputer/zeagle.h>
|
|
#include <libdivecomputer/atomics.h>
|
|
#include <libdivecomputer/shearwater.h>
|
|
#include <libdivecomputer/diverite.h>
|
|
#include <libdivecomputer/citizen.h>
|
|
#include <libdivecomputer/divesystem.h>
|
|
#include <libdivecomputer/cochran.h>
|
|
|
|
#include "context-private.h"
|
|
#include "parser-private.h"
|
|
#include "device-private.h"
|
|
|
|
#define REACTPROWHITE 0x4354
|
|
|
|
static dc_status_t
|
|
dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t family, unsigned int model, unsigned int serial, unsigned int devtime, dc_ticks_t systime)
|
|
{
|
|
dc_status_t rc = DC_STATUS_SUCCESS;
|
|
dc_parser_t *parser = NULL;
|
|
|
|
if (out == NULL)
|
|
return DC_STATUS_INVALIDARGS;
|
|
|
|
switch (family) {
|
|
case DC_FAMILY_SUUNTO_SOLUTION:
|
|
rc = suunto_solution_parser_create (&parser, context);
|
|
break;
|
|
case DC_FAMILY_SUUNTO_EON:
|
|
rc = suunto_eon_parser_create (&parser, context, 0);
|
|
break;
|
|
case DC_FAMILY_SUUNTO_VYPER:
|
|
if (model == 0x01)
|
|
rc = suunto_eon_parser_create (&parser, context, 1);
|
|
else
|
|
rc = suunto_vyper_parser_create (&parser, context);
|
|
break;
|
|
case DC_FAMILY_SUUNTO_VYPER2:
|
|
case DC_FAMILY_SUUNTO_D9:
|
|
rc = suunto_d9_parser_create (&parser, context, model, serial);
|
|
break;
|
|
case DC_FAMILY_SUUNTO_EONSTEEL:
|
|
rc = suunto_eonsteel_parser_create(&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_UWATEC_ALADIN:
|
|
case DC_FAMILY_UWATEC_MEMOMOUSE:
|
|
rc = uwatec_memomouse_parser_create (&parser, context, devtime, systime);
|
|
break;
|
|
case DC_FAMILY_UWATEC_SMART:
|
|
case DC_FAMILY_UWATEC_MERIDIAN:
|
|
rc = uwatec_smart_parser_create (&parser, context, model, devtime, systime);
|
|
break;
|
|
case DC_FAMILY_REEFNET_SENSUS:
|
|
rc = reefnet_sensus_parser_create (&parser, context, devtime, systime);
|
|
break;
|
|
case DC_FAMILY_REEFNET_SENSUSPRO:
|
|
rc = reefnet_sensuspro_parser_create (&parser, context, devtime, systime);
|
|
break;
|
|
case DC_FAMILY_REEFNET_SENSUSULTRA:
|
|
rc = reefnet_sensusultra_parser_create (&parser, context, devtime, systime);
|
|
break;
|
|
case DC_FAMILY_OCEANIC_VTPRO:
|
|
rc = oceanic_vtpro_parser_create2 (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_OCEANIC_VEO250:
|
|
rc = oceanic_veo250_parser_create (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_OCEANIC_ATOM2:
|
|
if (model == REACTPROWHITE)
|
|
rc = oceanic_veo250_parser_create (&parser, context, model);
|
|
else
|
|
rc = oceanic_atom2_parser_create (&parser, context, model, serial);
|
|
break;
|
|
case DC_FAMILY_MARES_NEMO:
|
|
case DC_FAMILY_MARES_PUCK:
|
|
rc = mares_nemo_parser_create (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_MARES_DARWIN:
|
|
rc = mares_darwin_parser_create (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_MARES_ICONHD:
|
|
rc = mares_iconhd_parser_create (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_HW_OSTC:
|
|
rc = hw_ostc_parser_create (&parser, context, serial, 0);
|
|
break;
|
|
case DC_FAMILY_HW_FROG:
|
|
case DC_FAMILY_HW_OSTC3:
|
|
rc = hw_ostc3_parser_create (&parser, context, serial, model);
|
|
break;
|
|
case DC_FAMILY_CRESSI_EDY:
|
|
case DC_FAMILY_ZEAGLE_N2ITION3:
|
|
rc = cressi_edy_parser_create (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_CRESSI_LEONARDO:
|
|
rc = cressi_leonardo_parser_create2 (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_ATOMICS_COBALT:
|
|
rc = atomics_cobalt_parser_create (&parser, context);
|
|
break;
|
|
case DC_FAMILY_SHEARWATER_PREDATOR:
|
|
rc = shearwater_predator_parser_create (&parser, context, serial);
|
|
break;
|
|
case DC_FAMILY_SHEARWATER_PETREL:
|
|
rc = shearwater_petrel_parser_create (&parser, context, serial);
|
|
break;
|
|
case DC_FAMILY_DIVERITE_NITEKQ:
|
|
rc = diverite_nitekq_parser_create (&parser, context);
|
|
break;
|
|
case DC_FAMILY_CITIZEN_AQUALAND:
|
|
rc = citizen_aqualand_parser_create (&parser, context);
|
|
break;
|
|
case DC_FAMILY_DIVESYSTEM_IDIVE:
|
|
rc = divesystem_idive_parser_create2 (&parser, context, model);
|
|
break;
|
|
case DC_FAMILY_COCHRAN_COMMANDER:
|
|
rc = cochran_commander_parser_create (&parser, context, model);
|
|
break;
|
|
default:
|
|
return DC_STATUS_INVALIDARGS;
|
|
}
|
|
|
|
*out = parser;
|
|
|
|
return rc;
|
|
}
|
|
|
|
dc_status_t
|
|
dc_parser_new (dc_parser_t **out, dc_device_t *device)
|
|
{
|
|
if (device == NULL)
|
|
return DC_STATUS_INVALIDARGS;
|
|
|
|
return dc_parser_new_internal (out, device->context,
|
|
dc_device_get_type (device),
|
|
device->devinfo.model,
|
|
device->devinfo.serial,
|
|
device->clock.devtime, device->clock.systime);
|
|
}
|
|
|
|
dc_status_t
|
|
dc_parser_new2 (dc_parser_t **out, dc_context_t *context, dc_descriptor_t *descriptor, unsigned int devtime, dc_ticks_t systime)
|
|
{
|
|
return dc_parser_new_internal (out, context,
|
|
dc_descriptor_get_type (descriptor),
|
|
dc_descriptor_get_model (descriptor),
|
|
dc_descriptor_get_serial (descriptor),
|
|
devtime, systime);
|
|
}
|
|
|
|
dc_parser_t *
|
|
dc_parser_allocate (dc_context_t *context, const dc_parser_vtable_t *vtable)
|
|
{
|
|
dc_parser_t *parser = NULL;
|
|
|
|
assert(vtable != NULL);
|
|
assert(vtable->size >= sizeof(dc_parser_t));
|
|
|
|
// Allocate memory.
|
|
parser = (dc_parser_t *) malloc (vtable->size);
|
|
if (parser == NULL) {
|
|
ERROR (context, "Failed to allocate memory.");
|
|
return parser;
|
|
}
|
|
|
|
// Initialize the base class.
|
|
parser->vtable = vtable;
|
|
parser->context = context;
|
|
parser->data = NULL;
|
|
parser->size = 0;
|
|
|
|
return parser;
|
|
}
|
|
|
|
void
|
|
dc_parser_deallocate (dc_parser_t *parser)
|
|
{
|
|
free (parser);
|
|
}
|
|
|
|
int
|
|
dc_parser_isinstance (dc_parser_t *parser, const dc_parser_vtable_t *vtable)
|
|
{
|
|
if (parser == NULL)
|
|
return 0;
|
|
|
|
return parser->vtable == vtable;
|
|
}
|
|
|
|
|
|
dc_family_t
|
|
dc_parser_get_type (dc_parser_t *parser)
|
|
{
|
|
if (parser == NULL)
|
|
return DC_FAMILY_NULL;
|
|
|
|
return parser->vtable->type;
|
|
}
|
|
|
|
|
|
dc_status_t
|
|
dc_parser_set_data (dc_parser_t *parser, const unsigned char *data, unsigned int size)
|
|
{
|
|
if (parser == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
if (parser->vtable->set_data == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
parser->data = data;
|
|
parser->size = size;
|
|
|
|
return parser->vtable->set_data (parser, data, size);
|
|
}
|
|
|
|
|
|
dc_status_t
|
|
dc_parser_get_datetime (dc_parser_t *parser, dc_datetime_t *datetime)
|
|
{
|
|
if (parser == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
if (parser->vtable->datetime == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
return parser->vtable->datetime (parser, datetime);
|
|
}
|
|
|
|
dc_status_t
|
|
dc_parser_get_field (dc_parser_t *parser, dc_field_type_t type, unsigned int flags, void *value)
|
|
{
|
|
if (parser == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
if (parser->vtable->field == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
return parser->vtable->field (parser, type, flags, value);
|
|
}
|
|
|
|
|
|
dc_status_t
|
|
dc_parser_samples_foreach (dc_parser_t *parser, dc_sample_callback_t callback, void *userdata)
|
|
{
|
|
if (parser == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
if (parser->vtable->samples_foreach == NULL)
|
|
return DC_STATUS_UNSUPPORTED;
|
|
|
|
return parser->vtable->samples_foreach (parser, callback, userdata);
|
|
}
|
|
|
|
|
|
dc_status_t
|
|
dc_parser_destroy (dc_parser_t *parser)
|
|
{
|
|
dc_status_t status = DC_STATUS_SUCCESS;
|
|
|
|
if (parser == NULL)
|
|
return DC_STATUS_SUCCESS;
|
|
|
|
if (parser->vtable->destroy) {
|
|
status = parser->vtable->destroy (parser);
|
|
}
|
|
|
|
dc_parser_deallocate (parser);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
void
|
|
sample_statistics_cb (dc_sample_type_t type, dc_sample_value_t value, void *userdata)
|
|
{
|
|
sample_statistics_t *statistics = (sample_statistics_t *) userdata;
|
|
|
|
switch (type) {
|
|
case DC_SAMPLE_TIME:
|
|
statistics->divetime = value.time;
|
|
break;
|
|
case DC_SAMPLE_DEPTH:
|
|
if (statistics->maxdepth < value.depth)
|
|
statistics->maxdepth = value.depth;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|