From 734d0cede556708c7df3ed28fb8c1eedd1477d46 Mon Sep 17 00:00:00 2001 From: Jef Driesen Date: Tue, 24 Jun 2008 12:28:44 +0000 Subject: [PATCH] Added a function to read individual dives from the Oceanic Atom 2. --- examples/oceanic_atom2_test.c | 8 +++ src/oceanic_atom2.c | 128 ++++++++++++++++++++++++++++++++++ src/oceanic_atom2.h | 2 + 3 files changed, 138 insertions(+) diff --git a/examples/oceanic_atom2_test.c b/examples/oceanic_atom2_test.c index e2d0710..4903ce1 100644 --- a/examples/oceanic_atom2_test.c +++ b/examples/oceanic_atom2_test.c @@ -44,6 +44,14 @@ int test_dump_memory (const char* name, const char* filename) fclose (fp); } + message ("oceanic_atom2_read_dives\n"); + rc = oceanic_atom2_read_dives (device, NULL, NULL); + if (rc != OCEANIC_SUCCESS) { + WARNING ("Cannot read dives."); + oceanic_atom2_close (device); + return rc; + } + message ("oceanic_atom2_close\n"); rc = oceanic_atom2_close (device); if (rc != OCEANIC_SUCCESS) { diff --git a/src/oceanic_atom2.c b/src/oceanic_atom2.c index 6f87b81..c396756 100644 --- a/src/oceanic_atom2.c +++ b/src/oceanic_atom2.c @@ -5,6 +5,7 @@ #include "oceanic.h" #include "serial.h" #include "utils.h" +#include "ringbuffer.h" #define MAXRETRIES 2 @@ -13,6 +14,22 @@ message ("%s:%d: %s\n", __FILE__, __LINE__, expr); \ } +#define RB_LOGBOOK_EMPTY 0x0230 +#define RB_LOGBOOK_BEGIN 0x0240 +#define RB_LOGBOOK_END 0x0A40 +#define RB_LOGBOOK_DISTANCE(a,b) ringbuffer_distance (a, b, RB_LOGBOOK_BEGIN, RB_LOGBOOK_END) + +#define RB_PROFILE_EMPTY 0x0A40 +#define RB_PROFILE_BEGIN 0x0A50 +#define RB_PROFILE_END 0xFFF0 +#define RB_PROFILE_DISTANCE(a,b) ringbuffer_distance (a, b, RB_PROFILE_BEGIN, RB_PROFILE_END) + +#define PT_LOGBOOK_FIRST(x) ( (x)[4] + ((x)[5] << 8) ) +#define PT_LOGBOOK_LAST(x) ( (x)[6] + ((x)[7] << 8) ) + +#define PT_PROFILE_FIRST(x) ( (x)[5] + (((x)[6] & 0x0F) << 8) ) +#define PT_PROFILE_LAST(x) ( ((x)[6] >> 4) + ((x)[7] << 4) ) + struct atom2 { struct serial *port; @@ -249,3 +266,114 @@ oceanic_atom2_read_memory (atom2 *device, unsigned int address, unsigned char da return OCEANIC_SUCCESS; } + + +static int +oceanic_atom2_read_ringbuffer (atom2 *device, unsigned int address, unsigned char data[], unsigned int size, unsigned int begin, unsigned int end) +{ + assert (address >= begin && address < end); + assert (size <= end - begin); + + if (address + size > end) { + unsigned int a = end - address; + unsigned int b = size - a; + + int rc = oceanic_atom2_read_memory (device, address, data, a); + if (rc != OCEANIC_SUCCESS) + return rc; + + rc = oceanic_atom2_read_memory (device, begin, data + a, b); + if (rc != OCEANIC_SUCCESS) + return rc; + } else { + int rc = oceanic_atom2_read_memory (device, address, data, size); + if (rc != OCEANIC_SUCCESS) + return rc; + } + + return OCEANIC_SUCCESS; +} + + +int +oceanic_atom2_read_dives (atom2 *device, dive_callback_t callback, void *userdata) +{ + if (device == NULL) + return OCEANIC_ERROR; + + // Read the pointer data. + unsigned char pointers[OCEANIC_ATOM2_PACKET_SIZE] = {0}; + int rc = oceanic_atom2_read_memory (device, 0x0040, pointers, OCEANIC_ATOM2_PACKET_SIZE); + if (rc != OCEANIC_SUCCESS) { + WARNING ("Cannot read pointers."); + return rc; + } + + // Get the logbook pointers. + unsigned int logbook_first = PT_LOGBOOK_FIRST (pointers); + unsigned int logbook_last = PT_LOGBOOK_LAST (pointers); + message ("logbook: first=%04x, last=%04x\n", logbook_first, logbook_last); + + // Calculate the total number of logbook entries. + // In a typical ringbuffer implementation (with only two pointers), + // there is no distinction between an empty and a full ringbuffer. + // However, the ATOM2 sets the pointers to a fixed (invalid) value + // to indicate an empty buffer. With this knowledge, we can detect + // the difference between both cases correctly. + if (logbook_first == RB_LOGBOOK_EMPTY && logbook_last == RB_LOGBOOK_EMPTY) + return OCEANIC_SUCCESS; + + unsigned int logbook_count = RB_LOGBOOK_DISTANCE (logbook_first, logbook_last) / + (OCEANIC_ATOM2_PACKET_SIZE / 2) + 1; + message ("logbook: count=%u\n", logbook_count); + + // Align the pointers to the packet size. + unsigned int logbook_page_offset = logbook_first % OCEANIC_ATOM2_PACKET_SIZE; + unsigned int logbook_page_first = (logbook_first / OCEANIC_ATOM2_PACKET_SIZE) * OCEANIC_ATOM2_PACKET_SIZE; + unsigned int logbook_page_last = (logbook_last / OCEANIC_ATOM2_PACKET_SIZE) * OCEANIC_ATOM2_PACKET_SIZE; + unsigned int logbook_page_len = RB_LOGBOOK_DISTANCE (logbook_page_first, logbook_page_last) + OCEANIC_ATOM2_PACKET_SIZE; + message ("logbook: first=%04x, last=%04x, len=%u, offset=%u\n", + logbook_page_first, logbook_page_last, logbook_page_len, logbook_page_offset); + + // Read the logbook data. + unsigned char logbooks[RB_LOGBOOK_END - RB_LOGBOOK_BEGIN] = {0}; + rc = oceanic_atom2_read_ringbuffer (device, logbook_page_first, logbooks, logbook_page_len, RB_LOGBOOK_BEGIN, RB_LOGBOOK_END); + if (rc != OCEANIC_SUCCESS) { + WARNING ("Cannot read dive logbooks."); + return rc; + } + + // Traverse the logbook ringbuffer backwards to retrieve the most recent + // dives first. The logbook ringbuffer is linearized at this point, so + // we do not have to take into account any memory wrapping near the end + // of the memory buffer. + unsigned char *current = logbooks + logbook_page_offset + (logbook_count - 1) * (OCEANIC_ATOM2_PACKET_SIZE / 2); + for (unsigned int i = 0; i < logbook_count; ++i) { + message ("logbook: index=%u\n", i); + + // Get the profile pointers. + unsigned int profile_first = PT_PROFILE_FIRST (current) * OCEANIC_ATOM2_PACKET_SIZE; + unsigned int profile_last = PT_PROFILE_LAST (current) * OCEANIC_ATOM2_PACKET_SIZE; + unsigned int profile_len = RB_PROFILE_DISTANCE (profile_first, profile_last) + OCEANIC_ATOM2_PACKET_SIZE; + message ("profile: first=%04x, last=%04x, len=%u\n", profile_first, profile_last, profile_len); + + // Read the profile data. + unsigned char profile[RB_PROFILE_END - RB_PROFILE_BEGIN + 8] = {0}; + rc = oceanic_atom2_read_ringbuffer (device, profile_first, profile + 8, profile_len, RB_PROFILE_BEGIN, RB_PROFILE_END); + if (rc != OCEANIC_SUCCESS) { + WARNING ("Cannot read dive profiles."); + return rc; + } + + // Copy the logbook data to the profile. + memcpy (profile, current, 8); + + if (callback) + callback (profile, profile_len + 8, userdata); + + // Advance to the next logbook entry. + current -= (OCEANIC_ATOM2_PACKET_SIZE / 2); + } + + return OCEANIC_SUCCESS; +} diff --git a/src/oceanic_atom2.h b/src/oceanic_atom2.h index 27ae260..3749df4 100644 --- a/src/oceanic_atom2.h +++ b/src/oceanic_atom2.h @@ -18,6 +18,8 @@ int oceanic_atom2_read_version (atom2 *device, unsigned char data[], unsigned in int oceanic_atom2_read_memory (atom2 *device, unsigned int address, unsigned char data[], unsigned int size); +int oceanic_atom2_read_dives (atom2 *device, dive_callback_t callback, void *userdata); + #ifdef __cplusplus } #endif /* __cplusplus */