2017-04-27 18:18:03 +00:00
// SPDX-License-Identifier: GPL-2.0
2017-03-11 20:08:31 +00:00
# ifdef __clang__
2016-03-09 18:18:05 +00:00
// Clang has a bug on zero-initialization of C structs.
# pragma clang diagnostic ignored "-Wmissing-field-initializers"
2017-03-11 20:08:31 +00:00
# endif
2016-03-09 18:18:05 +00:00
2011-09-12 16:19:21 +00:00
# include <stdio.h>
2011-11-27 17:10:37 +00:00
# include <unistd.h>
# include <inttypes.h>
2013-10-05 07:29:09 +00:00
# include <string.h>
2013-10-06 15:55:58 +00:00
# include "gettext.h"
2011-09-12 16:50:40 +00:00
# include "dive.h"
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
# include "device.h"
2011-09-12 20:25:05 +00:00
# include "divelist.h"
2011-09-12 16:19:21 +00:00
# include "display.h"
2016-03-06 14:52:55 +00:00
# include <libdivecomputer/version.h>
2016-03-08 01:18:10 +00:00
# include "libdivecomputer.h"
2011-09-15 04:00:49 +00:00
2017-06-28 03:52:12 +00:00
# if !defined(SSRF_LIBDC_VERSION) || SSRF_LIBDC_VERSION < 2
# pragma message "Subsurface requires a reasonably current version of the Subsurface-branch"
# pragma message "of libdivecomputer (at least version 2 of our API)."
2017-06-23 00:53:53 +00:00
# pragma message "Please get it from http: //github.com/Subsurface-divelog/libdc Subsurface-branch"
# endif
2016-07-18 07:18:17 +00:00
//
// If we have an old libdivecomputer, it doesn't
// have the new DC_TANKINFO bits, but just volume
// type information.
//
# ifndef DC_TANKINFO_METRIC
# define DC_TANKINFO_METRIC DC_TANKVOLUME_METRIC
# define DC_TANKINFO_IMPERIAL DC_TANKVOLUME_IMPERIAL
# define DC_TANKINFO_CC_O2 0
# define DC_TANKINFO_CC_DILUENT 0
# endif
2013-12-25 00:26:00 +00:00
char * dumpfile_name ;
char * logfile_name ;
2013-05-20 19:43:33 +00:00
const char * progress_bar_text = " " ;
2017-07-09 19:43:06 +00:00
void ( * progress_callback ) ( const char * text ) = NULL ;
2013-05-20 19:43:33 +00:00
double progress_bar_fraction = 0.0 ;
2012-12-08 22:02:31 +00:00
static int stoptime , stopdepth , ndl , po2 , cns ;
2013-10-05 07:29:09 +00:00
static bool in_deco , first_temp_is_air ;
2016-08-29 21:07:17 +00:00
static int current_gas_index ;
2012-09-20 19:56:42 +00:00
2017-05-30 03:56:42 +00:00
/* logging bits from libdivecomputer */
# ifndef __ANDROID__
# define INFO(context, fmt, ...) fprintf(stderr, "INFO: " fmt "\n", ##__VA_ARGS__)
# define ERROR(context, fmt, ...) fprintf(stderr, "ERROR: " fmt "\n", ##__VA_ARGS__)
# else
# include <android/log.h>
# define INFO(context, fmt, ...) __android_log_print(ANDROID_LOG_DEBUG, __FILE__, "INFO: " fmt "\n", ##__VA_ARGS__)
# define ERROR(context, fmt, ...) __android_log_print(ANDROID_LOG_DEBUG, __FILE__, "ERROR: " fmt "\n", ##__VA_ARGS__)
# endif
2015-04-03 19:33:10 +00:00
/*
* Directly taken from libdivecomputer ' s examples / common . c to improve
* the error messages resulting from libdc ' s return codes
*/
const char * errmsg ( dc_status_t rc )
{
switch ( rc ) {
case DC_STATUS_SUCCESS :
return " Success " ;
case DC_STATUS_UNSUPPORTED :
return " Unsupported operation " ;
case DC_STATUS_INVALIDARGS :
return " Invalid arguments " ;
case DC_STATUS_NOMEMORY :
return " Out of memory " ;
case DC_STATUS_NODEVICE :
return " No device found " ;
case DC_STATUS_NOACCESS :
return " Access denied " ;
case DC_STATUS_IO :
return " Input/output error " ;
case DC_STATUS_TIMEOUT :
return " Timeout " ;
case DC_STATUS_PROTOCOL :
return " Protocol error " ;
case DC_STATUS_DATAFORMAT :
return " Data format error " ;
case DC_STATUS_CANCELLED :
return " Cancelled " ;
default :
return " Unknown error " ;
}
}
2012-06-22 20:37:39 +00:00
static dc_status_t create_parser ( device_data_t * devdata , dc_parser_t * * parser )
2011-09-12 17:27:35 +00:00
{
2012-06-22 20:37:39 +00:00
return dc_parser_new ( parser , devdata - > device ) ;
2011-09-12 17:27:35 +00:00
}
2016-03-10 02:25:30 +00:00
static int parse_gasmixes ( device_data_t * devdata , struct dive * dive , dc_parser_t * parser , unsigned int ngases )
2011-09-12 18:05:32 +00:00
{
2014-08-06 13:19:31 +00:00
static bool shown_warning = false ;
2016-03-10 02:25:30 +00:00
unsigned int i ;
int rc ;
2014-11-09 06:20:59 +00:00
# if DC_VERSION_CHECK(0, 5, 0) && defined(DC_GASMIX_UNKNOWN)
2016-03-10 02:25:30 +00:00
unsigned int ntanks = 0 ;
2014-11-09 06:20:59 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_TANK_COUNT , 0 , & ntanks ) ;
if ( rc = = DC_STATUS_SUCCESS ) {
2017-02-02 09:56:22 +00:00
if ( ntanks & & ntanks < ngases ) {
2014-11-09 06:20:59 +00:00
shown_warning = true ;
2017-02-03 15:32:27 +00:00
report_error ( " Warning: different number of gases (%d) and cylinders (%d) " , ngases , ntanks ) ;
2017-02-02 09:56:22 +00:00
} else if ( ntanks > ngases ) {
shown_warning = true ;
2017-02-03 15:32:27 +00:00
report_error ( " Warning: smaller number of gases (%d) than cylinders (%d). Assuming air. " , ngases , ntanks ) ;
2014-11-09 06:20:59 +00:00
}
}
# endif
2017-02-02 09:56:22 +00:00
bool no_volume = true ;
for ( i = 0 ; i < ngases | | i < ntanks ; i + + ) {
if ( i < ngases ) {
dc_gasmix_t gasmix = { 0 } ;
int o2 , he ;
rc = dc_parser_get_field ( parser , DC_FIELD_GASMIX , i , & gasmix ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED )
return rc ;
if ( i > = MAX_CYLINDERS )
continue ;
2017-03-08 06:41:41 +00:00
o2 = lrint ( gasmix . oxygen * 1000 ) ;
he = lrint ( gasmix . helium * 1000 ) ;
2017-02-02 09:56:22 +00:00
/* Ignore bogus data - libdivecomputer does some crazy stuff */
if ( o2 + he < = O2_IN_AIR | | o2 > 1000 ) {
if ( ! shown_warning ) {
shown_warning = true ;
report_error ( " unlikely dive gas data from libdivecomputer: o2 = %d he = %d " , o2 , he ) ;
}
o2 = 0 ;
2014-08-06 13:19:31 +00:00
}
2017-02-02 09:56:22 +00:00
if ( he < 0 | | o2 + he > 1000 ) {
if ( ! shown_warning ) {
shown_warning = true ;
report_error ( " unlikely dive gas data from libdivecomputer: o2 = %d he = %d " , o2 , he ) ;
}
he = 0 ;
2014-08-06 13:19:31 +00:00
}
2017-02-02 09:56:22 +00:00
dive - > cylinder [ i ] . gasmix . o2 . permille = o2 ;
dive - > cylinder [ i ] . gasmix . he . permille = he ;
} else {
dive - > cylinder [ i ] . gasmix . o2 . permille = 0 ;
dive - > cylinder [ i ] . gasmix . he . permille = 0 ;
2014-06-11 14:15:40 +00:00
}
2012-12-28 16:53:16 +00:00
2014-11-09 06:20:59 +00:00
# if DC_VERSION_CHECK(0, 5, 0) && defined(DC_GASMIX_UNKNOWN)
if ( i < ntanks ) {
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
dc_tank_t tank = { 0 } ;
2014-11-11 09:41:08 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_TANK , i , & tank ) ;
2014-11-09 06:20:59 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
2016-07-18 07:18:17 +00:00
cylinder_t * cyl = dive - > cylinder + i ;
2017-03-08 06:41:41 +00:00
cyl - > type . size . mliter = lrint ( tank . volume * 1000 ) ;
cyl - > type . workingpressure . mbar = lrint ( tank . workpressure * 1000 ) ;
2016-07-18 07:18:17 +00:00
cyl - > cylinder_use = OC_GAS ;
if ( tank . type & DC_TANKINFO_CC_O2 )
cyl - > cylinder_use = OXYGEN ;
if ( tank . type & DC_TANKINFO_CC_DILUENT )
cyl - > cylinder_use = DILUENT ;
if ( tank . type & DC_TANKINFO_IMPERIAL ) {
2015-10-22 11:15:33 +00:00
if ( same_string ( devdata - > model , " Suunto EON Steel " ) ) {
/* Suunto EON Steele gets this wrong. Badly.
* but on the plus side it only supports a few imperial sizes ,
* so let ' s try and guess at least the most common ones .
* First , the pressures are off by a constant factor . WTF ?
* Then we can round the wet sizes so we get to multiples of 10
* for cuft sizes ( as that ' s all that you can enter ) */
2017-03-09 16:07:30 +00:00
dive - > cylinder [ i ] . type . workingpressure . mbar = lrint (
dive - > cylinder [ i ] . type . workingpressure . mbar * 206.843 / 206.7 ) ;
2015-10-22 11:15:33 +00:00
char name_buffer [ 9 ] ;
2017-03-09 16:07:30 +00:00
int rounded_size = lrint ( ml_to_cuft ( gas_volume ( & dive - > cylinder [ i ] ,
dive - > cylinder [ i ] . type . workingpressure ) ) ) ;
2015-10-22 11:15:33 +00:00
rounded_size = ( int ) ( ( rounded_size + 5 ) / 10 ) * 10 ;
switch ( dive - > cylinder [ i ] . type . workingpressure . mbar ) {
case 206843 :
snprintf ( name_buffer , 9 , " AL%d " , rounded_size ) ;
break ;
case 234422 : /* this is wrong - HP tanks tend to be 3440, but Suunto only allows 3400 */
snprintf ( name_buffer , 9 , " HP%d " , rounded_size ) ;
break ;
case 179263 :
snprintf ( name_buffer , 9 , " LP+%d " , rounded_size ) ;
break ;
case 165474 :
snprintf ( name_buffer , 9 , " LP%d " , rounded_size ) ;
break ;
default :
snprintf ( name_buffer , 9 , " %d cuft " , rounded_size ) ;
break ;
}
dive - > cylinder [ i ] . type . description = copy_string ( name_buffer ) ;
2017-03-09 16:07:30 +00:00
dive - > cylinder [ i ] . type . size . mliter = lrint ( cuft_to_l ( rounded_size ) * 1000 /
mbar_to_atm ( dive - > cylinder [ i ] . type . workingpressure . mbar ) ) ;
2015-10-22 11:15:33 +00:00
}
2014-11-09 06:20:59 +00:00
}
if ( tank . gasmix ! = i ) { // we don't handle this, yet
shown_warning = true ;
report_error ( " gasmix %d for tank %d doesn't match " , tank . gasmix , i ) ;
}
}
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
if ( ! IS_FP_SAME ( tank . volume , 0.0 ) )
no_volume = false ;
2015-07-02 13:12:56 +00:00
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
// this new API also gives us the beginning and end pressure for the tank
2017-03-29 11:59:31 +00:00
// normally 0 is not a valid pressure, but for some Uwatec dive computers we
// don't get the actual start and end pressure, but instead a start pressure
// that matches the consumption and an end pressure of always 0
2017-03-30 09:30:23 +00:00
// In order to make this work, we arbitrary shift this up by 30bar so the
// rest of the code treats this as if they were valid values
if ( ! IS_FP_SAME ( tank . beginpressure , 0.0 ) ) {
if ( ! IS_FP_SAME ( tank . endpressure , 0.0 ) ) {
dive - > cylinder [ i ] . start . mbar = lrint ( tank . beginpressure * 1000 ) ;
dive - > cylinder [ i ] . end . mbar = lrint ( tank . endpressure * 1000 ) ;
} else if ( same_string ( devdata - > vendor , " Uwatec " ) ) {
dive - > cylinder [ i ] . start . mbar = lrint ( tank . beginpressure * 1000 + 30000 ) ;
dive - > cylinder [ i ] . end . mbar = 30000 ;
}
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
}
2015-07-02 13:12:56 +00:00
}
2014-11-09 06:20:59 +00:00
# endif
2014-11-09 07:03:10 +00:00
if ( no_volume ) {
2014-11-09 06:20:59 +00:00
/* for the first tank, if there is no tanksize available from the
* dive computer , fill in the default tank information ( if set ) */
2013-11-23 22:54:42 +00:00
fill_default_cylinder ( & dive - > cylinder [ i ] ) ;
2014-11-09 06:20:59 +00:00
}
2015-03-19 12:32:43 +00:00
/* whatever happens, make sure there is a name for the cylinder */
2015-02-09 21:40:17 +00:00
if ( same_string ( dive - > cylinder [ i ] . type . description , " " ) )
dive - > cylinder [ i ] . type . description = strdup ( translate ( " gettextFromC " , " unknown " ) ) ;
2011-09-12 18:05:32 +00:00
}
2012-06-22 20:37:39 +00:00
return DC_STATUS_SUCCESS ;
2011-09-12 18:05:32 +00:00
}
2012-11-24 02:51:27 +00:00
static void handle_event ( struct divecomputer * dc , struct sample * sample , dc_sample_value_t value )
2011-09-12 18:05:32 +00:00
{
2011-09-22 23:55:55 +00:00
int type , time ;
2016-08-29 21:07:17 +00:00
struct event * ev ;
2012-10-21 18:34:11 +00:00
/* we mark these for translation here, but we store the untranslated strings
* and only translate them when they are displayed on screen */
2011-09-12 18:05:32 +00:00
static const char * events [ ] = {
2016-09-21 04:30:18 +00:00
[ SAMPLE_EVENT_NONE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " none " ) ,
[ SAMPLE_EVENT_DECOSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " deco stop " ) ,
[ SAMPLE_EVENT_RBT ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " rbt " ) ,
[ SAMPLE_EVENT_ASCENT ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ascent " ) ,
[ SAMPLE_EVENT_CEILING ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ceiling " ) ,
[ SAMPLE_EVENT_WORKLOAD ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " workload " ) ,
[ SAMPLE_EVENT_TRANSMITTER ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " transmitter " ) ,
[ SAMPLE_EVENT_VIOLATION ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " violation " ) ,
[ SAMPLE_EVENT_BOOKMARK ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " bookmark " ) ,
[ SAMPLE_EVENT_SURFACE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " surface " ) ,
[ SAMPLE_EVENT_SAFETYSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop " ) ,
[ SAMPLE_EVENT_GASCHANGE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " gaschange " ) ,
[ SAMPLE_EVENT_SAFETYSTOP_VOLUNTARY ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop (voluntary) " ) ,
[ SAMPLE_EVENT_SAFETYSTOP_MANDATORY ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop (mandatory) " ) ,
[ SAMPLE_EVENT_DEEPSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " deepstop " ) ,
[ SAMPLE_EVENT_CEILING_SAFETYSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ceiling (safety stop) " ) ,
[ SAMPLE_EVENT_FLOOR ] = QT_TRANSLATE_NOOP3 ( " gettextFromC " , " below floor " , " event showing dive is below deco floor and adding deco time " ) ,
[ SAMPLE_EVENT_DIVETIME ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " divetime " ) ,
[ SAMPLE_EVENT_MAXDEPTH ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " maxdepth " ) ,
[ SAMPLE_EVENT_OLF ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " OLF " ) ,
[ SAMPLE_EVENT_PO2 ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " pO₂ " ) ,
[ SAMPLE_EVENT_AIRTIME ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " airtime " ) ,
[ SAMPLE_EVENT_RGBM ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " rgbm " ) ,
[ SAMPLE_EVENT_HEADING ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " heading " ) ,
[ SAMPLE_EVENT_TISSUELEVEL ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " tissue level warning " ) ,
[ SAMPLE_EVENT_GASCHANGE2 ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " gaschange " ) ,
2011-09-22 23:55:55 +00:00
} ;
const int nr_events = sizeof ( events ) / sizeof ( const char * ) ;
const char * name ;
/*
* Other evens might be more interesting , but for now we just print them out .
*/
type = value . event . type ;
2014-02-28 04:09:57 +00:00
name = QT_TRANSLATE_NOOP ( " gettextFromC " , " invalid event number " ) ;
2016-09-21 04:30:18 +00:00
if ( type < nr_events & & events [ type ] )
2012-10-21 18:34:11 +00:00
name = events [ type ] ;
2016-07-20 06:27:59 +00:00
# ifdef SAMPLE_EVENT_STRING
if ( type = = SAMPLE_EVENT_STRING )
name = value . event . name ;
# endif
2011-09-22 23:55:55 +00:00
time = value . event . time ;
if ( sample )
time + = sample - > time . seconds ;
2016-08-29 21:07:17 +00:00
ev = add_event ( dc , time , type , value . event . flags , value . event . value , name ) ;
if ( event_is_gaschange ( ev ) & & ev - > gas . index > = 0 )
current_gas_index = ev - > gas . index ;
2011-09-22 23:45:28 +00:00
}
Add support for libdivecomputer using DC_SAMPLE_GASMIX
New libdivecomputer versions use DC_SAMPLE_GASMIX to indicate a gas
change (which contains the cylinder index we're changing to) rather than
SAMPLE_EVENT_GASCHANGE*.
Unlike the old GASCHANGE model, and despite the name, DC_SAMPLE_GASMIX
does not actually say what the mix is, it only specifies a cylinder
index. We had already extended SAMPLE_EVENT_GASCHANGE2 to have the
cylinder index in the otherwise unused "flags" field, so this is not all
that different from what we used to do.
And subsurface internally already had the logic that "if we know what
the cylinder index is, take the gas mix from the cylinder data", so
we've already been able to transparently use _either_ the actual gas mix
or the cylinder index to show the event.
But we do want to make it an event rather than some sample data, because
we want to show it as such in the profile. But because we are happy
with just the cylinder index, we'll just translate the DC_SAMPLE_GASMIX
thing to the SAMPLE_EVENT_GASCHANGE2 event, and nothing really changes
for subsurface.
libdivecomputer has made other changes, like indicating the initial
cylinder index with an early DC_SAMPLE_GASMIX report, but we've seen
that before too (in the form of early SAMPLE_EVENT_GASCHANGE events), so
that doesn't really end up changing anything for us either.
HOWEVER, one thing that is worth noticing: do *not* apply this patch and
then use an old libdivecomputer library that sends both the
DC_SAMPLE_GASMIX samples _and_ the deprecated SAMPLE_EVENT_GASCHANGE
events. It will all *work*, but since subsurface will take either,
you'll then get duplicate gas mix events.
It's not like that is in any way fatal, but it might be a bit confusing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-01-03 23:18:03 +00:00
static void handle_gasmix ( struct divecomputer * dc , struct sample * sample , int idx )
{
if ( idx < 0 | | idx > = MAX_CYLINDERS )
return ;
add_event ( dc , sample - > time . seconds , SAMPLE_EVENT_GASCHANGE2 , idx + 1 , 0 , " gaschange " ) ;
current_gas_index = idx ;
}
2011-09-22 23:45:28 +00:00
void
2012-06-22 20:37:39 +00:00
sample_cb ( dc_sample_type_t type , dc_sample_value_t value , void * userdata )
2011-09-22 23:45:28 +00:00
{
2015-08-31 21:23:43 +00:00
static unsigned int nsensor = 0 ;
2012-11-24 02:51:27 +00:00
struct divecomputer * dc = userdata ;
2011-09-12 20:25:05 +00:00
struct sample * sample ;
/*
2012-06-22 20:37:39 +00:00
* We fill in the " previous " sample - except for DC_SAMPLE_TIME ,
2011-09-12 20:25:05 +00:00
* which creates a new one .
*/
2014-02-28 04:09:57 +00:00
sample = dc - > samples ? dc - > sample + dc - > samples - 1 : NULL ;
2011-09-12 18:05:32 +00:00
2013-12-10 23:53:36 +00:00
/*
2014-03-05 20:19:45 +00:00
* Ok , sanity check .
* If first sample is not a DC_SAMPLE_TIME , Allocate a sample for us
*/
2013-12-10 23:53:36 +00:00
if ( sample = = NULL & & type ! = DC_SAMPLE_TIME )
sample = prepare_sample ( dc ) ;
2011-09-12 18:05:32 +00:00
switch ( type ) {
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_TIME :
2015-08-31 21:23:43 +00:00
nsensor = 0 ;
2015-10-25 03:02:08 +00:00
// The previous sample gets some sticky values
// that may have been around from before, even
// if there was no new data
2012-12-05 22:35:49 +00:00
if ( sample ) {
2012-12-31 02:11:01 +00:00
sample - > in_deco = in_deco ;
2012-12-05 22:35:49 +00:00
sample - > ndl . seconds = ndl ;
sample - > stoptime . seconds = stoptime ;
sample - > stopdepth . mm = stopdepth ;
2014-10-19 14:07:07 +00:00
sample - > setpoint . mbar = po2 ;
2012-12-08 22:02:31 +00:00
sample - > cns = cns ;
2012-12-05 22:35:49 +00:00
}
2015-10-25 03:02:08 +00:00
// Create a new sample.
// Mark depth as negative
2012-11-24 02:51:27 +00:00
sample = prepare_sample ( dc ) ;
2011-09-12 20:25:05 +00:00
sample - > time . seconds = value . time ;
2015-10-25 03:02:08 +00:00
sample - > depth . mm = - 1 ;
2012-11-24 02:51:27 +00:00
finish_sample ( dc ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_DEPTH :
2017-03-08 06:41:41 +00:00
sample - > depth . mm = lrint ( value . depth * 1000 ) ;
2011-09-12 18:05:32 +00:00
break ;
Try to sanely download multiple concurrent cylinder pressures
This tries to sanely handle the case of a dive computer reporting
multiple cylinder pressures concurrently.
NOTE! There are various "interesting" situations that this whole issue
brings up:
- some dive computers may report more cylinder pressures than we have
slots for.
Currently we will drop such pressures on the floor if they come for
the same sample, but if they end up being spread across multiple
samples we will end up re-using the slots with different sensor
indexes.
That kind of slot re-use may or may not end up confusing other
subsurface logic - for example, make things believe there was a
cylidner change event.
- some dive computers might send only one sample at a time, but switch
*which* sample they send on a gas switch event. If they also report
the correct sensor number, we'll now start reporting that pressure in
the second slot.
This should all be fine, and is the RightThing(tm) to do, but is
different from what we used to do when we only ever used a single
slot.
- When people actually use multiple sensors, our old save format will
start to need fixing. Right now our save format comes from the CCR
model where the second sensor was always the Oxygen sensor.
We save that pressure fine (except we save it as "o2pressure" - just
an odd historical naming artifact), but we do *not* save the actual
sensor index, because in our traditional format that was always
implicit in the data ("it's the oxygen cylinder").
so while this code hopefully makes our libdivecomputer download do the
right thing, there *will* be further fallout from having multiple
cylinder pressure sensors. We're not done yet.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-07-24 18:55:47 +00:00
case DC_SAMPLE_PRESSURE :
add_sample_pressure ( sample , value . pressure . tank , lrint ( value . pressure . value * 1000 ) ) ;
2011-09-12 18:05:32 +00:00
break ;
Add support for libdivecomputer using DC_SAMPLE_GASMIX
New libdivecomputer versions use DC_SAMPLE_GASMIX to indicate a gas
change (which contains the cylinder index we're changing to) rather than
SAMPLE_EVENT_GASCHANGE*.
Unlike the old GASCHANGE model, and despite the name, DC_SAMPLE_GASMIX
does not actually say what the mix is, it only specifies a cylinder
index. We had already extended SAMPLE_EVENT_GASCHANGE2 to have the
cylinder index in the otherwise unused "flags" field, so this is not all
that different from what we used to do.
And subsurface internally already had the logic that "if we know what
the cylinder index is, take the gas mix from the cylinder data", so
we've already been able to transparently use _either_ the actual gas mix
or the cylinder index to show the event.
But we do want to make it an event rather than some sample data, because
we want to show it as such in the profile. But because we are happy
with just the cylinder index, we'll just translate the DC_SAMPLE_GASMIX
thing to the SAMPLE_EVENT_GASCHANGE2 event, and nothing really changes
for subsurface.
libdivecomputer has made other changes, like indicating the initial
cylinder index with an early DC_SAMPLE_GASMIX report, but we've seen
that before too (in the form of early SAMPLE_EVENT_GASCHANGE events), so
that doesn't really end up changing anything for us either.
HOWEVER, one thing that is worth noticing: do *not* apply this patch and
then use an old libdivecomputer library that sends both the
DC_SAMPLE_GASMIX samples _and_ the deprecated SAMPLE_EVENT_GASCHANGE
events. It will all *work*, but since subsurface will take either,
you'll then get duplicate gas mix events.
It's not like that is in any way fatal, but it might be a bit confusing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-01-03 23:18:03 +00:00
case DC_SAMPLE_GASMIX :
handle_gasmix ( dc , sample , value . gasmix ) ;
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_TEMPERATURE :
2013-11-26 22:11:30 +00:00
sample - > temperature . mkelvin = C_to_mkelvin ( value . temperature ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_EVENT :
2012-11-24 02:51:27 +00:00
handle_event ( dc , sample , value ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_RBT :
Add support for RBT reported sample value
RBT (Remaining Bottom Time) is a value calculated on the fly by some air
integrated divecomputers, for example Uwatec devices. This value is an
estimation based in some heuristic around time function pressure
gradients. This way, RBT would be the time a diver can spend at actual
depth without running out of gas (taking account of ascent, deco, if
required, and rock bottom gas reserve, if set).
Older Uwatec devices just made the calculus and only stored alarm events
if this time value reached zero, but modern devices store the value each
sample, in minutes.
It seems that Suunto Eon Steel is storing RBT values too, in seconds.
Libdivecomputer has supported RBT for a while, but Subsurface just
printed it to stdout and dropped it.
This adds support for RBT value on subsurface sample structure and shows
it in the profile's info box, right under TTS(calc), if selected, where
these two values can be easily compared by humans.
Signed-off-by: Salvador Cuñat <salvador.cunat@gmail.com>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-22 15:02:33 +00:00
sample - > rbt . seconds = ( ! strncasecmp ( dc - > model , " suunto " , 6 ) ) ? value . rbt : value . rbt * 60 ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_HEARTBEAT :
2014-01-17 22:00:28 +00:00
sample - > heartbeat = value . heartbeat ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_BEARING :
2014-06-03 17:21:41 +00:00
sample - > bearing . degrees = value . bearing ;
2011-09-12 18:05:32 +00:00
break ;
2014-11-20 23:04:01 +00:00
# ifdef DEBUG_DC_VENDOR
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_VENDOR :
2012-12-31 01:53:51 +00:00
printf ( " <vendor time='%u:%02u' type= \" %u \" size= \" %u \" > " , FRACTION ( sample - > time . seconds , 60 ) ,
2014-02-28 04:09:57 +00:00
value . vendor . type , value . vendor . size ) ;
2014-11-27 19:55:24 +00:00
for ( int i = 0 ; i < value . vendor . size ; + + i )
2014-02-28 04:09:57 +00:00
printf ( " %02X " , ( ( unsigned char * ) value . vendor . data ) [ i ] ) ;
2011-09-12 18:05:32 +00:00
printf ( " </vendor> \n " ) ;
break ;
2014-11-20 23:04:01 +00:00
# endif
2012-12-08 04:08:29 +00:00
# if DC_VERSION_CHECK(0, 3, 0)
case DC_SAMPLE_SETPOINT :
/* for us a setpoint means constant pO2 from here */
2017-03-08 06:41:41 +00:00
sample - > setpoint . mbar = po2 = lrint ( value . setpoint * 1000 ) ;
2012-12-08 04:08:29 +00:00
break ;
case DC_SAMPLE_PPO2 :
2015-08-31 21:23:43 +00:00
if ( nsensor < 3 )
2017-03-08 06:41:41 +00:00
sample - > o2sensor [ nsensor ] . mbar = lrint ( value . ppo2 * 1000 ) ;
2015-08-31 21:23:43 +00:00
else
report_error ( " %d is more o2 sensors than we can handle " , nsensor ) ;
nsensor + + ;
2015-09-13 17:58:55 +00:00
// Set the amount of detected o2 sensors
if ( nsensor > dc - > no_o2sensors )
dc - > no_o2sensors = nsensor ;
2012-12-08 04:08:29 +00:00
break ;
case DC_SAMPLE_CNS :
2017-03-08 06:41:41 +00:00
sample - > cns = cns = lrint ( value . cns * 100 ) ;
2012-12-08 04:08:29 +00:00
break ;
2012-12-11 15:43:11 +00:00
case DC_SAMPLE_DECO :
if ( value . deco . type = = DC_DECO_NDL ) {
2012-12-31 02:11:01 +00:00
sample - > ndl . seconds = ndl = value . deco . time ;
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2014-01-15 18:54:41 +00:00
sample - > in_deco = in_deco = false ;
2012-12-11 15:43:11 +00:00
} else if ( value . deco . type = = DC_DECO_DECOSTOP | |
value . deco . type = = DC_DECO_DEEPSTOP ) {
2014-01-15 18:54:41 +00:00
sample - > in_deco = in_deco = true ;
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2012-12-31 02:11:01 +00:00
sample - > stoptime . seconds = stoptime = value . deco . time ;
2012-12-29 02:39:01 +00:00
ndl = 0 ;
2012-12-31 02:11:01 +00:00
} else if ( value . deco . type = = DC_DECO_SAFETYSTOP ) {
2014-01-15 18:54:41 +00:00
sample - > in_deco = in_deco = false ;
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2012-12-31 02:11:01 +00:00
sample - > stoptime . seconds = stoptime = value . deco . time ;
2012-12-11 15:43:11 +00:00
}
2012-12-08 04:08:29 +00:00
# endif
2011-09-12 18:05:32 +00:00
default :
break ;
}
}
2012-05-03 00:40:39 +00:00
static void dev_info ( device_data_t * devdata , const char * fmt , . . . )
{
2016-03-07 19:47:26 +00:00
( void ) devdata ;
2013-03-04 01:53:43 +00:00
static char buffer [ 1024 ] ;
2012-05-03 00:40:39 +00:00
va_list ap ;
va_start ( ap , fmt ) ;
vsnprintf ( buffer , sizeof ( buffer ) , fmt , ap ) ;
va_end ( ap ) ;
2012-09-20 19:56:42 +00:00
progress_bar_text = buffer ;
2017-07-09 19:43:06 +00:00
if ( progress_callback )
( * progress_callback ) ( buffer ) ;
2012-05-03 00:40:39 +00:00
}
2011-09-12 18:05:32 +00:00
2012-05-03 00:40:39 +00:00
static int import_dive_number = 0 ;
2012-11-24 02:51:27 +00:00
static int parse_samples ( device_data_t * devdata , struct divecomputer * dc , dc_parser_t * parser )
2011-09-12 18:05:32 +00:00
{
2016-03-07 19:47:26 +00:00
( void ) devdata ;
2011-09-12 18:05:32 +00:00
// Parse the sample data.
2012-11-24 02:51:27 +00:00
return dc_parser_samples_foreach ( parser , sample_cb , dc ) ;
2011-09-12 18:05:32 +00:00
}
2012-12-28 22:12:10 +00:00
static int might_be_same_dc ( struct divecomputer * a , struct divecomputer * b )
{
if ( ! a - > model | | ! b - > model )
return 1 ;
if ( strcasecmp ( a - > model , b - > model ) )
return 0 ;
if ( ! a - > deviceid | | ! b - > deviceid )
return 1 ;
return a - > deviceid = = b - > deviceid ;
}
2012-12-16 18:40:17 +00:00
static int match_one_dive ( struct divecomputer * a , struct dive * dive )
2012-11-25 03:06:06 +00:00
{
2012-12-16 18:40:17 +00:00
struct divecomputer * b = & dive - > dc ;
/*
* Walk the existing dive computer data ,
* see if we have a match ( or an anti - match :
* the same dive computer but a different
* dive ID ) .
*/
do {
int match = match_one_dc ( a , b ) ;
if ( match )
return match > 0 ;
b = b - > next ;
} while ( b ) ;
/* Ok, no exact dive computer match. Does the date match? */
b = & dive - > dc ;
do {
2012-12-28 22:12:10 +00:00
if ( a - > when = = b - > when & & might_be_same_dc ( a , b ) )
2012-12-16 18:40:17 +00:00
return 1 ;
b = b - > next ;
} while ( b ) ;
return 0 ;
2012-11-25 03:06:06 +00:00
}
2011-09-26 20:04:14 +00:00
/*
* Check if this dive already existed before the import
*/
2012-11-25 03:06:06 +00:00
static int find_dive ( struct divecomputer * match )
2011-09-26 20:04:14 +00:00
{
int i ;
2017-05-28 19:25:44 +00:00
for ( i = dive_table . preexisting - 1 ; i > = 0 ; i - - ) {
2011-09-26 20:04:14 +00:00
struct dive * old = dive_table . dives [ i ] ;
2012-12-16 18:40:17 +00:00
if ( match_one_dive ( match , old ) )
2012-11-25 03:06:06 +00:00
return 1 ;
2011-09-26 20:04:14 +00:00
}
return 0 ;
}
2012-11-25 19:44:27 +00:00
/*
* Like g_strdup_printf ( ) , but without the stupid g_malloc / g_free confusion .
* And we limit the string to some arbitrary size .
*/
static char * str_printf ( const char * fmt , . . . )
{
va_list args ;
2013-03-04 01:53:43 +00:00
char buf [ 1024 ] ;
2012-11-25 19:44:27 +00:00
va_start ( args , fmt ) ;
2014-02-28 04:09:57 +00:00
vsnprintf ( buf , sizeof ( buf ) - 1 , fmt , args ) ;
2012-11-25 19:44:27 +00:00
va_end ( args ) ;
2014-02-28 04:09:57 +00:00
buf [ sizeof ( buf ) - 1 ] = 0 ;
2012-11-25 19:44:27 +00:00
return strdup ( buf ) ;
}
/*
* The dive ID for libdivecomputer dives is the first word of the
* SHA1 of the fingerprint , if it exists .
*
* NOTE ! This is byte - order dependent , and I don ' t care .
*/
static uint32_t calculate_diveid ( const unsigned char * fingerprint , unsigned int fsize )
{
uint32_t csum [ 5 ] ;
if ( ! fingerprint | | ! fsize )
return 0 ;
SHA1 ( fingerprint , fsize , ( unsigned char * ) csum ) ;
return csum [ 0 ] ;
}
2014-11-08 13:11:08 +00:00
# ifdef DC_FIELD_STRING
2014-10-22 19:11:12 +00:00
static uint32_t calculate_string_hash ( const char * str )
{
2015-05-28 12:59:08 +00:00
return calculate_diveid ( ( const unsigned char * ) str , strlen ( str ) ) ;
2014-10-22 19:11:12 +00:00
}
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
/*
* Find an existing device ID for this device model and serial number
*/
static void dc_match_serial ( void * _dc , const char * model , uint32_t deviceid , const char * nickname , const char * serial , const char * firmware )
{
2016-06-21 01:44:16 +00:00
( void ) nickname ;
( void ) firmware ;
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
struct divecomputer * dc = _dc ;
if ( ! deviceid )
return ;
2016-09-20 16:10:02 +00:00
if ( ! dc - > model | | ! model | | strcasecmp ( dc - > model , model ) )
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
return ;
2016-09-20 13:39:54 +00:00
if ( ! dc - > serial | | ! serial | | strcasecmp ( dc - > serial , serial ) )
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
return ;
dc - > deviceid = deviceid ;
}
/*
* Set the serial number .
*
* This also sets the device ID by looking for existing devices that
* have that serial number .
*
* If no existing device ID exists , create a new by hashing the serial
* number string .
*/
static void set_dc_serial ( struct divecomputer * dc , const char * serial )
{
dc - > serial = serial ;
call_for_each_dc ( dc , dc_match_serial , false ) ;
if ( ! dc - > deviceid )
dc - > deviceid = calculate_string_hash ( serial ) ;
}
2014-10-22 19:11:12 +00:00
static void parse_string_field ( struct dive * dive , dc_field_string_t * str )
{
// Our dive ID is the string hash of the "Dive ID" string
if ( ! strcmp ( str - > desc , " Dive ID " ) ) {
if ( ! dive - > dc . diveid )
dive - > dc . diveid = calculate_string_hash ( str - > value ) ;
return ;
}
2014-11-22 05:42:00 +00:00
add_extra_data ( & dive - > dc , str - > desc , str - > value ) ;
2014-10-22 19:11:12 +00:00
if ( ! strcmp ( str - > desc , " Serial " ) ) {
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
set_dc_serial ( & dive - > dc , str - > value ) ;
2014-10-22 19:11:12 +00:00
return ;
}
if ( ! strcmp ( str - > desc , " FW Version " ) ) {
2014-11-20 20:28:12 +00:00
dive - > dc . fw_version = strdup ( str - > value ) ;
2014-10-22 19:11:12 +00:00
return ;
}
}
# endif
2017-07-17 23:50:03 +00:00
static dc_status_t libdc_header_parser ( dc_parser_t * parser , device_data_t * devdata , struct dive * dive )
2011-09-12 17:27:35 +00:00
{
2015-04-03 22:44:01 +00:00
dc_status_t rc = 0 ;
2014-02-28 04:09:57 +00:00
dc_datetime_t dt = { 0 } ;
2011-09-12 20:25:05 +00:00
struct tm tm ;
2011-09-12 17:27:35 +00:00
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_datetime ( parser , & dt ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the datetime " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 17:27:35 +00:00
}
2015-04-03 22:44:01 +00:00
2012-11-25 19:44:27 +00:00
dive - > dc . deviceid = devdata - > deviceid ;
2011-09-12 17:27:35 +00:00
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
tm . tm_year = dt . year ;
tm . tm_mon = dt . month - 1 ;
tm . tm_mday = dt . day ;
tm . tm_hour = dt . hour ;
tm . tm_min = dt . minute ;
tm . tm_sec = dt . second ;
dive - > when = dive - > dc . when = utc_mktime ( & tm ) ;
}
2015-04-03 22:44:01 +00:00
2011-09-12 18:05:32 +00:00
// Parse the divetime.
2015-06-22 03:24:07 +00:00
const char * date_string = get_dive_date_c_string ( dive - > when ) ;
dev_info ( devdata , translate ( " gettextFromC " , " Dive %d: %s " ) , import_dive_number , date_string ) ;
free ( ( void * ) date_string ) ;
2011-09-12 18:05:32 +00:00
unsigned int divetime = 0 ;
2014-02-28 04:09:57 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_DIVETIME , 0 , & divetime ) ;
2012-06-22 20:37:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the divetime " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
dive - > dc . duration . seconds = divetime ;
2011-09-12 18:05:32 +00:00
// Parse the maxdepth.
double maxdepth = 0.0 ;
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_MAXDEPTH , 0 , & maxdepth ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the maxdepth " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
2017-03-08 06:41:41 +00:00
dive - > dc . maxdepth . mm = lrint ( maxdepth * 1000 ) ;
2011-09-12 18:05:32 +00:00
2014-11-08 06:45:59 +00:00
# if DC_VERSION_CHECK(0, 5, 0) && defined(DC_GASMIX_UNKNOWN)
// if this is defined then we have a fairly late version of libdivecomputer
// from the 0.5 development cylcle - most likely temperatures and tank sizes
// are supported
// Parse temperatures
double temperature ;
dc_field_type_t temp_fields [ ] = { DC_FIELD_TEMPERATURE_SURFACE ,
DC_FIELD_TEMPERATURE_MAXIMUM ,
DC_FIELD_TEMPERATURE_MINIMUM } ;
for ( int i = 0 ; i < 3 ; i + + ) {
rc = dc_parser_get_field ( parser , temp_fields [ i ] , 0 , & temperature ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing temperature " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2014-11-08 06:45:59 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
switch ( i ) {
case 0 :
dive - > dc . airtemp . mkelvin = C_to_mkelvin ( temperature ) ;
break ;
case 1 : // we don't distinguish min and max water temp here, so take min if given, max otherwise
case 2 :
dive - > dc . watertemp . mkelvin = C_to_mkelvin ( temperature ) ;
break ;
}
2014-11-08 06:45:59 +00:00
}
# endif
2011-09-12 18:05:32 +00:00
// Parse the gas mixes.
unsigned int ngases = 0 ;
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_GASMIX_COUNT , 0 , & ngases ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the gas mix count " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2013-10-03 12:06:12 +00:00
# if DC_VERSION_CHECK(0, 3, 0)
// Check if the libdivecomputer version already supports salinity & atmospheric
dc_salinity_t salinity = {
. type = DC_WATER_SALT ,
2014-02-28 04:09:57 +00:00
. density = SEAWATER_SALINITY / 10.0
2013-10-03 12:06:12 +00:00
} ;
2012-11-10 18:18:10 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_SALINITY , 0 , & salinity ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error obtaining water salinity " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2012-11-10 18:18:10 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
2017-03-08 06:41:41 +00:00
dive - > dc . salinity = lrint ( salinity . density * 10.0 ) ;
2013-10-03 12:06:12 +00:00
2014-02-12 22:11:21 +00:00
double surface_pressure = 0 ;
2013-10-03 12:06:12 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_ATMOSPHERIC , 0 , & surface_pressure ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error obtaining surface pressure " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2013-10-03 12:06:12 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
2017-03-08 06:41:41 +00:00
dive - > dc . surface_pressure . mbar = lrint ( surface_pressure * 1000.0 ) ;
2012-11-25 19:44:05 +00:00
# endif
2012-11-10 18:18:10 +00:00
2014-10-22 19:11:12 +00:00
# ifdef DC_FIELD_STRING
// The dive parsing may give us more device information
int idx ;
for ( idx = 0 ; idx < 100 ; idx + + ) {
dc_field_string_t str = { NULL } ;
rc = dc_parser_get_field ( parser , DC_FIELD_STRING , idx , & str ) ;
if ( rc ! = DC_STATUS_SUCCESS )
break ;
if ( ! str . desc | | ! str . value )
break ;
parse_string_field ( dive , & str ) ;
}
# endif
2014-11-08 13:11:09 +00:00
# if DC_VERSION_CHECK(0, 5, 0) && defined(DC_GASMIX_UNKNOWN)
dc_divemode_t divemode ;
rc = dc_parser_get_field ( parser , DC_FIELD_DIVEMODE , 0 , & divemode ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2017-02-20 09:23:14 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error obtaining dive mode " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2014-11-08 13:11:09 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
switch ( divemode ) {
case DC_DIVEMODE_FREEDIVE :
2015-01-21 07:52:28 +00:00
dive - > dc . divemode = FREEDIVE ;
break ;
2015-01-09 19:01:06 +00:00
case DC_DIVEMODE_GAUGE :
case DC_DIVEMODE_OC : /* Open circuit */
2015-01-10 23:01:15 +00:00
dive - > dc . divemode = OC ;
2015-01-09 19:01:06 +00:00
break ;
case DC_DIVEMODE_CC : /* Closed circuit */
2015-01-10 23:01:15 +00:00
dive - > dc . divemode = CCR ;
2015-01-09 19:01:06 +00:00
break ;
}
2014-11-08 13:11:09 +00:00
# endif
2015-04-03 23:11:35 +00:00
rc = parse_gasmixes ( devdata , dive , parser , ngases ) ;
2015-04-03 22:44:01 +00:00
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the gas mix " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
}
return DC_STATUS_SUCCESS ;
}
/* returns true if we want libdivecomputer's dc_device_foreach() to continue,
* false otherwise */
static int dive_cb ( const unsigned char * data , unsigned int size ,
const unsigned char * fingerprint , unsigned int fsize ,
void * userdata )
{
int rc ;
dc_parser_t * parser = NULL ;
device_data_t * devdata = userdata ;
struct dive * dive = NULL ;
2017-04-24 14:28:06 +00:00
/* reset static data, that is only valid per dive */
ndl = stoptime = stopdepth = po2 = 0 ;
2015-04-03 22:44:01 +00:00
in_deco = false ;
2016-08-29 21:07:17 +00:00
current_gas_index = - 1 ;
2015-04-03 22:44:01 +00:00
rc = create_parser ( devdata , & parser ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
dev_info ( devdata , translate ( " gettextFromC " , " Unable to create parser for %s %s " ) , devdata - > vendor , devdata - > product ) ;
return false ;
}
rc = dc_parser_set_data ( parser , data , size ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
dev_info ( devdata , translate ( " gettextFromC " , " Error registering the data " ) ) ;
2014-03-06 23:36:46 +00:00
goto error_exit ;
2011-09-12 18:05:32 +00:00
}
2015-04-03 22:44:01 +00:00
import_dive_number + + ;
dive = alloc_dive ( ) ;
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
// Fill in basic fields
dive - > dc . model = strdup ( devdata - > model ) ;
dive - > dc . diveid = calculate_diveid ( fingerprint , fsize ) ;
2015-04-03 22:44:01 +00:00
// Parse the dive's header data
rc = libdc_header_parser ( parser , devdata , dive ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
dev_info ( devdata , translate ( " getextFromC " , " Error parsing the header " ) ) ;
goto error_exit ;
}
2011-09-12 18:05:32 +00:00
// Initialize the sample data.
2012-11-24 02:51:27 +00:00
rc = parse_samples ( devdata , & dive - > dc , parser ) ;
2012-06-22 20:37:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Error parsing the samples " ) ) ;
2014-03-06 23:36:46 +00:00
goto error_exit ;
2011-09-12 18:05:32 +00:00
}
2011-09-26 20:04:14 +00:00
/* If we already saw this dive, abort. */
2017-07-09 23:29:16 +00:00
if ( ! devdata - > force_download & & find_dive ( & dive - > dc ) ) {
const char * date_string = get_dive_date_c_string ( dive - > when ) ;
dev_info ( devdata , translate ( " gettextFromC " , " Already downloaded dive at %s " ) , date_string ) ;
2014-03-06 23:36:46 +00:00
goto error_exit ;
2017-07-09 23:29:16 +00:00
}
2014-03-06 23:36:46 +00:00
dc_parser_destroy ( parser ) ;
2011-09-26 20:04:14 +00:00
2013-01-23 02:15:07 +00:00
/* Various libdivecomputer interface fixups */
2015-11-25 20:08:28 +00:00
if ( dive - > dc . airtemp . mkelvin = = 0 & & first_temp_is_air & & dive - > dc . samples ) {
2013-01-23 18:25:31 +00:00
dive - > dc . airtemp = dive - > dc . sample [ 0 ] . temperature ;
2013-01-23 02:15:07 +00:00
dive - > dc . sample [ 0 ] . temperature . mkelvin = 0 ;
}
2014-07-24 20:59:11 +00:00
if ( devdata - > create_new_trip ) {
if ( ! devdata - > trip )
devdata - > trip = create_and_hookup_trip_from_dive ( dive ) ;
else
add_dive_to_trip ( dive , devdata - > trip ) ;
}
2014-01-15 18:54:41 +00:00
dive - > downloaded = true ;
2015-01-09 22:44:38 +00:00
record_dive_to_table ( dive , devdata - > download_table ) ;
2014-01-15 18:54:41 +00:00
mark_divelist_changed ( true ) ;
2014-01-27 19:42:19 +00:00
return true ;
2014-03-06 23:36:46 +00:00
error_exit :
dc_parser_destroy ( parser ) ;
free ( dive ) ;
return false ;
2011-09-12 17:27:35 +00:00
}
2012-11-25 19:44:27 +00:00
/*
* The device ID for libdivecomputer devices is the first 32 - bit word
* of the SHA1 hash of the model / firmware / serial numbers .
*
* NOTE ! This is byte - order - dependent . And I can ' t find it in myself to
* care .
*/
static uint32_t calculate_sha1 ( unsigned int model , unsigned int firmware , unsigned int serial )
{
SHA_CTX ctx ;
uint32_t csum [ 5 ] ;
SHA1_Init ( & ctx ) ;
SHA1_Update ( & ctx , & model , sizeof ( model ) ) ;
SHA1_Update ( & ctx , & firmware , sizeof ( firmware ) ) ;
SHA1_Update ( & ctx , & serial , sizeof ( serial ) ) ;
SHA1_Final ( ( unsigned char * ) csum , & ctx ) ;
return csum [ 0 ] ;
}
2012-05-03 00:40:39 +00:00
2013-01-23 00:54:09 +00:00
/*
* libdivecomputer has returned two different serial numbers for the
* same device in different versions . First it used to just do the four
* bytes as one 32 - bit number , then it turned it into a decimal number
* with each byte giving two digits ( 0 - 99 ) .
*
* The only way we can tell is by looking at the format of the number ,
* so we ' ll just fix it to the first format .
*/
static unsigned int undo_libdivecomputer_suunto_nr_changes ( unsigned int serial )
{
unsigned char b0 , b1 , b2 , b3 ;
/*
* The second format will never have more than 8 decimal
* digits , so do a cheap check first
*/
if ( serial > = 100000000 )
return serial ;
/* The original format seems to be four bytes of values 00-99 */
b0 = ( serial > > 0 ) & 0xff ;
b1 = ( serial > > 8 ) & 0xff ;
b2 = ( serial > > 16 ) & 0xff ;
b3 = ( serial > > 24 ) & 0xff ;
/* Looks like an old-style libdivecomputer serial number */
if ( ( b0 < 100 ) & & ( b1 < 100 ) & & ( b2 < 100 ) & & ( b3 < 100 ) )
return serial ;
/* Nope, it was converted. */
2014-02-28 04:09:57 +00:00
b0 = serial % 100 ;
serial / = 100 ;
b1 = serial % 100 ;
serial / = 100 ;
b2 = serial % 100 ;
serial / = 100 ;
b3 = serial % 100 ;
2013-01-23 00:54:09 +00:00
serial = b0 + ( b1 < < 8 ) + ( b2 < < 16 ) + ( b3 < < 24 ) ;
return serial ;
}
static unsigned int fixup_suunto_versions ( device_data_t * devdata , const dc_event_devinfo_t * devinfo )
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
{
2013-01-23 00:54:09 +00:00
unsigned int serial = devinfo - > serial ;
2013-06-17 22:58:26 +00:00
char serial_nr [ 13 ] = " " ;
char firmware [ 13 ] = " " ;
2013-01-23 00:54:09 +00:00
2013-01-23 02:15:07 +00:00
first_temp_is_air = 1 ;
2013-01-23 00:54:09 +00:00
serial = undo_libdivecomputer_suunto_nr_changes ( serial ) ;
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
2013-06-17 22:58:26 +00:00
if ( serial ) {
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
snprintf ( serial_nr , sizeof ( serial_nr ) , " %02d%02d%02d%02d " ,
2014-02-28 04:09:57 +00:00
( devinfo - > serial > > 24 ) & 0xff ,
( devinfo - > serial > > 16 ) & 0xff ,
( devinfo - > serial > > 8 ) & 0xff ,
( devinfo - > serial > > 0 ) & 0xff ) ;
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
}
2013-06-17 22:58:26 +00:00
if ( devinfo - > firmware ) {
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
snprintf ( firmware , sizeof ( firmware ) , " %d.%d.%d " ,
2014-02-28 04:09:57 +00:00
( devinfo - > firmware > > 16 ) & 0xff ,
( devinfo - > firmware > > 8 ) & 0xff ,
( devinfo - > firmware > > 0 ) & 0xff ) ;
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
}
2013-06-17 22:58:26 +00:00
create_device_node ( devdata - > model , devdata - > deviceid , serial_nr , firmware , " " ) ;
2013-01-23 00:54:09 +00:00
return serial ;
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
}
2012-06-22 20:37:39 +00:00
static void event_cb ( dc_device_t * device , dc_event_type_t event , const void * data , void * userdata )
2011-09-12 16:50:40 +00:00
{
2016-03-07 19:47:26 +00:00
( void ) device ;
2012-06-22 20:37:39 +00:00
const dc_event_progress_t * progress = data ;
const dc_event_devinfo_t * devinfo = data ;
const dc_event_clock_t * clock = data ;
2014-01-07 19:38:36 +00:00
const dc_event_vendor_t * vendor = data ;
2011-10-06 19:08:48 +00:00
device_data_t * devdata = userdata ;
2013-01-23 00:54:09 +00:00
unsigned int serial ;
2011-09-12 17:37:54 +00:00
switch ( event ) {
2012-06-22 20:37:39 +00:00
case DC_EVENT_WAITING :
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Event: waiting for user action " ) ) ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_PROGRESS :
2012-09-20 19:56:42 +00:00
if ( ! progress - > maximum )
break ;
2014-02-28 04:09:57 +00:00
progress_bar_fraction = ( double ) progress - > current / ( double ) progress - > maximum ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_DEVINFO :
2017-07-08 05:19:23 +00:00
if ( dc_descriptor_get_model ( devdata - > descriptor ) ! = devinfo - > model ) {
fprintf ( stderr , " EVENT_DEVINFO gave us the correct detected product (model %d instead of %d) \n " ,
devinfo - > model , dc_descriptor_get_model ( devdata - > descriptor ) ) ;
dc_descriptor_t * better_descriptor = get_descriptor ( dc_descriptor_get_type ( devdata - > descriptor ) , devinfo - > model ) ;
if ( better_descriptor ! = NULL ) {
devdata - > descriptor = better_descriptor ;
devdata - > product = dc_descriptor_get_product ( better_descriptor ) ;
devdata - > vendor = dc_descriptor_get_vendor ( better_descriptor ) ;
devdata - > model = str_printf ( " %s %s " , devdata - > vendor , devdata - > product ) ;
}
}
2017-07-09 22:52:10 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " model=%s firmware=%u serial=%u " ) ,
devdata - > product , devinfo - > firmware , devinfo - > serial ) ;
if ( devdata - > libdc_logfile ) {
fprintf ( devdata - > libdc_logfile , " Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x) \n " ,
devinfo - > model , devinfo - > model ,
devinfo - > firmware , devinfo - > firmware ,
devinfo - > serial , devinfo - > serial ) ;
}
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
/*
* libdivecomputer doesn ' t give serial numbers in the proper string form ,
* so we have to see if we can do some vendor - specific munging .
*/
2013-01-23 00:54:09 +00:00
serial = devinfo - > serial ;
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
if ( ! strcmp ( devdata - > vendor , " Suunto " ) )
2013-01-23 00:54:09 +00:00
serial = fixup_suunto_versions ( devdata , devinfo ) ;
devdata - > deviceid = calculate_sha1 ( devinfo - > model , devinfo - > firmware , serial ) ;
2014-11-20 20:28:12 +00:00
/* really, serial and firmware version are NOT numbers. We'll try to save them here
* in something that might work , but this really needs to be handled with the
* DC_FIELD_STRING interface instead */
2014-12-27 16:27:16 +00:00
devdata - > libdc_serial = devinfo - > serial ;
devdata - > libdc_firmware = devinfo - > firmware ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_CLOCK :
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Event: systime=% " PRId64 " , devtime=%u \n " ) ,
( uint64_t ) clock - > systime , clock - > devtime ) ;
2014-01-07 19:38:36 +00:00
if ( devdata - > libdc_logfile ) {
2014-02-28 04:09:57 +00:00
fprintf ( devdata - > libdc_logfile , " Event: systime=% " PRId64 " , devtime=%u \n " ,
2014-01-07 19:38:36 +00:00
( uint64_t ) clock - > systime , clock - > devtime ) ;
}
break ;
case DC_EVENT_VENDOR :
if ( devdata - > libdc_logfile ) {
fprintf ( devdata - > libdc_logfile , " Event: vendor= " ) ;
for ( unsigned int i = 0 ; i < vendor - > size ; + + i )
fprintf ( devdata - > libdc_logfile , " %02X " , vendor - > data [ i ] ) ;
2014-02-28 04:09:57 +00:00
fprintf ( devdata - > libdc_logfile , " \n " ) ;
2014-01-07 19:38:36 +00:00
}
2011-09-12 17:37:54 +00:00
break ;
default :
break ;
}
2011-09-12 16:50:40 +00:00
}
2014-02-28 04:09:57 +00:00
int import_thread_cancelled ;
2011-09-16 05:58:02 +00:00
2016-03-07 19:47:26 +00:00
static int cancel_cb ( void * userdata )
2011-09-12 16:50:40 +00:00
{
2016-03-07 19:47:26 +00:00
( void ) userdata ;
2011-09-16 05:58:02 +00:00
return import_thread_cancelled ;
2011-09-12 16:50:40 +00:00
}
2012-08-27 22:06:58 +00:00
static const char * do_device_import ( device_data_t * data )
2011-09-12 16:19:21 +00:00
{
2012-06-22 20:37:39 +00:00
dc_status_t rc ;
2012-08-27 22:06:58 +00:00
dc_device_t * device = data - > device ;
2011-09-12 16:50:40 +00:00
Assemble the actual Suunto serial number
It turns out that the serial number returned by libdivecomputer isn't
really the serial number as interpreted by the vendor. Those tend to be
strings, but libdivecomputer gives us a 32bit number.
Some experimenting showed that for the Suunto devies tested the serial
number is encoded in that 32bit number:
It so happens that the Suunto serial number strings are strings that have
all numbers, but they aren't *one* number. They are four bytes
representing two numbers each, and the "23500027" string is actually the
four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has
incorrectly parsed those four bytes as one number, not as the encoded
serial number string it is. So the value 389152795 is actually hex
0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27.
This should be done by libdivecomputer, but hey, in the meantime this at
least shows the concept. And helps test the XML save/restore code.
It depends on the two patches that create the whole "device.c"
infrastructure, of course. With this, my dive file ends up having the
settings section look like this:
<divecomputerid model='Suunto Vyper Air' deviceid='d4629110'
serial='01201094' firmware='1.1.22'/>
<divecomputerid model='Suunto HelO2' deviceid='995dd566'
serial='23500027' firmware='1.0.4'/>
where the format of the firmware version is something I guessed at,
but it was the obvious choice (again, it's byte-based, I'm ignoring
the high byte that is zero for both of my Suuntos).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2013-01-10 00:14:21 +00:00
data - > model = str_printf ( " %s %s " , data - > vendor , data - > product ) ;
2011-09-12 16:50:40 +00:00
// Register the event handler.
2014-01-07 19:38:36 +00:00
int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK | DC_EVENT_VENDOR ;
2012-06-22 20:37:39 +00:00
rc = dc_device_set_events ( device , events , event_cb , data ) ;
2012-08-27 22:06:58 +00:00
if ( rc ! = DC_STATUS_SUCCESS )
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Error registering the event handler. " ) ;
2011-09-12 16:50:40 +00:00
// Register the cancellation handler.
2012-06-22 20:37:39 +00:00
rc = dc_device_set_cancel ( device , cancel_cb , data ) ;
2012-08-27 22:06:58 +00:00
if ( rc ! = DC_STATUS_SUCCESS )
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Error registering the cancellation handler. " ) ;
2011-09-12 16:50:40 +00:00
2013-12-25 00:26:00 +00:00
if ( data - > libdc_dump ) {
2014-02-28 04:09:57 +00:00
dc_buffer_t * buffer = dc_buffer_new ( 0 ) ;
2013-12-23 20:09:33 +00:00
2014-02-28 04:09:57 +00:00
rc = dc_device_dump ( device , buffer ) ;
2014-01-07 14:41:20 +00:00
if ( rc = = DC_STATUS_SUCCESS & & dumpfile_name ) {
2014-02-28 04:09:57 +00:00
FILE * fp = subsurface_fopen ( dumpfile_name , " wb " ) ;
2013-12-23 20:09:33 +00:00
if ( fp ! = NULL ) {
2014-02-28 04:09:57 +00:00
fwrite ( dc_buffer_get_data ( buffer ) , 1 , dc_buffer_get_size ( buffer ) , fp ) ;
fclose ( fp ) ;
2013-12-23 20:09:33 +00:00
}
}
2014-02-28 04:09:57 +00:00
dc_buffer_free ( buffer ) ;
2013-12-23 20:09:33 +00:00
} else {
rc = dc_device_foreach ( device , dive_cb , data ) ;
}
2014-02-26 13:34:16 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
progress_bar_fraction = 0.0 ;
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Dive data import error " ) ;
2014-02-26 13:34:16 +00:00
}
2011-09-12 17:27:35 +00:00
2012-08-27 22:06:58 +00:00
/* All good */
2011-09-16 05:58:02 +00:00
return NULL ;
}
2016-03-07 19:47:26 +00:00
void logfunc ( dc_context_t * context , dc_loglevel_t loglevel , const char * file , unsigned int line , const char * function , const char * msg , void * userdata )
2013-12-23 20:07:13 +00:00
{
2016-03-07 19:47:26 +00:00
( void ) context ;
2014-02-28 04:09:57 +00:00
const char * loglevels [ ] = { " NONE " , " ERROR " , " WARNING " , " INFO " , " DEBUG " , " ALL " } ;
2013-12-23 20:07:13 +00:00
2014-02-28 04:09:57 +00:00
FILE * fp = ( FILE * ) userdata ;
2013-12-23 20:07:13 +00:00
if ( loglevel = = DC_LOGLEVEL_ERROR | | loglevel = = DC_LOGLEVEL_WARNING ) {
fprintf ( fp , " %s: %s [in %s:%d (%s)] \n " , loglevels [ loglevel ] , msg , file , line , function ) ;
} else {
fprintf ( fp , " %s: %s \n " , loglevels [ loglevel ] , msg ) ;
}
}
2013-05-20 19:43:33 +00:00
const char * do_libdivecomputer_import ( device_data_t * data )
2012-08-27 22:06:58 +00:00
{
dc_status_t rc ;
const char * err ;
2013-12-23 20:07:13 +00:00
FILE * fp = NULL ;
2012-08-27 22:06:58 +00:00
import_dive_number = 0 ;
2013-01-23 02:15:07 +00:00
first_temp_is_air = 0 ;
2012-08-27 22:06:58 +00:00
data - > device = NULL ;
data - > context = NULL ;
2014-01-07 14:41:20 +00:00
if ( data - > libdc_log & & logfile_name )
2013-12-25 00:26:00 +00:00
fp = subsurface_fopen ( logfile_name , " w " ) ;
2013-12-23 20:07:13 +00:00
2014-01-07 19:38:36 +00:00
data - > libdc_logfile = fp ;
2012-08-27 22:06:58 +00:00
rc = dc_context_new ( & data - > context ) ;
if ( rc ! = DC_STATUS_SUCCESS )
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Unable to create libdivecomputer context " ) ;
2012-08-27 22:06:58 +00:00
2013-12-23 20:07:13 +00:00
if ( fp ) {
dc_context_set_loglevel ( data - > context , DC_LOGLEVEL_ALL ) ;
dc_context_set_logfunc ( data - > context , logfunc , fp ) ;
}
2014-02-28 04:09:57 +00:00
err = translate ( " gettextFromC " , " Unable to open %s %s (%s) " ) ;
2015-07-06 14:07:34 +00:00
2017-06-18 06:50:37 +00:00
# if defined(SSRF_CUSTOM_IO)
2015-08-20 22:19:45 +00:00
if ( data - > bluetooth_mode ) {
2017-06-18 06:50:37 +00:00
# if defined(BT_SUPPORT) && defined(SSRF_CUSTOM_IO)
Switch over to SSRF_CUSTOM_IO v2
I hate changing the IO interfaces this often, but when I converted the
custom serial interface to the more generic custom IO interface, I
intentionally left the legacy serial operations alone, because I didn't
want to change something I didn't care about.
But it turns out that leaving them with the old calling convention
caused extra problems when converting the bluetooth serial code to have
the BLE GATT packet fall-back, which requires mixing two kinds of
operations.
Also, the packet_open() routine was passed a copy of the 'dc_context_t',
which makes it possible to update the 'dc_custom_io_t' field on the fly
at open time. That makes a lot of chaining operations much simpler,
since now you can chain the 'custom_io_t' at open time and then
libdivecomputer will automatically call the new routines instead of the
old ones.
That dc_context_t availability gets rid of all the
if (device && device->ops)
return device->ops->serial_xyz(..);
hackery inside the rfcomm routines - now we can just at open time do a simple
dc_context_set_custom_io(context, &ble_serial_ops);
to switch things over to the BLE version of the serial code instead.
Finally, SSRF_CUSTOM_IO v2 added an opaque "dc_user_device_t" pointer
argument to the custom_io descriptor, which gets filled in as the
custom_io is registered with the download context. Note that unlike
most opaque pointers, this one is opaque to *libdivecomputer*, and the
type is supposed to be supplied by the user.
We define the "dc_user_device_t" as our old "struct device_data_t",
making it "struct user_device_t" instead. That means that the IO
routines now get passed the device info showing what device they are
supposed to download for.
That, in turn, means that now our BLE GATT open code can take the device
type it opens for into account if it wants to. And it will want to,
since the rules for Shearwater are different from the rules for Suunto,
for example.
NOTE! Because of the interface change with libdivecomputer, this will
need a flag-day again where libdivecomputer and subsurface are updated
together. It may not be the last time, either.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-06-27 18:59:11 +00:00
rc = dc_context_set_custom_io ( data - > context , get_qt_serial_ops ( ) , data ) ;
2015-10-26 13:05:27 +00:00
# endif
2015-08-20 22:19:45 +00:00
# ifdef SERIAL_FTDI
} else if ( ! strcmp ( data - > devname , " ftdi " ) ) {
Switch over to SSRF_CUSTOM_IO v2
I hate changing the IO interfaces this often, but when I converted the
custom serial interface to the more generic custom IO interface, I
intentionally left the legacy serial operations alone, because I didn't
want to change something I didn't care about.
But it turns out that leaving them with the old calling convention
caused extra problems when converting the bluetooth serial code to have
the BLE GATT packet fall-back, which requires mixing two kinds of
operations.
Also, the packet_open() routine was passed a copy of the 'dc_context_t',
which makes it possible to update the 'dc_custom_io_t' field on the fly
at open time. That makes a lot of chaining operations much simpler,
since now you can chain the 'custom_io_t' at open time and then
libdivecomputer will automatically call the new routines instead of the
old ones.
That dc_context_t availability gets rid of all the
if (device && device->ops)
return device->ops->serial_xyz(..);
hackery inside the rfcomm routines - now we can just at open time do a simple
dc_context_set_custom_io(context, &ble_serial_ops);
to switch things over to the BLE version of the serial code instead.
Finally, SSRF_CUSTOM_IO v2 added an opaque "dc_user_device_t" pointer
argument to the custom_io descriptor, which gets filled in as the
custom_io is registered with the download context. Note that unlike
most opaque pointers, this one is opaque to *libdivecomputer*, and the
type is supposed to be supplied by the user.
We define the "dc_user_device_t" as our old "struct device_data_t",
making it "struct user_device_t" instead. That means that the IO
routines now get passed the device info showing what device they are
supposed to download for.
That, in turn, means that now our BLE GATT open code can take the device
type it opens for into account if it wants to. And it will want to,
since the rules for Shearwater are different from the rules for Suunto,
for example.
NOTE! Because of the interface change with libdivecomputer, this will
need a flag-day again where libdivecomputer and subsurface are updated
together. It may not be the last time, either.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-06-27 18:59:11 +00:00
rc = dc_context_set_custom_io ( data - > context , & serial_ftdi_ops , data ) ;
2017-05-30 03:56:42 +00:00
INFO ( 0 , " setting up ftdi ops " ) ;
# else
INFO ( 0 , " FTDI disabled " ) ;
2015-08-20 22:19:45 +00:00
# endif
}
2015-09-09 16:39:12 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( errmsg ( rc ) ) ;
2015-07-06 14:07:34 +00:00
} else {
2015-07-07 18:47:48 +00:00
# else
{
# endif
2015-07-06 14:07:34 +00:00
rc = dc_device_open ( & data - > device , data - > context , data - > descriptor , data - > devname ) ;
2017-05-30 03:56:42 +00:00
INFO ( 0 , " dc_deveice_open error value of %d " , rc ) ;
2015-07-06 14:07:34 +00:00
if ( rc ! = DC_STATUS_SUCCESS & & subsurface_access ( data - > devname , R_OK | W_OK ) ! = 0 )
2017-08-21 15:13:19 +00:00
err = translate ( " gettextFromC " , " Error opening the device %s %s (%s). \n In most cases, in order to debug this issue, a libdivecomputer logfile will be useful. \n You can create this logfile by selecting the corresponding checkbox in the download dialog. " ) ;
2015-07-06 14:07:34 +00:00
}
2012-08-27 22:06:58 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
err = do_device_import ( data ) ;
2013-12-23 20:07:13 +00:00
/* TODO: Show the logfile to the user on error. */
2012-08-27 22:06:58 +00:00
dc_device_close ( data - > device ) ;
2014-12-29 23:25:57 +00:00
data - > device = NULL ;
2015-07-06 14:07:34 +00:00
}
2014-11-12 20:09:57 +00:00
2012-08-27 22:06:58 +00:00
dc_context_free ( data - > context ) ;
2014-12-29 23:25:57 +00:00
data - > context = NULL ;
2013-12-23 20:07:13 +00:00
if ( fp ) {
fclose ( fp ) ;
}
2012-08-27 22:06:58 +00:00
return err ;
}
2015-04-03 22:51:38 +00:00
/*
* Parse data buffers instead of dc devices downloaded data .
* Intended to be used to parse profile data from binary files during import tasks .
* Actually included Uwatec families because of works on datatrak and smartrak logs
* and OSTC families for OSTCTools logs import .
* For others , simply include them in the switch ( check parameters ) .
* Note that dc_descriptor_t in data * must * have been filled using dc_descriptor_iterator ( )
* calls .
*/
dc_status_t libdc_buffer_parser ( struct dive * dive , device_data_t * data , unsigned char * buffer , int size )
{
dc_status_t rc ;
dc_parser_t * parser = NULL ;
2016-12-29 14:41:44 +00:00
switch ( dc_descriptor_get_type ( data - > descriptor ) ) {
2015-04-03 22:51:38 +00:00
case DC_FAMILY_UWATEC_ALADIN :
case DC_FAMILY_UWATEC_MEMOMOUSE :
case DC_FAMILY_UWATEC_SMART :
case DC_FAMILY_UWATEC_MERIDIAN :
case DC_FAMILY_HW_OSTC :
case DC_FAMILY_HW_FROG :
case DC_FAMILY_HW_OSTC3 :
2016-12-29 15:02:02 +00:00
rc = dc_parser_new2 ( & parser , data - > context , data - > descriptor , 0 , 0 ) ;
2015-04-03 22:51:38 +00:00
break ;
2015-04-29 21:47:56 +00:00
default :
report_error ( " Device type not handled! " ) ;
return DC_STATUS_UNSUPPORTED ;
2015-04-03 22:51:38 +00:00
}
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( " Error creating parser. " ) ;
dc_parser_destroy ( parser ) ;
return rc ;
}
rc = dc_parser_set_data ( parser , buffer , size ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( " Error registering the data. " ) ;
dc_parser_destroy ( parser ) ;
return rc ;
}
// Do not parse Aladin/Memomouse headers as they are fakes
// Do not return on error, we can still parse the samples
2016-12-29 14:41:44 +00:00
if ( dc_descriptor_get_type ( data - > descriptor ) ! = DC_FAMILY_UWATEC_ALADIN & & dc_descriptor_get_type ( data - > descriptor ) ! = DC_FAMILY_UWATEC_MEMOMOUSE ) {
2015-04-03 22:51:38 +00:00
rc = libdc_header_parser ( parser , data , dive ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( " Error parsing the dive header data. Dive # %d \n Status = %s " , dive - > number , errmsg ( rc ) ) ;
}
}
rc = dc_parser_samples_foreach ( parser , sample_cb , & dive - > dc ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( " Error parsing the sample data. Dive # %d \n Status = %s " , dive - > number , errmsg ( rc ) ) ;
dc_parser_destroy ( parser ) ;
return rc ;
}
dc_parser_destroy ( parser ) ;
return ( DC_STATUS_SUCCESS ) ;
}
2016-12-28 19:55:52 +00:00
/*
2016-12-28 19:55:53 +00:00
* Returns a dc_descriptor_t structure based on dc model ' s number and family .
*
* That dc_descriptor_t needs to be freed with dc_descriptor_free by the reciver .
2016-12-28 19:55:52 +00:00
*/
2016-12-28 19:55:53 +00:00
dc_descriptor_t * get_descriptor ( dc_family_t type , unsigned int model )
2016-12-28 19:55:52 +00:00
{
2016-12-28 19:55:53 +00:00
dc_descriptor_t * descriptor = NULL , * needle = NULL ;
2016-12-28 19:55:52 +00:00
dc_iterator_t * iterator = NULL ;
dc_status_t rc ;
rc = dc_descriptor_iterator ( & iterator ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
fprintf ( stderr , " Error creating the device descriptor iterator. \n " ) ;
2016-12-28 19:55:53 +00:00
return NULL ;
2016-12-28 19:55:52 +00:00
}
while ( ( dc_iterator_next ( iterator , & descriptor ) ) = = DC_STATUS_SUCCESS ) {
2016-12-28 19:55:53 +00:00
unsigned int desc_model = dc_descriptor_get_model ( descriptor ) ;
dc_family_t desc_type = dc_descriptor_get_type ( descriptor ) ;
if ( model = = desc_model & & type = = desc_type ) {
needle = descriptor ;
2016-12-28 19:55:52 +00:00
break ;
}
dc_descriptor_free ( descriptor ) ;
}
dc_iterator_free ( iterator ) ;
2016-12-28 19:55:53 +00:00
return needle ;
2016-12-28 19:55:52 +00:00
}