From 4b4efb2c07884161b38065288607042992005696 Mon Sep 17 00:00:00 2001 From: Jef Driesen Date: Fri, 25 Mar 2022 20:00:39 +0100 Subject: [PATCH] Add support for the Seac Screen and Action --- examples/common.c | 1 + include/libdivecomputer/common.h | 2 + msvc/libdivecomputer.vcxproj | 3 + src/Makefile.am | 1 + src/descriptor.c | 3 + src/device.c | 4 + src/parser.c | 4 + src/seac_screen.c | 604 +++++++++++++++++++++++++++++++ src/seac_screen.h | 43 +++ src/seac_screen_parser.c | 376 +++++++++++++++++++ 10 files changed, 1041 insertions(+) create mode 100644 src/seac_screen.c create mode 100644 src/seac_screen.h create mode 100644 src/seac_screen_parser.c diff --git a/examples/common.c b/examples/common.c index 10eb496..4b3a63f 100644 --- a/examples/common.c +++ b/examples/common.c @@ -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[] = { diff --git a/include/libdivecomputer/common.h b/include/libdivecomputer/common.h index f6ca9fe..3553cf8 100644 --- a/include/libdivecomputer/common.h +++ b/include/libdivecomputer/common.h @@ -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 diff --git a/msvc/libdivecomputer.vcxproj b/msvc/libdivecomputer.vcxproj index 5c8fe3a..84bac6b 100644 --- a/msvc/libdivecomputer.vcxproj +++ b/msvc/libdivecomputer.vcxproj @@ -227,6 +227,8 @@ + + @@ -336,6 +338,7 @@ + diff --git a/src/Makefile.am b/src/Makefile.am index 5cec346..58916b6 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -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 \ diff --git a/src/descriptor.c b/src/descriptor.c index b55b2c3..0416157 100644 --- a/src/descriptor.c +++ b/src/descriptor.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 diff --git a/src/device.c b/src/device.c index affebc8..3080e6a 100644 --- a/src/device.c +++ b/src/device.c @@ -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; } diff --git a/src/parser.c b/src/parser.c index 9a0f71c..22833e2 100644 --- a/src/parser.c +++ b/src/parser.c @@ -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; } diff --git a/src/seac_screen.c b/src/seac_screen.c new file mode 100644 index 0000000..e9b5366 --- /dev/null +++ b/src/seac_screen.c @@ -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 // memcmp, memcpy +#include // 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; +} diff --git a/src/seac_screen.h b/src/seac_screen.h new file mode 100644 index 0000000..64c15b6 --- /dev/null +++ b/src/seac_screen.h @@ -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 +#include +#include +#include + +#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 */ diff --git a/src/seac_screen_parser.c b/src/seac_screen_parser.c new file mode 100644 index 0000000..28988e4 --- /dev/null +++ b/src/seac_screen_parser.c @@ -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 + +#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; +}