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

Add support for the Oceans S1

Browse Source 
The Oceans S1 uses a plaintext and line based communication protocol
over BLE. The larger payloads, which also contain plaintext data, are
transferred using the XMODEM-CRC protocol.

Based-on-code-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jef Driesen 2022-12-13 20:15:49 +01:00
parent 86e9cc3443
commit 9eef8c50c0
13 changed files with 1217 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
examples/common.c
View File

@ -97,6 +97,7 @@ static const backend_table_t g_backends[] = {
{"excursion", DC_FAMILY_DEEPSIX_EXCURSION, 0},
{"screen", DC_FAMILY_SEAC_SCREEN, 0},
{"cosmiq", DC_FAMILY_DEEPBLU_COSMIQ, 0},
{"s1", DC_FAMILY_OCEANS_S1, 0},
};
static const transport_table_t g_transports[] = {

2
include/libdivecomputer/common.h
View File

@ -116,6 +116,8 @@ typedef enum dc_family_t {
DC_FAMILY_SEAC_SCREEN = (20 << 16),
/* Deepblu Cosmiq */
DC_FAMILY_DEEPBLU_COSMIQ = (21 << 16),
/* Oceans S1 */
DC_FAMILY_OCEANS_S1 = (22 << 16),
} dc_family_t;
#ifdef __cplusplus

5
msvc/libdivecomputer.vcxproj
View File

@ -219,6 +219,9 @@
<ClCompile Include="..\src\oceanic_veo250_parser.c" />
<ClCompile Include="..\src\oceanic_vtpro.c" />
<ClCompile Include="..\src\oceanic_vtpro_parser.c" />
<ClCompile Include="..\src\oceans_s1.c" />
<ClCompile Include="..\src\oceans_s1_common.c" />
<ClCompile Include="..\src\oceans_s1_parser.c" />
<ClCompile Include="..\src\parser.c" />
<ClCompile Include="..\src\platform.c" />
<ClCompile Include="..\src\rbstream.c" />
@ -333,6 +336,8 @@
<ClInclude Include="..\src\oceanic_common.h" />
<ClInclude Include="..\src\oceanic_veo250.h" />
<ClInclude Include="..\src\oceanic_vtpro.h" />
<ClInclude Include="..\src\oceans_s1.h" />
<ClInclude Include="..\src\oceans_s1_common.h" />
<ClInclude Include="..\src\parser-private.h" />
<ClInclude Include="..\src\platform.h" />
<ClInclude Include="..\src\rbstream.h" />

2
src/Makefile.am
View File

@ -78,6 +78,8 @@ libdivecomputer_la_SOURCES = \
deepsix_excursion.h deepsix_excursion.c deepsix_excursion_parser.c \
seac_screen.h seac_screen.c seac_screen_parser.c \
deepblu_cosmiq.h deepblu_cosmiq.c deepblu_cosmiq_parser.c \
oceans_s1_common.h oceans_s1_common.c \
oceans_s1.h oceans_s1.c oceans_s1_parser.c \
socket.h socket.c \
irda.c \
usb.c \

16
src/descriptor.c
View File

@ -64,6 +64,7 @@ static int dc_filter_mclean (dc_transport_t transport, const void *userdata, voi
static int dc_filter_atomic (dc_transport_t transport, const void *userdata, void *params);
static int dc_filter_deepsix (dc_transport_t transport, const void *userdata, void *params);
static int dc_filter_deepblu (dc_transport_t transport, const void *userdata, void *params);
static int dc_filter_oceans (dc_transport_t transport, const void *userdata, void *params);
static dc_status_t dc_descriptor_iterator_next (dc_iterator_t *iterator, void *item);
@ -448,6 +449,8 @@ static const dc_descriptor_t g_descriptors[] = {
{"Seac", "Action", DC_FAMILY_SEAC_SCREEN, 0, DC_TRANSPORT_SERIAL, NULL},
/* Deepblu Cosmiq */
{"Deepblu", "Cosmiq+", DC_FAMILY_DEEPBLU_COSMIQ, 0, DC_TRANSPORT_BLE, dc_filter_deepblu},
/* Oceans S1 */
{"Oceans", "S1", DC_FAMILY_OCEANS_S1, 0, DC_TRANSPORT_BLE, dc_filter_oceans},
};
static int
@ -782,6 +785,19 @@ static int dc_filter_deepblu (dc_transport_t transport, const void *userdata, vo
return 1;
}
static int dc_filter_oceans (dc_transport_t transport, const void *userdata, void *params)
{
static const char * const bluetooth[] = {
"S1",
};
if (transport == DC_TRANSPORT_BLE) {
return DC_FILTER_INTERNAL (userdata, bluetooth, 0, dc_match_prefix);
}
return 1;
}
dc_status_t
dc_descriptor_iterator (dc_iterator_t **out)
{

4
src/device.c
View File

@ -63,6 +63,7 @@
#include "deepsix_excursion.h"
#include "seac_screen.h"
#include "deepblu_cosmiq.h"
#include "oceans_s1.h"
#include "device-private.h"
#include "context-private.h"
@ -235,6 +236,9 @@ dc_device_open (dc_device_t **out, dc_context_t *context, dc_descriptor_t *descr
case DC_FAMILY_DEEPBLU_COSMIQ:
rc = deepblu_cosmiq_device_open (&device, context, iostream);
break;
case DC_FAMILY_OCEANS_S1:
rc = oceans_s1_device_open (&device, context, iostream);
break;
default:
return DC_STATUS_INVALIDARGS;
}

717
src/oceans_s1.c Normal file
View File

@ -0,0 +1,717 @@
/*
* libdivecomputer
*
* Copyright (C) 2020 Linus Torvalds
* 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 <stdarg.h>
#include <stdio.h>
#include "oceans_s1.h"
#include "oceans_s1_common.h"
#include "context-private.h"
#include "device-private.h"
#include "platform.h"
#include "checksum.h"
#include "array.h"
#define SOH 0x01
#define EOT 0x04
#define ACK 0x06
#define NAK 0x15
#define CAN 0x18
#define CRC 0x43
#define SZ_PACKET 256
#define SZ_XMODEM 512
#define SZ_FINGERPRINT 8
typedef struct oceans_s1_dive_t {
struct oceans_s1_dive_t *next;
dc_ticks_t timestamp;
unsigned int number;
} oceans_s1_dive_t;
typedef struct oceans_s1_device_t {
dc_device_t base;
dc_iostream_t *iostream;
dc_ticks_t timestamp;
} oceans_s1_device_t;
static dc_status_t oceans_s1_device_set_fingerprint(dc_device_t *abstract, const unsigned char data[], unsigned int size);
static dc_status_t oceans_s1_device_foreach(dc_device_t *abstract, dc_dive_callback_t callback, void *userdata);
static dc_status_t oceans_s1_device_timesync(dc_device_t *abstract, const dc_datetime_t *datetime);
static const dc_device_vtable_t oceans_s1_device_vtable = {
sizeof(oceans_s1_device_t),
DC_FAMILY_OCEANS_S1,
oceans_s1_device_set_fingerprint, /* set_fingerprint */
NULL, /* read */
NULL, /* write */
NULL, /* dump */
oceans_s1_device_foreach, /* foreach */
oceans_s1_device_timesync, /* timesync */
NULL, /* close */
};
/*
* Oceans S1 initial sequence (all ASCII text with newlines):
*
* Cmd Reply
*
* utc\n utc>ok 1592912375\r\n
* battery\n battery>ok 59%\r\n
* version\n version>ok 1.1 42a7e564\r\n
* utc 1592912364\n utc>ok\r\n
* units 1\n units>ok\r\n
* dllist\n dllist>xmr\r\n
*
* At this point, the dive computer switches to the XMODEM protocol and
* the sequence is no longer single packets with a full line with newline
* termination.
*
* The actual payload remains ASCII text (note the single space indentation):
*
* divelog v1,10s/sample
* dive 1,0,21,1591372057
* continue 612,10
* enddive 3131,496
* dive 2,0,21,1591372925
* enddive 1535,277
* dive 3,0,32,1591463368
* enddive 1711,4515
* dive 4,0,32,1591961688
* continue 300,45
* continue 391,238
* continue 420,126
* continue 236,17
* enddive 1087,2636
* endlog
*
* Because the XMODEM protocol uses fixed size packets (512 bytes), the last
* packet is padded with newline characters.
*
* Then it goes back to line-mode:
*
* dlget 4 5\n dlget>xmr\r\n
*
* and the data is again transferred using the XMODEM protocol. The payload is
* also ASCII text (note the space indentation again):
*
* divelog v1,10s/sample
* dive 4,0,32,1591961688
* 365,13,1
* 382,13,51456
* 367,13,16640
* 381,13,49408
* 375,13,24576
* 355,13,16384
* 346,13,16384
* 326,14,16384
* 355,14,16384
* 394,14,24576
* 397,14,16384
* 434,14,49152
* 479,14,49152
* 488,14,16384
* 556,14,57344
* 616,14,49152
* 655,14,49152
* 738,14,49152
* 800,14,57344
* 800,14,49408
* 834,14,16640
* 871,14,24832
* 860,14,16640
* 860,14,16640
* 815,14,24832
* 738,14,16640
* 707,14,16640
* 653,14,24832
* 647,13,16640
* 670,13,16640
* 653,13,24832
* ...
* continue 236,17
* 227,13,57600
* 238,14,16640
* 267,14,24832
* 283,14,16384
* 272,14,16384
* 303,14,24576
* 320,14,16384
* 318,14,16384
* 318,14,16384
* 335,14,24576
* 332,14,16384
* 386,14,16384
* 417,14,24576
* 244,14,16640
* 71,14,16640
* enddive 1087,2636
* endlog
*
* Where the samples seem to be
* - depth in cm
* - temperature in °C
* - events
*
* Repeat with 'dlget 3 4', 'dlget 2 3', 'dlget 1 2'.
*
* Done.
*/
/*
* Add a dive to the dive list, sorted with newest dive first
*
* I'm not sure if the dive list is always presented sorted by the
* Oceans S1, but it arrives in the reverse order of what we want
* (we want newest first, it lists them oldest first). So we need
* to switch the order, and we might as well make sure it's sorted
* while doing that.
*/
static void
oceans_s1_list_add (oceans_s1_dive_t **head, oceans_s1_dive_t *dive)
{
if (head == NULL)
return;
oceans_s1_dive_t *current = *head, *previous = NULL;
while (current) {
if (dive->number >= current->number)
break;
previous = current;
current = current->next;
}
if (previous) {
dive->next = previous->next;
previous->next = dive;
} else {
dive->next = *head;
*head = dive;
}
}
static void
oceans_s1_list_free (oceans_s1_dive_t *head)
{
oceans_s1_dive_t *current = head;
while (current) {
oceans_s1_dive_t *next = current->next;
free (current);
current = next;
}
}
/*
* The main data is transferred using the XMODEM-CRC protocol.
*
* This variant of the XMODEM protocol uses a sequence of 517 byte packets,
* where each packet has a three byte header, 512 bytes of payload data and a
* two byte CRC checksum. The header is a 'SOH' byte, followed by the block
* number (starting at 1), and the inverse block number (255-block).
*
* We're supposed to start the sequence with a 'CRC' byte, and reply to each
* packet with a 'ACK' byte. When there is no more data, the device will
* send us a 'EOT' packet, which we'll ack with a final 'ACK' byte.
*
* So we get a sequence of:
*
* 01 01 fe <512 bytes> xx xx
* 01 02 fd <512 bytes> xx xx
* 01 03 fc <512 bytes> xx xx
* 01 04 fb <512 bytes> xx xx
* 01 05 fa <512 bytes> xx xx
* 01 06 f9 <512 bytes> xx xx
* 01 07 f8 <512 bytes> xx xx
* 04
*
* And we should reply with an 'ACK' byte for each of those entries.
*
* NOTE! The above is not in single BLE packets, although the
* sequence blocks always start at a packet boundary.
*
* NOTE! The Oceans Android app uses GATT "Write Commands" (0x53), and not
* GATT "Write Requests" (0x12) for sending the XMODEM single byte commands,
* but this difference does not seem to matter.
*/
static dc_status_t
oceans_s1_xmodem_packet (oceans_s1_device_t *device, unsigned char seq, unsigned char data[], size_t size)
{
dc_status_t status = DC_STATUS_SUCCESS;
unsigned char packet[3 + SZ_XMODEM + 2] = {0};
size_t nbytes = 0;
if (size < SZ_XMODEM)
return DC_STATUS_INVALIDARGS;
status = dc_iostream_read (device->iostream, packet, sizeof(packet), &nbytes);
if (status != DC_STATUS_SUCCESS) {
ERROR (device->base.context, "Failed to receive the packet.");
return status;
}
if (nbytes < 1) {
ERROR (device->base.context, "Unexpected packet length (" DC_PRINTF_SIZE ").", nbytes);
return DC_STATUS_PROTOCOL;
}
if (packet[0] == EOT) {
return DC_STATUS_DONE;
}
if (nbytes < 3) {
ERROR (device->base.context, "Unexpected packet length (" DC_PRINTF_SIZE ").", nbytes);
return DC_STATUS_PROTOCOL;
}
if (packet[0] != SOH || packet[1] != seq || packet[1] + packet[2] != 0xFF) {
ERROR (device->base.context, "Unexpected packet header.");
return DC_STATUS_PROTOCOL;
}
while (nbytes < sizeof(packet)) {
size_t received = 0;
status = dc_iostream_read (device->iostream, packet + nbytes, sizeof(packet) - nbytes, &received);
if (status != DC_STATUS_SUCCESS) {
ERROR (device->base.context, "Failed to receive the packet.");
return status;
}
nbytes += received;
}
unsigned short crc = array_uint16_be (packet + nbytes - 2);
unsigned short ccrc = checksum_crc16_ccitt (packet + 3, nbytes - 5, 0x0000);
if (crc != ccrc) {
ERROR (device->base.context, "Unexpected answer checksum (%04x %04x).", crc, ccrc);
return DC_STATUS_PROTOCOL;
}
memcpy (data, packet + 3, SZ_XMODEM);
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_xmodem_recv (oceans_s1_device_t *device, dc_buffer_t *buffer)
{
dc_status_t status = DC_STATUS_SUCCESS;
const unsigned char crc = CRC;
const unsigned char ack = ACK;
dc_buffer_clear (buffer);
// Request XMODEM-CRC mode.
status = dc_iostream_write (device->iostream, &crc, 1, NULL);
if (status != DC_STATUS_SUCCESS)
return status;
unsigned char seq = 1;
while (1) {
// Receive the XMODEM data packet.
unsigned char packet[SZ_XMODEM] = {0};
status = oceans_s1_xmodem_packet (device, seq, packet, sizeof(packet));
if (status != DC_STATUS_SUCCESS) {
if (status == DC_STATUS_DONE)
break;
return status;
}
dc_buffer_append (buffer, packet, sizeof(packet));
// Ack the data packet.
status = dc_iostream_write (device->iostream, &ack, 1, NULL);
if (status != DC_STATUS_SUCCESS)
return status;
seq++;
}
// Ack the EOT packet.
status = dc_iostream_write (device->iostream, &ack, 1, NULL);
if (status != DC_STATUS_SUCCESS) {
return status;
}
// Find trailing newline(s).
size_t size = dc_buffer_get_size (buffer);
unsigned char *data = dc_buffer_get_data (buffer);
while (size > 1 && (data[size - 2] == '\r' || data[size - 2] == '\n'))
size--;
// Remove trailing newline(s).
dc_buffer_slice (buffer, 0, size);
return DC_STATUS_SUCCESS;
}
static dc_status_t DC_ATTR_FORMAT_PRINTF(6, 7)
oceans_s1_transfer (oceans_s1_device_t *device, dc_buffer_t *buffer, char data[], size_t size, const char *cmd, const char *params, ...)
{
dc_status_t status = DC_STATUS_SUCCESS;
char buf[SZ_PACKET + 1] = {0};
size_t buflen = 0;
if (device_is_cancelled (&device->base))
return DC_STATUS_CANCELLED;
size_t cmdlen = strlen (cmd);
if (buflen + cmdlen > sizeof(buf) - 1) {
ERROR (device->base.context, "Not enough space for the command string.");
return DC_STATUS_NOMEMORY;
}
// Copy the command string.
memcpy (buf, cmd, cmdlen);
buflen += cmdlen;
// Null terminate the buffer.
buf[buflen] = 0;
if (params) {
if (buflen + 1 > sizeof(buf) - 1) {
ERROR (device->base.context, "Not enough space for the separator.");
return DC_STATUS_NOMEMORY;
}
// Append a space.
buf[buflen++] = ' ';
// Null terminate the buffer.
buf[buflen] = 0;
// Append the arguments.
va_list ap;
va_start (ap, params);
int n = dc_platform_vsnprintf (buf + buflen, sizeof(buf) - buflen, params, ap);
va_end (ap);
if (n < 0) {
ERROR (device->base.context, "Not enough space for the arguments.");
return DC_STATUS_NOMEMORY;
}
buflen += n;
}
DEBUG(device->base.context, "cmd: %s", buf);
if (buflen + 1 > sizeof(buf) - 1) {
ERROR (device->base.context, "Not enough space for the newline.");
return DC_STATUS_NOMEMORY;
}
// Append a newline.
buf[buflen++] = '\n';
// Null terminate the buffer.
buf[buflen] = 0;
// Send the command.
status = dc_iostream_write (device->iostream, buf, buflen, NULL);
if (status != DC_STATUS_SUCCESS) {
ERROR (device->base.context, "Failed to send the command.");
return status;
}
// Receive the response.
size_t nbytes = 0;
status = dc_iostream_read (device->iostream, buf, sizeof(buf) - 1, &nbytes);
if (status != DC_STATUS_SUCCESS) {
ERROR (device->base.context, "Failed to receive the response.");
return status;
}
// Remove trailing newline(s).
while (nbytes && (buf[nbytes - 1] == '\r' || buf[nbytes - 1] == '\n'))
nbytes--;
// Null terminate the buffer.
buf[nbytes] = 0;
DEBUG (device->base.context, "rcv: %s", buf);
// Verify the response.
if (strncmp (buf, cmd, cmdlen) != 0) {
ERROR (device->base.context, "Received unexpected packet data ('%s').", buf);
return DC_STATUS_PROTOCOL;
}
// Check the type of response.
// If the response indicates "ok", the payload data is send inline in
// the remainder of the response packet. If the response indicates "xmr",
// the payload data is send separately using the XMODEM protocol.
if (strncmp (buf + cmdlen, ">ok", 3) == 0) {
// Ignore leading whitespace.
const char *line = buf + cmdlen + 3;
while (*line == ' ')
line++;
// Copy the payload data.
size_t len = nbytes - (line - buf);
if (size) {
if (len + 1 > size) {
ERROR (device->base.context, "Unexpected packet length (" DC_PRINTF_SIZE ").", len);
return DC_STATUS_PROTOCOL;
}
memcpy (data, line, len + 1);
} else {
if (len != 0) {
ERROR (device->base.context, "Unexpected packet length (" DC_PRINTF_SIZE ").", len);
return DC_STATUS_PROTOCOL;
}
}
} else if (strncmp (buf + cmdlen, ">xmr", 4) == 0) {
if (nbytes > cmdlen + 4) {
WARNING (device->base.context, "Packet contains extra data ('%s').", buf + cmdlen + 4);
}
return oceans_s1_xmodem_recv (device, buffer);
} else {
ERROR (device->base.context, "Received unexpected packet data ('%s').", buf);
return DC_STATUS_PROTOCOL;
}
return status;
}
dc_status_t
oceans_s1_device_open(dc_device_t **out, dc_context_t *context, dc_iostream_t *iostream)
{
dc_status_t status = DC_STATUS_SUCCESS;
oceans_s1_device_t *device = NULL;
if (out == NULL)
return DC_STATUS_INVALIDARGS;
// Allocate memory.
device = (oceans_s1_device_t *) dc_device_allocate (context, &oceans_s1_device_vtable);
if (device == NULL) {
ERROR(context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
// Set the default values.
device->iostream = iostream;
device->timestamp = 0;
// Set the timeout for receiving data (4000 ms).
status = dc_iostream_set_timeout (device->iostream, 4000);
if (status != DC_STATUS_SUCCESS) {
ERROR (context, "Failed to set the timeout.");
goto error_free;
}
dc_iostream_purge (device->iostream, DC_DIRECTION_ALL);
*out = (dc_device_t *) device;
return DC_STATUS_SUCCESS;
error_free:
dc_device_deallocate ((dc_device_t *) device);
return status;
}
static dc_status_t
oceans_s1_device_set_fingerprint (dc_device_t *abstract, const unsigned char data[], unsigned int size)
{
oceans_s1_device_t *device = (oceans_s1_device_t *) abstract;
if (size && size != SZ_FINGERPRINT)
return DC_STATUS_INVALIDARGS;
if (size)
device->timestamp = array_uint64_be (data);
else
device->timestamp = 0;
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_device_foreach (dc_device_t *abstract, dc_dive_callback_t callback, void *userdata)
{
dc_status_t status = DC_STATUS_SUCCESS;
oceans_s1_device_t *device = (oceans_s1_device_t *) abstract;
dc_event_progress_t progress = EVENT_PROGRESS_INITIALIZER;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
char version[SZ_PACKET] = {0};
status = oceans_s1_transfer (device, NULL, version, sizeof(version), "version", NULL);
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to read the version.");
return status;
}
unsigned int major = 0, minor = 0, unknown = 0;
if (sscanf (version, "%u.%u %x", &major, &minor, &unknown) != 3) {
ERROR (abstract->context, "Failed to parse the version response.");
return DC_STATUS_PROTOCOL;
}
// Emit a device info event.
dc_event_devinfo_t devinfo;
devinfo.model = 0;
devinfo.firmware = major << 16 | minor;
devinfo.serial = 0;
device_event_emit (abstract, DC_EVENT_DEVINFO, &devinfo);
dc_buffer_t *buffer = dc_buffer_new (4096);
if (buffer == NULL) {
ERROR (abstract->context, "Failed to allocate memory.");
status = DC_STATUS_NOMEMORY;
goto error_exit;
}
status = oceans_s1_transfer (device, buffer, NULL, 0, "dllist", NULL);
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to download the dive list.");
goto error_free_buffer;
}
const unsigned char *data = dc_buffer_get_data (buffer);
size_t size = dc_buffer_get_size (buffer);
oceans_s1_dive_t *logbook = NULL, *dive = NULL;
unsigned int ndives = 0;
char *ptr = NULL;
size_t len = 0;
int n = 0;
while ((n = oceans_s1_getline (&ptr, &len, &data, &size)) != -1) {
// Ignore empty lines.
if (n == 0)
continue;
// Ignore leading whitespace.
const char *line = ptr;
while (*line == ' ')
line++;
if (strncmp (line, "divelog", 7) == 0 ||
strncmp (line, "endlog", 6) == 0 ||
strncmp (line, "continue", 8) == 0) {
// Nothing to do.
} else if (strncmp (line, "dive", 4) == 0) {
if (dive != NULL) {
ERROR (abstract->context, "Skipping dive without 'enddive' line.");
free (dive);
dive = NULL;
}
unsigned int number = 0, divemode = 0, o2 = 0;
dc_ticks_t timestamp = 0;
if (sscanf (line, "dive %u,%u,%u," DC_FORMAT_INT64, &number, &divemode, &o2, &timestamp) != 4) {
ERROR (abstract->context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free_list;
}
dive = (oceans_s1_dive_t *) malloc (sizeof (oceans_s1_dive_t));
if (dive == NULL) {
ERROR (abstract->context, "Failed to allocate memory.");
status = DC_STATUS_NOMEMORY;
goto error_free_list;
}
dive->next = NULL;
dive->timestamp = timestamp;
dive->number = number;
} else if (strncmp (line, "enddive", 7) == 0) {
if (dive) {
if (dive->timestamp > device->timestamp) {
oceans_s1_list_add (&logbook, dive);
ndives++;
} else {
free (dive);
}
dive = NULL;
} else {
WARNING (abstract->context, "Unexpected line '%s'.", line);
}
} else {
WARNING (abstract->context, "Unexpected line '%s'.", line);
}
}
if (dive != NULL) {
WARNING (abstract->context, "Skipping dive without 'enddive' line.");
free (dive);
dive = NULL;
}
progress.current = 1;
progress.maximum = 1 + ndives;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
for (dive = logbook; dive; dive = dive->next) {
status = oceans_s1_transfer (device, buffer, NULL, 0, "dlget", "%u %u", dive->number, dive->number + 1);
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to download the dive.");
goto error_free_list;
}
progress.current++;
device_event_emit (abstract, DC_EVENT_PROGRESS, &progress);
unsigned char fingerprint[SZ_FINGERPRINT] = {0};
array_uint64_be_set (fingerprint, dive->timestamp);
if (callback && !callback (dc_buffer_get_data (buffer), dc_buffer_get_size (buffer), fingerprint, sizeof(fingerprint), userdata))
break;
}
error_free_list:
oceans_s1_list_free (logbook);
free (ptr);
error_free_buffer:
dc_buffer_free (buffer);
error_exit:
return status;
}
static dc_status_t
oceans_s1_device_timesync (dc_device_t *abstract, const dc_datetime_t *datetime)
{
dc_status_t status = DC_STATUS_SUCCESS;
oceans_s1_device_t *device = (oceans_s1_device_t *) abstract;
// Ignore the timezone offset.
dc_datetime_t dt = *datetime;
dt.timezone = DC_TIMEZONE_NONE;
dc_ticks_t timestamp = dc_datetime_mktime (&dt);
if (timestamp < 0) {
ERROR (abstract->context, "Invalid date/time value specified.");
return DC_STATUS_INVALIDARGS;
}
status = oceans_s1_transfer (device, NULL, NULL, 0, "utc", DC_FORMAT_INT64, timestamp);
if (status != DC_STATUS_SUCCESS) {
ERROR (abstract->context, "Failed to set the date/time.");
return status;
}
return status;
}

44
src/oceans_s1.h Normal file
View File

@ -0,0 +1,44 @@
/*
* libdivecomputer
*
* Copyright (C) 2020 Linus Torvalds
* 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 OCEANS_S1_H
#define OCEANS_S1_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
oceans_s1_device_open (dc_device_t **device, dc_context_t *context, dc_iostream_t *iostream);
dc_status_t
oceans_s1_parser_create (dc_parser_t **parser, dc_context_t *context);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OCEANS_S1_H */

68
src/oceans_s1_common.c Normal file
View File

@ -0,0 +1,68 @@
/*
* 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 <stddef.h>
#include "oceans_s1_common.h"
int
oceans_s1_getline (char **line, size_t *linelen, const unsigned char **data, size_t *size)
{
if (line == NULL || linelen == NULL || data == NULL || size == NULL)
return -1;
if (*size == 0)
return -1;
// Find the end of the line.
unsigned int strip = 0;
const unsigned char *p = *data, *end = p + *size;
while (p != end) {
unsigned char c = *p++;
if (c == '\r' || c == '\n') {
strip = 1;
break;
}
}
// Get the length of the line.
size_t len = p - *data;
// Resize the buffer (if necessary).
if (*line == NULL || len + 1 > *linelen) {
char *buf = (char *) malloc (len + 1);
if (buf == NULL)
return -1;
free (*line);
*line = buf;
*linelen = len + 1;
}
// Copy the data.
memcpy (*line, *data, len - strip);
(*line)[len - strip] = 0;
*data += len;
*size -= len;
return len - strip;
}

35
src/oceans_s1_common.h Normal file
View File

@ -0,0 +1,35 @@
/*
* 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 OCEANS_S1_COMMON_H
#define OCEANS_S1_COMMON_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
int
oceans_s1_getline (char **line, size_t *linelen, const unsigned char **data, size_t *size);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OCEANS_S1_COMMON_H */

317
src/oceans_s1_parser.c Normal file
View File

@ -0,0 +1,317 @@
/*
* libdivecomputer
*
* Copyright (C) 2020 Linus Torvalds
* 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>
#include <stdlib.h>
#include <stdio.h>
#include "oceans_s1.h"
#include "oceans_s1_common.h"
#include "context-private.h"
#include "parser-private.h"
#include "platform.h"
#include "array.h"
#define SCUBA 0
#define APNEA 1
#define EVENT_DIVE_STARTED 0x0001
#define EVENT_DIVE_ENDED 0x0002
#define EVENT_DIVE_RESUMED 0x0004
#define EVENT_PING_SENT 0x0008
#define EVENT_PING_RECEIVED 0x0010
#define EVENT_DECO_STOP 0x0020
#define EVENT_SAFETY_STOP 0x0040
#define EVENT_BATTERY_LOW 0x0080
#define EVENT_BACKLIGHT_ON 0x0100
typedef struct oceans_s1_parser_t oceans_s1_parser_t;
struct oceans_s1_parser_t {
dc_parser_t base;
// Cached fields.
dc_ticks_t timestamp;
unsigned int cached;
unsigned int number;
unsigned int divemode;
unsigned int oxygen;
unsigned int maxdepth;
unsigned int divetime;
};
static dc_status_t oceans_s1_parser_set_data(dc_parser_t *abstract, const unsigned char *data, unsigned int size);
static dc_status_t oceans_s1_parser_get_datetime(dc_parser_t *abstract, dc_datetime_t *datetime);
static dc_status_t oceans_s1_parser_get_field(dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value);
static dc_status_t oceans_s1_parser_samples_foreach(dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata);
static const dc_parser_vtable_t oceans_s1_parser_vtable = {
sizeof(oceans_s1_parser_t),
DC_FAMILY_OCEANS_S1,
oceans_s1_parser_set_data, /* set_data */
NULL, /* set_clock */
NULL, /* set_atmospheric */
NULL, /* set_density */
oceans_s1_parser_get_datetime, /* datetime */
oceans_s1_parser_get_field, /* fields */
oceans_s1_parser_samples_foreach, /* samples_foreach */
NULL /* destroy */
};
dc_status_t
oceans_s1_parser_create (dc_parser_t **out, dc_context_t *context)
{
oceans_s1_parser_t *parser = NULL;
if (out == NULL)
return DC_STATUS_INVALIDARGS;
// Allocate memory.
parser = (oceans_s1_parser_t *) dc_parser_allocate (context, &oceans_s1_parser_vtable);
if (parser == NULL) {
ERROR (context, "Failed to allocate memory.");
return DC_STATUS_NOMEMORY;
}
// Set the default values.
parser->cached = 0;
parser->timestamp = 0;
parser->number = 0;
parser->divemode = 0;
parser->oxygen = 0;
parser->maxdepth = 0;
parser->divetime = 0;
*out = (dc_parser_t *) parser;
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_parser_set_data (dc_parser_t *abstract, const unsigned char *data, unsigned int size)
{
oceans_s1_parser_t *parser = (oceans_s1_parser_t *) abstract;
// Reset the cache.
parser->cached = 0;
parser->timestamp = 0;
parser->number = 0;
parser->divemode = 0;
parser->oxygen = 0;
parser->maxdepth = 0;
parser->divetime = 0;
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_parser_get_datetime (dc_parser_t *abstract, dc_datetime_t *datetime)
{
oceans_s1_parser_t *parser = (oceans_s1_parser_t *) abstract;
if (!parser->cached) {
dc_status_t status = oceans_s1_parser_samples_foreach (abstract, NULL, NULL);
if (status != DC_STATUS_SUCCESS)
return status;
}
if (!dc_datetime_gmtime (datetime, parser->timestamp))
return DC_STATUS_DATAFORMAT;
datetime->timezone = DC_TIMEZONE_NONE;
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_parser_get_field (dc_parser_t *abstract, dc_field_type_t type, unsigned int flags, void *value)
{
oceans_s1_parser_t *parser = (oceans_s1_parser_t *) abstract;
if (!parser->cached) {
dc_status_t status = oceans_s1_parser_samples_foreach (abstract, NULL, NULL);
if (status != DC_STATUS_SUCCESS)
return status;
}
dc_gasmix_t *gasmix = (dc_gasmix_t *) value;
if (value) {
switch (type) {
case DC_FIELD_DIVETIME:
*((unsigned int *) value) = parser->divetime;
break;
case DC_FIELD_MAXDEPTH:
*((double *) value) = parser->maxdepth / 100.0;
break;
case DC_FIELD_GASMIX_COUNT:
*((unsigned int *) value) = parser->divemode == SCUBA;
break;
case DC_FIELD_GASMIX:
gasmix->helium = 0.0;
gasmix->oxygen = parser->oxygen / 100.0;
gasmix->nitrogen = 1.0 - gasmix->oxygen - gasmix->helium;
break;
case DC_FIELD_DIVEMODE:
switch (parser->divemode) {
case SCUBA:
*((dc_divemode_t *) value) = DC_DIVEMODE_OC;
break;
case APNEA:
*((dc_divemode_t *) value) = DC_DIVEMODE_FREEDIVE;
break;
default:
return DC_STATUS_DATAFORMAT;
}
break;
default:
return DC_STATUS_UNSUPPORTED;
}
}
return DC_STATUS_SUCCESS;
}
static dc_status_t
oceans_s1_parser_samples_foreach (dc_parser_t *abstract, dc_sample_callback_t callback, void *userdata)
{
dc_status_t status = DC_STATUS_SUCCESS;
oceans_s1_parser_t *parser = (oceans_s1_parser_t *) abstract;
const unsigned char *data = abstract->data;
size_t size = abstract->size;
dc_ticks_t timestamp = 0;
unsigned int number = 0, divemode = 0, oxygen = 0;
unsigned int maxdepth = 0, divetime = 0;
unsigned int interval = 10;
unsigned int time = 0;
char *ptr = NULL;
size_t len = 0;
int n = 0;
while ((n = oceans_s1_getline (&ptr, &len, &data, &size)) != -1) {
dc_sample_value_t sample = {0};
// Ignore empty lines.
if (n == 0)
continue;
// Ignore leading whitespace.
const char *line = ptr;
while (*line == ' ')
line++;
if (strncmp (line, "divelog", 7) == 0) {
if (sscanf (line, "divelog v1,%us/sample", &interval) != 1) {
ERROR (parser->base.context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
if (interval == 0) {
ERROR (parser->base.context, "Invalid sample interval (%u).", interval);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
} else if (strncmp (line, "dive", 4) == 0) {
if (sscanf (line, "dive %u,%u,%u," DC_FORMAT_INT64, &number, &divemode, &oxygen, &timestamp) != 4) {
ERROR (parser->base.context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
} else if (strncmp (line, "continue", 8) == 0) {
unsigned int depth = 0, seconds = 0;
if (sscanf (line, "continue %u,%u", &depth, &seconds) != 2) {
ERROR (parser->base.context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
// Create surface samples for the surface time,
// and then a depth sample at the stated depth.
unsigned int nsamples = seconds / interval;
for (unsigned int i = 0; i < nsamples; ++i) {
time += interval;
sample.time = time;
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
sample.depth = 0;
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
}
time += interval;
sample.time = time;
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
sample.depth = depth / 100.0;
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
} else if (strncmp(line, "enddive", 7) == 0) {
if (sscanf(line, "enddive %u,%u", &maxdepth, &divetime) != 2) {
ERROR (parser->base.context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
} else if (strncmp (line, "endlog", 6) == 0) {
// Nothing to do.
} else {
unsigned int depth = 0, events = 0;
int temperature = 0;
if (sscanf (line, "%u,%d,%u", &depth, &temperature, &events) != 3) {
ERROR (parser->base.context, "Failed to parse the line '%s'.", line);
status = DC_STATUS_DATAFORMAT;
goto error_free;
}
time += interval;
sample.time = time;
if (callback) callback (DC_SAMPLE_TIME, sample, userdata);
sample.depth = depth / 100.0;
if (callback) callback (DC_SAMPLE_DEPTH, sample, userdata);
sample.temperature = temperature;
if (callback) callback (DC_SAMPLE_TEMPERATURE, sample, userdata);
if (events & EVENT_DECO_STOP) {
sample.deco.type = DC_DECO_DECOSTOP;
} else if (events & EVENT_SAFETY_STOP) {
sample.deco.type = DC_DECO_SAFETYSTOP;
} else {
sample.deco.type = DC_DECO_NDL;
}
sample.deco.depth = 0.0;
sample.deco.time = 0;
if (callback) callback (DC_SAMPLE_DECO, sample, userdata);
}
}
// Cache the data for later use.
parser->timestamp = timestamp;
parser->number = number;
parser->divemode = divemode;
parser->oxygen = oxygen;
parser->maxdepth = maxdepth;
parser->divetime = divetime;
parser->cached = 1;
error_free:
free (ptr);
return status;
}

4
src/parser.c
View File

@ -62,6 +62,7 @@
#include "deepsix_excursion.h"
#include "seac_screen.h"
#include "deepblu_cosmiq.h"
#include "oceans_s1.h"
#include "context-private.h"
#include "parser-private.h"
@ -195,6 +196,9 @@ dc_parser_new_internal (dc_parser_t **out, dc_context_t *context, dc_family_t fa
case DC_FAMILY_DEEPBLU_COSMIQ:
rc = deepblu_cosmiq_parser_create (&parser, context);
break;
case DC_FAMILY_OCEANS_S1:
rc = oceans_s1_parser_create (&parser, context);
break;
default:
return DC_STATUS_INVALIDARGS;
}

2
src/platform.h
View File

@ -36,8 +36,10 @@ extern "C" {
#ifdef _WIN32
#define DC_PRINTF_SIZE "%Iu"
#define DC_FORMAT_INT64 "%I64d"
#else
#define DC_PRINTF_SIZE "%zu"
#define DC_FORMAT_INT64 "%lld"
#endif
#ifdef _MSC_VER