Add support for the Seac Screen and Action
This commit is contained in:
Jef Driesen
parent
2443d3ea47
commit
4b4efb2c07
@ -95,6 +95,7 @@ static const backend_table_t g_backends[] = {
|
||||
{"lynx", DC_FAMILY_LIQUIVISION_LYNX, 0},
|
||||
{"sp2", DC_FAMILY_SPORASUB_SP2, 0},
|
||||
{"excursion", DC_FAMILY_DEEPSIX_EXCURSION, 0},
|
||||
{"screen", DC_FAMILY_SEAC_SCREEN, 0},
|
||||
};
|
||||
|
||||
static const transport_table_t g_transports[] = {
|
||||
|
||||
@ -112,6 +112,8 @@ typedef enum dc_family_t {
|
||||
DC_FAMILY_SPORASUB_SP2 = (18 << 16),
|
||||
/* Deep Six */
|
||||
DC_FAMILY_DEEPSIX_EXCURSION = (19 << 16),
|
||||
/* Seac Screen */
|
||||
DC_FAMILY_SEAC_SCREEN = (20 << 16),
|
||||
} dc_family_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@ -227,6 +227,8 @@
|
||||
<ClCompile Include="..\src\reefnet_sensusultra_parser.c" />
|
||||
<ClCompile Include="..\src\reefnet_sensus_parser.c" />
|
||||
<ClCompile Include="..\src\ringbuffer.c" />
|
||||
<ClCompile Include="..\src\seac_screen.c" />
|
||||
<ClCompile Include="..\src\seac_screen_parser.c" />
|
||||
<ClCompile Include="..\src\serial_win32.c" />
|
||||
<ClCompile Include="..\src\shearwater_common.c" />
|
||||
<ClCompile Include="..\src\shearwater_petrel.c" />
|
||||
@ -336,6 +338,7 @@
|
||||
<ClInclude Include="..\src\reefnet_sensusultra.h" />
|
||||
<ClInclude Include="..\src\revision.h" />
|
||||
<ClInclude Include="..\src\ringbuffer.h" />
|
||||
<ClInclude Include="..\src\seac_screen.h" />
|
||||
<ClInclude Include="..\src\shearwater_common.h" />
|
||||
<ClInclude Include="..\src\shearwater_petrel.h" />
|
||||
<ClInclude Include="..\src\shearwater_predator.h" />
|
||||
|
||||
@ -76,6 +76,7 @@ libdivecomputer_la_SOURCES = \
|
||||
liquivision_lynx.h liquivision_lynx.c liquivision_lynx_parser.c \
|
||||
sporasub_sp2.h sporasub_sp2.c sporasub_sp2_parser.c \
|
||||
deepsix_excursion.h deepsix_excursion.c deepsix_excursion_parser.c \
|
||||
seac_screen.h seac_screen.c seac_screen_parser.c \
|
||||
socket.h socket.c \
|
||||
irda.c \
|
||||
usb.c \
|
||||
|
||||
@ -429,6 +429,9 @@ static const dc_descriptor_t g_descriptors[] = {
|
||||
{"Crest", "CR-4", DC_FAMILY_DEEPSIX_EXCURSION, 0, DC_TRANSPORT_BLE, dc_filter_deepsix},
|
||||
{"Genesis", "Centauri", DC_FAMILY_DEEPSIX_EXCURSION, 0, DC_TRANSPORT_BLE, dc_filter_deepsix},
|
||||
{"Tusa", "TC1", DC_FAMILY_DEEPSIX_EXCURSION, 0, DC_TRANSPORT_BLE, dc_filter_deepsix},
|
||||
/* Seac Screen */
|
||||
{"Seac", "Screen", DC_FAMILY_SEAC_SCREEN, 0, DC_TRANSPORT_SERIAL, NULL},
|
||||
{"Seac", "Action", DC_FAMILY_SEAC_SCREEN, 0, DC_TRANSPORT_SERIAL, NULL},
|
||||
};
|
||||
|
||||
static int
|
||||
|
||||
@ -61,6 +61,7 @@
|
||||
#include "liquivision_lynx.h"
|
||||
#include "sporasub_sp2.h"
|
||||
#include "deepsix_excursion.h"
|
||||
#include "seac_screen.h"
|
||||
|
||||
#include "device-private.h"
|
||||
#include "context-private.h"
|
||||
@ -227,6 +228,9 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
|
||||
case DC_FAMILY_DEEPSIX_EXCURSION:
|
||||
rc = deepsix_excursion_device_open (&device, context, iostream);
|
||||
break;
|
||||
case DC_FAMILY_SEAC_SCREEN:
|
||||
rc = seac_screen_device_open (&device, context, iostream);
|
||||
break;
|
||||
default:
|
||||
return DC_STATUS_INVALIDARGS;
|
||||
}
|
||||
|
||||
@ -61,6 +61,7 @@
|
||||
#include "liquivision_lynx.h"
|
||||
#include "sporasub_sp2.h"
|
||||
#include "deepsix_excursion.h"
|
||||
#include "seac_screen.h"
|
||||
|
||||
#include "context-private.h"
|
||||
#include "parser-private.h"
|
||||
@ -188,6 +189,9 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
|
||||
case DC_FAMILY_DEEPSIX_EXCURSION:
|
||||
rc = deepsix_excursion_parser_create (&parser, context);
|
||||
break;
|
||||
case DC_FAMILY_SEAC_SCREEN:
|
||||
rc = seac_screen_parser_create (&parser, context);
|
||||
break;
|
||||
default:
|
||||
return DC_STATUS_INVALIDARGS;
|
||||
}
|
||||
|
||||
604
src/seac_screen.c
Normal file
604
src/seac_screen.c
Normal file
@ -0,0 +1,604 @@
|
||||
/*
|
||||
* libdivecomputer
|
||||
*
|
||||
* Copyright (C) 2022 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> // memcmp, memcpy
|
||||
#include <stdlib.h> // malloc, free
|
||||
|
||||
#include "seac_screen.h"
|
||||
#include "context-private.h"
|
||||
#include "device-private.h"
|
||||
#include "ringbuffer.h"
|
||||
#include "rbstream.h"
|
||||
#include "checksum.h"
|
||||
#include "array.h"
|
||||
|
||||
#define ISINSTANCE(device) dc_device_isinstance((device), &seac_screen_device_vtable)
|
||||
|
||||
#define MAXRETRIES 4
|
||||
|
||||
#define SZ_MAXCMD 8
|
||||
#define SZ_MAXRSP SZ_READ
|
||||
|
||||
#define CMD_HWINFO 0x1833
|
||||
#define CMD_SWINFO 0x1834
|
||||
#define CMD_RANGE 0x1840
|
||||
#define CMD_ADDRESS 0x1841
|
||||
#define CMD_READ 0x1842
|
||||
|
||||
#define SZ_HWINFO 256
|
||||
#define SZ_SWINFO 256
|
||||
#define SZ_RANGE 8
|
||||
#define SZ_ADDRESS 4
|
||||
#define SZ_READ 2048
|
||||
|
||||
#define SZ_HEADER 128
|
||||
#define SZ_SAMPLE 64
|
||||
|
||||
#define FP_OFFSET 0x0A
|
||||
#define FP_SIZE 7
|
||||
|
||||
#define RB_PROFILE_BEGIN 0x010000
|
||||
#define RB_PROFILE_END 0x200000
|
||||
#define RB_PROFILE_SIZE (RB_PROFILE_END - RB_PROFILE_BEGIN)
|
||||
#define RB_PROFILE_DISTANCE(a,b) ringbuffer_distance (a, b, 1, RB_PROFILE_BEGIN, RB_PROFILE_END)
|
||||
#define RB_PROFILE_INCR(a,d) ringbuffer_increment (a, d, RB_PROFILE_BEGIN, RB_PROFILE_END)
|
||||
|
||||
typedef struct seac_screen_device_t {
|
||||
dc_device_t base;
|
||||
dc_iostream_t *iostream;
|
||||
unsigned char info[SZ_HWINFO + SZ_SWINFO];
|
||||
unsigned char fingerprint[FP_SIZE];
|
||||
} seac_screen_device_t;
|
||||
|
||||
typedef struct seac_screen_logbook_t {
|
||||
unsigned int address;
|
||||
unsigned char header[SZ_HEADER];
|
||||
} seac_screen_logbook_t;
|
||||
|
||||
static dc_status_t seac_screen_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size);
|
||||
static dc_status_t seac_screen_device_read (dc_device_t *abstract, unsigned int address, unsigned char data[], unsigned int size);
|
||||
static dc_status_t seac_screen_device_dump (dc_device_t *abstract, dc_buffer_t *buffer);
|
||||
static dc_status_t seac_screen_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
|
||||
|
||||
static const dc_device_vtable_t seac_screen_device_vtable = {
|
||||
sizeof(seac_screen_device_t),
|
||||
DC_FAMILY_SEAC_SCREEN,
|
||||
seac_screen_device_set_fingerprint, /* set_fingerprint */
|
||||
seac_screen_device_read, /* read */
|
||||
NULL, /* write */
|
||||
seac_screen_device_dump, /* dump */
|
||||
seac_screen_device_foreach, /* foreach */
|
||||
NULL, /* timesync */
|
||||
NULL, /* close */
|
||||
};
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_send (seac_screen_device_t *device, unsigned short cmd, const unsigned char data[], size_t size)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
dc_device_t *abstract = (dc_device_t *) device;
|
||||
unsigned short crc = 0;
|
||||
|
||||
if (device_is_cancelled (abstract))
|
||||
return DC_STATUS_CANCELLED;
|
||||
|
||||
if (size > SZ_MAXCMD)
|
||||
return DC_STATUS_INVALIDARGS;
|
||||
|
||||
// Setup the data packet
|
||||
unsigned len = size + 6;
|
||||
unsigned char packet[SZ_MAXCMD + 7] = {
|
||||
0x55,
|
||||
(len >> 8) & 0xFF,
|
||||
(len ) & 0xFF,
|
||||
(cmd >> 8) & 0xFF,
|
||||
(cmd ) & 0xFF,
|
||||
};
|
||||
if (size) {
|
||||
memcpy (packet + 5, data, size);
|
||||
}
|
||||
crc = checksum_crc16_ccitt (packet, size + 5, 0xFFFF);
|
||||
packet[size + 5] = (crc >> 8) & 0xFF;
|
||||
packet[size + 6] = (crc ) & 0xFF;
|
||||
|
||||
// Send the data packet.
|
||||
status = dc_iostream_write (device->iostream, packet, size + 7, NULL);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to send the command.");
|
||||
return status;
|
||||
}
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_receive (seac_screen_device_t *device, unsigned short cmd, unsigned char data[], size_t size)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
dc_device_t *abstract = (dc_device_t *) device;
|
||||
unsigned char packet[SZ_MAXRSP + 8] = {0};
|
||||
|
||||
// Read the packet header.
|
||||
status = dc_iostream_read (device->iostream, packet, 3, NULL);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to receive the packet header.");
|
||||
return status;
|
||||
}
|
||||
|
||||
// Verify the start byte.
|
||||
if (packet[0] != 0x55) {
|
||||
ERROR (abstract->context, "Unexpected start byte (%02x).", packet[0]);
|
||||
return DC_STATUS_PROTOCOL;
|
||||
}
|
||||
|
||||
// Verify the length.
|
||||
unsigned int length = array_uint16_be (packet + 1);
|
||||
if (length < 7 || length + 1 > sizeof(packet)) {
|
||||
ERROR (abstract->context, "Unexpected packet length (%u).", length);
|
||||
return DC_STATUS_PROTOCOL;
|
||||
}
|
||||
|
||||
// Read the packet payload.
|
||||
status = dc_iostream_read (device->iostream, packet + 3, length - 2, NULL);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to receive the packet payload.");
|
||||
return status;
|
||||
}
|
||||
|
||||
// Verify the checksum.
|
||||
unsigned short crc = array_uint16_be (packet + 1 + length - 2);
|
||||
unsigned short ccrc = checksum_crc16_ccitt (packet, 1 + length - 2, 0xFFFF);
|
||||
if (crc != ccrc) {
|
||||
ERROR (abstract->context, "Unexpected packet checksum (%04x %04x).", crc, ccrc);
|
||||
return DC_STATUS_PROTOCOL;
|
||||
}
|
||||
|
||||
// Verify the command response.
|
||||
unsigned int rsp = array_uint16_be (packet + 3);
|
||||
unsigned int misc = packet[1 + length - 3];
|
||||
if (rsp != cmd || misc != 0x09) {
|
||||
ERROR (abstract->context, "Unexpected command response (%04x %02x).", rsp, misc);
|
||||
return DC_STATUS_PROTOCOL;
|
||||
}
|
||||
|
||||
if (length - 7 != size) {
|
||||
ERROR (abstract->context, "Unexpected packet length (%u).", length);
|
||||
return DC_STATUS_PROTOCOL;
|
||||
}
|
||||
|
||||
memcpy (data, packet + 5, length - 7);
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_packet (seac_screen_device_t *device, unsigned int cmd, const unsigned char data[], unsigned int size, unsigned char answer[], unsigned int asize)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
dc_device_t *abstract = (dc_device_t *) device;
|
||||
|
||||
status = seac_screen_send (device, cmd, data, size);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to send the command.");
|
||||
return status;
|
||||
}
|
||||
|
||||
status = seac_screen_receive (device, cmd, answer, asize);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to receive the response.");
|
||||
return status;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_transfer (seac_screen_device_t *device, unsigned int cmd, const unsigned char data[], unsigned int size, unsigned char answer[], unsigned int asize)
|
||||
{
|
||||
unsigned int nretries = 0;
|
||||
dc_status_t rc = DC_STATUS_SUCCESS;
|
||||
while ((rc = seac_screen_packet (device, cmd, data, size, answer, asize)) != DC_STATUS_SUCCESS) {
|
||||
// Automatically discard a corrupted packet,
|
||||
// and request a new one.
|
||||
if (rc != DC_STATUS_PROTOCOL && rc != DC_STATUS_TIMEOUT)
|
||||
return rc;
|
||||
|
||||
// Abort if the maximum number of retries is reached.
|
||||
if (nretries++ >= MAXRETRIES)
|
||||
return rc;
|
||||
|
||||
// Discard any garbage bytes.
|
||||
dc_iostream_sleep (device->iostream, 100);
|
||||
dc_iostream_purge (device->iostream, DC_DIRECTION_INPUT);
|
||||
}
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
dc_status_t
|
||||
seac_screen_device_open (dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
seac_screen_device_t *device = NULL;
|
||||
|
||||
if (out == NULL)
|
||||
return DC_STATUS_INVALIDARGS;
|
||||
|
||||
// Allocate memory.
|
||||
device = (seac_screen_device_t *) dc_device_allocate (context, &seac_screen_device_vtable);
|
||||
if (device == NULL) {
|
||||
ERROR (context, "Failed to allocate memory.");
|
||||
return DC_STATUS_NOMEMORY;
|
||||
}
|
||||
|
||||
// Set the default values.
|
||||
device->iostream = iostream;
|
||||
memset (device->fingerprint, 0, sizeof (device->fingerprint));
|
||||
|
||||
// Set the serial communication protocol (115200 8N1).
|
||||
status = dc_iostream_configure (device->iostream, 115200, 8, DC_PARITY_NONE, DC_STOPBITS_ONE, DC_FLOWCONTROL_NONE);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (context, "Failed to set the terminal attributes.");
|
||||
goto error_free;
|
||||
}
|
||||
|
||||
// Set the timeout for receiving data (1000ms).
|
||||
status = dc_iostream_set_timeout (device->iostream, 1000);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (context, "Failed to set the timeout.");
|
||||
goto error_free;
|
||||
}
|
||||
|
||||
// Make sure everything is in a sane state.
|
||||
dc_iostream_sleep (device->iostream, 100);
|
||||
dc_iostream_purge (device->iostream, DC_DIRECTION_ALL);
|
||||
|
||||
// Wakeup the device.
|
||||
const unsigned char init[] = {0x61};
|
||||
dc_iostream_write (device->iostream, init, sizeof (init), NULL);
|
||||
|
||||
// Read the hardware info.
|
||||
status = seac_screen_transfer (device, CMD_HWINFO, NULL, 0, device->info, SZ_HWINFO);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (context, "Failed to read the hardware info.");
|
||||
goto error_free;
|
||||
}
|
||||
|
||||
// Read the software info.
|
||||
status = seac_screen_transfer (device, CMD_SWINFO, NULL, 0, device->info + SZ_HWINFO, SZ_SWINFO);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (context, "Failed to read the software info.");
|
||||
goto error_free;
|
||||
}
|
||||
|
||||
*out = (dc_device_t *) device;
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
|
||||
error_free:
|
||||
dc_device_deallocate ((dc_device_t *) device);
|
||||
return status;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
|
||||
{
|
||||
seac_screen_device_t *device = (seac_screen_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
|
||||
seac_screen_device_read (dc_device_t *abstract, unsigned int address, unsigned char data[], unsigned int size)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
seac_screen_device_t *device = (seac_screen_device_t *) abstract;
|
||||
|
||||
unsigned int nbytes = 0;
|
||||
while (nbytes < size) {
|
||||
// Maximum payload size.
|
||||
unsigned int len = size - nbytes;
|
||||
if (len > SZ_READ)
|
||||
len = SZ_READ;
|
||||
|
||||
// Read the data packet.
|
||||
// Regardless of the requested payload size, the packet size is always
|
||||
// the maximum size. The remainder of the packet is padded with zeros.
|
||||
const unsigned char params[] = {
|
||||
(address >> 24) & 0xFF,
|
||||
(address >> 16) & 0xFF,
|
||||
(address >> 8) & 0xFF,
|
||||
(address ) & 0xFF,
|
||||
(len >> 24) & 0xFF,
|
||||
(len >> 16) & 0xFF,
|
||||
(len >> 8) & 0xFF,
|
||||
(len ) & 0xFF,
|
||||
};
|
||||
unsigned char packet[SZ_READ] = {0};
|
||||
status = seac_screen_transfer (device, CMD_READ, params, sizeof(params), packet, sizeof(packet));
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to send the read command.");
|
||||
return status;
|
||||
}
|
||||
|
||||
// Copy only the payload bytes.
|
||||
memcpy (data, packet, len);
|
||||
|
||||
nbytes += len;
|
||||
address += len;
|
||||
data += len;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_device_dump (dc_device_t *abstract, dc_buffer_t *buffer)
|
||||
{
|
||||
seac_screen_device_t *device = (seac_screen_device_t *) abstract;
|
||||
|
||||
// Emit a device info event.
|
||||
dc_event_devinfo_t devinfo;
|
||||
devinfo.model = 0;
|
||||
devinfo.firmware = array_uint32_le (device->info + 0x11C);
|
||||
devinfo.serial = array_uint32_le (device->info + 0x10);
|
||||
device_event_emit (abstract, DC_EVENT_DEVINFO, &devinfo);
|
||||
|
||||
// Emit a vendor event.
|
||||
dc_event_vendor_t vendor;
|
||||
vendor.data = device->info;
|
||||
vendor.size = sizeof(device->info);
|
||||
device_event_emit (abstract, DC_EVENT_VENDOR, &vendor);
|
||||
|
||||
// Allocate the required amount of memory.
|
||||
if (!dc_buffer_resize (buffer, RB_PROFILE_SIZE)) {
|
||||
ERROR (abstract->context, "Insufficient buffer space available.");
|
||||
return DC_STATUS_NOMEMORY;
|
||||
}
|
||||
|
||||
return device_dump_read (abstract, RB_PROFILE_BEGIN, dc_buffer_get_data (buffer),
|
||||
dc_buffer_get_size (buffer), SZ_READ);
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
|
||||
{
|
||||
dc_status_t status = DC_STATUS_SUCCESS;
|
||||
seac_screen_device_t *device = (seac_screen_device_t *) abstract;
|
||||
|
||||
// Enable progress notifications.
|
||||
dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
|
||||
progress.maximum = RB_PROFILE_SIZE;
|
||||
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
|
||||
|
||||
// Emit a device info event.
|
||||
dc_event_devinfo_t devinfo;
|
||||
devinfo.model = 0;
|
||||
devinfo.firmware = array_uint32_le (device->info + 0x11C);
|
||||
devinfo.serial = array_uint32_le (device->info + 0x010);
|
||||
device_event_emit (abstract, DC_EVENT_DEVINFO, &devinfo);
|
||||
|
||||
// Emit a vendor event.
|
||||
dc_event_vendor_t vendor;
|
||||
vendor.data = device->info;
|
||||
vendor.size = sizeof(device->info);
|
||||
device_event_emit (abstract, DC_EVENT_VENDOR, &vendor);
|
||||
|
||||
// Read the range of the available dive numbers.
|
||||
unsigned char range[SZ_RANGE] = {0};
|
||||
status = seac_screen_transfer (device, CMD_RANGE, NULL, 0, range, sizeof(range));
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to send the range command.");
|
||||
goto error_exit;
|
||||
}
|
||||
|
||||
// Extract the first and last dive number.
|
||||
unsigned int first = array_uint32_be (range + 0);
|
||||
unsigned int last = array_uint32_be (range + 4);
|
||||
if (first > last) {
|
||||
ERROR (abstract->context, "Invalid dive numbers (%u %u).", first, last);
|
||||
status = DC_STATUS_DATAFORMAT;
|
||||
goto error_exit;
|
||||
}
|
||||
|
||||
// Calculate the number of dives.
|
||||
unsigned int ndives = last - first + 1;
|
||||
|
||||
// Update and emit a progress event.
|
||||
progress.current += SZ_RANGE;
|
||||
progress.maximum += SZ_RANGE + ndives * (SZ_ADDRESS + SZ_HEADER);
|
||||
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
|
||||
|
||||
// Allocate memory for the logbook data.
|
||||
seac_screen_logbook_t *logbook = (seac_screen_logbook_t *) malloc (ndives * sizeof (seac_screen_logbook_t));
|
||||
if (logbook == NULL) {
|
||||
status = DC_STATUS_NOMEMORY;
|
||||
goto error_exit;
|
||||
}
|
||||
|
||||
// Read the header of each dive in reverse order (most recent first).
|
||||
unsigned int eop = 0;
|
||||
unsigned int previous = 0;
|
||||
unsigned int count = 0;
|
||||
unsigned int skip = 0;
|
||||
unsigned int rb_profile_size = 0;
|
||||
unsigned int remaining = RB_PROFILE_SIZE;
|
||||
for (unsigned int i = 0; i < ndives; ++i) {
|
||||
unsigned int number = last - i;
|
||||
|
||||
// Read the dive address.
|
||||
const unsigned char cmd_address[] = {
|
||||
(number >> 24) & 0xFF,
|
||||
(number >> 16) & 0xFF,
|
||||
(number >> 8) & 0xFF,
|
||||
(number ) & 0xFF,
|
||||
};
|
||||
unsigned char rsp_address[SZ_ADDRESS] = {0};
|
||||
status = seac_screen_transfer (device, CMD_ADDRESS, cmd_address, sizeof(cmd_address), rsp_address, sizeof(rsp_address));
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to read the dive address.");
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Get the dive address.
|
||||
logbook[i].address = array_uint32_be (rsp_address);
|
||||
if (logbook[i].address < RB_PROFILE_BEGIN || logbook[i].address >= RB_PROFILE_END) {
|
||||
ERROR (abstract->context, "Invalid ringbuffer pointer (0x%08x).", logbook[i].address);
|
||||
status = DC_STATUS_DATAFORMAT;
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Read the dive header.
|
||||
status = seac_screen_device_read (abstract, logbook[i].address, logbook[i].header, SZ_HEADER);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to read the dive header.");
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Update and emit a progress event.
|
||||
progress.current += SZ_ADDRESS + SZ_HEADER;
|
||||
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
|
||||
|
||||
// Check the header checksums.
|
||||
if (checksum_crc16_ccitt (logbook[i].header, SZ_HEADER / 2, 0xFFFF) != 0 ||
|
||||
checksum_crc16_ccitt (logbook[i].header + SZ_HEADER / 2, SZ_HEADER / 2, 0xFFFF) != 0) {
|
||||
ERROR (abstract->context, "Unexpected header checksum.");
|
||||
status = DC_STATUS_DATAFORMAT;
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Check the fingerprint.
|
||||
if (memcmp (logbook[i].header + FP_OFFSET, device->fingerprint, sizeof (device->fingerprint)) == 0) {
|
||||
skip = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Get the number of samples.
|
||||
unsigned int nsamples = array_uint32_le (logbook[i].header + 0x44);
|
||||
unsigned int nbytes = SZ_HEADER + nsamples * SZ_SAMPLE;
|
||||
|
||||
// Get the end-of-profile pointer.
|
||||
if (eop == 0) {
|
||||
eop = previous = RB_PROFILE_INCR (logbook[i].address, nbytes);
|
||||
}
|
||||
|
||||
// Calculate the length.
|
||||
unsigned int length = RB_PROFILE_DISTANCE (logbook[i].address, previous);
|
||||
|
||||
// Check for the end of the ringbuffer.
|
||||
if (length > remaining) {
|
||||
WARNING (abstract->context, "Reached the end of the ringbuffer.");
|
||||
skip = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Update the total profile size.
|
||||
rb_profile_size += length;
|
||||
|
||||
// Move to the start of the current dive.
|
||||
remaining -= length;
|
||||
previous = logbook[i].address;
|
||||
count++;
|
||||
}
|
||||
|
||||
// Update and emit a progress event.
|
||||
progress.maximum -= (ndives - count - skip) * (SZ_ADDRESS + SZ_HEADER) +
|
||||
(RB_PROFILE_SIZE - rb_profile_size);
|
||||
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
|
||||
|
||||
// Exit if no dives to download.
|
||||
if (count == 0) {
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Allocate memory for the profile data.
|
||||
unsigned char *profile = (unsigned char *) malloc (rb_profile_size);
|
||||
if (profile == NULL) {
|
||||
status = DC_STATUS_NOMEMORY;
|
||||
goto error_free_logbook;
|
||||
}
|
||||
|
||||
// Create the ringbuffer stream.
|
||||
dc_rbstream_t *rbstream = NULL;
|
||||
status = dc_rbstream_new (&rbstream, abstract, SZ_READ, SZ_READ, RB_PROFILE_BEGIN, RB_PROFILE_END, eop);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to create the ringbuffer stream.");
|
||||
goto error_free_profile;
|
||||
}
|
||||
|
||||
previous = eop;
|
||||
unsigned int offset = rb_profile_size;
|
||||
for (unsigned int i = 0; i < count; ++i) {
|
||||
// Calculate the length.
|
||||
unsigned int length = RB_PROFILE_DISTANCE (logbook[i].address, previous);
|
||||
|
||||
// Move to the start of the current dive.
|
||||
offset -= length;
|
||||
previous = logbook[i].address;
|
||||
|
||||
// Read the dive.
|
||||
status = dc_rbstream_read (rbstream, &progress, profile + offset, length);
|
||||
if (status != DC_STATUS_SUCCESS) {
|
||||
ERROR (abstract->context, "Failed to read the dive.");
|
||||
goto error_free_rbstream;
|
||||
}
|
||||
|
||||
// Check the dive header.
|
||||
if (memcmp (profile + offset, logbook[i].header, SZ_HEADER) != 0) {
|
||||
ERROR (abstract->context, "Unexpected dive header.");
|
||||
status = DC_STATUS_DATAFORMAT;
|
||||
goto error_free_rbstream;
|
||||
}
|
||||
|
||||
// Get the number of samples.
|
||||
// The actual size of the dive, based on the number of samples, can
|
||||
// sometimes be smaller than the maximum length. In that case, the
|
||||
// remainder of the data is padded with 0xFF bytes.
|
||||
unsigned int nsamples = array_uint32_le (logbook[i].header + 0x44);
|
||||
unsigned int nbytes = SZ_HEADER + nsamples * SZ_SAMPLE;
|
||||
if (nbytes > length) {
|
||||
ERROR (abstract->context, "Unexpected dive length (%u %u).", nbytes, length);
|
||||
status = DC_STATUS_DATAFORMAT;
|
||||
goto error_free_rbstream;
|
||||
}
|
||||
|
||||
if (callback && !callback (profile + offset, nbytes, profile + offset + FP_OFFSET, sizeof(device->fingerprint), userdata)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
error_free_rbstream:
|
||||
dc_rbstream_free (rbstream);
|
||||
error_free_profile:
|
||||
free (profile);
|
||||
error_free_logbook:
|
||||
free (logbook);
|
||||
error_exit:
|
||||
return status;
|
||||
}
|
||||
43
src/seac_screen.h
Normal file
43
src/seac_screen.h
Normal file
@ -0,0 +1,43 @@
|
||||
/*
|
||||
* libdivecomputer
|
||||
*
|
||||
* Copyright (C) 2022 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 SEAC_SCREEN_H
|
||||
#define SEAC_SCREEN_H
|
||||
|
||||
#include <libdivecomputer/context.h>
|
||||
#include <libdivecomputer/iostream.h>
|
||||
#include <libdivecomputer/device.h>
|
||||
#include <libdivecomputer/parser.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
dc_status_t
|
||||
seac_screen_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
|
||||
|
||||
dc_status_t
|
||||
seac_screen_parser_create (dc_parser_t **parser, dc_context_t *context);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* SEAC_SCREEN_H */
|
||||
376
src/seac_screen_parser.c
Normal file
376
src/seac_screen_parser.c
Normal file
@ -0,0 +1,376 @@
|
||||
/*
|
||||
* libdivecomputer
|
||||
*
|
||||
* Copyright (C) 2022 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 "seac_screen.h"
|
||||
#include "context-private.h"
|
||||
#include "parser-private.h"
|
||||
#include "checksum.h"
|
||||
#include "array.h"
|
||||
|
||||
#define ISINSTANCE(parser) dc_device_isinstance((parser), &seac_screen_parser_vtable)
|
||||
|
||||
#define SZ_HEADER 128
|
||||
#define SZ_SAMPLE 64
|
||||
|
||||
#define NGASMIXES 2
|
||||
|
||||
#define INVALID 0xFFFFFFFF
|
||||
|
||||
typedef struct seac_screen_parser_t seac_screen_parser_t;
|
||||
|
||||
struct seac_screen_parser_t {
|
||||
dc_parser_t base;
|
||||
// Cached fields.
|
||||
unsigned int cached;
|
||||
unsigned int ngasmixes;
|
||||
unsigned int oxygen[NGASMIXES];
|
||||
};
|
||||
|
||||
static dc_status_t seac_screen_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size);
|
||||
static dc_status_t seac_screen_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime);
|
||||
static dc_status_t seac_screen_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value);
|
||||
static dc_status_t seac_screen_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata);
|
||||
|
||||
static const dc_parser_vtable_t seac_screen_parser_vtable = {
|
||||
sizeof(seac_screen_parser_t),
|
||||
DC_FAMILY_SEAC_SCREEN,
|
||||
seac_screen_parser_set_data, /* set_data */
|
||||
seac_screen_parser_get_datetime, /* datetime */
|
||||
seac_screen_parser_get_field, /* fields */
|
||||
seac_screen_parser_samples_foreach, /* samples_foreach */
|
||||
NULL /* destroy */
|
||||
};
|
||||
|
||||
dc_status_t
|
||||
seac_screen_parser_create (dc_parser_t **out, dc_context_t *context)
|
||||
{
|
||||
seac_screen_parser_t *parser = NULL;
|
||||
|
||||
if (out == NULL)
|
||||
return DC_STATUS_INVALIDARGS;
|
||||
|
||||
// Allocate memory.
|
||||
parser = (seac_screen_parser_t *) dc_parser_allocate (context, &seac_screen_parser_vtable);
|
||||
if (parser == NULL) {
|
||||
ERROR (context, "Failed to allocate memory.");
|
||||
return DC_STATUS_NOMEMORY;
|
||||
}
|
||||
|
||||
// Set the default values.
|
||||
parser->cached = 0;
|
||||
parser->ngasmixes = 0;
|
||||
for (unsigned int i = 0; i < NGASMIXES; ++i) {
|
||||
parser->oxygen[i] = 0;
|
||||
}
|
||||
|
||||
*out = (dc_parser_t *) parser;
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size)
|
||||
{
|
||||
seac_screen_parser_t *parser = (seac_screen_parser_t *)abstract;
|
||||
|
||||
// Reset the cache.
|
||||
parser->cached = 0;
|
||||
parser->ngasmixes = 0;
|
||||
for (unsigned int i = 0; i < NGASMIXES; ++i) {
|
||||
parser->oxygen[i] = 0;
|
||||
}
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
|
||||
{
|
||||
const unsigned char *data = abstract->data;
|
||||
|
||||
static const signed int tz_array[] = {
|
||||
-12 * 60, /* UTC-12 */
|
||||
-11 * 60, /* UTC-11 */
|
||||
-10 * 60, /* UTC-10 */
|
||||
-9 * 60 - 30, /* UTC-9:30 */
|
||||
-9 * 60, /* UTC-9 */
|
||||
-8 * 60, /* UTC-8 */
|
||||
-7 * 60, /* UTC-7 */
|
||||
-6 * 60, /* UTC-6 */
|
||||
-5 * 60, /* UTC-5 */
|
||||
-4 * 60 - 30, /* UTC-4:30 */
|
||||
-4 * 60, /* UTC-4 */
|
||||
-3 * 60 - 30, /* UTC-3:30 */
|
||||
-3 * 60, /* UTC-3 */
|
||||
-2 * 60, /* UTC-2 */
|
||||
-1 * 60, /* UTC-1 */
|
||||
0 * 60, /* UTC */
|
||||
1 * 60, /* UTC+1 */
|
||||
2 * 60, /* UTC+2 */
|
||||
3 * 60, /* UTC+3 */
|
||||
3 * 60 + 30, /* UTC+3:30 */
|
||||
4 * 60, /* UTC+4 */
|
||||
4 * 60 + 30, /* UTC+4:30 */
|
||||
5 * 60, /* UTC+5 */
|
||||
5 * 60 + 30, /* UTC+5:30 */
|
||||
5 * 60 + 45, /* UTC+5:45 */
|
||||
6 * 60, /* UTC+6 */
|
||||
6 * 60 + 30, /* UTC+6:30 */
|
||||
7 * 60, /* UTC+7 */
|
||||
8 * 60, /* UTC+8 */
|
||||
8 * 60 + 45, /* UTC+8:45 */
|
||||
9 * 60, /* UTC+9 */
|
||||
9 * 60 + 30, /* UTC+9:30 */
|
||||
9 * 60 + 45, /* UTC+9:45 */
|
||||
10 * 60, /* UTC+10 */
|
||||
10 * 60 + 30, /* UTC+10:30 */
|
||||
11 * 60, /* UTC+11 */
|
||||
11 * 60 + 30, /* UTC+11:30 */
|
||||
12 * 60, /* UTC+12 */
|
||||
12 * 60 + 45, /* UTC+12:45 */
|
||||
13 * 60, /* UTC+13 */
|
||||
13 * 60 + 45, /* UTC+13:45 */
|
||||
14 * 60, /* UTC+14 */
|
||||
};
|
||||
|
||||
if (abstract->size < SZ_HEADER)
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
|
||||
// The date/time is stored as UTC time with a timezone offset. To convert to
|
||||
// local time, the UTC time is first converted to unix time (seconds since
|
||||
// the epoch), then adjusted for the timezone offset, and finally converted
|
||||
// back into the broken-down time format.
|
||||
|
||||
dc_datetime_t utc = {0};
|
||||
utc.year = data[0x10] + 2000;
|
||||
utc.month = data[0x0F];
|
||||
utc.day = data[0x0E];
|
||||
utc.hour = data[0x0B];
|
||||
utc.minute = data[0x0C];
|
||||
utc.second = data[0x0D];
|
||||
utc.timezone = 0;
|
||||
|
||||
unsigned int tz_idx = data[0x0A];
|
||||
if (tz_idx >= C_ARRAY_SIZE(tz_array)) {
|
||||
ERROR (abstract->context, "Invalid timezone index (%u).", tz_idx);
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
int timezone = tz_array[tz_idx] * 60;
|
||||
|
||||
dc_ticks_t ticks = dc_datetime_mktime (&utc);
|
||||
if (ticks == -1)
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
|
||||
ticks += timezone;
|
||||
|
||||
if (!dc_datetime_gmtime (datetime, ticks))
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
|
||||
datetime->timezone = timezone;
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
|
||||
{
|
||||
seac_screen_parser_t *parser = (seac_screen_parser_t *) abstract;
|
||||
const unsigned char *data = abstract->data;
|
||||
|
||||
if (abstract->size < SZ_HEADER)
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
|
||||
if (!parser->cached) {
|
||||
dc_status_t rc = seac_screen_parser_samples_foreach (abstract, NULL, NULL);
|
||||
if (rc != DC_STATUS_SUCCESS)
|
||||
return rc;
|
||||
}
|
||||
|
||||
dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
|
||||
|
||||
if (value) {
|
||||
switch (type) {
|
||||
case DC_FIELD_AVGDEPTH:
|
||||
*((double *) value) = array_uint16_le (data + 0x72) / 100.0;
|
||||
break;
|
||||
case DC_FIELD_MAXDEPTH:
|
||||
*((double *) value) = array_uint16_le (data + 0x62) / 100.0;
|
||||
break;
|
||||
case DC_FIELD_DIVETIME:
|
||||
*((unsigned int *) value) = array_uint32_le (data + 0x64);
|
||||
break;
|
||||
case DC_FIELD_TEMPERATURE_MINIMUM:
|
||||
*((double *) value) = array_uint16_le (data + 0x6A) / 100.0;
|
||||
break;
|
||||
case DC_FIELD_TEMPERATURE_MAXIMUM:
|
||||
*((double *) value) = array_uint16_le (data + 0x68) / 100.0;
|
||||
break;
|
||||
case DC_FIELD_GASMIX_COUNT:
|
||||
*((unsigned int *)value) = parser->ngasmixes;
|
||||
break;
|
||||
case DC_FIELD_GASMIX:
|
||||
gasmix->helium = 0.0;
|
||||
gasmix->oxygen = parser->oxygen[flags] / 100.0;
|
||||
gasmix->nitrogen = 1.0 - gasmix->oxygen - gasmix->helium;
|
||||
break;
|
||||
case DC_FIELD_DIVEMODE:
|
||||
switch (data[0x26]) {
|
||||
case 1:
|
||||
*((dc_divemode_t *) value) = DC_DIVEMODE_OC;
|
||||
break;
|
||||
case 2:
|
||||
*((dc_divemode_t *) value) = DC_DIVEMODE_GAUGE;
|
||||
break;
|
||||
case 3:
|
||||
*((dc_divemode_t *) value) = DC_DIVEMODE_FREEDIVE;
|
||||
break;
|
||||
default:
|
||||
ERROR (abstract->context, "Unknown dive mode %i", data[0x26]);
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return DC_STATUS_UNSUPPORTED;
|
||||
}
|
||||
}
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static dc_status_t
|
||||
seac_screen_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata)
|
||||
{
|
||||
seac_screen_parser_t *parser = (seac_screen_parser_t *) abstract;
|
||||
const unsigned char *data = abstract->data;
|
||||
unsigned int size = abstract->size;
|
||||
|
||||
if (abstract->size < SZ_HEADER)
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
|
||||
if (checksum_crc16_ccitt (data, SZ_HEADER / 2, 0xFFFF) != 0 ||
|
||||
checksum_crc16_ccitt (data + SZ_HEADER / 2, SZ_HEADER / 2, 0xFFFF) != 0) {
|
||||
ERROR (abstract->context, "Unexpected header checksum.");
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
|
||||
unsigned int dive_id = array_uint32_le (data + 0x00);
|
||||
|
||||
unsigned int ngasmixes = 0;
|
||||
unsigned int oxygen[NGASMIXES] = {0};
|
||||
unsigned int o2_previous = INVALID;
|
||||
|
||||
unsigned int time = 0;
|
||||
unsigned int offset = SZ_HEADER;
|
||||
while (offset + SZ_SAMPLE <= size) {
|
||||
dc_sample_value_t sample = {0};
|
||||
|
||||
if (checksum_crc16_ccitt (data + offset, SZ_SAMPLE, 0xFFFF) != 0) {
|
||||
ERROR (abstract->context, "Unexpected sample checksum.");
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
|
||||
unsigned int id = array_uint32_le (data + offset + 0x00);
|
||||
unsigned int timestamp = array_uint32_le (data + offset + 0x04);
|
||||
unsigned int depth = array_uint16_le (data + offset + 0x08);
|
||||
unsigned int temperature = array_uint16_le (data + offset + 0x0A);
|
||||
unsigned int o2 = data[offset + 0x0C];
|
||||
unsigned int decodepth = array_uint16_le (data + offset + 0x0E);
|
||||
unsigned int decotime = array_uint16_le (data + offset + 0x10);
|
||||
unsigned int ndl_tts = array_uint16_le (data + offset + 0x12);
|
||||
unsigned int cns = array_uint16_le (data + offset + 0x16);
|
||||
|
||||
if (id != dive_id) {
|
||||
ERROR (abstract->context, "Unexpected sample id (%u %u).", dive_id, id);
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
|
||||
// Time (seconds).
|
||||
if (timestamp < time) {
|
||||
ERROR (abstract->context, "Timestamp moved backwards (%u %u).", timestamp, time);
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
time = timestamp;
|
||||
sample.time = time;
|
||||
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
|
||||
|
||||
// Depth (1/100 m).
|
||||
sample.depth = depth / 100.0;
|
||||
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
|
||||
|
||||
// Temperature (1/100 °C).
|
||||
sample.temperature = temperature / 100.0;
|
||||
if (callback) callback (DC_SAMPLE_TEMPERATURE, sample, userdata);
|
||||
|
||||
// Gas mix
|
||||
if (o2 != o2_previous) {
|
||||
// Find the gasmix in the list.
|
||||
unsigned int idx = 0;
|
||||
while (idx < ngasmixes) {
|
||||
if (o2 == oxygen[idx])
|
||||
break;
|
||||
idx++;
|
||||
}
|
||||
|
||||
// Add it to list if not found.
|
||||
if (idx >= ngasmixes) {
|
||||
if (idx >= NGASMIXES) {
|
||||
ERROR (abstract->context, "Maximum number of gas mixes reached.");
|
||||
return DC_STATUS_DATAFORMAT;
|
||||
}
|
||||
oxygen[idx] = o2;
|
||||
ngasmixes = idx + 1;
|
||||
}
|
||||
|
||||
sample.gasmix = idx;
|
||||
if (callback) callback(DC_SAMPLE_GASMIX, sample, userdata);
|
||||
o2_previous = o2;
|
||||
}
|
||||
|
||||
// NDL / Deco
|
||||
if (decodepth) {
|
||||
sample.deco.type = DC_DECO_DECOSTOP;
|
||||
sample.deco.time = decotime;
|
||||
sample.deco.depth = decodepth;
|
||||
} else {
|
||||
sample.deco.type = DC_DECO_NDL;
|
||||
sample.deco.time = ndl_tts;
|
||||
sample.deco.depth = 0;
|
||||
}
|
||||
if (callback) callback (DC_SAMPLE_DECO, sample, userdata);
|
||||
|
||||
// CNS
|
||||
sample.cns = cns / 100.0;
|
||||
if (callback) callback (DC_SAMPLE_CNS, sample, userdata);
|
||||
|
||||
offset += SZ_SAMPLE;
|
||||
}
|
||||
|
||||
// Cache the data for later use.
|
||||
for (unsigned int i = 0; i < ngasmixes; ++i) {
|
||||
parser->oxygen[i] = oxygen[i];
|
||||
}
|
||||
parser->ngasmixes = ngasmixes;
|
||||
parser->cached = 1;
|
||||
|
||||
return DC_STATUS_SUCCESS;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user