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

Add support for the Cressi Leonardo.

Browse Source 
This is only a preliminary version. There is certainly some room for
improvement, but the basic functionality is already in place. That
should be sufficient for daily use, and possibles issues can always be
fixed when discovered.
This commit is contained in:
Jef Driesen 2013-01-15 09:49:46 +01:00
parent 1e4d051b1e
commit 0b20855d56
15 changed files with 757 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
examples/Makefile.am
View File

@ -23,6 +23,7 @@ bin_PROGRAMS = \
ostc \
frog \
edy \
leonardo \
n2ition3 \
predator
@ -75,6 +76,8 @@ frog_SOURCES = hw_frog_test.c $(COMMON)
edy_SOURCES = cressi_edy_test.c $(COMMON)
leonardo_SOURCES = cressi_leonardo_test.c $(COMMON)
n2ition3_SOURCES = zeagle_n2ition3_test.c $(COMMON)
predator_SOURCES = shearwater_predator_test.c $(COMMON)

107
examples/cressi_leonardo_test.c Normal file
View File

@ -0,0 +1,107 @@
/*
* libdivecomputer
*
* Copyright (C) 2013 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 <stdio.h> // fopen, fwrite, fclose
#include <libdivecomputer/cressi_leonardo.h>
#include "utils.h"
#include "common.h"
dc_status_t
test_dump_memory (const char* name, const char* filename)
{
dc_context_t *context = NULL;
dc_device_t *device = NULL;
dc_context_new (&context);
dc_context_set_loglevel (context, DC_LOGLEVEL_ALL);
dc_context_set_logfunc (context, logfunc, NULL);
message ("cressi_leonardo_device_open\n");
dc_status_t rc = cressi_leonardo_device_open (&device, context, name);
if (rc != DC_STATUS_SUCCESS) {
WARNING ("Error opening serial port.");
dc_context_free (context);
return rc;
}
dc_buffer_t *buffer = dc_buffer_new (0);
message ("dc_device_dump\n");
rc = dc_device_dump (device, buffer);
if (rc != DC_STATUS_SUCCESS) {
WARNING ("Cannot read memory.");
dc_buffer_free (buffer);
dc_device_close (device);
dc_context_free (context);
return rc;
}
message ("Dumping data\n");
FILE* fp = fopen (filename, "wb");
if (fp != NULL) {
fwrite (dc_buffer_get_data (buffer), sizeof (unsigned char), dc_buffer_get_size (buffer), fp);
fclose (fp);
}
dc_buffer_free (buffer);
message ("dc_device_close\n");
rc = dc_device_close (device);
if (rc != DC_STATUS_SUCCESS) {
WARNING ("Cannot close device.");
dc_context_free (context);
return rc;
}
dc_context_free (context);
return DC_STATUS_SUCCESS;
}
int main(int argc, char *argv[])
{
message_set_logfile ("LEONARDO.LOG");
#ifdef _WIN32
const char* name = "COM1";
#else
const char* name = "/dev/ttyS0";
#endif
if (argc > 1) {
name = argv[1];
}
message ("DEVICE=%s\n", name);
dc_status_t a = test_dump_memory (name, "LEONARDO.DMP");
message ("\nSUMMARY\n");
message ("-------\n");
message ("test_dump_memory: %s\n", errmsg (a));
message_set_logfile (NULL);
return 0;
}

1
examples/universal.c
View File

@ -94,6 +94,7 @@ static const backend_table_t g_backends[] = {
{"ostc", DC_FAMILY_HW_OSTC},
{"frog", DC_FAMILY_HW_FROG},
{"edy", DC_FAMILY_CRESSI_EDY},
{"leonardo", DC_FAMILY_CRESSI_LEONARDO},
{"n2ition3", DC_FAMILY_ZEAGLE_N2ITION3},
{"cobalt", DC_FAMILY_ATOMICS_COBALT},
{"predator", DC_FAMILY_SHEARWATER_PREDATOR}

1
include/libdivecomputer/Makefile.am
View File

@ -38,6 +38,7 @@ libdivecomputer_HEADERS = \
hw_frog.h \
cressi.h \
cressi_edy.h \
cressi_leonardo.h \
zeagle.h \
zeagle_n2ition3.h \
atomics.h \

1
include/libdivecomputer/common.h
View File

@ -71,6 +71,7 @@ typedef enum dc_family_t {
DC_FAMILY_HW_FROG,
/* Cressi */
DC_FAMILY_CRESSI_EDY = (7 << 16),
DC_FAMILY_CRESSI_LEONARDO,
/* Zeagle */
DC_FAMILY_ZEAGLE_N2ITION3 = (8 << 16),
/* Atomic Aquatics */

1
include/libdivecomputer/cressi.h
View File

@ -23,5 +23,6 @@
#define CRESSI_H
#include "cressi_edy.h"
#include "cressi_leonardo.h"
#endif /* CRESSI_H */

45
include/libdivecomputer/cressi_leonardo.h Normal file
View File

@ -0,0 +1,45 @@
/*
* libdivecomputer
*
* Copyright (C) 2013 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
*/
#ifndef CRESSI_LEONARDO_H
#define CRESSI_LEONARDO_H
#include "context.h"
#include "device.h"
#include "parser.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
dc_status_t
cressi_leonardo_device_open (dc_device_t **device, dc_context_t *context, const char *name);
dc_status_t
cressi_leonardo_extract_dives (dc_device_t *abstract, const unsigned char data[], unsigned int size, dc_dive_callback_t callback, void *userdata);
dc_status_t
cressi_leonardo_parser_create (dc_parser_t **parser, dc_context_t *context);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CRESSI_LEONARDO_H */

12
msvc/libdivecomputer.vcproj
View File

@ -210,6 +210,14 @@
RelativePath="..\src\cressi_edy_parser.c"
>
</File>
<File
RelativePath="..\src\cressi_leonardo.c"
>
</File>
<File
RelativePath="..\src\cressi_leonardo_parser.c"
>
</File>
<File
RelativePath="..\src\datetime.c"
>
@ -460,6 +468,10 @@
RelativePath="..\include\libdivecomputer\cressi_edy.h"
>
</File>
<File
RelativePath="..\include\libdivecomputer\cressi_leonardo.h"
>
</File>
<File
RelativePath="..\include\libdivecomputer\datetime.h"
>

1
src/Makefile.am
View File

@ -42,6 +42,7 @@ libdivecomputer_la_SOURCES = \
hw_ostc.c hw_ostc_parser.c \
hw_frog.c \
cressi_edy.c cressi_edy_parser.c \
cressi_leonardo.c cressi_leonardo_parser.c \
zeagle_n2ition3.c \
atomics_cobalt.c atomics_cobalt_parser.c \
shearwater_predator.c shearwater_predator_parser.c \

381
src/cressi_leonardo.c Normal file
View File

@ -0,0 +1,381 @@
/*
* libdivecomputer
*
* Copyright (C) 2013 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 <string.h> // memcpy, memcmp
#include <stdlib.h> // malloc, free
#include <assert.h> // assert
#include <libdivecomputer/cressi_leonardo.h>
#include "context-private.h"
#include "device-private.h"
#include "serial.h"
#include "checksum.h"
#include "array.h"
#include "ringbuffer.h"
#define EXITCODE(rc) \
( \
rc == -1 ? DC_STATUS_IO : DC_STATUS_TIMEOUT \
)
#define SZ_MEMORY 32000
#define RB_LOGBOOK_BEGIN 0x0100
#define RB_LOGBOOK_END 0x1438
#define RB_LOGBOOK_SIZE 0x52
#define RB_LOGBOOK_COUNT ((RB_LOGBOOK_END - RB_LOGBOOK_BEGIN) / RB_LOGBOOK_SIZE)
#define RB_PROFILE_BEGIN 0x1338
#define RB_PROFILE_END SZ_MEMORY
#define RB_PROFILE_DISTANCE(a,b) ringbuffer_distance (a, b, 0, RB_PROFILE_BEGIN, RB_PROFILE_END)
typedef struct cressi_leonardo_device_t {
dc_device_t base;
serial_t *port;
unsigned char fingerprint[5];
} cressi_leonardo_device_t;
static dc_status_t cressi_leonardo_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size);
static dc_status_t cressi_leonardo_device_dump (dc_device_t *abstract, dc_buffer_t *buffer);
static dc_status_t cressi_leonardo_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
static dc_status_t cressi_leonardo_device_close (dc_device_t *abstract);
static const device_backend_t cressi_leonardo_device_backend = {
DC_FAMILY_CRESSI_LEONARDO,
cressi_leonardo_device_set_fingerprint, /* set_fingerprint */
NULL, /* read */
NULL, /* write */
cressi_leonardo_device_dump, /* dump */
cressi_leonardo_device_foreach, /* foreach */
cressi_leonardo_device_close /* close */
};
static int
device_is_cressi_leonardo (dc_device_t *abstract)
{
if (abstract == NULL)
return 0;
return abstract->backend == &cressi_leonardo_device_backend;
}
dc_status_t
cressi_leonardo_device_open (dc_device_t **out, dc_context_t *context, const char *name)
{
if (out == NULL)
return DC_STATUS_INVALIDARGS;
// Allocate memory.
cressi_leonardo_device_t *device = (cressi_leonardo_device_t *) malloc (sizeof (cressi_leonardo_device_t));
if (device == NULL) {
ERROR (context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
// Initialize the base class.
device_init (&device->base, context, &cressi_leonardo_device_backend);
// Set the default values.
device->port = NULL;
// Open the device.
int rc = serial_open (&device->port, context, name);
if (rc == -1) {
ERROR (context, "Failed to open the serial port.");
free (device);
return DC_STATUS_IO;
}
// Set the serial communication protocol (115200 8N1).
rc = serial_configure (device->port, 115200, 8, SERIAL_PARITY_NONE, 1, SERIAL_FLOWCONTROL_NONE);
if (rc == -1) {
ERROR (context, "Failed to set the terminal attributes.");
serial_close (device->port);
free (device);
return DC_STATUS_IO;
}
// Set the timeout for receiving data (1000 ms).
if (serial_set_timeout (device->port, 1000) == -1) {
ERROR (context, "Failed to set the timeout.");
serial_close (device->port);
free (device);
return DC_STATUS_IO;
}
// Clear the DTR and set the RTS line.
if (serial_set_dtr (device->port, 0) == -1 ||
serial_set_rts (device->port, 1) == -1) {
ERROR (context, "Failed to set the DTR/RTS line.");
serial_close (device->port);
free (device);
return DC_STATUS_IO;
}
*out = (dc_device_t *) device;
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_device_close (dc_device_t *abstract)
{
cressi_leonardo_device_t *device = (cressi_leonardo_device_t *) abstract;
// Close the device.
if (serial_close (device->port) == -1) {
free (device);
return DC_STATUS_IO;
}
// Free memory.
free (device);
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
{
cressi_leonardo_device_t *device = (cressi_leonardo_device_t *) abstract;
if (size && size != sizeof (device->fingerprint))
return DC_STATUS_INVALIDARGS;
if (size)
memcpy (device->fingerprint, data, sizeof (device->fingerprint));
else
memset (device->fingerprint, 0, sizeof (device->fingerprint));
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_device_dump (dc_device_t *abstract, dc_buffer_t *buffer)
{
cressi_leonardo_device_t *device = (cressi_leonardo_device_t *) abstract;
// Erase the current contents of the buffer and
// pre-allocate the required amount of memory.
if (!dc_buffer_clear (buffer) || !dc_buffer_resize (buffer, SZ_MEMORY)) {
ERROR (abstract->context, "Insufficient buffer space available.");
return DC_STATUS_NOMEMORY;
}
// Enable progress notifications.
dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
progress.maximum = SZ_MEMORY;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
// Send the command header to the dive computer.
const unsigned char command[] = {0x7B, 0x31, 0x32, 0x33, 0x44, 0x42, 0x41, 0x7d};
int n = serial_write (device->port, command, sizeof (command));
if (n != sizeof (command)) {
ERROR (abstract->context, "Failed to send the command.");
return EXITCODE (n);
}
// Receive the header packet.
unsigned char header[7] = {0};
n = serial_read (device->port, header, sizeof (header));
if (n != sizeof (header)) {
ERROR (abstract->context, "Failed to receive the answer.");
return EXITCODE (n);
}
// Verify the header packet.
const unsigned char expected[] = {0x7B, 0x21, 0x44, 0x35, 0x42, 0x33, 0x7d};
if (memcmp (header, expected, sizeof (expected)) != 0) {
ERROR (abstract->context, "Unexpected answer byte.");
return DC_STATUS_PROTOCOL;
}
unsigned char *data = dc_buffer_get_data (buffer);
unsigned int nbytes = 0;
while (nbytes < SZ_MEMORY) {
// Set the minimum packet size.
unsigned int len = 1024;
// Increase the packet size if more data is immediately available.
int available = serial_get_received (device->port);
if (available > len)
len = available;
// Limit the packet size to the total size.
if (nbytes + len > SZ_MEMORY)
len = SZ_MEMORY - nbytes;
// Read the packet.
n = serial_read (device->port, data + nbytes, len);
if (n != len) {
ERROR (abstract->context, "Failed to receive the answer.");
return EXITCODE (n);
}
// Update and emit a progress event.
progress.current += len;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
nbytes += len;
}
// Receive the trailer packet.
unsigned char trailer[4] = {0};
n = serial_read (device->port, trailer, sizeof (trailer));
if (n != sizeof (trailer)) {
ERROR (abstract->context, "Failed to receive the answer.");
return EXITCODE (n);
}
// Convert to a binary checksum.
unsigned char checksum[2] = {0};
array_convert_hex2bin (trailer, sizeof (trailer), checksum, sizeof (checksum));
// Verify the checksum.
unsigned int csum1 = array_uint16_be (checksum);
unsigned int csum2 = checksum_crc_ccitt_uint16 (data, SZ_MEMORY);
if (csum1 != csum2) {
ERROR (abstract->context, "Unexpected answer bytes.");
return DC_STATUS_PROTOCOL;
}
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
{
dc_buffer_t *buffer = dc_buffer_new (SZ_MEMORY);
if (buffer == NULL)
return DC_STATUS_NOMEMORY;
dc_status_t rc = cressi_leonardo_device_dump (abstract, buffer);
if (rc != DC_STATUS_SUCCESS) {
dc_buffer_free (buffer);
return rc;
}
rc = cressi_leonardo_extract_dives (abstract, dc_buffer_get_data (buffer),
dc_buffer_get_size (buffer), callback, userdata);
dc_buffer_free (buffer);
return rc;
}
dc_status_t
cressi_leonardo_extract_dives (dc_device_t *abstract, const unsigned char data[], unsigned int size, dc_dive_callback_t callback, void *userdata)
{
cressi_leonardo_device_t *device = (cressi_leonardo_device_t *) abstract;
dc_context_t *context = (abstract ? abstract->context : NULL);
if (abstract && !device_is_cressi_leonardo (abstract))
return DC_STATUS_INVALIDARGS;
if (size < SZ_MEMORY)
return DC_STATUS_DATAFORMAT;
// Locate the most recent dive.
// The device maintains an internal counter which is incremented for every
// dive, and the current value at the time of the dive is stored in the
// dive header. Thus the most recent dive will have the highest value.
unsigned int count = 0;
unsigned int latest = 0;
unsigned int maximum = 0;
for (unsigned int i = 0; i < RB_LOGBOOK_COUNT; ++i) {
unsigned int offset = RB_LOGBOOK_BEGIN + i * RB_LOGBOOK_SIZE;
// Ignore uninitialized header entries.
if (array_isequal (data + offset, RB_LOGBOOK_SIZE, 0xFF))
break;
// Get the internal dive number.
unsigned int current = array_uint16_le (data + offset);
if (current > maximum) {
maximum = current;
latest = i;
}
count++;
}
unsigned char *buffer = (unsigned char *) malloc (RB_LOGBOOK_SIZE + RB_PROFILE_END - RB_PROFILE_BEGIN);
if (buffer == NULL) {
ERROR (context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
for (unsigned int i = 0; i < count; ++i) {
unsigned int idx = (latest + RB_LOGBOOK_COUNT - i) % RB_LOGBOOK_COUNT;
unsigned int offset = RB_LOGBOOK_BEGIN + idx * RB_LOGBOOK_SIZE;
// Get the ringbuffer pointers.
unsigned int header = array_uint16_le (data + offset + 2);
unsigned int footer = array_uint16_le (data + offset + 4);
if (header < RB_PROFILE_BEGIN || header + 2 > RB_PROFILE_END ||
footer < RB_PROFILE_BEGIN || footer + 2 > RB_PROFILE_END)
{
ERROR (abstract->context, "Invalid ringbuffer pointer detected.");
free (buffer);
return DC_STATUS_DATAFORMAT;
}
// Get the same pointers from the profile.
unsigned int header2 = array_uint16_le (data + footer);
unsigned int footer2 = array_uint16_le (data + header);
if (header2 != header || footer2 != footer) {
ERROR (abstract->context, "Invalid ringbuffer pointer detected.");
free (buffer);
return DC_STATUS_DATAFORMAT;
}
// Calculate the profile address and length.
unsigned int address = header + 2;
unsigned int length = RB_PROFILE_DISTANCE (header, footer) - 2;
// Check the fingerprint data.
if (device && memcmp (data + offset + 8, device->fingerprint, sizeof (device->fingerprint)) == 0)
break;
// Copy the logbook entry.
memcpy (buffer, data + offset, RB_LOGBOOK_SIZE);
// Copy the profile data.
if (address + length > RB_PROFILE_END) {
unsigned int len_a = RB_PROFILE_END - address;
unsigned int len_b = length - len_a;
memcpy (buffer + RB_LOGBOOK_SIZE, data + address, len_a);
memcpy (buffer + RB_LOGBOOK_SIZE + len_a, data + RB_PROFILE_BEGIN, len_b);
} else {
memcpy (buffer + RB_LOGBOOK_SIZE, data + address, length);
}
if (callback && !callback (buffer, RB_LOGBOOK_SIZE + length, buffer + 8, sizeof (device->fingerprint), userdata)) {
break;
}
}
free (buffer);
return DC_STATUS_SUCCESS;
}

194
src/cressi_leonardo_parser.c Normal file
View File

@ -0,0 +1,194 @@
/*
* libdivecomputer
*
* Copyright (C) 2013 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 <libdivecomputer/cressi_leonardo.h>
#include "context-private.h"
#include "parser-private.h"
#include "array.h"
#define SZ_HEADER 82
typedef struct cressi_leonardo_parser_t cressi_leonardo_parser_t;
struct cressi_leonardo_parser_t {
dc_parser_t base;
};
static dc_status_t cressi_leonardo_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size);
static dc_status_t cressi_leonardo_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime);
static dc_status_t cressi_leonardo_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value);
static dc_status_t cressi_leonardo_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata);
static dc_status_t cressi_leonardo_parser_destroy (dc_parser_t *abstract);
static const parser_backend_t cressi_leonardo_parser_backend = {
DC_FAMILY_CRESSI_EDY,
cressi_leonardo_parser_set_data, /* set_data */
cressi_leonardo_parser_get_datetime, /* datetime */
cressi_leonardo_parser_get_field, /* fields */
cressi_leonardo_parser_samples_foreach, /* samples_foreach */
cressi_leonardo_parser_destroy /* destroy */
};
static int
parser_is_cressi_leonardo (dc_parser_t *abstract)
{
if (abstract == NULL)
return 0;
return abstract->backend == &cressi_leonardo_parser_backend;
}
dc_status_t
cressi_leonardo_parser_create (dc_parser_t **out, dc_context_t *context)
{
if (out == NULL)
return DC_STATUS_INVALIDARGS;
// Allocate memory.
cressi_leonardo_parser_t *parser = (cressi_leonardo_parser_t *) malloc (sizeof (cressi_leonardo_parser_t));
if (parser == NULL) {
ERROR (context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
// Initialize the base class.
parser_init (&parser->base, context, &cressi_leonardo_parser_backend);
*out = (dc_parser_t*) parser;
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_parser_destroy (dc_parser_t *abstract)
{
if (! parser_is_cressi_leonardo (abstract))
return DC_STATUS_INVALIDARGS;
// Free memory.
free (abstract);
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size)
{
if (! parser_is_cressi_leonardo (abstract))
return DC_STATUS_INVALIDARGS;
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
{
if (abstract->size < SZ_HEADER)
return DC_STATUS_DATAFORMAT;
const unsigned char *p = abstract->data;
if (datetime) {
datetime->year = p[8] + 2000;
datetime->month = p[9];
datetime->day = p[10];
datetime->hour = p[11];
datetime->minute = p[12];
datetime->second = 0;
}
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
{
if (abstract->size < SZ_HEADER)
return DC_STATUS_DATAFORMAT;
const unsigned char *data = abstract->data;
dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
if (value) {
switch (type) {
case DC_FIELD_DIVETIME:
*((unsigned int *) value) = array_uint16_le (data + 0x06) * 20;
break;
case DC_FIELD_MAXDEPTH:
*((double *) value) = array_uint16_le (data + 0x20) / 10.0;
break;
case DC_FIELD_GASMIX_COUNT:
*((unsigned int *) value) = 1;
break;
case DC_FIELD_GASMIX:
gasmix->helium = 0.0;
gasmix->oxygen = data[0x19] / 100.0;
gasmix->nitrogen = 1.0 - gasmix->oxygen - gasmix->helium;
break;
default:
return DC_STATUS_UNSUPPORTED;
}
}
return DC_STATUS_SUCCESS;
}
static dc_status_t
cressi_leonardo_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata)
{
const unsigned char *data = abstract->data;
unsigned int size = abstract->size;
unsigned int time = 0;
unsigned int interval = 20;
unsigned int offset = SZ_HEADER;
while (offset + 2 <= size) {
dc_sample_value_t sample = {0};
unsigned int value = array_uint16_le (data + offset);
unsigned int depth = value & 0x3FFF;
// Time (seconds).
time += interval;
sample.time = time;
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
// Depth (1/10 m).
sample.depth = depth / 10.0;
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
offset += 2;
}
return DC_STATUS_SUCCESS;
}

2
src/descriptor.c
View File

@ -164,6 +164,8 @@ static const dc_descriptor_t g_descriptors[] = {
{"Heinrichs Weikamp", "Frog", DC_FAMILY_HW_FROG, 0},
/* Cressi Edy */
{"Cressi", "Edy", DC_FAMILY_CRESSI_EDY, 0},
/* Cressi Leonardo */
{"Cressi", "Leonardo", DC_FAMILY_CRESSI_LEONARDO, 0},
/* Zeagle N2iTiON3 */
{"Zeagle", "N2iTiON3", DC_FAMILY_ZEAGLE_N2ITION3, 0},
{"Apeks", "Quantum X", DC_FAMILY_ZEAGLE_N2ITION3, 0},

3
src/device.c
View File

@ -129,6 +129,9 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
case DC_FAMILY_CRESSI_EDY:
rc = cressi_edy_device_open (&device, context, name);
break;
case DC_FAMILY_CRESSI_LEONARDO:
rc = cressi_leonardo_device_open (&device, context, name);
break;
case DC_FAMILY_ZEAGLE_N2ITION3:
rc = zeagle_n2ition3_device_open (&device, context, name);
break;

2
src/libdivecomputer.symbols
View File

@ -60,6 +60,7 @@ oceanic_veo250_parser_create
oceanic_atom2_parser_create
hw_ostc_parser_create
cressi_edy_parser_create
cressi_leonardo_parser_create
atomics_cobalt_parser_create
atomics_cobalt_parser_set_calibration
shearwater_predator_parser_create
@ -76,6 +77,7 @@ dc_device_set_fingerprint
dc_device_write
cressi_edy_device_open
cressi_leonardo_device_open
mares_nemo_device_open
mares_nemo_extract_dives
mares_puck_device_open

3
src/parser.c
View File

@ -108,6 +108,9 @@ dc_parser_new (dc_parser_t **out, dc_device_t *device)
case DC_FAMILY_ZEAGLE_N2ITION3:
rc = cressi_edy_parser_create (&parser, context, device->devinfo.model);
break;
case DC_FAMILY_CRESSI_LEONARDO:
rc = cressi_leonardo_parser_create (&parser, context);
break;
case DC_FAMILY_ATOMICS_COBALT:
rc = atomics_cobalt_parser_create (&parser, context);
break;