Mercurial > public > ostc4

comparison Discovery/Src/logbook.c @ 470:dd0d0952ef35

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merged in Ideenmodellierer/ostc4/Improve_Logtansfer (pull request #42) Improve Logtansfer
author heinrichsweikamp <bitbucket@heinrichsweikamp.com>
date Wed, 15 Apr 2020 07:01:11 +0000
parents 2c2df051e554
children 73da921869d9
comparison
equal deleted inserted replaced
462:dddfe7917131 470:dd0d0952ef35
89 static SDivisor divisorBackup; 89 static SDivisor divisorBackup;
90 90
91 static SSmallHeader smallDummyHeader; 91 static SSmallHeader smallDummyHeader;
92 static uint16_t dummyWriteIdx; 92 static uint16_t dummyWriteIdx;
93 static uint16_t dummyReadIdx; 93 static uint16_t dummyReadIdx;
94 static uint8_t dummyMemoryBuffer[1000*4]; 94 static uint8_t dummyMemoryBuffer[5000];
95 95
96 96
97 /* Private function prototypes -----------------------------------------------*/ 97 /* Private function prototypes -----------------------------------------------*/
98 static void clear_divisor(void); 98 static void clear_divisor(void);
99 static void logbook_SetAverageDepth(float average_depth_meter); 99 static void logbook_SetAverageDepth(float average_depth_meter);
979 int32_t temperatureFirst = 0; 979 int32_t temperatureFirst = 0;
980 int32_t cnsLast = 0; 980 int32_t cnsLast = 0;
981 int16_t decostepDepthVal = 0; 981 int16_t decostepDepthVal = 0;
982 int16_t decostepDepthLast = 0; 982 int16_t decostepDepthLast = 0;
983 uint16_t tankVal = 0; 983 uint16_t tankVal = 0;
984 uint32_t small_profileLength = 0;
984 985
985 SManualGas manualGasVal; 986 SManualGas manualGasVal;
986 SManualGas manualGasLast; 987 SManualGas manualGasLast;
987 manualGasLast.percentageO2 = 0; 988 manualGasLast.percentageO2 = 0;
988 manualGasLast.percentageHe = 0; 989 manualGasLast.percentageHe = 0;
1038 //We start with fist gasid 1039 //We start with fist gasid
1039 gasidLast = firstgasid; 1040 gasidLast = firstgasid;
1040 1041
1041 1042
1042 //uint16_t* ppo2, uint16_t* cns# 1043 //uint16_t* ppo2, uint16_t* cns#
1043 uint32_t totalNumberOfBytes = 0; 1044 uint32_t totalNumberOfBytes = 0;
1044 uint32_t bytesRead = 0; 1045 uint32_t bytesRead = 0;
1045 ext_flash_open_read_sample( StepBackwards,&totalNumberOfBytes); 1046 ext_flash_open_read_sample( StepBackwards,&totalNumberOfBytes);
1046 ext_flash_read_next_sample_part((uint8_t*)&smallHeader, sizeof(SSmallHeader)); 1047 ext_flash_read_next_sample_part((uint8_t*)&smallHeader, sizeof(SSmallHeader));
1047 bytesRead += sizeof(SSmallHeader); 1048 bytesRead += sizeof(SSmallHeader);
1048 1049
1049 clear_divisor(); 1050 clear_divisor();
1050 1051
1051 iNum = 0; 1052 iNum = 0;
1052 int counter = 0; 1053 int counter = 0;
1053 temperatureLast = -1000; 1054 temperatureLast = -1000;
1054 if(totalNumberOfBytes > 2) /* read real data */ 1055
1056 small_profileLength = (smallHeader.profileLength[2] << 16) + (smallHeader.profileLength[1] << 8) + smallHeader.profileLength[0];
1057
1058 if(totalNumberOfBytes == small_profileLength) /* sizes provided by header and small header are the same => real data */
1055 { 1059 {
1056 while ((bytesRead < totalNumberOfBytes) && (iNum < length)) 1060 while ((bytesRead < totalNumberOfBytes) && (iNum < length))
1057 { 1061 {
1058 ext_flash_set_entry_point(); 1062 ext_flash_set_entry_point();
1059 divisorBackup = divisor; 1063 divisorBackup = divisor;
1458 *********************************************************************************/ 1462 *********************************************************************************/
1459 SLogbookHeaderOSTC3 * logbook_build_ostc3header(SLogbookHeader* pHead) 1463 SLogbookHeaderOSTC3 * logbook_build_ostc3header(SLogbookHeader* pHead)
1460 { 1464 {
1461 convert_Type data,data2; 1465 convert_Type data,data2;
1462 uint16_t dummyLength = 0; 1466 uint16_t dummyLength = 0;
1463 1467 uint8_t returnEmptyHeader = 0;
1464 memcpy(headerOSTC3.diveHeaderStart, &pHead->diveHeaderStart, 2); 1468
1465 memcpy(headerOSTC3.pBeginProfileData, &pHead->pBeginProfileData, 3); 1469 uint32_t headerProfileLength, sampleProfileLength, sampleProfileStart;
1466 memcpy(headerOSTC3.pEndProfileData, &pHead->pEndProfileData, 3); 1470
1467 1471
1468 1472 if(pHead->diveHeaderStart != 0xFAFA)
1469 data.u8bit.byteHigh = 0; 1473 {
1470 data.u8bit.byteLow = pHead->pBeginProfileData[0]; 1474 returnEmptyHeader = 1;
1471 data.u8bit.byteMidLow = pHead->pBeginProfileData[1];
1472 data.u8bit.byteMidHigh = pHead->pBeginProfileData[2];
1473
1474 data2.u8bit.byteHigh = 0;
1475 data2.u8bit.byteLow = pHead->pEndProfileData[0];
1476 data2.u8bit.byteMidLow = pHead->pEndProfileData[1];
1477 data2.u8bit.byteMidHigh = pHead->pEndProfileData[2];
1478
1479 if( (pHead->pBeginProfileData[0] == 0) /* no sample data available => use dummy */
1480 &&(pHead->pBeginProfileData[1] == 0)
1481 &&(pHead->pBeginProfileData[2] == 0))
1482 {
1483 dummyLength = logbook_fillDummySampleBuffer(pHead);
1484
1485 data2.u32bit = data.u32bit + dummyLength; /* calc new end address (which is equal to dummyLength) */
1486 data.u32bit = data2.u32bit; /* data is used below to represent the length */
1487 } 1475 }
1488 else 1476 else
1489 { 1477 {
1490 /* check if sample address information are corrupted by address range. */ 1478 memcpy(headerOSTC3.diveHeaderStart, &pHead->diveHeaderStart, 2);
1491 /* TODO: Workaround. Better solution would be to check end of ring for 0xFF pattern */ 1479 memcpy(headerOSTC3.pBeginProfileData, &pHead->pBeginProfileData, 3);
1492 if((data.u32bit > data2.u32bit) && (data.u32bit < (SAMPLESTOP - 0x9000))) 1480 memcpy(headerOSTC3.pEndProfileData, &pHead->pEndProfileData, 3);
1481
1482 data.u8bit.byteHigh = 0;
1483 data.u8bit.byteLow = pHead->pBeginProfileData[0];
1484 data.u8bit.byteMidLow = pHead->pBeginProfileData[1];
1485 data.u8bit.byteMidHigh = pHead->pBeginProfileData[2];
1486
1487 sampleProfileStart = data.u32bit;
1488
1489 data2.u8bit.byteHigh = 0;
1490 data2.u8bit.byteLow = pHead->pEndProfileData[0];
1491 data2.u8bit.byteMidLow = pHead->pEndProfileData[1];
1492 data2.u8bit.byteMidHigh = pHead->pEndProfileData[2];
1493
1494 data.u8bit.byteHigh = 0;
1495 data.u8bit.byteLow = pHead->profileLength[0];
1496 data.u8bit.byteMidLow = pHead->profileLength[1];
1497 data.u8bit.byteMidHigh = pHead->profileLength[2];
1498
1499 if(data.u32bit != 0xFFFFFF) /* if the profile in use ? */
1493 { 1500 {
1494 data2.u32bit = data.u32bit + DEFAULT_SAMPLES; 1501 if(data2.u32bit < sampleProfileStart) /* Wrap around of sample ring detected */
1495 pHead->pEndProfileData[0] = data2.u8bit.byteLow; 1502 {
1496 pHead->pEndProfileData[1] = data2.u8bit.byteMidLow; 1503 if(ext_flash_SampleOverrunValid() == 0) /* Wrap around does not seem to be valid => fallback */
1497 pHead->pEndProfileData[2] = data2.u8bit.byteMidHigh; 1504 {
1498 data.u32bit = DEFAULT_SAMPLES; 1505 sampleProfileStart = 0;
1506 }
1507 }
1508 if( sampleProfileStart == 0) /* should never happen unless OSTC with older debug version is in use (or invalid overrun) */
1509 {
1510 sampleProfileLength = 1;
1511 headerProfileLength = 2;
1512 }
1513 else
1514 {
1515 headerProfileLength = (pHead->profileLength[2] << 16) + (pHead->profileLength[1] << 8) + pHead->profileLength[0];
1516 sampleProfileLength = ext_flash_read_profilelength_small_header(sampleProfileStart);
1517 }
1518
1519 if(sampleProfileLength != headerProfileLength)
1520 {
1521 dummyLength = logbook_fillDummySampleBuffer(pHead);
1522
1523 data2.u32bit = sampleProfileStart + dummyLength; /* calc new end address (which is equal to dummyLength) */
1524 data.u32bit = dummyLength; /* data is used below to represent the length */
1525 }
1526
1527 data.u32bit += 3;
1528 headerOSTC3.profileLength[0] = data.u8bit.byteLow;
1529 headerOSTC3.profileLength[1] = data.u8bit.byteMidLow;
1530 headerOSTC3.profileLength[2] = data.u8bit.byteMidHigh;
1531
1532 memcpy(headerOSTC3.gasordil, pHead->gasordil, 20);
1533
1534 if(pHead->logbookProfileVersion == LOGBOOK_VERSION)
1535 {
1536 headerOSTC3.logbookProfileVersion = LOGBOOK_VERSION_OSTC3;
1537 memcpy(headerOSTC3.personalDiveCount, &pHead->personalDiveCount, 2);
1538 headerOSTC3.safetyDistance_10cm = 0;
1539
1540 for(int i=0;i<5;i++)
1541 {
1542 if(!pHead->gasordil[i].note.ub.active)
1543 headerOSTC3.gasordil[3 + (i*4)] = 0;
1544 else if(pHead->gasordil[i].note.ub.first)
1545 {
1546 /* depth = 0, note = 1 */
1547 headerOSTC3.gasordil[2 + (i*4)] = 0;
1548 headerOSTC3.gasordil[3 + (i*4)] = 1;
1549 }
1550 else if( pHead->gasordil[i].depth_meter)
1551 {
1552 /* note = 3 */
1553 headerOSTC3.gasordil[3 + (i*4)] = 3;
1554 }
1555 }
1556 }
1557 else
1558 {
1559 headerOSTC3.logbookProfileVersion = 0xFF;
1560 headerOSTC3.personalDiveCount[0] = 0xFF;
1561 headerOSTC3.personalDiveCount[1] = 0xFF;
1562 headerOSTC3.safetyDistance_10cm = 0xFF;
1563 }
1564
1565 headerOSTC3.dateYear = pHead->dateYear;
1566 headerOSTC3.dateMonth = pHead->dateMonth;
1567 headerOSTC3.dateDay = pHead->dateDay;
1568 headerOSTC3.timeHour = pHead->timeHour;
1569 headerOSTC3.timeMinute = pHead->timeMinute;
1570
1571 memcpy(headerOSTC3.maxDepth, &pHead->maxDepth, 2);
1572 memcpy(headerOSTC3.diveTimeMinutes, &pHead->diveTimeMinutes, 2);
1573
1574 headerOSTC3.diveTimeSeconds = pHead->diveTimeSeconds;
1575
1576 memcpy(headerOSTC3.minTemp, &pHead->minTemp, 2);
1577 memcpy(headerOSTC3.surfacePressure_mbar,&pHead->surfacePressure_mbar, 2);
1578 memcpy(headerOSTC3.desaturationTime, &pHead->desaturationTime, 2);
1579
1580 headerOSTC3.firmwareVersionHigh = pHead->firmwareVersionHigh;
1581 headerOSTC3.firmwareVersionLow = pHead->firmwareVersionLow;
1582
1583 memcpy(headerOSTC3.batteryVoltage, &pHead->batteryVoltage, 2);
1584
1585 headerOSTC3.samplingRate = pHead->samplingRate;
1586
1587 memcpy(headerOSTC3.cnsAtBeginning, &pHead->cnsAtBeginning, 2);
1588
1589 headerOSTC3.gfAtBeginning = pHead->gfAtBeginning;
1590 headerOSTC3.gfAtEnd = pHead->gfAtEnd;
1591
1592 memcpy(headerOSTC3.setpoint, pHead->setpoint, 10);
1593
1594 headerOSTC3.salinity = pHead->salinity;
1595
1596 memcpy(headerOSTC3.maxCNS, &pHead->maxCNS, 2);
1597 memcpy(headerOSTC3.averageDepth_mbar, &pHead->averageDepth_mbar, 2);
1598 memcpy(headerOSTC3.total_diveTime_seconds, &pHead->total_diveTime_seconds, 2);
1599
1600 headerOSTC3.gfLow_or_Vpm_conservatism = pHead->gfLow_or_Vpm_conservatism;
1601 headerOSTC3.gfHigh = pHead->gfHigh;
1602 headerOSTC3.decoModel = pHead->decoModel;
1603
1604 memcpy(headerOSTC3.diveNumber, &pHead->diveNumber, 2);
1605
1606 headerOSTC3.diveMode = pHead->diveMode;
1607 headerOSTC3.CCRmode = pHead->CCRmode;
1608
1609 memcpy(headerOSTC3.n2CompartDesatTime_min,pHead->n2CompartDesatTime_min, 16);
1610 memcpy(headerOSTC3.n2Compartments, pHead->n2Compartments, 64);
1611 memcpy(headerOSTC3.heCompartDesatTime_min,pHead->heCompartDesatTime_min, 16);
1612 memcpy(headerOSTC3.heCompartments, pHead->heCompartments, 64);
1613
1614 headerOSTC3.lastDecostop_m = pHead->lastDecostop_m;
1615
1616 memcpy(headerOSTC3.hwHudBattery_mV, &pHead->hwHudBattery_mV, 2);
1617
1618 headerOSTC3.hwHudLastStatus = pHead->hwHudLastStatus;
1619
1620 memcpy(headerOSTC3.batteryGaugeRegisters,&pHead->batteryGaugeRegisters, 6);
1621
1622
1623 memcpy(headerOSTC3.diveHeaderEnd, &pHead->diveHeaderEnd, 2);
1499 } 1624 }
1500 else 1625 else
1501 { 1626 {
1502 data.u8bit.byteHigh = 0; 1627 returnEmptyHeader = 1;
1503 data.u8bit.byteLow = pHead->profileLength[0];
1504 data.u8bit.byteMidLow = pHead->profileLength[1];
1505 data.u8bit.byteMidHigh = pHead->profileLength[2];
1506 } 1628 }
1507 } 1629 }
1508 if(data.u32bit != 0xFFFFFF) 1630 if(returnEmptyHeader) /* profile not in use => return array full of 0xFF */
1509 data.u32bit += 3; 1631 {
1510 1632 memset(&headerOSTC3, 0xFF, sizeof(headerOSTC3));
1511 headerOSTC3.profileLength[0] = data.u8bit.byteLow; 1633 }
1512 headerOSTC3.profileLength[1] = data.u8bit.byteMidLow;
1513 headerOSTC3.profileLength[2] = data.u8bit.byteMidHigh;
1514
1515 memcpy(headerOSTC3.gasordil, pHead->gasordil, 20);
1516
1517 if(pHead->logbookProfileVersion == LOGBOOK_VERSION)
1518 {
1519 headerOSTC3.logbookProfileVersion = LOGBOOK_VERSION_OSTC3;
1520 memcpy(headerOSTC3.personalDiveCount, &pHead->personalDiveCount, 2);
1521 headerOSTC3.safetyDistance_10cm = 0;
1522
1523 for(int i=0;i<5;i++)
1524 {
1525 if(!pHead->gasordil[i].note.ub.active)
1526 headerOSTC3.gasordil[3 + (i*4)] = 0;
1527 else if(pHead->gasordil[i].note.ub.first)
1528 {
1529 /* depth = 0, note = 1 */
1530 headerOSTC3.gasordil[2 + (i*4)] = 0;
1531 headerOSTC3.gasordil[3 + (i*4)] = 1;
1532 }
1533 else if( pHead->gasordil[i].depth_meter)
1534 {
1535 /* note = 3 */
1536 headerOSTC3.gasordil[3 + (i*4)] = 3;
1537 }
1538 }
1539 }
1540 else
1541 {
1542 headerOSTC3.logbookProfileVersion = 0xFF;
1543 headerOSTC3.personalDiveCount[0] = 0xFF;
1544 headerOSTC3.personalDiveCount[1] = 0xFF;
1545 headerOSTC3.safetyDistance_10cm = 0xFF;
1546 }
1547
1548 headerOSTC3.dateYear = pHead->dateYear;
1549 headerOSTC3.dateMonth = pHead->dateMonth;
1550 headerOSTC3.dateDay = pHead->dateDay;
1551 headerOSTC3.timeHour = pHead->timeHour;
1552 headerOSTC3.timeMinute = pHead->timeMinute;
1553
1554
1555 memcpy(headerOSTC3.maxDepth, &pHead->maxDepth, 2);
1556 memcpy(headerOSTC3.diveTimeMinutes, &pHead->diveTimeMinutes, 2);
1557
1558 headerOSTC3.diveTimeSeconds = pHead->diveTimeSeconds;
1559
1560 memcpy(headerOSTC3.minTemp, &pHead->minTemp, 2);
1561 memcpy(headerOSTC3.surfacePressure_mbar,&pHead->surfacePressure_mbar, 2);
1562 memcpy(headerOSTC3.desaturationTime, &pHead->desaturationTime, 2);
1563
1564 headerOSTC3.firmwareVersionHigh = pHead->firmwareVersionHigh;
1565 headerOSTC3.firmwareVersionLow = pHead->firmwareVersionLow;
1566
1567 memcpy(headerOSTC3.batteryVoltage, &pHead->batteryVoltage, 2);
1568
1569 headerOSTC3.samplingRate = pHead->samplingRate;
1570
1571 memcpy(headerOSTC3.cnsAtBeginning, &pHead->cnsAtBeginning, 2);
1572
1573 headerOSTC3.gfAtBeginning = pHead->gfAtBeginning;
1574 headerOSTC3.gfAtEnd = pHead->gfAtEnd;
1575
1576 memcpy(headerOSTC3.setpoint, pHead->setpoint, 10);
1577
1578 headerOSTC3.salinity = pHead->salinity;
1579
1580 memcpy(headerOSTC3.maxCNS, &pHead->maxCNS, 2);
1581 memcpy(headerOSTC3.averageDepth_mbar, &pHead->averageDepth_mbar, 2);
1582 memcpy(headerOSTC3.total_diveTime_seconds,&pHead->total_diveTime_seconds, 2);
1583
1584 headerOSTC3.gfLow_or_Vpm_conservatism = pHead->gfLow_or_Vpm_conservatism;
1585 headerOSTC3.gfHigh = pHead->gfHigh;
1586 headerOSTC3.decoModel = pHead->decoModel;
1587
1588 memcpy(headerOSTC3.diveNumber, &pHead->diveNumber, 2);
1589
1590 headerOSTC3.diveMode = pHead->diveMode;
1591 headerOSTC3.CCRmode = pHead->CCRmode;
1592
1593 memcpy(headerOSTC3.n2CompartDesatTime_min,pHead->n2CompartDesatTime_min, 16);
1594 memcpy(headerOSTC3.n2Compartments, pHead->n2Compartments, 64);
1595 memcpy(headerOSTC3.heCompartDesatTime_min,pHead->heCompartDesatTime_min, 16);
1596 memcpy(headerOSTC3.heCompartments, pHead->heCompartments, 64);
1597
1598 headerOSTC3.lastDecostop_m = pHead->lastDecostop_m;
1599
1600 memcpy(headerOSTC3.hwHudBattery_mV, &pHead->hwHudBattery_mV, 2);
1601
1602 headerOSTC3.hwHudLastStatus = pHead->hwHudLastStatus;
1603
1604 memcpy(headerOSTC3.batteryGaugeRegisters,&pHead->batteryGaugeRegisters, 6);
1605
1606
1607 memcpy(headerOSTC3.diveHeaderEnd, &pHead->diveHeaderEnd, 2);
1608 1634
1609 return &headerOSTC3; 1635 return &headerOSTC3;
1610 } 1636 }
1611 1637
1612 1638
1616 * @version V0.0.1 1642 * @version V0.0.1
1617 * @date 31-Juli-2015 1643 * @date 31-Juli-2015
1618 *********************************************************************************/ 1644 *********************************************************************************/
1619 SLogbookHeaderOSTC3compact * logbook_build_ostc3header_compact(SLogbookHeader* pHead) 1645 SLogbookHeaderOSTC3compact * logbook_build_ostc3header_compact(SLogbookHeader* pHead)
1620 { 1646 {
1647 uint8_t returnEmptyHeader = 0;
1621 convert_Type data, data2; 1648 convert_Type data, data2;
1622 uint32_t dummyLength = 0; 1649 uint32_t dummyLength = 0;
1623 1650 uint32_t headerProfileLength, sampleProfileLength, sampleProfileStart;
1624 1651
1625 data.u8bit.byteHigh = 0; 1652 if(pHead->diveHeaderStart != 0xFAFA)
1626 data.u8bit.byteLow = pHead->pBeginProfileData[0]; 1653 {
1627 data.u8bit.byteMidLow = pHead->pBeginProfileData[1]; 1654 returnEmptyHeader = 1;
1628 data.u8bit.byteMidHigh = pHead->pBeginProfileData[2];
1629
1630 data2.u8bit.byteHigh = 0;
1631 data2.u8bit.byteLow = pHead->pEndProfileData[0];
1632 data2.u8bit.byteMidLow = pHead->pEndProfileData[1];
1633 data2.u8bit.byteMidHigh = pHead->pEndProfileData[2];
1634
1635 if( (pHead->pBeginProfileData[0] == 0) /* no sample data available => use dummy */
1636 &&(pHead->pBeginProfileData[1] == 0)
1637 &&(pHead->pBeginProfileData[2] == 0))
1638 {
1639 dummyLength = logbook_fillDummySampleBuffer(pHead);
1640
1641 data2.u32bit = data.u32bit + dummyLength; /* calc new end address (which is equal to dummyLength) */
1642 data.u32bit = data2.u32bit; /* data is used below to represent the length */
1643 } 1655 }
1644 else 1656 else
1645 { 1657 {
1646 /* check if sample address information are corrupted by address range. */ 1658 data.u8bit.byteHigh = 0;
1647 /* TODO: Workaround. Better solution would be to check end of ring for 0xFF pattern */ 1659 data.u8bit.byteLow = pHead->pBeginProfileData[0];
1648 if((data.u32bit > data2.u32bit) && (data.u32bit < (SAMPLESTOP - 0x9000))) 1660 data.u8bit.byteMidLow = pHead->pBeginProfileData[1];
1661 data.u8bit.byteMidHigh = pHead->pBeginProfileData[2];
1662
1663 sampleProfileStart = data.u32bit;
1664
1665 data2.u8bit.byteHigh = 0;
1666 data2.u8bit.byteLow = pHead->pEndProfileData[0];
1667 data2.u8bit.byteMidLow = pHead->pEndProfileData[1];
1668 data2.u8bit.byteMidHigh = pHead->pEndProfileData[2];
1669
1670 data.u8bit.byteHigh = 0;
1671 data.u8bit.byteLow = pHead->profileLength[0];
1672 data.u8bit.byteMidLow = pHead->profileLength[1];
1673 data.u8bit.byteMidHigh = pHead->profileLength[2];
1674
1675 if(data.u32bit != 0xFFFFFF)
1649 { 1676 {
1650 data2.u32bit = data.u32bit + DEFAULT_SAMPLES; 1677 if(data2.u32bit < sampleProfileStart) /* Wrap around of sample ring detected */
1651 pHead->pEndProfileData[0] = data2.u8bit.byteLow; 1678 {
1652 pHead->pEndProfileData[1] = data2.u8bit.byteMidLow; 1679 if(ext_flash_SampleOverrunValid() == 0) /* Wrap around does not seem to be valid => fallback */
1653 pHead->pEndProfileData[2] = data2.u8bit.byteMidHigh; 1680 {
1654 data.u32bit = DEFAULT_SAMPLES; 1681 sampleProfileStart = 0;
1682 }
1683 }
1684
1685 if( sampleProfileStart == 0) /* no sample data available => use dummy */
1686 {
1687 sampleProfileLength = 1;
1688 headerProfileLength = 2;
1689 }
1690 else
1691 {
1692 headerProfileLength = (pHead->profileLength[2] << 16) + (pHead->profileLength[1] << 8) + pHead->profileLength[0];
1693 sampleProfileLength = ext_flash_read_profilelength_small_header(sampleProfileStart);
1694 }
1695 if(sampleProfileLength != headerProfileLength)
1696 {
1697 dummyLength = logbook_fillDummySampleBuffer(pHead);
1698
1699 data2.u32bit = sampleProfileStart + dummyLength; /* calc new end address (which is equal to dummyLength) */
1700 data.u32bit = dummyLength; /* data is used below to represent the length */
1701 }
1702 data.u32bit += 3;
1703 headerOSTC3compact.profileLength[0] = data.u8bit.byteLow;
1704 headerOSTC3compact.profileLength[1] = data.u8bit.byteMidLow;
1705 headerOSTC3compact.profileLength[2] = data.u8bit.byteMidHigh;
1706
1707 headerOSTC3compact.dateYear = pHead->dateYear;
1708 headerOSTC3compact.dateMonth = pHead->dateMonth;
1709 headerOSTC3compact.dateDay = pHead->dateDay;
1710 headerOSTC3compact.timeHour = pHead->timeHour;
1711 headerOSTC3compact.timeMinute = pHead->timeMinute;
1712
1713 memcpy(headerOSTC3compact.maxDepth, &pHead->maxDepth, 2);
1714 memcpy(headerOSTC3compact.diveTimeMinutes, &pHead->diveTimeMinutes, 2);
1715
1716 headerOSTC3compact.diveTimeSeconds = pHead->diveTimeSeconds;
1717 headerOSTC3compact.totalDiveNumberLow = pHead->diveNumber & 0xFF;
1718 headerOSTC3compact.totalDiveNumberHigh = (uint8_t)(pHead->diveNumber/256);
1719 headerOSTC3compact.profileVersion = 0x24; // Logbook-Profile version, 0x24 = date and time is start not end
1655 } 1720 }
1656 else 1721 else
1657 { 1722 {
1658 data.u8bit.byteHigh = 0; 1723 returnEmptyHeader = 1;
1659 data.u8bit.byteLow = pHead->profileLength[0];
1660 data.u8bit.byteMidLow = pHead->profileLength[1];
1661 data.u8bit.byteMidHigh = pHead->profileLength[2];
1662 } 1724 }
1663 } 1725 }
1664 if(data.u32bit != 0xFFFFFF) 1726 if(returnEmptyHeader)
1665 {
1666 data.u32bit += 3;
1667
1668 headerOSTC3compact.profileLength[0] = data.u8bit.byteLow;
1669 headerOSTC3compact.profileLength[1] = data.u8bit.byteMidLow;
1670 headerOSTC3compact.profileLength[2] = data.u8bit.byteMidHigh;
1671
1672 headerOSTC3compact.dateYear = pHead->dateYear;
1673 headerOSTC3compact.dateMonth = pHead->dateMonth;
1674 headerOSTC3compact.dateDay = pHead->dateDay;
1675 headerOSTC3compact.timeHour = pHead->timeHour;
1676 headerOSTC3compact.timeMinute = pHead->timeMinute;
1677
1678 memcpy(headerOSTC3compact.maxDepth, &pHead->maxDepth, 2);
1679 memcpy(headerOSTC3compact.diveTimeMinutes, &pHead->diveTimeMinutes, 2);
1680
1681 headerOSTC3compact.diveTimeSeconds = pHead->diveTimeSeconds;
1682
1683
1684 headerOSTC3compact.totalDiveNumberLow = pHead->diveNumber & 0xFF;
1685 headerOSTC3compact.totalDiveNumberHigh = (uint8_t)(pHead->diveNumber/256);
1686 headerOSTC3compact.profileVersion = 0x24; // Logbook-Profile version, 0x24 = date and time is start not end
1687 }
1688 else
1689 { 1727 {
1690 memset(&headerOSTC3compact, 0xFF, sizeof(SLogbookHeaderOSTC3compact)); 1728 memset(&headerOSTC3compact, 0xFF, sizeof(SLogbookHeaderOSTC3compact));
1691 } 1729 }
1692 return &headerOSTC3compact; 1730 return &headerOSTC3compact;
1693 } 1731 }
1908 else 1946 else
1909 { 1947 {
1910 divisor.temperature--; 1948 divisor.temperature--;
1911 } 1949 }
1912 1950
1913 logbook_writeDummy((void *) &smallDummyHeader,sizeof(smallDummyHeader)); 1951 logbook_writeDummy((void *) sample,length);
1914 } 1952 }
1915 1953
1916 1954
1917 uint16_t logbook_fillDummySampleBuffer(SLogbookHeader* pHeader) 1955 uint16_t logbook_fillDummySampleBuffer(SLogbookHeader* pHeader)
1918 { 1956 {