/* keyvalue "key" "value"
* so we have two strings (possibly empty) in the membuffer, separated by a '\0' */
static void parse_dc_keyvalue(char *line, struct membuffer *str, void *_dc)
{
const char *key, *value;
struct divecomputer *dc = _dc;
// Let's make sure we have two strings...
int string_counter = 0;
while(*line) {
if (*line == '"')
string_counter++;
line++;
}
if (string_counter != 2)
return;
// stupidly the second string in the membuffer isn't NUL terminated;
// asking for a cstring fixes that; interestingly enough, given that there are two
// strings in the mb, the next command at the same time assigns a pointer to the
// first string to 'key' and NUL terminates the second string (which then goes to 'value')
key = mb_cstring(str);
value = key + strlen(key) + 1;
add_extra_data(dc, key, value);
}
int parse_txt_file(const char *filename, const char *csv)
{
struct memblock memtxt, memcsv;
if (readfile(filename, &memtxt) < 0) {
return report_error(translate("gettextFromC", "Failed to read '%s'"), filename);
}
/*
* MkVI stores some information in .txt file but the whole profile and events are stored in .csv file. First
* make sure the input .txt looks like proper MkVI file, then start parsing the .csv.
*/
if (MATCH(memtxt.buffer, "MkVI_Config") == 0) {
int d, m, y, he;
int hh = 0, mm = 0, ss = 0;
int prev_depth = 0, cur_sampletime = 0, prev_setpoint = -1, prev_ndl = -1;
bool has_depth = false, has_setpoint = false, has_ndl = false;
char *lineptr, *key, *value;
int cur_cylinder_index = 0;
unsigned int prev_time = 0;
struct dive *dive;
struct divecomputer *dc;
struct tm cur_tm;
value = parse_mkvi_value(memtxt.buffer, "Dive started at");
if (sscanf(value, "%d-%d-%d %d:%d:%d", &y, &m, &d, &hh, &mm, &ss) != 6) {
free(value);
return -1;
}
free(value);
cur_tm.tm_year = y;
cur_tm.tm_mon = m - 1;
cur_tm.tm_mday = d;
cur_tm.tm_hour = hh;
cur_tm.tm_min = mm;
cur_tm.tm_sec = ss;
dive = alloc_dive();
dive->when = utc_mktime(&cur_tm);;
dive->dc.model = strdup("Poseidon MkVI Discovery");
value = parse_mkvi_value(memtxt.buffer, "Rig Serial number");
dive->dc.deviceid = atoi(value);
free(value);
dive->dc.divemode = CCR;
dive->dc.no_o2sensors = 2;
dive->cylinder[cur_cylinder_index].cylinder_use = OXYGEN;
dive->cylinder[cur_cylinder_index].type.size.mliter = 3000;
dive->cylinder[cur_cylinder_index].type.workingpressure.mbar = 200000;
dive->cylinder[cur_cylinder_index].type.description = strdup("3l Mk6");
dive->cylinder[cur_cylinder_index].gasmix.o2.permille = 1000;
cur_cylinder_index++;
dive->cylinder[cur_cylinder_index].cylinder_use = DILUENT;
dive->cylinder[cur_cylinder_index].type.size.mliter = 3000;
dive->cylinder[cur_cylinder_index].type.workingpressure.mbar = 200000;
dive->cylinder[cur_cylinder_index].type.description = strdup("3l Mk6");
value = parse_mkvi_value(memtxt.buffer, "Helium percentage");
he = atoi(value);
free(value);
value = parse_mkvi_value(memtxt.buffer, "Nitrogen percentage");
dive->cylinder[cur_cylinder_index].gasmix.o2.permille = (100 - atoi(value) - he) * 10;
free(value);
dive->cylinder[cur_cylinder_index].gasmix.he.permille = he * 10;
cur_cylinder_index++;
lineptr = strstr(memtxt.buffer, "Dive started at");
while (!empty_string(lineptr) && (lineptr = strchr(lineptr, '\n'))) {
++lineptr; // Skip over '\n'
key = next_mkvi_key(lineptr);
if (!key)
break;
value = parse_mkvi_value(lineptr, key);
if (!value) {
free(key);
break;
}
add_extra_data(&dive->dc, key, value);
free(key);
free(value);
}
dc = &dive->dc;
/*
* Read samples from the CSV file. A sample contains all the lines with same timestamp. The CSV file has
* the following format:
*
* timestamp, type, value
*
* And following fields are of interest to us:
*
* 6 sensor1
* 7 sensor2
* 8 depth
* 13 o2 tank pressure
* 14 diluent tank pressure
* 20 o2 setpoint
* 39 water temp
*/
if (readfile(csv, &memcsv) < 0) {
free(dive);
return report_error(translate("gettextFromC", "Poseidon import failed: unable to read '%s'"), csv);
}
lineptr = memcsv.buffer;
for (;;) {
struct sample *sample;
int type;
int value;
int sampletime;
int gaschange = 0;
/* Collect all the information for one sample */
sscanf(lineptr, "%d,%d,%d", &cur_sampletime, &type, &value);
has_depth = false;
has_setpoint = false;
has_ndl = false;
sample = prepare_sample(dc);
/*
* There was a bug in MKVI download tool that resulted in erroneous sample
* times. This fix should work similarly as the vendor's own.
*/
sample->time.seconds = cur_sampletime < 0xFFFF * 3 / 4 ? cur_sampletime : prev_time;
prev_time = sample->time.seconds;
do {
int i = sscanf(lineptr, "%d,%d,%d", &sampletime, &type, &value);
switch (i) {
case 3:
switch (type) {
case 0:
//Mouth piece position event: 0=OC, 1=CC, 2=UN, 3=NC
switch (value) {
case 0:
add_event(dc, cur_sampletime, 0, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "Mouth piece position OC"));
break;
case 1:
add_event(dc, cur_sampletime, 0, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "Mouth piece position CC"));
break;
case 2:
add_event(dc, cur_sampletime, 0, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "Mouth piece position unknown"));
break;
case 3:
add_event(dc, cur_sampletime, 0, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "Mouth piece position not connected"));
break;
}
break;
case 3:
//Power Off event
add_event(dc, cur_sampletime, 0, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "Power off"));
break;
case 4:
//Battery State of Charge in %
#ifdef SAMPLE_EVENT_BATTERY
add_event(dc, cur_sampletime, SAMPLE_EVENT_BATTERY, 0,
value, QT_TRANSLATE_NOOP("gettextFromC", "battery"));
#endif
break;
case 6:
//PO2 Cell 1 Average
add_sample_data(sample, POSEIDON_SENSOR1, value);
break;
case 7:
//PO2 Cell 2 Average
add_sample_data(sample, POSEIDON_SENSOR2, value);
break;
case 8:
//Depth * 2
has_depth = true;
prev_depth = value;
add_sample_data(sample, POSEIDON_DEPTH, value);
break;
//9 Max Depth * 2
//10 Ascent/Descent Rate * 2
case 11:
//Ascent Rate Alert >10 m/s
add_event(dc, cur_sampletime, SAMPLE_EVENT_ASCENT, 0, 0,
QT_TRANSLATE_NOOP("gettextFromC", "ascent"));
break;
case 13:
//O2 Tank Pressure
add_sample_pressure(sample, 0, lrint(value * 1000));
break;
case 14:
//Diluent Tank Pressure
add_sample_pressure(sample, 1, lrint(value * 1000));
break;
//16 Remaining dive time #1?
//17 related to O2 injection
case 20:
//PO2 Setpoint
has_setpoint = true;
prev_setpoint = value;
add_sample_data(sample, POSEIDON_SETPOINT, value);
break;
case 22:
//End of O2 calibration Event: 0 = OK, 2 = Failed, rest of dive setpoint 1.0
if (value == 2)
add_event(dc, cur_sampletime, 0, SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "O₂ calibration failed"));
add_event(dc, cur_sampletime, 0, SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "O₂ calibration"));
break;
case 25:
//25 Max Ascent depth
add_sample_data(sample, POSEIDON_CEILING, value);
break;
case 31:
//Start of O2 calibration Event
add_event(dc, cur_sampletime, 0, SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "O₂ calibration"));
break;
case 37:
//Remaining dive time #2?
has_ndl = true;
prev_ndl = value;
add_sample_data(sample, POSEIDON_NDL, value);
break;
case 39:
// Water Temperature in Celcius
add_sample_data(sample, POSEIDON_TEMP, value);
break;
case 85:
//He diluent part in %
gaschange += value << 16;
break;
case 86:
//O2 diluent part in %
gaschange += value;
break;
//239 Unknown, maybe PO2 at sensor validation?
//240 Unknown, maybe PO2 at sensor validation?
//247 Unknown, maybe PO2 Cell 1 during pressure test
//248 Unknown, maybe PO2 Cell 2 during pressure test
//250 PO2 Cell 1
//251 PO2 Cell 2
default:
break;
} /* sample types */
break;
case EOF:
break;
default:
printf("Unable to parse input: %s\n", lineptr);
break;
}
lineptr = strchr(lineptr, '\n');
if (!lineptr || !*lineptr)
break;
lineptr++;
/* Grabbing next sample time */
sscanf(lineptr, "%d,%d,%d", &cur_sampletime, &type, &value);
} while (sampletime == cur_sampletime);
if (gaschange)
add_event(dc, cur_sampletime, SAMPLE_EVENT_GASCHANGE2, 0, gaschange,
QT_TRANSLATE_NOOP("gettextFromC", "gaschange"));
if (!has_depth)
add_sample_data(sample, POSEIDON_DEPTH, prev_depth);
if (!has_setpoint && prev_setpoint >= 0)
add_sample_data(sample, POSEIDON_SETPOINT, prev_setpoint);
if (!has_ndl && prev_ndl >= 0)
add_sample_data(sample, POSEIDON_NDL, prev_ndl);
finish_sample(dc);
if (!lineptr || !*lineptr)
break;
}
record_dive(dive);
return 1;
} else {
return 0;
}
return 0;
}
/*
* OSTCTools stores the raw dive data in heavily padded files, one dive
* each file. So it's not necessary to iterate once and again on a parsing
* function. Actually there's only one kind of archive for every DC model.
*/
void ostctools_import(const char *file, struct dive_table *divetable)
{
FILE *archive;
device_data_t *devdata = calloc(1, sizeof(device_data_t));
dc_family_t dc_fam;
unsigned char *buffer = calloc(65536, 1), *uc_tmp;
char *tmp;
struct dive *ostcdive = alloc_dive();
dc_status_t rc = 0;
int model, ret, i = 0;
unsigned int serial;
struct extra_data *ptr;
// Open the archive
if ((archive = subsurface_fopen(file, "rb")) == NULL) {
report_error(translate("gettextFromC", "Failed to read '%s'"), file);
free(ostcdive);
goto out;
}
// Read dive number from the log
uc_tmp = calloc(2, 1);
fseek(archive, 258, 0);
fread(uc_tmp, 1, 2, archive);
ostcdive->number = uc_tmp[0] + (uc_tmp[1] << 8);
free(uc_tmp);
// Read device's serial number
uc_tmp = calloc(2, 1);
fseek(archive, 265, 0);
fread(uc_tmp, 1, 2, archive);
serial = uc_tmp[0] + (uc_tmp[1] << 8);
free(uc_tmp);
// Read dive's raw data, header + profile
fseek(archive, 456, 0);
while (!feof(archive)) {
fread(buffer + i, 1, 1, archive);
if (buffer[i] == 0xFD && buffer[i - 1] == 0xFD)
break;
i++;
}
// Try to determine the dc family based on the header type
if (buffer[2] == 0x20 || buffer[2] == 0x21) {
dc_fam = DC_FAMILY_HW_OSTC;
} else {
switch (buffer[8]) {
case 0x22:
dc_fam = DC_FAMILY_HW_FROG;
break;
case 0x23:
dc_fam = DC_FAMILY_HW_OSTC3;
break;
default:
report_error(translate("gettextFromC", "Unknown DC in dive %d"), ostcdive->number);
free(ostcdive);
fclose(archive);
goto out;
}
}
// Try to determine the model based on serial number
switch (dc_fam) {
case DC_FAMILY_HW_OSTC:
if (serial > 7000)
model = 3; //2C
else if (serial > 2048)
model = 2; //2N
else if (serial > 300)
model = 1; //MK2
else
model = 0; //OSTC
break;
case DC_FAMILY_HW_FROG:
model = 0;
break;
default:
if (serial > 10000)
model = 0x12; //Sport
else
model = 0x0A; //OSTC3
}
// Prepare data to pass to libdivecomputer.
ret = ostc_prepare_data(model, dc_fam, devdata);
if (ret == 0) {
report_error(translate("gettextFromC", "Unknown DC in dive %d"), ostcdive->number);
free(ostcdive);
fclose(archive);
goto out;
}
tmp = calloc(strlen(devdata->vendor) + strlen(devdata->model) + 28, 1);
sprintf(tmp, "%s %s (Imported from OSTCTools)", devdata->vendor, devdata->model);
ostcdive->dc.model = copy_string(tmp);
free(tmp);
// Parse the dive data
rc = libdc_buffer_parser(ostcdive, devdata, buffer, i + 1);
if (rc != DC_STATUS_SUCCESS)
report_error(translate("gettextFromC", "Error - %s - parsing dive %d"), errmsg(rc), ostcdive->number);
// Serial number is not part of the header nor the profile, so libdc won't
// catch it. If Serial is part of the extra_data, and set to zero, remove
// it from the list and add again.
tmp = calloc(12, 1);
sprintf(tmp, "%d", serial);
ostcdive->dc.serial = copy_string(tmp);
free(tmp);
if (ostcdive->dc.extra_data) {
ptr = ostcdive->dc.extra_data;
while (strcmp(ptr->key, "Serial"))
ptr = ptr->next;
if (!strcmp(ptr->value, "0")) {
add_extra_data(&ostcdive->dc, "Serial", ostcdive->dc.serial);
*ptr = *(ptr)->next;
}
} else {
add_extra_data(&ostcdive->dc, "Serial", ostcdive->dc.serial);
}
record_dive_to_table(ostcdive, divetable);
mark_divelist_changed(true);
sort_table(divetable);
fclose(archive);
out:
free(devdata);
free(buffer);
}
/*
* OSTCTools stores the raw dive data in heavily padded files, one dive
* each file. So it's not necesary to iterate once and again on a parsing
* function. Actually there's only one kind of archive for every DC model.
*/
void ostctools_import(const char *file, struct dive_table *divetable)
{
FILE *archive;
device_data_t *devdata = calloc(1, sizeof(device_data_t));
dc_family_t dc_fam;
unsigned char *buffer = calloc(65536, 1),
*tmp;
struct dive *ostcdive = alloc_dive();
dc_status_t rc = 0;
int model = 0, i = 0;
unsigned int serial;
struct extra_data *ptr;
// Open the archive
if ((archive = subsurface_fopen(file, "rb")) == NULL) {
report_error(translate("gettextFromC", "Error: couldn't open the file"));
return;
}
// Read dive number from the log
tmp = calloc(2,1);
fseek(archive, 258, 0);
fread(tmp, 1, 2, archive);
ostcdive->number = tmp[0] + (tmp[1] << 8);
free(tmp);
// Read device's serial number
tmp = calloc(2, 1);
fseek(archive, 265, 0);
fread(tmp, 1, 2, archive);
serial = tmp[0] + (tmp[1] << 8);
free(tmp);
// Read dive's raw data, header + profile
fseek(archive, 456, 0);
while (!feof(archive)) {
fread(buffer+i, 1, 1, archive);
if (buffer[i] == 0xFD && buffer[i-1] == 0xFD)
break;
i++;
}
// Try to determine the dc family based on the header type
switch (buffer[2]) {
case 0x20:
case 0x21:
dc_fam = DC_FAMILY_HW_OSTC;
break;
case 0x22:
dc_fam = DC_FAMILY_HW_FROG;
break;
case 0x23:
dc_fam = DC_FAMILY_HW_OSTC3;
break;
}
// Prepare data to pass to libdivecomputer. OSTC protocol doesn't include
// a model number so will use 0.
ostc_prepare_data(model, dc_fam, devdata);
tmp = calloc(strlen(devdata->vendor)+strlen(devdata->model)+28,1);
sprintf(tmp,"%s %s (Imported from OSTCTools)", devdata->vendor, devdata->model);
ostcdive->dc.model = copy_string(tmp);
free(tmp);
// Parse the dive data
rc = libdc_buffer_parser(ostcdive, devdata, buffer, i+1);
if (rc != DC_STATUS_SUCCESS)
report_error("Libdc returned error -%s- for dive %d", errmsg(rc), ostcdive->number);
// Serial number is not part of the header nor the profile, so libdc won't
// catch it. If Serial is part of the extra_data, and set to zero, remove
// it from the list and add again.
tmp = calloc(12,1);
sprintf(tmp, "%d", serial);
ostcdive->dc.serial = copy_string(tmp);
free(tmp);
ptr = ostcdive->dc.extra_data;
while (strcmp(ptr->key, "Serial"))
ptr = ptr->next;
if (!strcmp(ptr->value, "0")) {
add_extra_data(&ostcdive->dc, "Serial", ostcdive->dc.serial);
*ptr = *(ptr)->next;
}
free(devdata);
free(buffer);
record_dive_to_table(ostcdive, divetable);
mark_divelist_changed(true);
sort_table(divetable);
fclose(archive);
}
