FlapJackApps/libdc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add support for the Mares Genius

Browse Source 
The Mares Genius supports a new command to download different types of
objects (e.g. dive header, dive profiles, etc) directly, without needing
to manually read and parse the contents of the flash memory.

The data structure also changed significantly. The profile data is now
organized into different records. Each record starts and ends with a 4
byte ascii marker:

  DSTR: Dive start record
  TISS: Tissue record
  DPRS: Sample record
  AIRS: Air integration record
  DEND: Dive end record

and contains a CRC checksum. The contents of the records remains very
similar to the existing iconhd data format.

Based-on-code-by: Janice McLaughlin <janice@moremobilesoftware.com>
This commit is contained in:
Jef Driesen 2019-04-15 11:12:15 +02:00
parent a74d4ca14d
commit feec939a29
3 changed files with 697 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/descriptor.c
View File

@ -252,6 +252,7 @@ static const dc_descriptor_t g_descriptors[] = {
{"Mares", "Icon HD Net Ready", DC_FAMILY_MARES_ICONHD , 0x15, DC_TRANSPORT_SERIAL, NULL},
{"Mares", "Puck Pro", DC_FAMILY_MARES_ICONHD , 0x18, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, dc_filter_mares},
{"Mares", "Nemo Wide 2", DC_FAMILY_MARES_ICONHD , 0x19, DC_TRANSPORT_SERIAL, NULL},
{"Mares", "Genius", DC_FAMILY_MARES_ICONHD , 0x1C, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, dc_filter_mares},
{"Mares", "Puck 2", DC_FAMILY_MARES_ICONHD , 0x1F, DC_TRANSPORT_SERIAL, NULL},
{"Mares", "Quad Air", DC_FAMILY_MARES_ICONHD , 0x23, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, dc_filter_mares},
{"Mares", "Smart Air", DC_FAMILY_MARES_ICONHD , 0x24, DC_TRANSPORT_SERIAL | DC_TRANSPORT_BLE, dc_filter_mares},

284
src/mares_iconhd.c
View File

@ -28,11 +28,15 @@
#include "device-private.h"
#include "array.h"
#include "rbstream.h"
#include "platform.h"
#define C_ARRAY_SIZE(array) (sizeof (array) / sizeof *(array))
#define ISINSTANCE(device) dc_device_isinstance((device), &mares_iconhd_device_vtable)
#define NSTEPS 1000
#define STEP(i,n) (NSTEPS * (i) / (n))
#define MATRIX 0x0F
#define SMART 0x000010
#define SMARTAPNEA 0x010010
@ -40,6 +44,7 @@
#define ICONHDNET 0x15
#define PUCKPRO 0x18
#define NEMOWIDE2 0x19
#define GENIUS 0x1C
#define PUCK2 0x1F
#define QUADAIR 0x23
#define SMARTAIR 0x24
@ -54,6 +59,15 @@
#define CMD_VERSION 0xC2
#define CMD_FLASHSIZE 0xB3
#define CMD_READ 0xE7
#define CMD_OBJ_INIT 0xBF
#define CMD_OBJ_EVEN 0xAC
#define CMD_OBJ_ODD 0xFE
#define OBJ_LOGBOOK 0x2008
#define OBJ_LOGBOOK_COUNT 0x01
#define OBJ_DIVE 0x3000
#define OBJ_DIVE_HEADER 0x02
#define OBJ_DIVE_DATA 0x03
#define AIR 0
#define GAUGE 1
@ -76,6 +90,7 @@ typedef struct mares_iconhd_device_t {
dc_iostream_t *iostream;
const mares_iconhd_layout_t *layout;
unsigned char fingerprint[10];
unsigned int fingerprint_size;
unsigned char version[140];
unsigned int model;
unsigned int packetsize;
@ -136,6 +151,7 @@ mares_iconhd_get_model (mares_iconhd_device_t *device)
{"Icon AIR", ICONHDNET},
{"Puck Pro", PUCKPRO},
{"Nemo Wide 2", NEMOWIDE2},
{"Genius", GENIUS},
{"Puck 2", PUCK2},
{"Quad Air", QUADAIR},
{"Smart Air", SMARTAIR},
@ -316,6 +332,119 @@ mares_iconhd_transfer (mares_iconhd_device_t *device, const unsigned char comman
return DC_STATUS_SUCCESS;
}
static dc_status_t
mares_iconhd_read_object(mares_iconhd_device_t *device, dc_event_progress_t *progress, dc_buffer_t *buffer, unsigned int index, unsigned int subindex)
{
dc_status_t status = DC_STATUS_SUCCESS;
dc_device_t *abstract = (dc_device_t *) device;
dc_transport_t transport = dc_iostream_get_transport (device->iostream);
const unsigned int maxpacket = (transport == DC_TRANSPORT_BLE) ? 124 : 504;
// Update and emit a progress event.
unsigned int initial = 0;
if (progress) {
initial = progress->current;
device_event_emit (abstract, DC_EVENT_PROGRESS, progress);
}
// Transfer the init packet.
unsigned char rsp_init[16];
unsigned char cmd_init[18] = {
CMD_OBJ_INIT,
CMD_OBJ_INIT ^ XOR,
0x40,
(index >> 0) & 0xFF,
(index >> 8) & 0xFF,
subindex & 0xFF
};
memset (cmd_init + 6, 0x00, sizeof(cmd_init) - 6);
status = mares_iconhd_transfer (device, cmd_init, sizeof (cmd_init), rsp_init, sizeof (rsp_init));
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to transfer the init packet.");
return status;
}
// Verify the packet header.
if (memcmp (cmd_init + 3, rsp_init + 1, 3) != 0) {
ERROR (abstract->context, "Unexpected packet header.");
return DC_STATUS_PROTOCOL;
}
unsigned int nbytes = 0, size = 0;
if (rsp_init[0] == 0x41) {
// A large (and variable size) payload is split into multiple
// data packets. The first packet contains only the total size
// of the payload.
size = array_uint32_le (rsp_init + 4);
} else if (rsp_init[0] == 0x42) {
// A short (and fixed size) payload is embedded into the first
// data packet.
size = sizeof(rsp_init) - 4;
// Append the payload to the output buffer.
if (!dc_buffer_append (buffer, rsp_init + 4, sizeof(rsp_init) - 4)) {
ERROR (abstract->context, "Insufficient buffer space available.");
return DC_STATUS_NOMEMORY;
}
nbytes += sizeof(rsp_init) - 4;
} else {
ERROR (abstract->context, "Unexpected packet type (%02x).", rsp_init[0]);
return DC_STATUS_PROTOCOL;
}
// Update and emit a progress event.
if (progress) {
progress->current = initial + STEP (nbytes, size);
device_event_emit (abstract, DC_EVENT_PROGRESS, progress);
}
unsigned int npackets = 0;
while (nbytes < size) {
// Get the command byte.
unsigned char toggle = npackets % 2;
unsigned char cmd = toggle == 0 ? CMD_OBJ_EVEN : CMD_OBJ_ODD;
// Get the packet size.
unsigned int len = size - nbytes;
if (len > maxpacket) {
len = maxpacket;
}
// Transfer the segment packet.
unsigned char rsp_segment[1 + 504];
unsigned char cmd_segment[] = {cmd, cmd ^ XOR};
status = mares_iconhd_transfer (device, cmd_segment, sizeof (cmd_segment), rsp_segment, len + 1);
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to transfer the segment packet.");
return status;
}
// Verify the packet header.
if ((rsp_segment[0] & 0xF0) >> 4 != toggle) {
ERROR (abstract->context, "Unexpected packet header (%02x).", rsp_segment[0]);
return DC_STATUS_PROTOCOL;
}
// Append the payload to the output buffer.
if (!dc_buffer_append (buffer, rsp_segment + 1, len)) {
ERROR (abstract->context, "Insufficient buffer space available.");
return DC_STATUS_NOMEMORY;
}
nbytes += len;
npackets++;
// Update and emit the progress events.
if (progress) {
progress->current = initial + STEP (nbytes, size);
device_event_emit (abstract, DC_EVENT_PROGRESS, progress);
}
}
return status;
}
dc_status_t
mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream)
{
@ -336,6 +465,7 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_
device->iostream = iostream;
device->layout = NULL;
memset (device->fingerprint, 0, sizeof (device->fingerprint));
device->fingerprint_size = sizeof (device->fingerprint);
memset (device->version, 0, sizeof (device->version));
device->model = 0;
device->packetsize = 0;
@ -426,6 +556,11 @@ mares_iconhd_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_
device->layout = &mares_iconhdnet_layout;
device->packetsize = 256;
break;
case GENIUS:
device->layout = &mares_iconhdnet_layout;
device->packetsize = 256;
device->fingerprint_size = 4;
break;
case ICONHDNET:
device->layout = &mares_iconhdnet_layout;
device->packetsize = 4096;
@ -452,13 +587,13 @@ mares_iconhd_device_set_fingerprint (dc_device_t *abstract, const unsigned char
{
mares_iconhd_device_t *device = (mares_iconhd_device_t *) abstract;
if (size && size != sizeof (device->fingerprint))
if (size && size != device->fingerprint_size)
return DC_STATUS_INVALIDARGS;
if (size)
memcpy (device->fingerprint, data, sizeof (device->fingerprint));
memcpy (device->fingerprint, data, device->fingerprint_size);
else
memset (device->fingerprint, 0, sizeof (device->fingerprint));
memset (device->fingerprint, 0, device->fingerprint_size);
return DC_STATUS_SUCCESS;
}
@ -521,48 +656,19 @@ mares_iconhd_device_dump (dc_device_t *abstract, dc_buffer_t *buffer)
dc_buffer_get_size (buffer), device->packetsize);
}
static dc_status_t
mares_iconhd_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
mares_iconhd_device_foreach_raw (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
{
dc_status_t rc = DC_STATUS_SUCCESS;
mares_iconhd_device_t *device = (mares_iconhd_device_t *) abstract;
if (!ISINSTANCE (abstract))
return DC_STATUS_INVALIDARGS;
const mares_iconhd_layout_t *layout = device->layout;
// Enable progress notifications.
dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
progress.maximum = layout->rb_profile_end - layout->rb_profile_begin + 4;
progress.maximum = layout->rb_profile_end - layout->rb_profile_begin;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
// Emit a vendor event.
dc_event_vendor_t vendor;
vendor.data = device->version;
vendor.size = sizeof (device->version);
device_event_emit (abstract, DC_EVENT_VENDOR, &vendor);
// Read the serial number.
unsigned char serial[4] = {0};
rc = mares_iconhd_device_read (abstract, 0x0C, serial, sizeof (serial));
if (rc != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the memory.");
return rc;
}
// Update and emit a progress event.
progress.current += sizeof (serial);
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
// Emit a device info event.
dc_event_devinfo_t devinfo;
devinfo.model = device->model;
devinfo.firmware = 0;
devinfo.serial = array_uint32_le (serial);
device_event_emit (abstract, DC_EVENT_DEVINFO, &devinfo);
// Get the model code.
unsigned int model = device->model;
@ -739,3 +845,113 @@ mares_iconhd_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback,
return rc;
}
static dc_status_t
mares_iconhd_device_foreach_object (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
{
dc_status_t rc = DC_STATUS_SUCCESS;
mares_iconhd_device_t *device = (mares_iconhd_device_t *) abstract;
// Enable progress notifications.
dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
// Allocate memory for the dives.
dc_buffer_t *buffer = dc_buffer_new (4096);
if (buffer == NULL) {
ERROR (abstract->context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
// Read the number of dives.
rc = mares_iconhd_read_object (device, NULL, buffer, OBJ_LOGBOOK, OBJ_LOGBOOK_COUNT);
if (rc != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the number of dives.");
dc_buffer_free (buffer);
return rc;
}
if (dc_buffer_get_size (buffer) < 2) {
ERROR (abstract->context, "Unexpected number of bytes received (" DC_PRINTF_SIZE ").",
dc_buffer_get_size (buffer));
dc_buffer_free (buffer);
return DC_STATUS_PROTOCOL;
}
// Get the number of dives.
unsigned int ndives = array_uint16_le (dc_buffer_get_data(buffer));
// Update and emit a progress event.
progress.current = 1 * NSTEPS;
progress.maximum = (1 + ndives * 2) * NSTEPS;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
// Download the dives.
for (unsigned int i = 0; i < ndives; ++i) {
// Erase the buffer.
dc_buffer_clear (buffer);
// Read the dive header.
rc = mares_iconhd_read_object (device, &progress, buffer, OBJ_DIVE + i, OBJ_DIVE_HEADER);
if (rc != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the dive header.");
break;
}
// Check the fingerprint data.
if (memcmp (dc_buffer_get_data (buffer) + 0x08, device->fingerprint, device->fingerprint_size) == 0) {
INFO (abstract->context, "Stopping due to detecting a matching fingerprint");
break;
}
// Read the dive data.
rc = mares_iconhd_read_object (device, &progress, buffer, OBJ_DIVE + i, OBJ_DIVE_DATA);
if (rc != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the dive data.");
break;
}
const unsigned char *data = dc_buffer_get_data (buffer);
if (callback && !callback (data, dc_buffer_get_size (buffer), data + 0x08, device->fingerprint_size, userdata)) {
break;
}
}
dc_buffer_free(buffer);
return rc;
}
static dc_status_t
mares_iconhd_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
{
dc_status_t rc = DC_STATUS_SUCCESS;
mares_iconhd_device_t *device = (mares_iconhd_device_t *) abstract;
// Emit a vendor event.
dc_event_vendor_t vendor;
vendor.data = device->version;
vendor.size = sizeof (device->version);
device_event_emit (abstract, DC_EVENT_VENDOR, &vendor);
// Read the serial number.
unsigned char serial[4] = {0};
rc = mares_iconhd_device_read (abstract, 0x0C, serial, sizeof (serial));
if (rc != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the memory.");
return rc;
}
// Emit a device info event.
dc_event_devinfo_t devinfo;
devinfo.model = device->model;
devinfo.firmware = 0;
devinfo.serial = array_uint32_le (serial);
device_event_emit (abstract, DC_EVENT_DEVINFO, &devinfo);
if (device->model == GENIUS) {
return mares_iconhd_device_foreach_object (abstract, callback, userdata);
} else {
return mares_iconhd_device_foreach_raw (abstract, callback, userdata);
}
}

515
src/mares_iconhd_parser.c
View File

@ -27,6 +27,7 @@
#include "context-private.h"
#include "parser-private.h"
#include "array.h"
#include "checksum.h"
#define ISINSTANCE(parser) dc_parser_isinstance((parser), &mares_iconhd_parser_vtable)
@ -34,16 +35,79 @@
#define SMARTAPNEA 0x010010
#define ICONHD 0x14
#define ICONHDNET 0x15
#define GENIUS 0x1C
#define QUADAIR 0x23
#define SMARTAIR 0x24
#define NGASMIXES 3
#define NTANKS NGASMIXES
#define NGASMIXES_ICONHD 3
#define NGASMIXES_GENIUS 5
#define NGASMIXES NGASMIXES_GENIUS
#define AIR 0
#define GAUGE 1
#define NITROX 2
#define FREEDIVE 3
#define NTANKS_ICONHD NGASMIXES_ICONHD
#define NTANKS_GENIUS NGASMIXES_GENIUS
#define NTANKS NGASMIXES
#define ICONHD_AIR 0
#define ICONHD_GAUGE 1
#define ICONHD_NITROX 2
#define ICONHD_FREEDIVE 3
#define GENIUS_AIR 0
#define GENIUS_NITROX_SINGLE 1
#define GENIUS_NITROX_MULTI 2
#define GENIUS_TRIMIX 3
#define GENIUS_GAUGE 4
#define GENIUS_FREEDIVE 5
// Record types and sizes
#define DSTR_TYPE 0x44535452 // Dive start record
#define DSTR_SIZE 58
#define TISS_TYPE 0x54495353 // Tissue record
#define TISS_SIZE 138
#define DPRS_TYPE 0x44505253 // Sample record
#define DPRS_SIZE 34
#define AIRS_TYPE 0x41495253 // Air integration record
#define AIRS_SIZE 16
#define DEND_TYPE 0x44454E44 // Dive end record
#define DEND_SIZE 162
#define GASMIX_OFF 0
#define GASMIX_READY 1
#define GASMIX_INUSE 2
#define GASMIX_IGNRD 3
#define WATER_SALT 0
#define WATER_FRESH 1
#define WATER_EN13319 2
#define ALARM_NONE 0
#define ALARM_SLOW_DOWN 1
#define ALARM_FAST_ASCENT 2
#define ALARM_UNCONTROLLED_ASCENT 3
#define ALARM_MOD_REACHED 4
#define ALARM_CNS_DANGER 5
#define ALARM_CNS_EXTREME 6
#define ALARM_MISSED_DECO 7
#define ALARM_DIVE_VIOLATION_DECO 8
#define ALARM_LOW_BATTERY 9
#define ALARM_VERY_LOW_BATTERY 10
#define ALARM_PROBE_LOW_BATTERY 11
#define ALARM_LOW_TANK_PRESSURE 12
#define ALARM_TANK_RESERVE_REACHED 13
#define ALARM_TANK_LOST_LINK 14
#define ALARM_MAX_DIVE_DEPTH 15
#define ALARM_RUN_AWAY_DECO 16
#define ALARM_TANK_HALF_REACHED 17
#define ALARM_NODECO_2MIN 18
#define ALARM_NODECO_DECO 19
#define ALARM_MULTIGAS_ATANKISLOW 20
#define ALARM_DIVETIME_HALFTIME 21
#define ALARM_DIVETIME_FULLTIME 22
#define ALARM_GAS_SWITCHPOINT 23
#define ALARM_GAS_IGNORED 24
#define ALARM_GAS_CHANGED 25
#define ALARM_GAS_NOTCHANGED 26
#define ALARM_GAS_ADDED 27
typedef struct mares_iconhd_parser_t mares_iconhd_parser_t;
@ -92,17 +156,35 @@ static const dc_parser_vtable_t mares_iconhd_parser_vtable = {
NULL /* destroy */
};
static unsigned int
mares_genius_isvalid (const unsigned char data[], size_t size, unsigned int type)
{
if (size < 10) {
return 0;
}
unsigned int head = array_uint32_be(data);
unsigned int tail = array_uint32_be(data + size - 4);
if (head != type || tail != type) {
return 0;
}
unsigned short crc = array_uint16_le(data + size - 6);
unsigned short ccrc = checksum_crc16_ccitt(data + 4, size - 10, 0x0000);
if (crc != ccrc) {
return 0;
}
return 1;
}
static dc_status_t
mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
mares_iconhd_cache (mares_iconhd_parser_t *parser)
{
dc_parser_t *abstract = (dc_parser_t *) parser;
const unsigned char *data = parser->base.data;
unsigned int size = parser->base.size;
if (parser->cached) {
return DC_STATUS_SUCCESS;
}
unsigned int header = 0x5C;
if (parser->model == ICONHDNET)
header = 0x80;
@ -147,7 +229,7 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
headersize = 0x84;
samplesize = 12;
} else if (parser->model == SMART) {
if (mode == FREEDIVE) {
if (mode == ICONHD_FREEDIVE) {
headersize = 0x2E;
samplesize = 6;
} else {
@ -173,7 +255,7 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
unsigned int settings = 0;
if (parser->model == SMARTAPNEA) {
settings = array_uint16_le (p + 0x1C);
} else if (parser->mode == FREEDIVE) {
} else if (parser->mode == ICONHD_FREEDIVE) {
settings = array_uint16_le (p + 0x08);
} else {
settings = array_uint16_le (p + 0x0C);
@ -208,10 +290,10 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
// Gas mixes
unsigned int ngasmixes = 0;
mares_iconhd_gasmix_t gasmix[NGASMIXES] = {0};
if (mode == GAUGE || mode == FREEDIVE) {
mares_iconhd_gasmix_t gasmix[NGASMIXES_ICONHD] = {0};
if (mode == ICONHD_GAUGE || mode == ICONHD_FREEDIVE) {
ngasmixes = 0;
} else if (mode == AIR) {
} else if (mode == ICONHD_AIR) {
gasmix[0].oxygen = 21;
gasmix[0].helium = 0;
ngasmixes = 1;
@ -220,7 +302,7 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
// mixes are always first, so we stop counting as soon
// as the first gas marked as disabled is found.
ngasmixes = 0;
while (ngasmixes < NGASMIXES) {
while (ngasmixes < NGASMIXES_ICONHD) {
if (p[0x10 + ngasmixes * 4 + 1] & 0x80)
break;
gasmix[ngasmixes].oxygen = p[0x10 + ngasmixes * 4];
@ -231,10 +313,10 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
// Tanks
unsigned int ntanks = 0;
mares_iconhd_tank_t tank[NTANKS] = {0};
mares_iconhd_tank_t tank[NTANKS_ICONHD] = {0};
if (parser->model == ICONHDNET || parser->model == QUADAIR || parser->model == SMARTAIR) {
unsigned int tankoffset = (parser->model == ICONHDNET) ? 0x58 : 0x5C;
while (ntanks < NTANKS) {
while (ntanks < NTANKS_ICONHD) {
tank[ntanks].volume = array_uint16_le (p + tankoffset + 0x0C + ntanks * 8 + 0);
tank[ntanks].workpressure = array_uint16_le (p + tankoffset + 0x0C + ntanks * 8 + 2);
tank[ntanks].beginpressure = array_uint16_le (p + tankoffset + ntanks * 4 + 0);
@ -269,6 +351,129 @@ mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
return DC_STATUS_SUCCESS;
}
static dc_status_t
mares_genius_cache (mares_iconhd_parser_t *parser)
{
dc_parser_t *abstract = (dc_parser_t *) parser;
const unsigned char *data = parser->base.data;
unsigned int size = parser->base.size;
if (size < 4) {
ERROR (abstract->context, "Buffer overflow detected!");
return DC_STATUS_DATAFORMAT;
}
// Check the header type and version.
unsigned int type = array_uint16_le (data);
unsigned int major = data[2];
unsigned int minor = data[3];
if (type != 1 || major != 0 || minor != 0) {
ERROR (abstract->context, "Unsupported object type (%u) or version (%u.%u).",
type, major, minor);
return DC_STATUS_DATAFORMAT;
}
// Get the header size.
unsigned int headersize = 0xB8;
if (headersize > size) {
ERROR (abstract->context, "Buffer overflow detected!");
return DC_STATUS_DATAFORMAT;
}
// Get the number of samples in the profile data.
unsigned int nsamples = array_uint16_le (data + 0x20);
// Get the dive settings.
unsigned int settings = array_uint32_le (data + 0x0C);
// Get the dive mode.
unsigned int mode = settings & 0xF;
// Calculate the total number of bytes for this dive.
unsigned int nbytes = headersize + 4 + DSTR_SIZE + TISS_SIZE + nsamples * DPRS_SIZE + (nsamples / 4) * AIRS_SIZE + DEND_SIZE;
if (nbytes > size) {
ERROR (abstract->context, "Buffer overflow detected!");
return DC_STATUS_DATAFORMAT;
}
// Gas mixes and tanks.
unsigned int ntanks = 0;
unsigned int ngasmixes = 0;
mares_iconhd_gasmix_t gasmix[NGASMIXES_GENIUS] = {0};
mares_iconhd_tank_t tank[NTANKS_GENIUS] = {0};
for (unsigned int i = 0; i < NGASMIXES_GENIUS; i++) {
unsigned int offset = 0x54 + i * 20;
unsigned int gasmixparams = array_uint32_le(data + offset + 0);
unsigned int beginpressure = array_uint16_le(data + offset + 4);
unsigned int endpressure = array_uint16_le(data + offset + 6);
unsigned int volume = array_uint16_le(data + offset + 8);
unsigned int workpressure = array_uint16_le(data + offset + 10);
unsigned int o2 = (gasmixparams ) & 0x7F;
unsigned int n2 = (gasmixparams >> 7) & 0x7F;
unsigned int he = (gasmixparams >> 14) & 0x7F;
unsigned int state = (gasmixparams >> 21) & 0x03;
unsigned int changed = (gasmixparams >> 23) & 0x01;
if (o2 + n2 + he != 100) {
WARNING (abstract->context, "Invalid gas mix (%u%% He, %u%% O2, %u%% N2).", he, o2, n2);
}
// The active gas mixes are always first, so we stop processing
// as soon as the first gas mix marked as disabled is found.
if (state != GASMIX_OFF && ngasmixes == i) {
gasmix[i].oxygen = o2;
gasmix[i].helium = he;
ngasmixes++;
}
// Assume the active transmitters are always first, so we can
// stop processing as soon as the first inactive transmitter is
// found.
if ((beginpressure != 0 || (endpressure != 0 && endpressure != 36000)) &&
(ntanks == i)) {
tank[i].volume = volume;
tank[i].workpressure = workpressure;
tank[i].beginpressure = beginpressure;
tank[i].endpressure = endpressure;
ntanks++;
}
}
// Cache the data for later use.
parser->mode = mode;
parser->nsamples = nsamples;
parser->samplesize = DPRS_SIZE;
parser->headersize = headersize;
parser->settings = settings;
parser->interval = 5;
parser->samplerate = 1;
parser->ntanks = ntanks;
parser->ngasmixes = ngasmixes;
for (unsigned int i = 0; i < ngasmixes; ++i) {
parser->gasmix[i] = gasmix[i];
}
for (unsigned int i = 0; i < ntanks; ++i) {
parser->tank[i] = tank[i];
}
parser->cached = 1;
return DC_STATUS_SUCCESS;
}
static dc_status_t
mares_iconhd_parser_cache (mares_iconhd_parser_t *parser)
{
if (parser->cached) {
return DC_STATUS_SUCCESS;
}
if (parser->model == GENIUS) {
return mares_genius_cache (parser);
} else {
return mares_iconhd_cache (parser);
}
}
dc_status_t
mares_iconhd_parser_create (dc_parser_t **out, dc_context_t *context, unsigned int model)
@ -288,7 +493,7 @@ mares_iconhd_parser_create (dc_parser_t **out, dc_context_t *context, unsigned i
// Set the default values.
parser->model = model;
parser->cached = 0;
parser->mode = AIR;
parser->mode = (model == GENIUS) ? GENIUS_AIR : ICONHD_AIR;
parser->nsamples = 0;
parser->samplesize = 0;
parser->headersize = 0;
@ -321,7 +526,7 @@ mares_iconhd_parser_set_data (dc_parser_t *abstract, const unsigned char *data,
// Reset the cache.
parser->cached = 0;
parser->mode = AIR;
parser->mode = (parser->model == GENIUS) ? GENIUS_AIR : ICONHD_AIR;
parser->nsamples = 0;
parser->samplesize = 0;
parser->headersize = 0;
@ -356,27 +561,42 @@ mares_iconhd_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime
return rc;
// Pointer to the header data.
const unsigned char *p = abstract->data + abstract->size - parser->headersize;
if (parser->model != SMART && parser->model != SMARTAPNEA && parser->model != SMARTAIR) {
p += 4;
const unsigned char *p = abstract->data;
if (parser->model != GENIUS) {
p += abstract->size - parser->headersize;
if (parser->model != SMART && parser->model != SMARTAPNEA && parser->model != SMARTAIR) {
p += 4;
}
}
// Offset to the date/time field.
if (parser->model == SMARTAPNEA) {
if (parser->model == GENIUS) {
p += 0x08;
} else if (parser->model == SMARTAPNEA) {
p += 0x40;
} else if (parser->mode == FREEDIVE) {
} else if (parser->mode == ICONHD_FREEDIVE) {
p += 0x20;
} else {
p += 2;
}
if (datetime) {
datetime->hour = array_uint16_le (p + 0);
datetime->minute = array_uint16_le (p + 2);
datetime->second = 0;
datetime->day = array_uint16_le (p + 4);
datetime->month = array_uint16_le (p + 6) + 1;
datetime->year = array_uint16_le (p + 8) + 1900;
if (parser->model == GENIUS) {
unsigned int timestamp = array_uint32_le (p);
datetime->hour = (timestamp ) & 0x1F;
datetime->minute = (timestamp >> 5) & 0x3F;
datetime->second = 0;
datetime->day = (timestamp >> 11) & 0x1F;
datetime->month = (timestamp >> 16) & 0x0F;
datetime->year = (timestamp >> 20) & 0x0FFF;
} else {
datetime->hour = array_uint16_le (p + 0);
datetime->minute = array_uint16_le (p + 2);
datetime->second = 0;
datetime->day = array_uint16_le (p + 4);
datetime->month = array_uint16_le (p + 6) + 1;
datetime->year = array_uint16_le (p + 8) + 1900;
}
datetime->timezone = DC_TIMEZONE_NONE;
}
@ -395,11 +615,16 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
return rc;
// Pointer to the header data.
const unsigned char *p = abstract->data + abstract->size - parser->headersize;
if (parser->model != SMART && parser->model != SMARTAPNEA && parser->model != SMARTAIR) {
p += 4;
const unsigned char *p = abstract->data;
if (parser->model != GENIUS) {
p += abstract->size - parser->headersize;
if (parser->model != SMART && parser->model != SMARTAPNEA && parser->model != SMARTAIR) {
p += 4;
}
}
unsigned int metric = parser->model == GENIUS ? p[0x34] : parser->settings & 0x0100;
dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
dc_tank_t *tank = (dc_tank_t *) value;
dc_salinity_t *water = (dc_salinity_t *) value;
@ -407,9 +632,11 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
if (value) {
switch (type) {
case DC_FIELD_DIVETIME:
if (parser->model == SMARTAPNEA) {
if (parser->model == GENIUS) {
*((unsigned int *) value) = parser->nsamples * parser->interval;
} else if (parser->model == SMARTAPNEA) {
*((unsigned int *) value) = array_uint16_le (p + 0x24);
} else if (parser->mode == FREEDIVE) {
} else if (parser->mode == ICONHD_FREEDIVE) {
unsigned int divetime = 0;
unsigned int offset = 4;
for (unsigned int i = 0; i < parser->nsamples; ++i) {
@ -422,9 +649,11 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
}
break;
case DC_FIELD_MAXDEPTH:
if (parser->model == SMARTAPNEA)
if (parser->model == GENIUS)
*((double *) value) = array_uint16_le (p + 0x22) / 10.0;
else if (parser->model == SMARTAPNEA)
*((double *) value) = array_uint16_le (p + 0x3A) / 10.0;
else if (parser->mode == FREEDIVE)
else if (parser->mode == ICONHD_FREEDIVE)
*((double *) value) = array_uint16_le (p + 0x1A) / 10.0;
else
*((double *) value) = array_uint16_le (p + 0x00) / 10.0;
@ -441,7 +670,7 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
*((unsigned int *) value) = parser->ntanks;
break;
case DC_FIELD_TANK:
if (parser->settings & 0x0100) {
if (metric) {
tank->type = DC_TANKVOLUME_METRIC;
tank->volume = parser->tank[flags].volume;
tank->workpressure = parser->tank[flags].workpressure;
@ -462,16 +691,35 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
}
break;
case DC_FIELD_ATMOSPHERIC:
// Pressure (1/8 millibar)
if (parser->model == SMARTAPNEA)
if (parser->model == GENIUS)
*((double *) value) = array_uint16_le (p + 0x3E) / 1000.0;
else if (parser->model == SMARTAPNEA)
*((double *) value) = array_uint16_le (p + 0x38) / 1000.0;
else if (parser->mode == FREEDIVE)
else if (parser->mode == ICONHD_FREEDIVE)
*((double *) value) = array_uint16_le (p + 0x18) / 1000.0;
else
*((double *) value) = array_uint16_le (p + 0x22) / 8000.0;
break;
case DC_FIELD_SALINITY:
if (parser->model == SMARTAPNEA) {
if (parser->model == GENIUS) {
unsigned int salinity = (parser->settings >> 5) & 0x03;
switch (salinity) {
case WATER_FRESH:
water->type = DC_WATER_FRESH;
water->density = 0.0;
break;
case WATER_SALT:
water->type = DC_WATER_SALT;
water->density = 0.0;
break;
case WATER_EN13319:
water->type = DC_WATER_SALT;
water->density = MSW / GRAVITY;
break;
default:
return DC_STATUS_DATAFORMAT;
}
} else if (parser->model == SMARTAPNEA) {
unsigned int salinity = parser->settings & 0x003F;
if (salinity == 0) {
water->type = DC_WATER_FRESH;
@ -489,35 +737,58 @@ mares_iconhd_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsi
}
break;
case DC_FIELD_TEMPERATURE_MINIMUM:
if (parser->model == SMARTAPNEA)
if (parser->model == GENIUS)
*((double *) value) = (signed short) array_uint16_le (p + 0x28) / 10.0;
else if (parser->model == SMARTAPNEA)
*((double *) value) = (signed short) array_uint16_le (p + 0x3E) / 10.0;
else if (parser->mode == FREEDIVE)
else if (parser->mode == ICONHD_FREEDIVE)
*((double *) value) = (signed short) array_uint16_le (p + 0x1C) / 10.0;
else
*((double *) value) = (signed short) array_uint16_le (p + 0x42) / 10.0;
break;
case DC_FIELD_TEMPERATURE_MAXIMUM:
if (parser->model == SMARTAPNEA)
if (parser->model == GENIUS)
*((double *) value) = (signed short) array_uint16_le (p + 0x26) / 10.0;
else if (parser->model == SMARTAPNEA)
*((double *) value) = (signed short) array_uint16_le (p + 0x3C) / 10.0;
else if (parser->mode == FREEDIVE)
else if (parser->mode == ICONHD_FREEDIVE)
*((double *) value) = (signed short) array_uint16_le (p + 0x1E) / 10.0;
else
*((double *) value) = (signed short) array_uint16_le (p + 0x44) / 10.0;
break;
case DC_FIELD_DIVEMODE:
switch (parser->mode) {
case AIR:
case NITROX:
*((dc_divemode_t *) value) = DC_DIVEMODE_OC;
break;
case GAUGE:
*((dc_divemode_t *) value) = DC_DIVEMODE_GAUGE;
break;
case FREEDIVE:
*((dc_divemode_t *) value) = DC_DIVEMODE_FREEDIVE;
break;
default:
return DC_STATUS_DATAFORMAT;
if (parser->model == GENIUS) {
switch (parser->mode) {
case GENIUS_AIR:
case GENIUS_NITROX_SINGLE:
case GENIUS_NITROX_MULTI:
case GENIUS_TRIMIX:
*((dc_divemode_t *) value) = DC_DIVEMODE_OC;
break;
case GENIUS_GAUGE:
*((dc_divemode_t *) value) = DC_DIVEMODE_GAUGE;
break;
case GENIUS_FREEDIVE:
*((dc_divemode_t *) value) = DC_DIVEMODE_FREEDIVE;
break;
default:
return DC_STATUS_DATAFORMAT;
}
} else {
switch (parser->mode) {
case ICONHD_AIR:
case ICONHD_NITROX:
*((dc_divemode_t *) value) = DC_DIVEMODE_OC;
break;
case ICONHD_GAUGE:
*((dc_divemode_t *) value) = DC_DIVEMODE_GAUGE;
break;
case ICONHD_FREEDIVE:
*((dc_divemode_t *) value) = DC_DIVEMODE_FREEDIVE;
break;
default:
return DC_STATUS_DATAFORMAT;
}
}
break;
default:
@ -552,10 +823,43 @@ mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t
// Previous gas mix - initialize with impossible value
unsigned int gasmix_previous = 0xFFFFFFFF;
unsigned int isairintegrated = (parser->model == ICONHDNET || parser->model == QUADAIR || parser->model == SMARTAIR);
unsigned int isairintegrated = (parser->model == ICONHDNET || parser->model == QUADAIR || parser->model == SMARTAIR || parser->model == GENIUS);
unsigned int offset = 4;
unsigned int marker = 0;
if (parser->model == GENIUS) {
// Skip the dive header.
data += parser->headersize;
// Check the profile type and version.
unsigned int type = array_uint16_le (data);
unsigned int major = data[2];
unsigned int minor = data[3];
if (type != 0 || major != 2 || minor != 0) {
ERROR (abstract->context, "Unsupported object type (%u) or version (%u.%u).",
type, major, minor);
return DC_STATUS_DATAFORMAT;
}
// Skip the DSTR record.
if (!mares_genius_isvalid (data + offset, DSTR_SIZE, DSTR_TYPE)) {
ERROR (abstract->context, "Invalid DSTR record.");
return DC_STATUS_DATAFORMAT;
}
offset += DSTR_SIZE;
// Skip the TISS record.
if (!mares_genius_isvalid (data + offset, TISS_SIZE, TISS_TYPE)) {
ERROR (abstract->context, "Invalid TISS record.");
return DC_STATUS_DATAFORMAT;
}
offset += TISS_SIZE;
// Size of the record type marker.
marker = 4;
}
unsigned int time = 0;
unsigned int offset = 4;
unsigned int nsamples = 0;
while (nsamples < parser->nsamples) {
dc_sample_value_t sample = {0};
@ -590,7 +894,7 @@ mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t
offset += 2 * parser->samplerate;
}
} else if (parser->mode == FREEDIVE) {
} else if (parser->model != GENIUS && parser->mode == ICONHD_FREEDIVE) {
unsigned int maxdepth = array_uint16_le (data + offset + 0);
unsigned int divetime = array_uint16_le (data + offset + 2);
unsigned int surftime = array_uint16_le (data + offset + 4);
@ -616,23 +920,39 @@ mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t
offset += parser->samplesize;
nsamples++;
} else {
unsigned int depth = 0, temperature = 0;
unsigned int gasmix = 0, misc = 0, alarms = 0;
if (parser->model == GENIUS) {
if (!mares_genius_isvalid (data + offset, DPRS_SIZE, DPRS_TYPE)) {
ERROR (abstract->context, "Invalid DPRS record.");
return DC_STATUS_DATAFORMAT;
}
depth = array_uint16_le (data + offset + marker + 0);
temperature = array_uint16_le (data + offset + marker + 4);
alarms = array_uint32_le (data + offset + marker + 0x0C);
misc = array_uint32_le (data + offset + marker + 0x14);
gasmix = (misc >> 6) & 0xF;
} else {
depth = array_uint16_le (data + offset + 0);
temperature = array_uint16_le (data + offset + 2) & 0x0FFF;
gasmix = (data[offset + 3] & 0xF0) >> 4;
}
// Time (seconds).
time += parser->interval;
sample.time = time;
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
// Depth (1/10 m).
unsigned int depth = array_uint16_le (data + offset + 0);
sample.depth = depth / 10.0;
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
// Temperature (1/10 °C).
unsigned int temperature = array_uint16_le (data + offset + 2) & 0x0FFF;
sample.temperature = temperature / 10.0;
if (callback) callback (DC_SAMPLE_TEMPERATURE, sample, userdata);
// Current gas mix
unsigned int gasmix = (data[offset + 3] & 0xF0) >> 4;
if (parser->ngasmixes > 0) {
if (gasmix >= parser->ngasmixes) {
ERROR (abstract->context, "Invalid gas mix index.");
@ -645,13 +965,61 @@ mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t
}
}
if (parser->model == GENIUS) {
// Deco stop / NDL.
unsigned int decostop = (misc >> 18) & 0x01;
unsigned int decodepth = (misc >> 19) & 0x7F;
if (decostop) {
sample.deco.type = DC_DECO_DECOSTOP;
sample.deco.depth = decodepth;
} else {
sample.deco.type = DC_DECO_NDL;
sample.deco.depth = 0.0;
}
sample.deco.time = array_uint16_le (data + offset + marker + 0x0A) * 60;
if (callback) callback (DC_SAMPLE_DECO, sample, userdata);
// Alarms
for (unsigned int v = alarms, i = 0; v; v >>= 1, ++i) {
if ((v & 1) == 0) {
continue;
}
switch (i) {
case ALARM_FAST_ASCENT:
case ALARM_UNCONTROLLED_ASCENT:
sample.event.type = SAMPLE_EVENT_ASCENT;
break;
case ALARM_MISSED_DECO:
case ALARM_DIVE_VIOLATION_DECO:
sample.event.type = SAMPLE_EVENT_CEILING;
break;
default:
sample.event.type = SAMPLE_EVENT_NONE;
break;
}
if (sample.event.type != SAMPLE_EVENT_NONE) {
sample.event.time = 0;
sample.event.flags = 0;
sample.event.value = 0;
if (callback) callback (DC_SAMPLE_EVENT, sample, userdata);
}
}
}
offset += parser->samplesize;
nsamples++;
// Some extra data.
if (isairintegrated && (nsamples % 4) == 0) {
if (parser->model == GENIUS && !mares_genius_isvalid (data + offset, AIRS_SIZE, AIRS_TYPE)) {
ERROR (abstract->context, "Invalid AIRS record.");
return DC_STATUS_DATAFORMAT;
}
// Pressure (1/100 bar).
unsigned int pressure = array_uint16_le(data + offset);
unsigned int pressure = array_uint16_le(data + offset + marker + 0);
if (gasmix < parser->ntanks) {
sample.pressure.tank = gasmix;
sample.pressure.value = pressure / 100.0;
@ -660,10 +1028,19 @@ mares_iconhd_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t
WARNING (abstract->context, "Invalid tank with non-zero pressure.");
}
offset += 8;
offset += (parser->model == GENIUS) ? AIRS_SIZE : 8;
}
}
}
if (parser->model == GENIUS) {
// Skip the DEND record.
if (!mares_genius_isvalid (data + offset, DEND_SIZE, DEND_TYPE)) {
ERROR (abstract->context, "Invalid DEND record.");
return DC_STATUS_DATAFORMAT;
}
offset += DEND_SIZE;
}
return DC_STATUS_SUCCESS;
}