Mercurial > public > ostc4
annotate Discovery/Src/logbook.c @ 157:018586760ca7 FlipDisplay
Binaries for beta testing
SPI monitoring active
author | Ideenmodellierer |
---|---|
date | Sun, 03 Mar 2019 19:20:18 +0100 |
parents | e1d66bc78f9a |
children | f23b9055436f |
rev | line source |
---|---|
38 | 1 /** |
2 ****************************************************************************** | |
3 * @copyright heinrichs weikamp | |
4 * @file logbook.c | |
5 * @author heinrichs weikamp gmbh and heinrichs weikamp gmbh | |
6 * @date 22-Apr-2014 | |
7 * @version V0.0.3 | |
8 * @since 03-Feb-2016 | |
9 * @brief Everything about creating and evaluating the logbook | |
10 * without the flash part which is included in externLogbookFlash.c | |
11 * and the USB/Bluetooth part in tComm.c | |
12 * CHANGE V0.0.3 hw: ppO2 sensor values | |
13 * CHANGE V0.0.4 hw: fix event bytes according to hwos_interface.odt dated 160610 in bitbucket hwOS | |
14 * @bug | |
15 * @warning | |
16 @verbatim | |
17 ============================================================================== | |
18 ##### Header ##### | |
19 ============================================================================== | |
20 [..] SLogbookHeader | |
21 The order has changed in comparsion to OSTC3 for perfect alignment | |
22 with 16bit and 32bit. The header is 256kB as well. | |
23 DO NOT rearrange anything but add new data to a second page | |
24 beyond diveHeaderEnd. Use extraPagesWithData to indicate that there is | |
25 data available that was not available in the OSTC3 256KB | |
26 This data will be behind the diveHeaderEnd. DO NOT delete diveHeaderEnd. | |
27 | |
28 [..] SLogbookHeaderOSTC3 | |
29 is the format used by the OSTC3. | |
30 logbook_getHeaderOSTC3() does the job using the global headers in logbook.c | |
31 | |
32 [..] SSmallHeader | |
33 - is the format used by the OSTC3 | |
34 | |
35 [..] Summary | |
36 The header format is not perfect and might be optimized prior to | |
37 releasing the diving computer. For now it is good to be compatible | |
38 with PC software available for checking the content of the logbook | |
39 | |
40 | |
41 @endverbatim | |
42 ****************************************************************************** | |
43 * @attention | |
44 * | |
45 * <h2><center>© COPYRIGHT(c) 2014 heinrichs weikamp</center></h2> | |
46 * | |
47 ****************************************************************************** | |
48 */ | |
49 | |
50 /* Includes ------------------------------------------------------------------*/ | |
51 #include <stdint.h> | |
52 #include <string.h> | |
53 #include "logbook.h" | |
54 //#include "test_vpm.h" | |
55 #include "externLogbookFlash.h" | |
56 #include "data_exchange.h" | |
57 #include "decom.h" | |
58 #include "tHome.h" // for tHome_findNextStop() | |
59 | |
60 /* Private types -------------------------------------------------------------*/ | |
61 | |
62 #define NUM_GASES 5 | |
63 | |
64 #define LOGBOOK_VERSION (0x30) | |
65 #define LOGBOOK_VERSION_OSTC3 (0x24) | |
66 | |
67 typedef struct /* don't forget to adjust void clear_divisor(void) */ | |
68 { | |
69 uint8_t temperature; | |
70 uint8_t deco_ndl; | |
71 uint8_t gradientFactor; | |
72 uint8_t ppo2; | |
73 uint8_t decoplan; | |
74 uint8_t cns; | |
75 uint8_t tank; | |
76 } SDivisor; | |
77 | |
78 /* Exported variables --------------------------------------------------------*/ | |
79 | |
80 /* Private variables ---------------------------------------------------------*/ | |
81 uint8_t data_store[10000]; | |
82 SLogbookHeader header; | |
83 SLogbookHeaderOSTC3 headerOSTC3; | |
84 SLogbookHeaderOSTC3compact headerOSTC3compact; | |
85 SSmallHeader smallHeader; | |
86 SDivisor divisor; | |
87 SDivisor divisorBackup; | |
88 | |
89 /* Private function prototypes -----------------------------------------------*/ | |
90 void clear_divisor(void); | |
91 void logbook_SetAverageDepth(float average_depth_meter); | |
92 void logbook_SetMinTemperature(float min_temperature_celsius); | |
93 void logbook_SetMaxCNS(float max_cns_percentage); | |
94 void logbook_SetCompartmentDesaturation(void); | |
95 void logbook_SetLastStop(float last_stop_depth_bar); | |
96 void logbook_writedata(void * data, int length_byte); | |
97 void logbook_UpdateHeader(void); | |
98 | |
99 /* Exported functions --------------------------------------------------------*/ | |
100 | |
101 /** used by test_vpm.c at the moment */ | |
102 void logbook_EndDive(void) | |
103 { | |
104 ext_flash_close_new_dive_log((uint8_t*) &header); | |
105 } | |
106 | |
107 | |
108 // =============================================================================== | |
109 // logbook_last_totalDiveCount | |
110 /// @brief Fix setting issues | |
111 /// @date 04-April-2016 | |
112 /// | |
113 /// @return diveNumber (totalDiveCounter) of latest log entry, 0 if not a valid header | |
114 // =============================================================================== | |
115 uint16_t logbook_lastDive_diveNumber(void) | |
116 { | |
117 SLogbookHeader tempLogbookHeader; | |
118 if(logbook_getHeader(0, &tempLogbookHeader)) | |
119 { | |
120 return tempLogbookHeader.diveNumber; | |
121 } | |
122 else | |
123 { | |
124 return 0; | |
125 } | |
126 } | |
127 | |
128 | |
129 /** | |
130 ****************************************************************************** | |
131 * @brief logbook_getCurrentHeader. / | |
132 * @author Peter Ryser | |
133 * @version V0.0.1 | |
134 * @date 22-April-2014 | |
135 ****************************************************************************** | |
136 * | |
137 * @return SLogbookHeader*: | |
138 */ | |
139 SLogbookHeader* logbook_getCurrentHeader(void) | |
140 { | |
141 return &header; | |
142 } | |
143 | |
144 /** | |
145 ****************************************************************************** | |
146 * @brief logbook_getHeaderOSTC3. / | |
147 * @author heinrichs weikamp gmbh | |
148 * @version V0.0.1 | |
149 * @date 26-Nov-2014 | |
150 ****************************************************************************** | |
151 * | |
152 * @param StepBackwards : 0 Last lokbook entry, 1 second to last entry, etc. | |
153 * @param SSLogbookHeader* pLogbookHeader: Output found LogbookHeader | |
154 * @return uint8_t : 1 = success | |
155 */ | |
156 /* | |
157 SLogbookHeaderOSTC3 * logbook_getHeaderOSTC3(uint8_t StepBackwards) | |
158 { | |
159 if(!logbook_getHeader(StepBackwards, &header)) | |
160 return 0; | |
161 else | |
162 { | |
163 logbook_build_ostc3header(); | |
164 return &headerOSTC3; | |
165 } | |
166 } | |
167 */ | |
168 | |
169 /** | |
170 ****************************************************************************** | |
171 * @brief logbook_getNumberOfHeaders. / | |
172 * @author heinrichs weikamp gmbh | |
173 * @version V0.0.1 | |
174 * @date 18-May-2016 | |
175 ****************************************************************************** | |
176 * | |
177 * @return uint8_t : number of valid headers (0xFAFA) found. | |
178 */ | |
179 uint8_t logbook_getNumberOfHeaders(void) | |
180 { | |
181 return ext_flash_count_dive_headers(); | |
182 } | |
183 | |
184 | |
185 /** | |
186 ****************************************************************************** | |
187 * @brief logbook_getHeader. / | |
188 * @author Peter Ryser | |
189 * @version V0.0.1 | |
190 * @date 22-April-2014 | |
191 ****************************************************************************** | |
192 * | |
193 * @param StepBackwards : 0 Last lokbook entry, 1 second to last entry, etc. | |
194 * @param SSLogbookHeader* pLogbookHeader: Output found LogbookHeader | |
195 * @return uint8_t : 1 = success | |
196 */ | |
197 uint8_t logbook_getHeader(uint8_t StepBackwards,SLogbookHeader* pLogbookHeader) | |
198 { | |
199 ext_flash_read_dive_header((uint8_t *)pLogbookHeader, StepBackwards); | |
200 if(pLogbookHeader->diveHeaderStart != 0xFAFA) | |
201 return 0; | |
202 else | |
203 return 1; | |
204 } | |
205 | |
206 /** | |
207 ****************************************************************************** | |
208 * @brief logbook_initNewdiveProfile. / | |
209 * creates header and smallHeader from diveState and global Settings | |
210 * and writes new lookboock entry on flash device | |
211 * diveState | |
212 * @author Peter Ryser | |
213 * @version V0.0.1 | |
214 * @date 22-April-2014 | |
215 ****************************************************************************** | |
216 * | |
217 * @param SDiveState* pInfo: Input | |
218 * @param SSettings* pSettings: Input | |
219 */ | |
220 | |
221 void logbook_initNewdiveProfile(const SDiveState* pInfo, SSettings* pSettings) | |
222 { | |
223 RTC_DateTypeDef Sdate; | |
224 RTC_TimeTypeDef Stime; | |
225 | |
226 for(int i = 0; i < sizeof(SLogbookHeader); i++) | |
227 { | |
228 ((uint8_t*)(&header))[i] = 0; | |
229 } | |
230 header.diveHeaderStart = 0xFAFA; | |
231 header.diveHeaderEnd = 0xFBFB; | |
232 header.samplingRate = 2; | |
233 if(pInfo->diveSettings.diveMode == DIVEMODE_OC) | |
234 { | |
235 for(int i = 0; i < 5; i++) | |
236 { | |
237 header.gasordil[i].oxygen_percentage = pSettings->gas[i+1].oxygen_percentage; | |
238 header.gasordil[i].helium_percentage = pSettings->gas[i+1].helium_percentage; | |
239 header.gasordil[i].note.uw = pSettings->gas[i+1].note.uw; | |
240 header.gasordil[i].depth_meter = pSettings->gas[i+1].depth_meter; | |
241 } | |
242 } | |
243 else | |
244 { | |
245 for(int i = 0; i < 5; i++) | |
246 { | |
247 header.gasordil[i].oxygen_percentage = pSettings->gas[i+6].oxygen_percentage; | |
248 header.gasordil[i].helium_percentage = pSettings->gas[i+6].helium_percentage; | |
249 header.gasordil[i].note.uw = pSettings->gas[i+6].note.uw; | |
250 header.gasordil[i].depth_meter = pSettings->gas[i+6].depth_meter; | |
251 } | |
252 | |
253 for(int i = 0; i < 5; i++) | |
254 { | |
255 header.setpoint[i].setpoint_cbar = pSettings->setpoint[i+1].setpoint_cbar; | |
256 header.setpoint[i].depth_meter = pSettings->setpoint[i+1].depth_meter; | |
257 } | |
258 } | |
259 // header.gasordil[pInfo->lifeData.actualGas.GasIdInSettings].depth_meter = 0; | |
260 | |
261 translateDate(pInfo->lifeData.dateBinaryFormat, &Sdate); | |
262 translateTime(pInfo->lifeData.timeBinaryFormat, &Stime); | |
263 header.dateYear = Sdate.Year; | |
264 header.dateMonth = Sdate.Month; | |
265 header.dateDay = Sdate.Date; | |
266 header.timeHour = Stime.Hours; | |
267 header.timeMinute = Stime.Minutes; | |
268 header.cnsAtBeginning = (uint16_t)((pInfo->lifeData.cns * 100) + 0.5f); | |
269 header.surfacePressure_mbar = (uint16_t)(pInfo->lifeData.pressure_surface_bar * 1000); | |
270 header.firmwareVersionHigh = firmwareVersion_16bit_high(); | |
271 header.firmwareVersionLow = firmwareVersion_16bit_low(); | |
272 header.logbookProfileVersion = LOGBOOK_VERSION; | |
273 header.salinity = pSettings->salinity; | |
274 header.diveNumber = pSettings->totalDiveCounter; | |
275 header.personalDiveCount = pSettings->personalDiveCount; | |
276 | |
277 header.diveMode = pInfo->diveSettings.diveMode; | |
278 header.CCRmode = pInfo->diveSettings.CCR_Mode; | |
279 header.lastDecostop_m = pSettings->last_stop_depth_meter; | |
280 | |
281 if(pInfo->diveSettings.deco_type.ub.standard == GF_MODE) | |
282 { | |
283 header.decoModel = 1; | |
284 header.gfLow_or_Vpm_conservatism = pInfo->diveSettings.gf_low; | |
285 header.gfHigh = pInfo->diveSettings.gf_high; | |
286 } | |
287 else | |
288 { | |
289 header.decoModel = 2; | |
290 header.gfLow_or_Vpm_conservatism = pInfo->diveSettings.vpm_conservatism; | |
291 header.gfHigh = 0; | |
292 } | |
293 | |
294 memcpy(header.n2Compartments, pInfo->lifeData.tissue_nitrogen_bar, 64); | |
295 memcpy(header.heCompartments, pInfo->lifeData.tissue_helium_bar, 64); | |
296 | |
297 logbook_SetCompartmentDesaturation(); | |
298 | |
299 ext_flash_start_new_dive_log_and_set_actualPointerSample((uint8_t*)&header); | |
300 | |
301 smallHeader.profileLength[0] = 0xFF; | |
302 smallHeader.profileLength[1] = 0xFF; | |
303 smallHeader.profileLength[2] = 0xFF; | |
304 smallHeader.samplingRate_seconds = 2; | |
305 smallHeader.numDivisors = 7; | |
306 | |
307 smallHeader.tempType = 0; | |
308 smallHeader.tempLength = 2; | |
309 smallHeader.tempDivisor = 6; | |
310 | |
311 smallHeader.deco_ndlType = 1; | |
312 smallHeader.deco_ndlLength = 2; | |
313 smallHeader.deco_ndlDivisor = 6; //= 6; | |
314 | |
315 /* GF in % at actual position */ | |
316 smallHeader.gfType = 2; | |
317 smallHeader.gfLength = 1; | |
318 smallHeader.gfDivisor = 0; //12; | |
319 | |
320 /* 3 Sensors: 8bit ppO2 in 0.01bar, 16bit voltage in 0,1mV */ | |
321 smallHeader.ppo2Type = 3; | |
322 smallHeader.ppo2Length = 9; | |
323 smallHeader.ppo2Divisor = 2; //2 | |
324 | |
325 /* last 15 stops in minutes (last, second_to_last, ... */ | |
326 /* last stop depth is defined in header */ | |
327 smallHeader.decoplanType = 4; | |
328 smallHeader.decoplanLength = 15; | |
329 smallHeader.decoplanDivisor = 12;//12; | |
330 | |
331 smallHeader.cnsType = 5; | |
332 smallHeader.cnsLength = 2; | |
333 smallHeader.cnsDivisor = 12; | |
334 | |
335 smallHeader.tankType = 6; | |
336 smallHeader.tankLength = 0; | |
337 smallHeader.tankDivisor = 0; | |
338 | |
339 logbook_writedata((void *) &smallHeader,sizeof(smallHeader)); | |
340 | |
341 clear_divisor(); | |
342 } | |
343 | |
344 /** | |
345 ****************************************************************************** | |
346 * @brief clear_divisor / clears divisor struct | |
347 * @author Peter Ryser | |
348 * @version V0.0.1 | |
349 * @date 22-April-2014 | |
350 ****************************************************************************** | |
351 * | |
352 */ | |
353 void clear_divisor(void) | |
354 { | |
355 divisor.cns = smallHeader.cnsDivisor - 1; | |
356 divisor.decoplan = smallHeader.decoplanDivisor - 1; | |
357 divisor.deco_ndl = smallHeader.deco_ndlDivisor - 1; | |
358 divisor.gradientFactor = smallHeader.gfDivisor -1 ; | |
359 divisor.ppo2 = smallHeader.ppo2Divisor - 1; | |
360 divisor.tank = smallHeader.tankDivisor - 1; | |
361 divisor.temperature = smallHeader.tempDivisor - 1; | |
362 } | |
363 | |
364 | |
365 /** | |
366 ****************************************************************************** | |
367 * @brief add16. / adds 16 bit variable to 8 bit array | |
368 * @author Peter Ryser | |
369 * @version V0.0.1 | |
370 * @date 22-April-2014 | |
371 ****************************************************************************** | |
372 * | |
373 * @param uint8_t *pos: Output 8 bit array | |
374 * @param uint16_t var: 16 bit variable | |
375 */ | |
376 void addU16(uint8_t *pos, uint16_t var) | |
377 { | |
378 *((uint16_t*)pos) = var; | |
379 } | |
380 | |
381 void addS16(uint8_t *pos, int16_t var) | |
382 { | |
383 *((int16_t*)pos) = var; | |
384 } | |
385 | |
386 /** | |
387 ****************************************************************************** | |
388 * @brief logbook_writeSample. / Writes one logbook sampl | |
389 * @author Peter Ryser | |
390 * @date 22-April-2014 | |
391 * @version V0.0.2 | |
392 * @since 20-June-2016 | |
393 * @bug Deco/NDL Status fixed in V0.0.2 | |
394 | |
395 | |
396 ****************************************************************************** | |
397 * | |
398 * @param SDiveState state: | |
399 */ | |
400 | |
401 void logbook_writeSample(SDiveState state) | |
402 { | |
403 uint8_t sample[256]; | |
404 // int position = 0; | |
405 int length = 0; | |
406 // _Bool bEvent = 0; | |
407 uint8_t nextstopDepthMeter = 0; | |
408 uint16_t nextstopLengthSeconds = 0; | |
409 uint8_t nextstopLengthMinutes = 0; | |
410 bit8_Type eventByte1, eventByte2; | |
411 bit8_Type profileByteFlag; | |
412 int i = 0; | |
413 for(i = 0; i <256 ;i++) | |
414 sample[i] = 0; | |
415 addU16(sample, (uint16_t)(state.lifeData.depth_meter * 100)); | |
416 length += 2; | |
417 sample[2] = 0; | |
418 length++; | |
419 eventByte1.uw = 0; | |
420 eventByte2.uw = 0; | |
421 //uint16_t tmpU16 = 0; | |
130
b7689d9e888a
Minor changes to improved code quality and to eliminate warnings
Ideenmodellierer
parents:
38
diff
changeset
|
422 const SDecoinfo * pDecoinfo; // new hw 160620 |
38 | 423 |
424 //BuildEevntyte 1 | |
425 // sub old 0-3 only one at a time | |
426 if(state.events.manualMarker) | |
427 { | |
428 eventByte1.uw = 6; | |
429 } | |
430 else | |
431 if(state.warnings.decoMissed) | |
432 { | |
433 eventByte1.uw = 2; | |
434 } | |
435 else | |
436 if(state.warnings.ppO2Low) | |
437 { | |
438 eventByte1.uw = 4; | |
439 } | |
440 else | |
441 if(state.warnings.ppO2High) | |
442 { | |
443 eventByte1.uw = 5; | |
444 } | |
445 else | |
446 if(state.warnings.lowBattery) | |
447 { | |
448 eventByte1.uw = 7; | |
449 } | |
450 else | |
451 if(state.warnings.slowWarning) | |
452 { | |
453 eventByte1.uw = 1; | |
454 } | |
455 // sub bit 4 to 7 | |
456 if(state.events.manuelGasSet) | |
457 { | |
458 eventByte1.ub.bit4 = 1; | |
459 } | |
460 if(state.events.gasChange) | |
461 { | |
462 eventByte1.ub.bit5 = 1; | |
463 } | |
464 if(state.events.setpointChange) | |
465 { | |
466 eventByte1.ub.bit6 = 1; | |
467 } | |
468 // sub bit 7 + eventbyte2 | |
469 if(state.events.bailout) | |
470 { | |
471 eventByte1.ub.bit7 = 1; | |
472 eventByte2.ub.bit0 = 1; | |
473 } | |
474 //Add EventByte 1 | |
475 if(eventByte1.uw > 0) | |
476 { | |
477 sample[length] = eventByte1.uw; | |
478 length++; | |
479 } | |
480 if(eventByte2.uw > 0) | |
481 { | |
482 sample[length] = eventByte2.uw; | |
483 length++; | |
484 } | |
485 //Add EventInfos | |
486 if(state.events.manuelGasSet) | |
487 { | |
488 //manual gas in %O2 & %He | |
489 sample[length] = state.events.info_manuelGasSetO2; | |
490 length += 1; | |
491 sample[length] = state.events.info_manuelGasSetHe; | |
492 length += 1; | |
493 } | |
494 if(state.events.gasChange) | |
495 { | |
496 //Current gas (gasid) | |
497 sample[length] = state.events.info_GasChange; | |
498 length += 1; | |
499 } | |
500 if(state.events.setpointChange) | |
501 { | |
502 //New setpoint in cbar | |
503 sample[length] = state.events.info_SetpointChange; | |
504 length += 1; | |
505 } | |
506 if(state.events.bailout) | |
507 { | |
508 //bailout gas in % O2 & %He | |
509 sample[length] = state.events.info_bailoutO2; | |
510 length += 1; | |
511 sample[length] = state.events.info_bailoutHe; | |
512 length += 1; | |
513 } | |
514 | |
515 | |
516 if(divisor.temperature == 0) | |
517 { | |
518 divisor.temperature = smallHeader.tempDivisor - 1; | |
519 addS16(&sample[length], (int16_t)((state.lifeData.temperature_celsius * 10.0f) + 0.5f)); | |
520 length += 2; | |
521 } | |
522 else | |
523 { | |
524 divisor.temperature--; | |
525 } | |
526 | |
527 | |
528 if(smallHeader.deco_ndlDivisor > 0) | |
529 { | |
530 if(divisor.deco_ndl == 0) | |
531 { | |
532 divisor.deco_ndl = smallHeader.deco_ndlDivisor - 1; | |
533 | |
534 if(stateUsed->diveSettings.deco_type.ub.standard == GF_MODE) | |
535 pDecoinfo = &stateUsed->decolistBuehlmann; | |
536 else if(stateUsed->diveSettings.deco_type.ub.standard == VPM_MODE) | |
537 pDecoinfo = &stateUsed->decolistVPM; | |
538 else // should not happen as only GF and VPM at the moment | |
539 { | |
540 sample[length] = 0; | |
541 length += 1; | |
542 sample[length] = 0; | |
543 length += 1; | |
544 } | |
545 | |
546 if(pDecoinfo->output_ndl_seconds > 0) | |
547 { | |
548 sample[length] = 0; | |
549 length += 1; | |
550 sample[length] = (uint8_t)pDecoinfo->output_ndl_seconds / 60; | |
551 length += 1; | |
552 } | |
553 else if(pDecoinfo->output_time_to_surface_seconds) | |
554 { | |
555 tHome_findNextStop(pDecoinfo->output_stop_length_seconds, &nextstopDepthMeter, &nextstopLengthSeconds); | |
556 nextstopLengthMinutes = (nextstopLengthSeconds +59 ) / 60; | |
557 | |
558 sample[length] = nextstopDepthMeter; | |
559 length += 1; | |
560 sample[length] = nextstopLengthMinutes; | |
561 length += 1; | |
562 } | |
563 else | |
564 { | |
565 sample[length] = 0; | |
566 length += 1; | |
567 sample[length] = 0; | |
568 length += 1; | |
569 } | |
570 } | |
571 else | |
572 { | |
573 divisor.deco_ndl --; | |
574 } | |
575 } | |
576 | |
577 | |
578 if(smallHeader.ppo2Divisor) | |
579 { | |
580 if(divisor.ppo2 == 0) | |
581 { | |
582 divisor.ppo2 = smallHeader.ppo2Divisor - 1; | |
583 | |
584 for(int i = 0; i <3; i++) | |
585 { | |
586 sample[length] = (uint8_t)(state.lifeData.ppO2Sensor_bar[i] * 100.0f + 0.5f); | |
587 length += 1; | |
588 addU16(&sample[length], (uint16_t)(state.lifeData.sensorVoltage_mV[i] * 10.0f + 0.5f)); | |
589 length += 2; | |
590 } | |
591 } | |
592 else | |
593 { | |
594 divisor.ppo2--; | |
595 } | |
596 } | |
597 | |
598 | |
599 if(smallHeader.decoplanDivisor) | |
600 { | |
601 if(divisor.decoplan == 0) | |
602 { | |
603 divisor.decoplan = smallHeader.decoplanDivisor - 1; | |
604 if(state.diveSettings.deco_type.ub.standard == VPM_MODE) | |
605 { | |
606 for(int i = 0; i <15; i++) | |
607 { | |
608 sample[length] = state.decolistVPM.output_stop_length_seconds[i] / 60; | |
609 length += 1; | |
610 } | |
611 } | |
612 else if(state.diveSettings.deco_type.ub.standard == GF_MODE) | |
613 { | |
614 for(int i = 0; i <15; i++) | |
615 { | |
616 sample[length] = state.decolistBuehlmann.output_stop_length_seconds[i] / 60; | |
617 length += 1; | |
618 } | |
619 } | |
620 else | |
621 { | |
622 for(int i = 0; i <15; i++) | |
623 { | |
624 sample[length] = 0; | |
625 length += 1; | |
626 } | |
627 } | |
628 // add16(&sample[length], state.temperature); | |
629 //length += 2; | |
630 } | |
631 else | |
632 { | |
633 divisor.decoplan --; | |
634 } | |
635 } | |
636 if(divisor.cns == 0) | |
637 { | |
638 divisor.cns = smallHeader.cnsDivisor - 1; | |
639 //addU16(&sample[length], (uint16_t)(state.lifeData.cns * 100.0f + 0.5f)); | |
640 addU16(&sample[length], (uint16_t)(state.lifeData.cns)); // hw 151110 cns is 0 to 100 % and more (not 0 to 1.00 and more) | |
641 length += 2; | |
642 } | |
643 else | |
644 { | |
645 divisor.cns--; | |
646 } | |
647 | |
648 profileByteFlag.uw = length - 3; | |
649 if(eventByte1.uw) | |
650 { | |
651 profileByteFlag.ub.bit7 = 1; | |
652 } | |
653 sample[2] = profileByteFlag.uw; | |
654 logbook_writedata((void *) sample,length); | |
655 | |
656 } | |
657 | |
658 | |
659 | |
660 uint16_t actual_depth1; | |
661 uint16_t actual_depth2; | |
662 uint16_t actual_length1; | |
663 uint16_t actual_length2; | |
664 uint16_t actual_inum; | |
665 | |
666 /** | |
667 ****************************************************************************** | |
668 * @brief readSample. / Reads data of one logbook sample | |
669 * @author Peter Ryser | |
670 * @version V0.0.1 | |
671 * @date 22-April-2014 | |
672 ****************************************************************************** | |
673 * | |
674 * @param int32_t* depth: output Value | |
675 * @param int16_t * gasid: output Value | |
676 * @param int32_t* temperature: output Value | |
677 * @param int32_t* sensor1, sensor2, sensor3: output Value | |
678 * @param int32_t* cns: output Value | |
679 * @return bytes read / 0 = reading Error | |
680 */ | |
681 uint16_t readSample(int32_t* depth, int16_t * gasid, int16_t* setpoint_cbar, int32_t* temperature, int32_t* sensor1, int32_t* sensor2, int32_t* sensor3, int32_t* cns, SManualGas* manualGas, int16_t* bailout, int16_t* decostopDepth) | |
682 { | |
683 int length = 0; | |
684 _Bool bEvent = 0; | |
685 bit8_Type eventByte1, eventByte2; | |
686 bit8_Type profileByteFlag; | |
687 | |
688 eventByte1.uw = 0; | |
689 eventByte2.uw = 0; | |
690 uint8_t tempU8 = 0; | |
691 uint16_t temp = 0; | |
692 uint16_t bytesRead = 0; | |
693 | |
694 if(gasid) | |
695 *gasid = -1; | |
696 if(temperature) | |
697 *temperature = -1000; | |
698 if(sensor1) | |
699 *sensor1 = -1; | |
700 if(sensor2) | |
701 *sensor2 = -1; | |
702 if(sensor3) | |
703 *sensor3 = -1; | |
704 if(cns) | |
705 *cns = -1; | |
706 if(setpoint_cbar) | |
707 *setpoint_cbar = -1; | |
708 if(bailout) | |
709 *bailout = -1; | |
710 if(manualGas) | |
711 { | |
712 manualGas->percentageO2 =-1; | |
713 manualGas->percentageHe =-1; | |
714 } | |
715 if(decostopDepth) | |
716 *decostopDepth = -1; | |
717 | |
718 ext_flash_read_next_sample_part( (uint8_t*)&temp, 2); | |
719 if(depth) | |
720 *depth = (int32_t)temp; | |
721 bytesRead += 2; | |
722 | |
723 ext_flash_read_next_sample_part( &profileByteFlag.uw, 1); | |
724 bytesRead ++; | |
725 | |
726 bEvent = profileByteFlag.ub.bit7; | |
727 profileByteFlag.ub.bit7 = 0; | |
728 length = profileByteFlag.uw; | |
729 | |
730 if(bEvent) | |
731 { | |
732 ext_flash_read_next_sample_part( &eventByte1.uw, 1); | |
733 bytesRead ++; | |
734 | |
735 length--; | |
736 | |
737 //second event byte | |
738 if(eventByte1.ub.bit7) | |
739 { | |
740 ext_flash_read_next_sample_part( &eventByte2.uw, 1); | |
741 bytesRead ++; | |
742 length--; | |
743 } | |
744 else | |
745 { | |
746 eventByte2.uw = 0; | |
747 } | |
748 | |
749 //manual Gas Set | |
750 if( eventByte1.ub.bit4) | |
751 { | |
752 //Evaluate manual Gas | |
753 ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1); | |
754 bytesRead +=1; | |
755 length -= 1; | |
756 manualGas->percentageO2 = tempU8; | |
757 ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1); | |
758 bytesRead +=1; | |
759 length -= 1; | |
760 manualGas->percentageHe = tempU8; | |
761 if(gasid) | |
762 *gasid = 0; | |
763 } | |
764 //gas change | |
765 if( eventByte1.ub.bit5) | |
766 { | |
767 ext_flash_read_next_sample_part( &tempU8, 1); | |
768 bytesRead +=1; | |
769 length -= 1; | |
770 if(gasid) | |
771 *gasid = (uint16_t)tempU8; | |
772 } | |
773 //SetpointChange | |
774 if( eventByte1.ub.bit6) | |
775 { | |
776 ext_flash_read_next_sample_part( &tempU8, 1); | |
777 *setpoint_cbar = tempU8; | |
778 bytesRead +=1; | |
779 length -= 1; | |
780 } | |
781 | |
782 // second event Byte | |
783 //bailout | |
784 if(eventByte2.ub.bit1) | |
785 { | |
786 //evaluate bailout gas Gas | |
787 *bailout = 1; | |
788 | |
789 ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1); | |
790 bytesRead +=1; | |
791 length -= 1; | |
792 manualGas->percentageO2 = tempU8; | |
793 ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1); | |
794 bytesRead +=1; | |
795 length -= 1; | |
796 manualGas->percentageHe = tempU8; | |
797 | |
798 if(gasid) | |
799 *gasid = 0; | |
800 } | |
801 } | |
802 | |
803 if(divisor.temperature == 0) | |
804 { | |
805 divisor.temperature = smallHeader.tempDivisor - 1; | |
806 ext_flash_read_next_sample_part( (uint8_t*)&temp, 2); | |
807 bytesRead +=2; | |
808 length -= 2; | |
809 if(temperature) | |
810 { | |
811 *temperature = (int32_t)temp; | |
812 } | |
813 } | |
814 else | |
815 { | |
816 divisor.temperature--; | |
817 } | |
818 | |
819 if(smallHeader.deco_ndlDivisor > 0) | |
820 { | |
821 if(divisor.deco_ndl == 0) | |
822 { | |
823 divisor.deco_ndl = smallHeader.deco_ndlDivisor - 1; | |
824 ext_flash_read_next_sample_part( &tempU8, 1); | |
825 if(decostopDepth) | |
826 { | |
827 *decostopDepth = tempU8 * 100; | |
828 } | |
829 ext_flash_read_next_sample_part( &tempU8, 1); | |
830 bytesRead += 2; | |
831 length -= 2; | |
832 } | |
833 else | |
834 { | |
835 divisor.deco_ndl--; | |
836 } | |
837 } | |
838 | |
839 if(divisor.ppo2 == 0) | |
840 { | |
841 int32_t ppO2Tmp = 0; | |
842 divisor.ppo2 = smallHeader.ppo2Divisor -1; | |
843 for(int i = 0; i <3 ; i++) | |
844 { | |
845 ext_flash_read_next_sample_part( &tempU8, 1); | |
846 ppO2Tmp += tempU8; | |
847 bytesRead +=1; | |
848 length -= 1; | |
849 ext_flash_read_next_sample_part( (uint8_t*)&temp, 2); | |
850 bytesRead +=2; | |
851 length -= 2; | |
852 if(sensor1 && (i==0)) | |
853 *sensor1 = (((int32_t)tempU8) * 0xFFFF) + temp; | |
854 if(sensor2 && (i==1)) | |
855 *sensor2 = (((int32_t)tempU8) * 0xFFFF) + temp; | |
856 if(sensor3 && (i==2)) | |
857 *sensor3 = (((int32_t)tempU8) * 0xFFFF) + temp; | |
858 } | |
859 } | |
860 else | |
861 { | |
862 divisor.ppo2--; | |
863 } | |
864 | |
865 if(smallHeader.decoplanDivisor > 0) | |
866 { | |
867 if(divisor.decoplan == 0) | |
868 { | |
869 divisor.decoplan = smallHeader.decoplanDivisor - 1; | |
870 for(int i = 0; i <15; i++) | |
871 ext_flash_read_next_sample_part( &tempU8, 1); | |
872 bytesRead += 15; | |
873 length -= 15; | |
874 } | |
875 else | |
876 { | |
877 divisor.decoplan--; | |
878 } | |
879 } | |
880 | |
881 | |
882 | |
883 if(divisor.cns == 0) | |
884 { | |
885 divisor.cns = smallHeader.cnsDivisor - 1; | |
886 | |
887 ext_flash_read_next_sample_part( (uint8_t*)&temp, 2); | |
888 bytesRead +=2; | |
889 length -= 2; | |
890 if(cns) | |
891 { | |
892 *cns = (int32_t)temp; | |
893 } | |
894 } | |
895 else | |
896 { | |
897 divisor.cns--; | |
898 } | |
899 | |
900 if (length != 0) | |
901 return 0; | |
902 | |
903 return bytesRead; | |
904 } | |
905 /** | |
906 ****************************************************************************** | |
907 * @brief logbook_readSampleData. / Reads sample data of whole logbook entry | |
908 * @author Peter Ryser | |
909 * @version V0.0.1 | |
910 * @date 22-April-2014 | |
911 ****************************************************************************** | |
912 * | |
913 * @param uint8_t StepBackwards: witch lookbook entry? | |
914 * @param uint16_t length : maxlength of output arrays | |
915 * @param int32_t* depth : output array | |
916 * @param int16_t * gasid : output array | |
917 * @param int32_t* temperature : output array | |
918 * @param int32_t* ppo2 : output array | |
919 * @param int32_t* cns : output array | |
920 * @return length of output | |
921 */ | |
922 uint16_t logbook_readSampleData(uint8_t StepBackwards, uint16_t length,uint16_t* depth, uint8_t* gasid, int16_t* temperature, uint16_t* ppo2, uint16_t* setpoint, uint16_t* sensor1, uint16_t* sensor2, uint16_t* sensor3, uint16_t* cns, uint8_t* bailout, uint16_t* decostopDepth) | |
923 { | |
924 //Test read | |
925 //SLogbookHeader header; | |
926 | |
927 //logbook_getHeader(&header); | |
928 SLogbookHeader header; | |
929 int iNum; | |
930 int firstgasid = 0; | |
931 int retVal = 0; | |
932 int compression = 0; | |
933 int i; | |
934 // uint32_t diveTime_seconds; | |
935 int32_t depthVal = 0; | |
936 int16_t gasidVal = 0; | |
937 int16_t setPointVal = 0; | |
938 int16_t bailoutVal = 0; | |
939 int16_t bailoutLast = 0; | |
940 uint16_t setPointLast = 0; | |
941 int32_t temperatureVal = 0; | |
942 int32_t sensor1Val = 0; | |
943 int32_t sensor2Val = 0; | |
944 int32_t sensor3Val = 0; | |
945 int32_t sensor1Last = 0; | |
946 int32_t sensor2Last = 0; | |
947 int32_t sensor3Last = 0; | |
948 int32_t cnsVal = 0; | |
949 int32_t depthLast = 0; | |
950 int16_t gasidLast = 0; | |
951 int32_t temperatureLast = 0; | |
952 int32_t temperatureFirst = 0; | |
953 int32_t cnsLast = 0; | |
954 int16_t decostepDepthVal = 0; | |
955 int16_t decostepDepthLast = 0; | |
956 | |
957 SManualGas manualGasVal; | |
958 SManualGas manualGasLast; | |
959 manualGasLast.percentageO2 = 0; | |
960 manualGasLast.percentageHe = 0; | |
961 | |
962 float ambiant_pressure_bar = 0; | |
963 float ppO2 = 0; | |
964 ext_flash_read_dive_header((uint8_t*)&header, StepBackwards); | |
965 for(i = 0;i< 5;i++) | |
966 { | |
967 if(header.gasordil[i].note.ub.first) | |
968 break; | |
969 } | |
970 firstgasid = i + 1; | |
971 if(header.diveMode == DIVEMODE_CCR) | |
972 setPointLast = header.setpoint[0].setpoint_cbar; | |
973 else | |
974 setPointLast = 0; | |
975 //diveTime_seconds = header.diveTime_seconds ; | |
976 for(compression = 1; compression < 100; compression ++) | |
977 { | |
978 if((header.total_diveTime_seconds / header.samplingRate)/compression <= length) | |
979 break; | |
980 } | |
981 | |
982 | |
983 for(i = 0;i< length;i++) | |
984 { | |
985 if(depth) | |
986 depth[i] = 0; | |
987 if(temperature) | |
988 temperature[i] = 0; | |
989 if(gasid) | |
990 gasid[i] = 0; | |
991 if(ppo2) | |
992 ppo2[i] = 0; | |
993 if(setpoint) | |
994 setpoint[i] = 0; | |
995 if(sensor1) | |
996 sensor1[i] = 0; | |
997 if(sensor2) | |
998 sensor2[i] = 0; | |
999 if(sensor3) | |
1000 sensor3[i] = 0; | |
1001 if(cns) | |
1002 cns[i] = 0; | |
1003 } | |
1004 //We start with fist gasid | |
1005 gasidLast = firstgasid; | |
1006 | |
1007 | |
1008 //uint16_t* ppo2, uint16_t* cns# | |
1009 uint32_t totalNumberOfBytes = 0; | |
1010 uint32_t bytesRead = 0; | |
1011 ext_flash_open_read_sample( StepBackwards,&totalNumberOfBytes); | |
1012 ext_flash_read_next_sample_part((uint8_t*)&smallHeader, sizeof(SSmallHeader)); | |
1013 bytesRead += sizeof(SSmallHeader); | |
1014 | |
1015 clear_divisor(); | |
1016 | |
1017 iNum = 0; | |
1018 int counter = 0; | |
1019 temperatureLast = -1000; | |
1020 while ((bytesRead < totalNumberOfBytes) && (iNum < length)) | |
1021 { | |
1022 ext_flash_set_entry_point(); | |
1023 divisorBackup = divisor; | |
1024 retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, &decostepDepthVal); | |
1025 | |
1026 if(retVal == 0) | |
1027 { | |
1028 //Error try to read again!!! | |
1029 ext_flash_reopen_read_sample_at_entry_point(); | |
1030 divisor = divisorBackup; | |
1031 retVal = readSample(&depthVal,&gasidVal,&setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, &decostepDepthVal); | |
1032 | |
1033 if(retVal == 0) | |
1034 break; | |
1035 } | |
1036 bytesRead +=retVal; | |
1037 | |
1038 //if for some variable no new value is in the sample for (z.B. gasidVal = -1), we take the last value | |
1039 if(depthVal == -1) | |
1040 depthVal = depthLast; | |
1041 else | |
1042 depthLast = depthVal; | |
1043 | |
1044 if(gasidVal == -1) | |
1045 gasidVal = gasidLast; | |
1046 else | |
1047 gasidLast = gasidVal; | |
1048 | |
1049 if(temperatureVal == -1000) | |
1050 temperatureVal = temperatureLast; | |
1051 else | |
1052 { | |
1053 if(temperatureLast == -1000) | |
1054 temperatureFirst = temperatureVal; | |
1055 temperatureLast = temperatureVal; | |
1056 } | |
1057 | |
1058 if(setPointVal == -1) | |
1059 setPointVal = setPointLast; | |
1060 else | |
1061 setPointLast = setPointVal; | |
1062 | |
1063 if(sensor1Val == -1) | |
1064 sensor1Val = sensor1Last; | |
1065 else | |
1066 sensor1Last = sensor1Val; | |
1067 | |
1068 if(sensor2Val == -1) | |
1069 sensor2Val = sensor2Last; | |
1070 else | |
1071 sensor2Last = sensor2Val; | |
1072 | |
1073 if(sensor3Val == -1) | |
1074 sensor3Val = sensor3Last; | |
1075 else | |
1076 sensor3Last = sensor3Val; | |
1077 | |
1078 if(cnsVal == -1) | |
1079 cnsVal = cnsLast; | |
1080 else | |
1081 cnsLast = cnsVal; | |
1082 | |
1083 if(manualGasVal.percentageO2 == -1) | |
1084 manualGasVal = manualGasLast; | |
1085 else | |
1086 manualGasLast = manualGasVal; | |
1087 | |
1088 if(bailoutVal == -1) | |
1089 bailoutVal = bailoutLast; | |
1090 else | |
1091 bailoutLast = bailoutVal; | |
1092 | |
1093 if(decostepDepthVal == -1) | |
1094 decostepDepthVal = decostepDepthLast; | |
1095 else | |
1096 decostepDepthLast = decostepDepthVal; | |
1097 | |
1098 counter++; | |
1099 // Heed compression | |
1100 // Write here to arrays | |
1101 if(counter == compression) | |
1102 { | |
1103 if(depth) | |
1104 depth[iNum] = depthVal; | |
1105 if(gasid) | |
1106 gasid[iNum] = gasidVal; | |
1107 if(temperature) | |
1108 temperature[iNum] = temperatureVal; | |
1109 if(cns) | |
1110 cns[iNum] = cnsVal; | |
1111 if(bailout) | |
1112 bailout[iNum] = bailoutVal; | |
1113 if(decostopDepth) | |
1114 decostopDepth[iNum] = decostepDepthVal; | |
1115 | |
1116 if(ppo2) | |
1117 { | |
1118 //Calc ppo2 - Values | |
1119 SGas gas; | |
1120 gas.setPoint_cbar = setPointVal; | |
1121 if(gasidVal > 0) | |
1122 { | |
1123 gas.helium_percentage = header.gasordil[gasidVal - 1].helium_percentage; | |
1124 gas.nitrogen_percentage = 100 - gas.helium_percentage - header.gasordil[gasidVal - 1].oxygen_percentage; | |
1125 } | |
1126 else | |
1127 { | |
1128 gas.helium_percentage = manualGasVal.percentageHe; | |
1129 gas.nitrogen_percentage = 100 - gas.helium_percentage - manualGasVal.percentageO2; | |
1130 } | |
1131 ambiant_pressure_bar =((float)(depthVal + header.surfacePressure_mbar))/1000; | |
1132 ppO2 = decom_calc_ppO2(ambiant_pressure_bar, &gas ); | |
1133 ppo2[iNum] = (uint16_t) ( ppO2 * 100); | |
1134 } | |
1135 | |
1136 if(setpoint) | |
1137 setpoint[iNum] = setPointVal; | |
1138 | |
1139 if(sensor1) | |
1140 sensor1[iNum] = (sensor1Val / 0xFFFF) & 0xFF; | |
1141 if(sensor2) | |
1142 sensor2[iNum] = (sensor2Val / 0xFFFF) & 0xFF; | |
1143 if(sensor3) | |
1144 sensor3[iNum] = (sensor3Val / 0xFFFF) & 0xFF; | |
1145 iNum++; | |
1146 counter = 0; | |
1147 } | |
1148 } | |
1149 | |
1150 // Fix first Temperature Entries 150930 hw | |
1151 if(temperature) | |
1152 { | |
1153 int i = 0; | |
1154 while((temperature[i] == -1000) && (i < iNum)) | |
1155 temperature[i++] = temperatureFirst; | |
1156 } | |
1157 | |
1158 ext_flash_close_read_sample(); | |
1159 return iNum; | |
1160 } | |
1161 | |
1162 | |
1163 /******************************************************************************** | |
1164 * @brief logbook_InitAndWrite. / Controls writing of logbook | |
1165 * Should be called ten times per second | |
1166 * Automatically Initializes logbook at beginning of dive, | |
1167 * write samples every 2 seconds | |
1168 * and finishes logbook after end of dive | |
1169 *********************************************************************************/ | |
1170 | |
1171 void logbook_InitAndWrite(void) | |
1172 { | |
1173 SSettings *pSettings = settingsGetPointer(); | |
1174 static uint8_t bDiveMode = 0; | |
1175 static uint32_t tickstart = 0; | |
1176 uint32_t ticksdiff = 0; | |
1177 uint32_t lasttick = 0; | |
1178 static float min_temperature_float_celsius = 0; | |
1179 | |
1180 const SDiveState * pStateReal = stateRealGetPointer(); | |
1181 | |
1182 if(!bDiveMode) | |
1183 { | |
1184 if((pStateReal->mode == MODE_DIVE) && (pStateReal->diveSettings.diveMode != DIVEMODE_Apnea) && (pStateReal->lifeData.dive_time_seconds >= 5)) | |
1185 { | |
1186 //InitdiveProfile | |
1187 pSettings->totalDiveCounter++; | |
1188 logbook_initNewdiveProfile(pStateReal,settingsGetPointer()); | |
1189 min_temperature_float_celsius = pStateReal->lifeData.temperature_celsius; | |
1190 //Write logbook sample | |
1191 logbook_writeSample(*pStateReal); | |
1192 resetEvents(); | |
1193 tickstart = HAL_GetTick(); | |
1194 bDiveMode = 1; | |
1195 } | |
1196 } | |
1197 else if((pStateReal->mode == MODE_DIVE) && (pStateReal->diveSettings.diveMode != DIVEMODE_Apnea)) | |
1198 { | |
1199 lasttick = HAL_GetTick(); | |
1200 ticksdiff = time_elapsed_ms(tickstart,lasttick); | |
1201 // | |
1202 if(ticksdiff >= 2000) | |
1203 { | |
1204 //Write logbook sample | |
1205 logbook_writeSample(*pStateReal); | |
1206 resetEvents(); | |
1207 if(min_temperature_float_celsius > pStateReal->lifeData.temperature_celsius) | |
1208 min_temperature_float_celsius = pStateReal->lifeData.temperature_celsius; | |
1209 tickstart = lasttick; | |
1210 if((bDiveMode == 1) && (pStateReal->lifeData.dive_time_seconds >= pSettings->divetimeToCreateLogbook)) | |
1211 { | |
1212 ext_flash_create_new_dive_log((uint8_t*)&header); | |
1213 /** save settings | |
1214 * with new lastDiveLogId and time and day | |
1215 */ | |
1216 pSettings->personalDiveCount++; | |
1217 if(pSettings->logbookOffset) | |
1218 { | |
1219 pSettings->logbookOffset++; | |
1220 } | |
1221 ext_flash_write_settings(); | |
1222 ext_flash_disable_protection_for_logbook(); | |
1223 bDiveMode = 3; | |
1224 } | |
1225 if(bDiveMode == 3) | |
1226 logbook_UpdateHeader(); | |
1227 } | |
1228 } | |
1229 else if(bDiveMode == 3) | |
1230 { | |
1231 //End of Dive | |
1232 logbook_SetAverageDepth(pStateReal->lifeData.average_depth_meter); | |
1233 logbook_SetMinTemperature(min_temperature_float_celsius); | |
1234 logbook_SetMaxCNS(pStateReal->lifeData.cns); | |
1235 logbook_SetCompartmentDesaturation(); | |
1236 logbook_SetLastStop(pStateReal->diveSettings.last_stop_depth_bar); | |
1237 logbook_EndDive(); | |
1238 bDiveMode = 0; | |
1239 } else | |
1240 { | |
1241 ext_flash_enable_protection(); | |
1242 } | |
1243 } | |
1244 | |
1245 | |
1246 /* Private functions ---------------------------------------------------------*/ | |
1247 | |
1248 /******************************************************************************** | |
1249 * @brief logbook_UpdateHeader. / | |
1250 * set date, time, max depth. etc. pp. | |
1251 * the internal pointer to the end of profile and length will be set by | |
1252 ext_flash_close_new_dive_log() in externLogbookFlash.c | |
1253 * @author heinrichs weikamp gmbh | |
1254 * @version V0.0.1 | |
1255 * @date 27-Nov-2014 | |
1256 *********************************************************************************/ | |
1257 void logbook_UpdateHeader(void) | |
1258 { | |
1259 const SDiveState * pStateReal = stateRealGetPointer(); | |
149 | 1260 |
38 | 1261 // uint16_t secondsAtShallow = 0; |
1262 RTC_DateTypeDef Sdate; | |
1263 RTC_TimeTypeDef Stime; | |
1264 uint32_t time1_u32, time2_u32; | |
1265 uint32_t divetimeHelper; | |
1266 | |
1267 /* time and day */ | |
1268 /* don't update CHANGE 160224 hw, maybe save actual time and date at other place | |
1269 translateDate(pStateReal->lifeData.dateBinaryFormat, &Sdate); | |
1270 translateTime(pStateReal->lifeData.timeBinaryFormat, &Stime); | |
1271 | |
1272 header.dateYear = Sdate.Year; | |
1273 header.dateMonth = Sdate.Month; | |
1274 header.dateDay = Sdate.Date; | |
1275 header.timeHour = Stime.Hours; | |
1276 header.timeMinute = Stime.Minutes; | |
1277 */ | |
1278 /// 160315 Quick fix for empty date problem | |
1279 if((!(header.dateYear)) || (!(header.dateMonth)) || (!(header.dateDay))) | |
1280 { | |
1281 translateDate(pStateReal->lifeData.dateBinaryFormat, &Sdate); | |
1282 translateTime(pStateReal->lifeData.timeBinaryFormat, &Stime); | |
1283 | |
1284 header.dateYear = Sdate.Year; | |
1285 header.dateMonth = Sdate.Month; | |
1286 header.dateDay = Sdate.Date; | |
1287 | |
1288 time1_u32 = (uint32_t)header.timeMinute + (uint32_t)(header.timeHour * 60); | |
1289 time2_u32 = (uint32_t)Stime.Minutes + (uint32_t)(Stime.Hours * 60); | |
1290 if(time2_u32 < time1_u32) | |
1291 { | |
1292 if(header.dateDay > 1) | |
1293 { | |
1294 header.dateDay -= 1; | |
1295 } | |
1296 else | |
1297 { | |
1298 header.dateMonth --; | |
1299 if(!header.dateMonth) | |
1300 { | |
1301 header.dateYear--; | |
1302 header.dateMonth = 12; | |
1303 header.dateDay = 31; | |
1304 } | |
1305 else | |
1306 { | |
1307 if(header.dateMonth == 2) | |
1308 header.dateDay = 28; | |
1309 else | |
1310 if((header.dateMonth == 4) || (header.dateMonth == 6) || (header.dateMonth == 9) || (header.dateMonth == 11)) | |
1311 header.dateDay = 30; | |
1312 else | |
1313 header.dateDay = 31; | |
1314 } | |
1315 } | |
1316 } | |
1317 } | |
1318 | |
1319 /* duration */ | |
1320 header.total_diveTime_seconds = pStateReal->lifeData.dive_time_seconds; | |
1321 header.maxDepth = pStateReal->lifeData.max_depth_meter * 100; | |
1322 | |
1323 /* old: | |
1324 | |
1325 secondsAtShallow = pSettings->timeoutDiveReachedZeroDepth; | |
1326 if(pStateReal->lifeData.dive_time_seconds <= secondsAtShallow) | |
1327 secondsAtShallow = 0; | |
1328 header.diveTimeMinutes = (header.total_diveTime_seconds - secondsAtShallow )/ 60; | |
1329 header.diveTimeSeconds = header.total_diveTime_seconds - secondsAtShallow - (header.diveTimeMinutes * 60); | |
1330 */ | |
1331 divetimeHelper = pStateReal->lifeData.dive_time_seconds_without_surface_time; | |
1332 header.diveTimeMinutes = (uint16_t)(divetimeHelper/60); | |
1333 divetimeHelper -= 60 * (uint32_t)header.diveTimeMinutes; | |
1334 header.diveTimeSeconds = (uint16_t)divetimeHelper; | |
1335 | |
1336 /* deco algorithm (final) */ | |
1337 if(pStateReal->diveSettings.deco_type.ub.standard == GF_MODE) | |
1338 { | |
1339 header.decoModel = 1; | |
1340 header.gfLow_or_Vpm_conservatism = pStateReal->diveSettings.gf_low; | |
1341 header.gfHigh = pStateReal->diveSettings.gf_high; | |
1342 } | |
1343 else | |
1344 { | |
1345 header.decoModel = 2; | |
1346 header.gfLow_or_Vpm_conservatism = pStateReal->diveSettings.vpm_conservatism; | |
1347 header.gfHigh = 0; | |
1348 } | |
1349 | |
1350 /* tissue load */ | |
1351 memcpy(header.n2Compartments, pStateReal->lifeData.tissue_nitrogen_bar, 64); | |
1352 memcpy(header.heCompartments, pStateReal->lifeData.tissue_helium_bar, 64); | |
1353 | |
1354 } | |
1355 | |
1356 | |
1357 void logbook_SetAverageDepth(float average_depth_meter) | |
1358 { | |
1359 header.averageDepth_mbar = (uint16_t)(average_depth_meter * 100); | |
1360 } | |
1361 | |
1362 | |
1363 void logbook_SetMinTemperature(float min_temperature_celsius) | |
1364 { | |
1365 header.minTemp = (int16_t)((min_temperature_celsius * 10.0f) + 0.5f); | |
1366 } | |
1367 | |
1368 | |
1369 void logbook_SetMaxCNS(float max_cns_percentage) | |
1370 { | |
1371 if(max_cns_percentage < 9999) | |
1372 header.maxCNS = (uint16_t)(max_cns_percentage); | |
1373 else | |
1374 header.maxCNS = 9999; | |
1375 } | |
1376 | |
1377 | |
1378 void logbook_SetDesaturationTime(void) | |
1379 { | |
1380 header.desaturationTime = 48 * 60; | |
1381 } | |
1382 | |
1383 | |
1384 void logbook_SetCompartmentDesaturation(void) | |
1385 { | |
1386 const SDiveState * pStateReal = stateRealGetPointer(); | |
1387 | |
1388 decom_tissues_desaturation_time(&pStateReal->lifeData, &secondaryInformation); | |
1389 for(int i=0;i<16;i++) | |
1390 { | |
1391 if(secondaryInformation.tissue_nitrogen_desaturation_time_minutes[i] <= (15 * 255)) | |
1392 header.n2CompartDesatTime_min[i] = (uint8_t)((secondaryInformation.tissue_nitrogen_desaturation_time_minutes[i] + 14) / 15); | |
1393 else | |
1394 header.n2CompartDesatTime_min[i] = 255; | |
1395 if(secondaryInformation.tissue_helium_desaturation_time_minutes[i] <= (15 * 255)) | |
1396 header.heCompartDesatTime_min[i] = (uint8_t)((secondaryInformation.tissue_helium_desaturation_time_minutes[i] + 14 )/ 15); | |
1397 else | |
1398 header.heCompartDesatTime_min[i] = 255; | |
1399 } | |
1400 } | |
1401 | |
1402 void logbook_SetLastStop(float last_stop_depth_bar) | |
1403 { | |
1404 header.lastDecostop_m = (uint8_t)(last_stop_depth_bar / 10.0f); | |
1405 } | |
1406 | |
1407 void logbook_writedata(void * data, int length_byte) | |
1408 { | |
1409 ext_flash_write_sample(data, length_byte); | |
1410 } | |
1411 | |
1412 | |
1413 /******************************************************************************** | |
1414 * @brief logbook_build_ostc3header. / | |
1415 * @author heinrichs weikamp gmbh | |
1416 * @version V0.0.2 | |
1417 * @date 27-Nov-2014 | |
1418 *********************************************************************************/ | |
1419 SLogbookHeaderOSTC3 * logbook_build_ostc3header(SLogbookHeader* pHead) | |
1420 { | |
1421 convert_Type data; | |
1422 | |
1423 memcpy(headerOSTC3.diveHeaderStart, &pHead->diveHeaderStart, 2); | |
1424 memcpy(headerOSTC3.pBeginProfileData, &pHead->pBeginProfileData, 3); | |
1425 memcpy(headerOSTC3.pEndProfileData, &pHead->pEndProfileData, 3); | |
1426 | |
1427 data.u8bit.byteHigh = 0; | |
1428 data.u8bit.byteLow = pHead->profileLength[0]; | |
1429 data.u8bit.byteMidLow = pHead->profileLength[1]; | |
1430 data.u8bit.byteMidHigh = pHead->profileLength[2]; | |
1431 | |
1432 if(data.u32bit != 0xFFFFFF) | |
1433 data.u32bit += 3; | |
1434 | |
1435 headerOSTC3.profileLength[0] = data.u8bit.byteLow; | |
1436 headerOSTC3.profileLength[1] = data.u8bit.byteMidLow; | |
1437 headerOSTC3.profileLength[2] = data.u8bit.byteMidHigh; | |
1438 | |
1439 memcpy(headerOSTC3.gasordil, pHead->gasordil, 20); | |
1440 | |
1441 if(pHead->logbookProfileVersion == LOGBOOK_VERSION) | |
1442 { | |
1443 headerOSTC3.logbookProfileVersion = LOGBOOK_VERSION_OSTC3; | |
1444 memcpy(headerOSTC3.personalDiveCount, &pHead->personalDiveCount, 2); | |
1445 headerOSTC3.safetyDistance_10cm = 0; | |
1446 | |
1447 for(int i=0;i<5;i++) | |
1448 { | |
1449 if(!pHead->gasordil[i].note.ub.active) | |
1450 headerOSTC3.gasordil[3 + (i*4)] = 0; | |
1451 else if(pHead->gasordil[i].note.ub.first) | |
1452 { | |
1453 /* depth = 0, note = 1 */ | |
1454 headerOSTC3.gasordil[2 + (i*4)] = 0; | |
1455 headerOSTC3.gasordil[3 + (i*4)] = 1; | |
1456 } | |
1457 else if( pHead->gasordil[i].depth_meter) | |
1458 { | |
1459 /* note = 3 */ | |
1460 headerOSTC3.gasordil[3 + (i*4)] = 3; | |
1461 } | |
1462 } | |
1463 } | |
1464 else | |
1465 { | |
1466 headerOSTC3.logbookProfileVersion = 0xFF; | |
1467 headerOSTC3.personalDiveCount[0] = 0xFF; | |
1468 headerOSTC3.personalDiveCount[1] = 0xFF; | |
1469 headerOSTC3.safetyDistance_10cm = 0xFF; | |
1470 } | |
1471 | |
1472 headerOSTC3.dateYear = pHead->dateYear; | |
1473 headerOSTC3.dateMonth = pHead->dateMonth; | |
1474 headerOSTC3.dateDay = pHead->dateDay; | |
1475 headerOSTC3.timeHour = pHead->timeHour; | |
1476 headerOSTC3.timeMinute = pHead->timeMinute; | |
1477 | |
1478 | |
1479 memcpy(headerOSTC3.maxDepth, &pHead->maxDepth, 2); | |
1480 memcpy(headerOSTC3.diveTimeMinutes, &pHead->diveTimeMinutes, 2); | |
1481 | |
1482 headerOSTC3.diveTimeSeconds = pHead->diveTimeSeconds; | |
1483 | |
1484 memcpy(headerOSTC3.minTemp, &pHead->minTemp, 2); | |
1485 memcpy(headerOSTC3.surfacePressure_mbar,&pHead->surfacePressure_mbar, 2); | |
1486 memcpy(headerOSTC3.desaturationTime, &pHead->desaturationTime, 2); | |
1487 | |
1488 headerOSTC3.firmwareVersionHigh = pHead->firmwareVersionHigh; | |
1489 headerOSTC3.firmwareVersionLow = pHead->firmwareVersionLow; | |
1490 | |
1491 memcpy(headerOSTC3.batteryVoltage, &pHead->batteryVoltage, 2); | |
1492 | |
1493 headerOSTC3.samplingRate = pHead->samplingRate; | |
1494 | |
1495 memcpy(headerOSTC3.cnsAtBeginning, &pHead->cnsAtBeginning, 2); | |
1496 | |
1497 headerOSTC3.gfAtBeginning = pHead->gfAtBeginning; | |
1498 headerOSTC3.gfAtEnd = pHead->gfAtEnd; | |
1499 | |
1500 memcpy(headerOSTC3.setpoint, pHead->setpoint, 10); | |
1501 | |
1502 headerOSTC3.salinity = pHead->salinity; | |
1503 | |
1504 memcpy(headerOSTC3.maxCNS, &pHead->maxCNS, 2); | |
1505 memcpy(headerOSTC3.averageDepth_mbar, &pHead->averageDepth_mbar, 2); | |
1506 memcpy(headerOSTC3.total_diveTime_seconds,&pHead->total_diveTime_seconds, 2); | |
1507 | |
1508 headerOSTC3.gfLow_or_Vpm_conservatism = pHead->gfLow_or_Vpm_conservatism; | |
1509 headerOSTC3.gfHigh = pHead->gfHigh; | |
1510 headerOSTC3.decoModel = pHead->decoModel; | |
1511 | |
1512 memcpy(headerOSTC3.diveNumber, &pHead->diveNumber, 2); | |
1513 | |
1514 headerOSTC3.diveMode = pHead->diveMode; | |
1515 headerOSTC3.CCRmode = pHead->CCRmode; | |
1516 | |
1517 memcpy(headerOSTC3.n2CompartDesatTime_min,pHead->n2CompartDesatTime_min, 16); | |
1518 memcpy(headerOSTC3.n2Compartments, pHead->n2Compartments, 64); | |
1519 memcpy(headerOSTC3.heCompartDesatTime_min,pHead->heCompartDesatTime_min, 16); | |
1520 memcpy(headerOSTC3.heCompartments, pHead->heCompartments, 64); | |
1521 | |
1522 headerOSTC3.lastDecostop_m = pHead->lastDecostop_m; | |
1523 | |
1524 memcpy(headerOSTC3.hwHudBattery_mV, &pHead->hwHudBattery_mV, 2); | |
1525 | |
1526 headerOSTC3.hwHudLastStatus = pHead->hwHudLastStatus; | |
1527 | |
1528 memcpy(headerOSTC3.batteryGaugeRegisters,&pHead->batteryGaugeRegisters, 6); | |
1529 | |
1530 | |
1531 memcpy(headerOSTC3.diveHeaderEnd, &pHead->diveHeaderEnd, 2); | |
1532 | |
1533 return &headerOSTC3; | |
1534 } | |
1535 | |
1536 | |
1537 /******************************************************************************** | |
1538 * @brief logbook_build_ostc3header_compact. / | |
1539 * @author heinrichs weikamp gmbh | |
1540 * @version V0.0.1 | |
1541 * @date 31-Juli-2015 | |
1542 *********************************************************************************/ | |
1543 SLogbookHeaderOSTC3compact * logbook_build_ostc3header_compact(SLogbookHeader* pHead) | |
1544 { | |
1545 convert_Type data; | |
1546 | |
1547 data.u8bit.byteHigh = 0; | |
1548 data.u8bit.byteLow = pHead->profileLength[0]; | |
1549 data.u8bit.byteMidLow = pHead->profileLength[1]; | |
1550 data.u8bit.byteMidHigh = pHead->profileLength[2]; | |
1551 | |
1552 if(data.u32bit != 0xFFFFFF) | |
1553 { | |
1554 data.u32bit += 3; | |
1555 | |
1556 headerOSTC3compact.profileLength[0] = data.u8bit.byteLow; | |
1557 headerOSTC3compact.profileLength[1] = data.u8bit.byteMidLow; | |
1558 headerOSTC3compact.profileLength[2] = data.u8bit.byteMidHigh; | |
1559 | |
1560 headerOSTC3compact.dateYear = pHead->dateYear; | |
1561 headerOSTC3compact.dateMonth = pHead->dateMonth; | |
1562 headerOSTC3compact.dateDay = pHead->dateDay; | |
1563 headerOSTC3compact.timeHour = pHead->timeHour; | |
1564 headerOSTC3compact.timeMinute = pHead->timeMinute; | |
1565 | |
1566 memcpy(headerOSTC3compact.maxDepth, &pHead->maxDepth, 2); | |
1567 memcpy(headerOSTC3compact.diveTimeMinutes, &pHead->diveTimeMinutes, 2); | |
1568 | |
1569 headerOSTC3compact.diveTimeSeconds = pHead->diveTimeSeconds; | |
1570 | |
1571 | |
1572 headerOSTC3compact.totalDiveNumberLow = pHead->diveNumber & 0xFF; | |
1573 headerOSTC3compact.totalDiveNumberHigh = (uint8_t)(pHead->diveNumber/256); | |
1574 headerOSTC3compact.profileVersion = 0x24; // Logbook-Profile version, 0x24 = date and time is start not end | |
1575 } | |
1576 else | |
1577 { | |
1578 memset(&headerOSTC3compact, 0xFF, sizeof(SLogbookHeaderOSTC3compact)); | |
1579 } | |
1580 return &headerOSTC3compact; | |
1581 } | |
1582 | |
1583 | |
1584 /** | |
1585 ****************************************************************************** | |
1586 * @brief logbook_readSampleData. / Reads sample data of whole logbook entry | |
1587 * @author Peter Ryser | |
1588 * @version V0.0.1 | |
1589 * @date 22-April-2014 | |
1590 ****************************************************************************** | |
1591 * | |
1592 * @param uint8_t StepBackwards: witch lookbook entry? | |
1593 * @param uint16_t length : maxlength of output arrays | |
1594 * @param int32_t* depth : output array | |
1595 * @param int16_t * gasid : output array | |
1596 * @param int32_t* temperature : output array | |
1597 * @param int32_t* ppo2 : output array | |
1598 * @param int32_t* cns : output array | |
1599 * @return length of output | |
1600 */ | |
1601 void logbook_recover_brokenlog(uint8_t headerId) | |
1602 { | |
1603 int16_t retVal; | |
1604 int32_t depthVal = 0; | |
1605 int16_t gasidVal = 0; | |
1606 int16_t setPointVal = 0; | |
1607 int16_t bailoutVal = 0; | |
1608 int32_t temperatureVal = 0; | |
1609 int32_t sensor1Val = 0; | |
1610 int32_t sensor2Val = 0; | |
1611 int32_t sensor3Val = 0; | |
1612 int32_t cnsVal = 0; | |
1613 SManualGas manualGasVal; | |
1614 | |
1615 //uint16_t* ppo2, uint16_t* cns# | |
1616 uint32_t bytesRead = 0; | |
1617 | |
1618 ext_flash_read_block_start(); | |
1619 ext_flash_read_next_sample_part((uint8_t*)&smallHeader, sizeof(SSmallHeader)); | |
1620 bytesRead += sizeof(SSmallHeader); | |
1621 | |
1622 clear_divisor(); | |
1623 | |
1624 | |
1625 int sampleCounter = 0; | |
1626 int maxdepth = 0; | |
1627 uint32_t avrdepth = 0; | |
1628 while (true) | |
1629 { | |
1630 | |
1631 ext_flash_set_entry_point(); | |
1632 divisorBackup = divisor; | |
1633 retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL); | |
1634 if(retVal == 0) | |
1635 { | |
1636 //Error try to read again!!! | |
1637 ext_flash_reopen_read_sample_at_entry_point(); | |
1638 divisor = divisorBackup; | |
1639 retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL); | |
1640 | |
1641 if(retVal == 0) | |
1642 { | |
1643 //Error try to read again!!! | |
1644 ext_flash_reopen_read_sample_at_entry_point(); | |
1645 divisor = divisorBackup; | |
1646 retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL); | |
1647 | |
1648 if(retVal == 0) | |
1649 { | |
1650 ext_flash_reopen_read_sample_at_entry_point(); | |
1651 break; | |
1652 } | |
1653 | |
1654 } | |
1655 } | |
1656 if(depthVal > maxdepth) | |
1657 maxdepth = depthVal; | |
1658 avrdepth += depthVal; | |
1659 sampleCounter++; | |
1660 bytesRead +=retVal; | |
1661 } | |
1662 avrdepth/= sampleCounter; | |
1663 ext_flash_close_read_sample(); | |
1664 SLogbookHeader header; | |
1665 | |
1666 ext_flash_read_dive_header2((uint8_t*) &header, headerId, false); | |
1667 header.total_diveTime_seconds = sampleCounter * header.samplingRate; | |
1668 header.diveTimeMinutes = header.total_diveTime_seconds /60; | |
1669 header.diveTimeSeconds = header.total_diveTime_seconds - header.diveTimeMinutes * 60; | |
1670 header.maxDepth = maxdepth; | |
1671 header.averageDepth_mbar = avrdepth; | |
1672 SSettings * settings = settingsGetPointer(); | |
1673 settings->lastDiveLogId = headerId; | |
1674 ext_flash_close_new_dive_log((uint8_t *)&header); | |
1675 } | |
1676 | |
1677 /************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/ |