/**
  ******************************************************************************
	* @copyright heinrichs weikamp
  * @file   		logbook.c
  * @author 		heinrichs weikamp gmbh and heinrichs weikamp gmbh
  * @date   		22-Apr-2014
  * @version		V0.0.3
  * @since			03-Feb-2016
  * @brief			Everything about creating and evaluating the logbook
	*							without the flash part which is included in externLogbookFlash.c
	*							and the USB/Bluetooth part in tComm.c
	*							CHANGE V0.0.3 hw: ppO2 sensor values
	*							CHANGE V0.0.4 hw: fix event bytes according to hwos_interface.odt dated 160610 in bitbucket hwOS
	* @bug
	* @warning
  @verbatim
  ==============================================================================
              ##### Header #####
  ==============================================================================
  [..] SLogbookHeader
				The order has changed in comparsion to OSTC3 for perfect alignment
				with 16bit and 32bit. The header is 256kB as well.
				DO NOT rearrange anything but add new data to a second page
				beyond diveHeaderEnd. Use extraPagesWithData to indicate that there is
				data available that was not available in the OSTC3 256KB
				This data will be behind the diveHeaderEnd. DO NOT delete diveHeaderEnd.

	[..] SLogbookHeaderOSTC3
				is the format used by the OSTC3.
				logbook_getHeaderOSTC3() does the job using the global headers in logbook.c

	[..] SSmallHeader
				- is the format used by the OSTC3

	[..] Summary
				The header format is not perfect and might be optimized prior to
				releasing the diving computer. For now it is good to be compatible
				with PC software available for checking the content of the logbook


	@endverbatim
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2014 heinrichs weikamp</center></h2>
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include <string.h>
#include "logbook.h"
//#include "test_vpm.h"
#include "externLogbookFlash.h"
#include "data_exchange.h"
#include "decom.h"
#include "tHome.h" // for  tHome_findNextStop()
 
/* Private types -------------------------------------------------------------*/

#define NUM_GASES 5

#define LOGBOOK_VERSION (0x30)
#define LOGBOOK_VERSION_OSTC3 (0x24)

typedef struct /* don't forget to adjust void clear_divisor(void) */
{
	uint8_t temperature;
	uint8_t deco_ndl;
	uint8_t gradientFactor;
	uint8_t ppo2;
	uint8_t decoplan;
	uint8_t cns;
	uint8_t tank;
} SDivisor;

/* Exported variables --------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/
uint8_t data_store[10000];
SLogbookHeader  header;
SLogbookHeaderOSTC3	headerOSTC3;
SLogbookHeaderOSTC3compact headerOSTC3compact;
SSmallHeader smallHeader;
SDivisor divisor;
SDivisor divisorBackup;

/* Private function prototypes -----------------------------------------------*/
void clear_divisor(void);
void logbook_SetAverageDepth(float average_depth_meter);
void logbook_SetMinTemperature(float min_temperature_celsius);
void logbook_SetMaxCNS(float max_cns_percentage);
void logbook_SetCompartmentDesaturation(void);
void logbook_SetLastStop(float last_stop_depth_bar);
void logbook_writedata(void * data, int length_byte);
void logbook_UpdateHeader(void);

/* Exported functions --------------------------------------------------------*/

/** used by test_vpm.c at the moment */
void logbook_EndDive(void)
{
	ext_flash_close_new_dive_log((uint8_t*) &header);
}


//  ===============================================================================
//	logbook_last_totalDiveCount
/// @brief	Fix setting issues
///	@date    04-April-2016
///
/// @return diveNumber (totalDiveCounter) of latest log entry, 0 if not a valid header
//  ===============================================================================
uint16_t logbook_lastDive_diveNumber(void)
{
	SLogbookHeader  tempLogbookHeader;
	if(logbook_getHeader(0, &tempLogbookHeader))
	{
		return tempLogbookHeader.diveNumber;
	}
	else
	{
		return 0;
	}
}


/**
  ******************************************************************************
  * @brief   logbook_getCurrentHeader. /
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
    * @return  SLogbookHeader*:
*/
SLogbookHeader* logbook_getCurrentHeader(void)
{
    return &header;
}

/**
  ******************************************************************************
  * @brief   logbook_getHeaderOSTC3. /
  * @author  heinrichs weikamp gmbh
  * @version V0.0.1
  * @date    26-Nov-2014
  ******************************************************************************
	*
    * @param  StepBackwards : 0 Last lokbook entry, 1 second to last entry, etc.
     * @param  SSLogbookHeader* pLogbookHeader:  Output found LogbookHeader
    * @return  uint8_t : 1 = success
*/
/*
SLogbookHeaderOSTC3 * logbook_getHeaderOSTC3(uint8_t StepBackwards)
{
    if(!logbook_getHeader(StepBackwards, &header))
        return 0;
    else
		{
			logbook_build_ostc3header();
			return &headerOSTC3;
		}
}
*/

/**
  ******************************************************************************
  * @brief   logbook_getNumberOfHeaders. /
  * @author  heinrichs weikamp gmbh
  * @version V0.0.1
  * @date    18-May-2016
  ******************************************************************************
	*
  * @return  uint8_t : number of valid headers (0xFAFA) found.
*/
uint8_t logbook_getNumberOfHeaders(void)
{
	return ext_flash_count_dive_headers();
}


/**
  ******************************************************************************
  * @brief   logbook_getHeader. /
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
    * @param  StepBackwards : 0 Last lokbook entry, 1 second to last entry, etc.
     * @param  SSLogbookHeader* pLogbookHeader:  Output found LogbookHeader
    * @return  uint8_t : 1 = success
*/
uint8_t logbook_getHeader(uint8_t StepBackwards,SLogbookHeader* pLogbookHeader)
{
    ext_flash_read_dive_header((uint8_t *)pLogbookHeader,  StepBackwards);
    if(pLogbookHeader->diveHeaderStart != 0xFAFA)
        return 0;
    else
        return 1;
}

/**
  ******************************************************************************
  * @brief   logbook_initNewdiveProfile. /
  *           creates header and smallHeader from diveState and global Settings
  *           and writes new lookboock entry on flash device
  *           diveState
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
    * @param  SDiveState* pInfo: Input
    * @param  SSettings* pSettings:  Input
*/

void logbook_initNewdiveProfile(const SDiveState* pInfo, SSettings* pSettings)
{
	RTC_DateTypeDef Sdate;
	RTC_TimeTypeDef Stime;

	for(int i = 0; i < sizeof(SLogbookHeader); i++)
	{
		((uint8_t*)(&header))[i] = 0;
	}
	header.diveHeaderStart = 0xFAFA;
	header.diveHeaderEnd = 0xFBFB;
	header.samplingRate = 2;
	if(pInfo->diveSettings.diveMode == DIVEMODE_OC)
  {
    for(int i = 0; i < 5; i++)
    {
      header.gasordil[i].oxygen_percentage = pSettings->gas[i+1].oxygen_percentage;
      header.gasordil[i].helium_percentage = pSettings->gas[i+1].helium_percentage;
      header.gasordil[i].note.uw = pSettings->gas[i+1].note.uw;
      header.gasordil[i].depth_meter = pSettings->gas[i+1].depth_meter;
    }
  }
  else
  {
    for(int i = 0; i < 5; i++)
    {
      header.gasordil[i].oxygen_percentage = pSettings->gas[i+6].oxygen_percentage;
      header.gasordil[i].helium_percentage = pSettings->gas[i+6].helium_percentage;
      header.gasordil[i].note.uw = pSettings->gas[i+6].note.uw;
      header.gasordil[i].depth_meter = pSettings->gas[i+6].depth_meter;
    }

    for(int i = 0; i < 5; i++)
    {
      header.setpoint[i].setpoint_cbar = pSettings->setpoint[i+1].setpoint_cbar;
      header.setpoint[i].depth_meter = pSettings->setpoint[i+1].depth_meter;
    }
  }
//	header.gasordil[pInfo->lifeData.actualGas.GasIdInSettings].depth_meter = 0;

	translateDate(pInfo->lifeData.dateBinaryFormat, &Sdate);
	translateTime(pInfo->lifeData.timeBinaryFormat, &Stime);
	header.dateYear = Sdate.Year;
	header.dateMonth = Sdate.Month;
	header.dateDay = Sdate.Date;
	header.timeHour = Stime.Hours;
	header.timeMinute = Stime.Minutes;
	header.cnsAtBeginning = (uint16_t)((pInfo->lifeData.cns * 100) + 0.5f);
	header.surfacePressure_mbar = (uint16_t)(pInfo->lifeData.pressure_surface_bar * 1000);
	header.firmwareVersionHigh = firmwareVersion_16bit_high();
	header.firmwareVersionLow = firmwareVersion_16bit_low();
	header.logbookProfileVersion = LOGBOOK_VERSION;
	header.salinity = pSettings->salinity;
	header.diveNumber = pSettings->totalDiveCounter;
	header.personalDiveCount = pSettings->personalDiveCount;

	header.diveMode = pInfo->diveSettings.diveMode;
	header.CCRmode = pInfo->diveSettings.CCR_Mode;
	header.lastDecostop_m = pSettings->last_stop_depth_meter;

	if(pInfo->diveSettings.deco_type.ub.standard == GF_MODE)
	{
		header.decoModel = 1;
		header.gfLow_or_Vpm_conservatism = pInfo->diveSettings.gf_low;
		header.gfHigh = pInfo->diveSettings.gf_high;
	}
	else
	{
		header.decoModel = 2;
		header.gfLow_or_Vpm_conservatism = pInfo->diveSettings.vpm_conservatism;
		header.gfHigh = 0;
	}

	memcpy(header.n2Compartments, pInfo->lifeData.tissue_nitrogen_bar, 64);
	memcpy(header.heCompartments, pInfo->lifeData.tissue_helium_bar, 64);

	logbook_SetCompartmentDesaturation();

	ext_flash_start_new_dive_log_and_set_actualPointerSample((uint8_t*)&header);

	smallHeader.profileLength[0] = 0xFF;
	smallHeader.profileLength[1] = 0xFF;
	smallHeader.profileLength[2] = 0xFF;
	smallHeader.samplingRate_seconds = 2;
	smallHeader.numDivisors = 7;

	smallHeader.tempType = 0;
	smallHeader.tempLength = 2;
	smallHeader.tempDivisor = 6;

	smallHeader.deco_ndlType = 1;
	smallHeader.deco_ndlLength = 2;
	smallHeader.deco_ndlDivisor = 6; //= 6;

	/* GF in % at actual position */
	smallHeader.gfType =  2;
	smallHeader.gfLength = 1;
	smallHeader.gfDivisor = 0; //12;

	/* 3 Sensors: 8bit ppO2 in 0.01bar, 16bit voltage in 0,1mV */
	smallHeader.ppo2Type = 3;
	smallHeader.ppo2Length = 9;
	smallHeader.ppo2Divisor = 2; //2

	/* last 15 stops in minutes (last, second_to_last, ... */
	/* last stop depth is defined in header */
	smallHeader.decoplanType = 4;
	smallHeader.decoplanLength = 15;
	smallHeader.decoplanDivisor = 12;//12;

	smallHeader.cnsType = 5;
	smallHeader.cnsLength = 2;
	smallHeader.cnsDivisor = 12;

	smallHeader.tankType = 6;
	smallHeader.tankLength = 0;
	smallHeader.tankDivisor = 0;

	logbook_writedata((void *) &smallHeader,sizeof(smallHeader));

	clear_divisor();
}

/**
  ******************************************************************************
  * @brief   clear_divisor /  clears divisor struct
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
*/
void clear_divisor(void)
{
	divisor.cns = smallHeader.cnsDivisor - 1;
	divisor.decoplan = smallHeader.decoplanDivisor - 1;
	divisor.deco_ndl = smallHeader.deco_ndlDivisor - 1;
	divisor.gradientFactor = smallHeader.gfDivisor -1 ;
	divisor.ppo2 = smallHeader.ppo2Divisor - 1;
	divisor.tank = smallHeader.tankDivisor - 1;
	divisor.temperature = smallHeader.tempDivisor - 1;
}


/**
  ******************************************************************************
  * @brief   add16. /  adds 16 bit variable to 8 bit array
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
    * @param  uint8_t *pos: Output 8 bit array
    * @param  uint16_t var:  16 bit variable
*/
void addU16(uint8_t *pos, uint16_t var)
{
       *((uint16_t*)pos) = var;
}

void addS16(uint8_t *pos, int16_t var)
{
       *((int16_t*)pos) = var;
}

/**
  ******************************************************************************
  * @brief   logbook_writeSample. /  Writes one logbook sampl
  * @author  Peter Ryser
  * @date    22-April-2014
  * @version V0.0.2
  * @since   20-June-2016
	* @bug		 Deco/NDL Status fixed in V0.0.2


******************************************************************************
	*
  * @param  SDiveState state:
  */

void logbook_writeSample(SDiveState state)
{
    uint8_t sample[256];
  //  int position = 0;
    int length = 0;
//    _Bool bEvent = 0;
    uint8_t nextstopDepthMeter = 0;
		uint16_t nextstopLengthSeconds = 0;
		uint8_t	nextstopLengthMinutes = 0;
    bit8_Type eventByte1, eventByte2;
    bit8_Type profileByteFlag;
    int i = 0;
    for(i = 0; i <256 ;i++)
            sample[i] = 0;
    addU16(sample, (uint16_t)(state.lifeData.depth_meter * 100));
    length += 2;
    sample[2] = 0;
    length++;
    eventByte1.uw = 0;
    eventByte2.uw = 0;
    //uint16_t tmpU16 = 0;
	const SDecoinfo * pDecoinfo; // new hw 160620

    //BuildEevntyte 1
		// sub old 0-3 only one at a time
    if(state.events.manualMarker)
    {
        eventByte1.uw = 6;
    }
		else
    if(state.warnings.decoMissed)
    {
        eventByte1.uw = 2;
    }
		else
    if(state.warnings.ppO2Low)
    {
        eventByte1.uw = 4;
    }
		else
    if(state.warnings.ppO2High)
    {
        eventByte1.uw = 5;
    }
		else
    if(state.warnings.lowBattery)
    {
        eventByte1.uw = 7;
    }
		else
    if(state.warnings.slowWarning)
    {
        eventByte1.uw = 1;
    }
		// sub bit 4 to 7
    if(state.events.manuelGasSet)
    {
        eventByte1.ub.bit4 = 1;
    }
    if(state.events.gasChange)
    {
        eventByte1.ub.bit5 = 1;
    }
    if(state.events.setpointChange)
    {
        eventByte1.ub.bit6 = 1;
    }
		// sub bit 7 + eventbyte2
    if(state.events.bailout)
    {
        eventByte1.ub.bit7 = 1;
        eventByte2.ub.bit0 = 1;
    }
    //Add EventByte 1
    if(eventByte1.uw > 0)
    {
        sample[length] = eventByte1.uw;
        length++;
    }
    if(eventByte2.uw > 0)
    {
        sample[length] = eventByte2.uw;
        length++;
    }
    //Add EventInfos
    if(state.events.manuelGasSet)
    {
        //manual gas in %O2 & %He
        sample[length] = state.events.info_manuelGasSetO2;
        length += 1;
        sample[length] = state.events.info_manuelGasSetHe;
        length += 1;
    }
    if(state.events.gasChange)
    {
        //Current gas (gasid)
        sample[length] = state.events.info_GasChange;
        length += 1;
    }
    if(state.events.setpointChange)
    {
        //New setpoint in cbar
        sample[length] = state.events.info_SetpointChange;
        length += 1;
    }
    if(state.events.bailout)
    {
      //bailout gas in % O2 & %He
        sample[length] = state.events.info_bailoutO2;
        length += 1;
        sample[length] = state.events.info_bailoutHe;
        length += 1;
    }


    if(divisor.temperature == 0)
    {
			divisor.temperature = smallHeader.tempDivisor - 1;
			addS16(&sample[length], (int16_t)((state.lifeData.temperature_celsius * 10.0f) + 0.5f));
			length += 2;
    }
    else
    {
        divisor.temperature--;
    }
		
		
    if(smallHeader.deco_ndlDivisor > 0)
    {
      if(divisor.deco_ndl == 0)
      {
				divisor.deco_ndl  = smallHeader.deco_ndlDivisor - 1;
				
				if(stateUsed->diveSettings.deco_type.ub.standard == GF_MODE)
					pDecoinfo = &stateUsed->decolistBuehlmann;
				else if(stateUsed->diveSettings.deco_type.ub.standard == VPM_MODE)
					pDecoinfo = &stateUsed->decolistVPM;
				else // should not happen as only GF and VPM at the moment
				{
					sample[length] = 0;
					length += 1;
					sample[length] = 0;
					length += 1;
				}
					
				if(pDecoinfo->output_ndl_seconds > 0)
				{
					sample[length] = 0;
					length += 1;
					sample[length] = (uint8_t)pDecoinfo->output_ndl_seconds / 60;
					length += 1;
				}
				else if(pDecoinfo->output_time_to_surface_seconds)
				{
					tHome_findNextStop(pDecoinfo->output_stop_length_seconds, &nextstopDepthMeter, &nextstopLengthSeconds);
					nextstopLengthMinutes = (nextstopLengthSeconds +59 ) / 60;
					
					sample[length] = nextstopDepthMeter;
					length += 1;
					sample[length] = nextstopLengthMinutes;
					length += 1;
				}
				else
				{
					sample[length] = 0;
					length += 1;
					sample[length] = 0;
					length += 1;
				}
      }
      else
      {
          divisor.deco_ndl --;
      }
    }

		
    if(smallHeader.ppo2Divisor)
    {
      if(divisor.ppo2 == 0)
      {
          divisor.ppo2 = smallHeader.ppo2Divisor - 1;

        for(int i = 0; i <3; i++)
        {
          sample[length] = (uint8_t)(state.lifeData.ppO2Sensor_bar[i] * 100.0f + 0.5f);
          length += 1;
          addU16(&sample[length], (uint16_t)(state.lifeData.sensorVoltage_mV[i] * 10.0f + 0.5f));
          length += 2;
        }
      }
      else
      {
          divisor.ppo2--;
      }
    }


    if(smallHeader.decoplanDivisor)
    {
      if(divisor.decoplan == 0)
      {
          divisor.decoplan  = smallHeader.decoplanDivisor - 1;
          if(state.diveSettings.deco_type.ub.standard == VPM_MODE)
          {
            for(int i = 0; i <15; i++)
            {
              sample[length] = state.decolistVPM.output_stop_length_seconds[i] / 60;
              length += 1;
            }
          }
          else if(state.diveSettings.deco_type.ub.standard == GF_MODE)
          {
            for(int i = 0; i <15; i++)
            {
              sample[length] = state.decolistBuehlmann.output_stop_length_seconds[i] / 60;
              length += 1;
            }
          }
          else
          {
             for(int i = 0; i <15; i++)
             {
                sample[length] = 0;
                length += 1;
             }
          }
         // add16(&sample[length], state.temperature);
          //length += 2;
      }
      else
      {
          divisor.decoplan --;
      }
    }
    if(divisor.cns == 0)
    {
        divisor.cns = smallHeader.cnsDivisor - 1;
        //addU16(&sample[length], (uint16_t)(state.lifeData.cns * 100.0f + 0.5f));
        addU16(&sample[length], (uint16_t)(state.lifeData.cns)); // hw 151110 cns is 0 to 100 % and more (not 0 to 1.00 and more)
        length += 2;
    }
    else
    {
        divisor.cns--;
    }

    profileByteFlag.uw = length - 3;
    if(eventByte1.uw)
    {
        profileByteFlag.ub.bit7 = 1;
    }
    sample[2] = profileByteFlag.uw;
    logbook_writedata((void *) sample,length);

}



uint16_t actual_depth1;
uint16_t actual_depth2;
uint16_t actual_length1;
uint16_t actual_length2;
uint16_t actual_inum;

/**
  ******************************************************************************
  * @brief   readSample. /  Reads data of one logbook sample
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
  * @param  int32_t* depth: output Value
  * @param  int16_t * gasid: output Value
  * @param  int32_t* temperature: output Value
  * @param  int32_t* sensor1, sensor2, sensor3: output Value
  * @param  int32_t* cns: output Value
  * @return bytes read / 0 = reading Error
  */
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)
{
	int length = 0;
	_Bool bEvent = 0;
	bit8_Type eventByte1, eventByte2;
	bit8_Type profileByteFlag;

	eventByte1.uw = 0;
	eventByte2.uw = 0;
	uint8_t tempU8 = 0;
	uint16_t temp = 0;
	uint16_t bytesRead = 0;

	if(gasid)
		*gasid = -1;
	if(temperature)
			*temperature = -1000;
	if(sensor1)
			*sensor1 = -1;
	if(sensor2)
			*sensor2 = -1;
	if(sensor3)
			*sensor3 = -1;
	if(cns)
			*cns = -1;
  if(setpoint_cbar)
    *setpoint_cbar = -1;
  if(bailout)
    *bailout = -1;
  if(manualGas)
  {
    manualGas->percentageO2 =-1;
    manualGas->percentageHe =-1;
  }
  if(decostopDepth)
    *decostopDepth = -1;

	ext_flash_read_next_sample_part( (uint8_t*)&temp, 2);
	if(depth)
        *depth = (int32_t)temp;
	bytesRead += 2;

	ext_flash_read_next_sample_part( &profileByteFlag.uw, 1);
	bytesRead ++;

	bEvent = profileByteFlag.ub.bit7;
	profileByteFlag.ub.bit7 = 0;
	length = profileByteFlag.uw;

	if(bEvent)
	{
			ext_flash_read_next_sample_part( &eventByte1.uw, 1);
			bytesRead ++;

			length--;

			//second event byte
			if(eventByte1.ub.bit7)
      {
        ext_flash_read_next_sample_part( &eventByte2.uw, 1);
        bytesRead ++;
        length--;
      }
			else
			{
				eventByte2.uw = 0;
			}
		
			//manual Gas Set
      if( eventByte1.ub.bit4)
			{
          //Evaluate manual Gas
					ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1);
					bytesRead +=1;
					length -= 1;
           manualGas->percentageO2 = tempU8;
          ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1);
					bytesRead +=1;
					length -= 1;
          manualGas->percentageHe = tempU8;
					if(gasid)
							*gasid = 0;
			}
			//gas change
			if( eventByte1.ub.bit5)
			{
					ext_flash_read_next_sample_part( &tempU8, 1);
					bytesRead +=1;
					length -= 1;
					if(gasid)
							*gasid = (uint16_t)tempU8;
			}
			//SetpointChange
			if( eventByte1.ub.bit6)
			{
					ext_flash_read_next_sample_part( &tempU8, 1);
					*setpoint_cbar = tempU8;
					bytesRead +=1;
					length -= 1;
			}
			
			// second event Byte
			//bailout
			if(eventByte2.ub.bit1)
			{
				//evaluate bailout gas Gas
				 *bailout = 1;

				ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1);
				bytesRead +=1;
				length -= 1;
				manualGas->percentageO2 = tempU8;
				ext_flash_read_next_sample_part( (uint8_t*)&tempU8, 1);
				bytesRead +=1;
				length -= 1;
				manualGas->percentageHe = tempU8;

				if(gasid)
						*gasid = 0;
			}
	}

	if(divisor.temperature == 0)
	{
			divisor.temperature = smallHeader.tempDivisor - 1;
			ext_flash_read_next_sample_part( (uint8_t*)&temp, 2);
			bytesRead +=2;
			length -= 2;
			if(temperature)
			{
					*temperature = (int32_t)temp;
			}
	}
	else
	{
			divisor.temperature--;
	}

	if(smallHeader.deco_ndlDivisor > 0)
  {
    if(divisor.deco_ndl == 0)
    {
      divisor.deco_ndl = smallHeader.deco_ndlDivisor - 1;
      ext_flash_read_next_sample_part( &tempU8, 1);
			if(decostopDepth)
			{
				*decostopDepth = tempU8 * 100;
			}
      ext_flash_read_next_sample_part( &tempU8, 1);
      bytesRead += 2;
      length -= 2;
    }
    else
    {
        divisor.deco_ndl--;
    }
  }

	if(divisor.ppo2 == 0)
	{
      int32_t ppO2Tmp = 0;
			divisor.ppo2 = smallHeader.ppo2Divisor -1;
			for(int i = 0; i <3 ; i++)
      {
        ext_flash_read_next_sample_part( &tempU8, 1);
        ppO2Tmp += tempU8;
        bytesRead +=1;
        length -= 1;
        ext_flash_read_next_sample_part( (uint8_t*)&temp, 2);
        bytesRead +=2;
        length -= 2;
				if(sensor1 && (i==0))
					*sensor1 = (((int32_t)tempU8) * 0xFFFF) + temp;
				if(sensor2 && (i==1))
					*sensor2 = (((int32_t)tempU8) * 0xFFFF) + temp;
				if(sensor3 && (i==2))
					*sensor3 = (((int32_t)tempU8) * 0xFFFF) + temp;
      }
	}
	else
	{
			divisor.ppo2--;
	}

  if(smallHeader.decoplanDivisor > 0)
  {
    if(divisor.decoplan == 0)
    {
      divisor.decoplan = smallHeader.decoplanDivisor - 1;
      for(int i = 0; i <15; i++)
        ext_flash_read_next_sample_part( &tempU8, 1);
      bytesRead += 15;
      length -= 15;
    }
    else
    {
        divisor.decoplan--;
    }
  }

	
	
	if(divisor.cns == 0)
	{
			 divisor.cns = smallHeader.cnsDivisor - 1;

      ext_flash_read_next_sample_part( (uint8_t*)&temp, 2);
			bytesRead +=2;
			length -= 2;
			if(cns)
			{
					*cns = (int32_t)temp;
			}
	}
	else
	{
			divisor.cns--;
	}

	if (length != 0)
			return 0;

	return bytesRead;
}
/**
  ******************************************************************************
  * @brief   logbook_readSampleData. /  Reads sample data of whole logbook entry
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
  * @param  uint8_t StepBackwards: witch lookbook entry?
  * @param  uint16_t length : maxlength of output arrays
  * @param  int32_t* depth : output  array
  * @param  int16_t * gasid : output  array
  * @param  int32_t* temperature : output  array
  * @param  int32_t* ppo2 : output  array
  * @param  int32_t* cns : output  array
  * @return length of output
  */
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)
{
     //Test read
    //SLogbookHeader header;

    //logbook_getHeader(&header);
    SLogbookHeader header;
    int iNum;
    int firstgasid = 0;
    int retVal = 0;
    int compression = 0;
     int i;
   // uint32_t diveTime_seconds;
    int32_t depthVal = 0;
    int16_t  gasidVal = 0;
    int16_t setPointVal = 0;
    int16_t bailoutVal = 0;
    int16_t bailoutLast = 0;
    uint16_t setPointLast = 0;
    int32_t temperatureVal = 0;
    int32_t sensor1Val = 0;
    int32_t sensor2Val = 0;
    int32_t sensor3Val = 0;
    int32_t sensor1Last = 0;
    int32_t sensor2Last = 0;
    int32_t sensor3Last = 0;
    int32_t cnsVal = 0;
    int32_t depthLast = 0;
    int16_t  gasidLast = 0;
    int32_t temperatureLast = 0;
    int32_t temperatureFirst = 0;
    int32_t cnsLast = 0;
		int16_t decostepDepthVal = 0;
		int16_t decostepDepthLast = 0;

     SManualGas manualGasVal;
     SManualGas manualGasLast;
     manualGasLast.percentageO2 = 0;
     manualGasLast.percentageHe = 0;

     float ambiant_pressure_bar = 0;
     float ppO2 = 0;
    ext_flash_read_dive_header((uint8_t*)&header,  StepBackwards);
    for(i = 0;i< 5;i++)
    {
        if(header.gasordil[i].note.ub.first)
            break;
    }
    firstgasid = i + 1;
    if(header.diveMode == DIVEMODE_CCR)
      setPointLast = header.setpoint[0].setpoint_cbar;
    else
      setPointLast = 0;
    //diveTime_seconds = header.diveTime_seconds ;
    for(compression = 1; compression < 100; compression ++)
    {
        if((header.total_diveTime_seconds / header.samplingRate)/compression <= length)
            break;
    }


    for(i = 0;i< length;i++)
    {
        if(depth)
            depth[i] = 0;
        if(temperature)
            temperature[i] = 0;
        if(gasid)
            gasid[i] = 0;
        if(ppo2)
            ppo2[i] = 0;
        if(setpoint)
            setpoint[i] = 0;
        if(sensor1)
            sensor1[i] = 0;
        if(sensor2)
            sensor2[i] = 0;
        if(sensor3)
            sensor3[i] = 0;
        if(cns)
            cns[i] = 0;
    }
    //We start with fist gasid
    gasidLast = firstgasid;


		//uint16_t* ppo2, uint16_t* cns#
     uint32_t totalNumberOfBytes = 0;
     uint32_t bytesRead = 0;
    ext_flash_open_read_sample( StepBackwards,&totalNumberOfBytes);
    ext_flash_read_next_sample_part((uint8_t*)&smallHeader,  sizeof(SSmallHeader));
    bytesRead += sizeof(SSmallHeader);

    clear_divisor();

    iNum = 0;
    int counter = 0;
		temperatureLast = -1000;
    while ((bytesRead < totalNumberOfBytes) && (iNum < length))
    {
			ext_flash_set_entry_point();
			divisorBackup = divisor;
			retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, &decostepDepthVal);

			if(retVal == 0)
			{
					//Error try to read again!!!
					ext_flash_reopen_read_sample_at_entry_point();
					divisor = divisorBackup;
					retVal = readSample(&depthVal,&gasidVal,&setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, &decostepDepthVal);

					if(retVal == 0)
							break;
			}
			bytesRead +=retVal;

			//if for some variable no new value is in the sample for (z.B. gasidVal = -1), we take the last value
			if(depthVal == -1)
					depthVal = depthLast;
			else
					depthLast = depthVal;

			if(gasidVal == -1)
					gasidVal = gasidLast;
			else
					gasidLast = gasidVal;

			if(temperatureVal == -1000)
					temperatureVal = temperatureLast;
			else
			{	
				if(temperatureLast == -1000)
					temperatureFirst = temperatureVal;
				temperatureLast = temperatureVal;
			}

			if(setPointVal == -1)
				setPointVal = setPointLast;
			else
				setPointLast = setPointVal;

			if(sensor1Val == -1)
					sensor1Val = sensor1Last;
			else
					sensor1Last = sensor1Val;

			if(sensor2Val == -1)
					sensor2Val = sensor2Last;
			else
					sensor2Last = sensor2Val;

			if(sensor3Val == -1)
					sensor3Val = sensor3Last;
			else
					sensor3Last = sensor3Val;

			if(cnsVal == -1)
					cnsVal = cnsLast;
			else
					cnsLast = cnsVal;

			if(manualGasVal.percentageO2 == -1)
				manualGasVal = manualGasLast;
			else
				manualGasLast = manualGasVal;

			if(bailoutVal == -1)
				bailoutVal = bailoutLast;
			else
				bailoutLast = bailoutVal;

			if(decostepDepthVal == -1)
					decostepDepthVal = decostepDepthLast;
			else
					decostepDepthLast = decostepDepthVal;
			
			counter++;
			// Heed compression
			// Write here to arrays
			if(counter == compression)
			{
				if(depth)
					depth[iNum] = depthVal;
				if(gasid)
					gasid[iNum] = gasidVal;
				if(temperature)
					temperature[iNum] = temperatureVal;
				if(cns)
					cns[iNum] = cnsVal;
				if(bailout)
					bailout[iNum] = bailoutVal;
				if(decostopDepth)
					decostopDepth[iNum] = decostepDepthVal;
					
				if(ppo2)
				{
					//Calc ppo2 - Values
					SGas gas;
					gas.setPoint_cbar = setPointVal;
					if(gasidVal > 0)
					{
						gas.helium_percentage = header.gasordil[gasidVal - 1].helium_percentage;
						gas.nitrogen_percentage = 100 -  gas.helium_percentage - header.gasordil[gasidVal - 1].oxygen_percentage;
					}
					else
					{
						gas.helium_percentage = manualGasVal.percentageHe;
						gas.nitrogen_percentage = 100 -  gas.helium_percentage - manualGasVal.percentageO2;
					}
					ambiant_pressure_bar =((float)(depthVal + header.surfacePressure_mbar))/1000;
					ppO2 = decom_calc_ppO2(ambiant_pressure_bar, &gas );
					ppo2[iNum] = (uint16_t) ( ppO2 * 100);
				}

				if(setpoint)
					setpoint[iNum] = setPointVal;

				if(sensor1)
					sensor1[iNum] = (sensor1Val / 0xFFFF) & 0xFF;
				if(sensor2)
					sensor2[iNum] = (sensor2Val / 0xFFFF) & 0xFF;
				if(sensor3)
					sensor3[iNum] = (sensor3Val / 0xFFFF) & 0xFF;
				iNum++;
				counter = 0;
			}
    }
		
		// Fix first Temperature Entries 150930 hw
		if(temperature)
		{
			int i = 0;
			while((temperature[i] == -1000) && (i < iNum))
				temperature[i++] = temperatureFirst;
		}
	
    ext_flash_close_read_sample();
    return iNum;
}


/********************************************************************************
 * @brief   logbook_InitAndWrite. /  Controls writing of logbook
 *          Should be called ten times per second
 *          Automatically Initializes logbook at beginning of dive,
 *          write samples every 2 seconds
 *          and finishes logbook after end of dive
*********************************************************************************/

void logbook_InitAndWrite(void)
{
	SSettings *pSettings = settingsGetPointer();
	static uint8_t bDiveMode = 0;
	static uint32_t tickstart = 0;
	uint32_t ticksdiff = 0;
	uint32_t lasttick = 0;
	static float min_temperature_float_celsius = 0;

	const SDiveState * pStateReal = stateRealGetPointer();

	if(!bDiveMode)
	{
		if((pStateReal->mode == MODE_DIVE) && (pStateReal->diveSettings.diveMode != DIVEMODE_Apnea) && (pStateReal->lifeData.dive_time_seconds >= 5))
		{
			//InitdiveProfile
			pSettings->totalDiveCounter++;
			logbook_initNewdiveProfile(pStateReal,settingsGetPointer());
			min_temperature_float_celsius = pStateReal->lifeData.temperature_celsius;
			//Write logbook sample
			logbook_writeSample(*pStateReal);
			resetEvents();
			tickstart = HAL_GetTick();
			bDiveMode = 1;
		}
	}
	else if((pStateReal->mode == MODE_DIVE) && (pStateReal->diveSettings.diveMode != DIVEMODE_Apnea))
	{
		lasttick = HAL_GetTick();
		ticksdiff = time_elapsed_ms(tickstart,lasttick);
		//
		if(ticksdiff >= 2000)
		{
			//Write logbook sample
			logbook_writeSample(*pStateReal);
			resetEvents();
			if(min_temperature_float_celsius > pStateReal->lifeData.temperature_celsius)
				min_temperature_float_celsius = pStateReal->lifeData.temperature_celsius;
			tickstart = lasttick;
			if((bDiveMode == 1) && (pStateReal->lifeData.dive_time_seconds >= pSettings->divetimeToCreateLogbook))
			{
				ext_flash_create_new_dive_log((uint8_t*)&header);
				/** save settings
					* with new lastDiveLogId and time and day
					*/
				pSettings->personalDiveCount++;
				if(pSettings->logbookOffset)
				{
					pSettings->logbookOffset++;
				}
				ext_flash_write_settings();
				ext_flash_disable_protection_for_logbook();
				bDiveMode = 3;
			}
			if(bDiveMode == 3)
				logbook_UpdateHeader();
		}
	}
	else if(bDiveMode == 3)
	{
		//End of Dive
		logbook_SetAverageDepth(pStateReal->lifeData.average_depth_meter);
		logbook_SetMinTemperature(min_temperature_float_celsius);
		logbook_SetMaxCNS(pStateReal->lifeData.cns);
		logbook_SetCompartmentDesaturation();
		logbook_SetLastStop(pStateReal->diveSettings.last_stop_depth_bar);
		logbook_EndDive();
		bDiveMode = 0;
	} else
	{
	  ext_flash_enable_protection();
	}
}


/* Private functions ---------------------------------------------------------*/

/********************************************************************************
	* @brief   logbook_UpdateHeader. /
	*					 set date, time, max depth. etc. pp.
	*					 the internal pointer to the end of profile and length will be set by
						 ext_flash_close_new_dive_log() in externLogbookFlash.c
  * @author  heinrichs weikamp gmbh
  * @version V0.0.1
  * @date    27-Nov-2014
*********************************************************************************/
void logbook_UpdateHeader(void)
{
	const SDiveState * pStateReal = stateRealGetPointer();
	SSettings *pSettings = settingsGetPointer();
//	uint16_t secondsAtShallow = 0;
	RTC_DateTypeDef Sdate;
	RTC_TimeTypeDef Stime;
	uint32_t time1_u32, time2_u32;
	uint32_t divetimeHelper;

	/* time and day */
	/* don't update CHANGE 160224 hw, maybe save actual time and date at other place
	translateDate(pStateReal->lifeData.dateBinaryFormat, &Sdate);
	translateTime(pStateReal->lifeData.timeBinaryFormat, &Stime);

	header.dateYear = Sdate.Year;
	header.dateMonth = Sdate.Month;
	header.dateDay = Sdate.Date;
	header.timeHour = Stime.Hours;
	header.timeMinute = Stime.Minutes;
	*/
	/// 160315 Quick fix for empty date problem
	if((!(header.dateYear)) || (!(header.dateMonth)) || (!(header.dateDay)))
	{
		translateDate(pStateReal->lifeData.dateBinaryFormat, &Sdate);
		translateTime(pStateReal->lifeData.timeBinaryFormat, &Stime);

		header.dateYear = Sdate.Year;
		header.dateMonth = Sdate.Month;
		header.dateDay = Sdate.Date;
		
		time1_u32 = (uint32_t)header.timeMinute + (uint32_t)(header.timeHour * 60);
		time2_u32 = (uint32_t)Stime.Minutes + (uint32_t)(Stime.Hours * 60);
		if(time2_u32 < time1_u32)
		{
			if(header.dateDay > 1)
			{
				header.dateDay -= 1;
			}
			else
			{
				header.dateMonth --;
				if(!header.dateMonth)
				{
					header.dateYear--;
					header.dateMonth = 12;
					header.dateDay = 31;
				}
				else
				{
					if(header.dateMonth == 2)
						header.dateDay = 28;
					else
					if((header.dateMonth == 4) || (header.dateMonth == 6) || (header.dateMonth == 9) || (header.dateMonth == 11))
						header.dateDay = 30;
					else
						header.dateDay = 31;
				}
			}
		}
	}
	
	/* duration */
	header.total_diveTime_seconds = pStateReal->lifeData.dive_time_seconds;
	header.maxDepth = pStateReal->lifeData.max_depth_meter * 100;

	/* old:
	
	secondsAtShallow = pSettings->timeoutDiveReachedZeroDepth;
	if(pStateReal->lifeData.dive_time_seconds <= secondsAtShallow)
		secondsAtShallow = 0;
	header.diveTimeMinutes = (header.total_diveTime_seconds - secondsAtShallow )/ 60;
	header.diveTimeSeconds = header.total_diveTime_seconds - secondsAtShallow - (header.diveTimeMinutes * 60);
	*/
	divetimeHelper = pStateReal->lifeData.dive_time_seconds_without_surface_time;
	header.diveTimeMinutes = (uint16_t)(divetimeHelper/60);
	divetimeHelper -= 60 * (uint32_t)header.diveTimeMinutes;
	header.diveTimeSeconds = (uint16_t)divetimeHelper;
	
	/* deco algorithm (final) */
	if(pStateReal->diveSettings.deco_type.ub.standard == GF_MODE)
	{
		header.decoModel = 1;
		header.gfLow_or_Vpm_conservatism = pStateReal->diveSettings.gf_low;
		header.gfHigh = pStateReal->diveSettings.gf_high;
	}
	else
	{
		header.decoModel = 2;
		header.gfLow_or_Vpm_conservatism = pStateReal->diveSettings.vpm_conservatism;
		header.gfHigh = 0;
	}

	/* tissue load */
	memcpy(header.n2Compartments, pStateReal->lifeData.tissue_nitrogen_bar, 64);
	memcpy(header.heCompartments, pStateReal->lifeData.tissue_helium_bar, 64);

}


void logbook_SetAverageDepth(float average_depth_meter)
{
		header.averageDepth_mbar = (uint16_t)(average_depth_meter * 100);
}


void logbook_SetMinTemperature(float min_temperature_celsius)
{
		header.minTemp = (int16_t)((min_temperature_celsius * 10.0f) + 0.5f);
}


void logbook_SetMaxCNS(float max_cns_percentage)
{
	if(max_cns_percentage < 9999)
		header.maxCNS = (uint16_t)(max_cns_percentage);
	else
		header.maxCNS = 9999;
}


void logbook_SetDesaturationTime(void)
{
		header.desaturationTime = 48 * 60;
}


void logbook_SetCompartmentDesaturation(void)
{
	const SDiveState * pStateReal = stateRealGetPointer();

	decom_tissues_desaturation_time(&pStateReal->lifeData, &secondaryInformation);
	for(int i=0;i<16;i++)
	{
		if(secondaryInformation.tissue_nitrogen_desaturation_time_minutes[i] <= (15 * 255))
			header.n2CompartDesatTime_min[i] = (uint8_t)((secondaryInformation.tissue_nitrogen_desaturation_time_minutes[i] + 14) / 15);
		else
			header.n2CompartDesatTime_min[i] = 255;
		if(secondaryInformation.tissue_helium_desaturation_time_minutes[i] <= (15 * 255))
			header.heCompartDesatTime_min[i] = (uint8_t)((secondaryInformation.tissue_helium_desaturation_time_minutes[i] + 14 )/ 15);
		else
			header.heCompartDesatTime_min[i] = 255;
	}
}

void logbook_SetLastStop(float last_stop_depth_bar)
{
	header.lastDecostop_m = (uint8_t)(last_stop_depth_bar / 10.0f);
}

void logbook_writedata(void * data, int length_byte)
{
    ext_flash_write_sample(data, length_byte);
}


/********************************************************************************
	* @brief   logbook_build_ostc3header. /
  * @author  heinrichs weikamp gmbh
  * @version V0.0.2
  * @date    27-Nov-2014
*********************************************************************************/
SLogbookHeaderOSTC3 * logbook_build_ostc3header(SLogbookHeader* pHead)
{
	convert_Type data;

	memcpy(headerOSTC3.diveHeaderStart,			&pHead->diveHeaderStart,					2);
	memcpy(headerOSTC3.pBeginProfileData,		&pHead->pBeginProfileData,				3);
	memcpy(headerOSTC3.pEndProfileData,			&pHead->pEndProfileData,					3);

	data.u8bit.byteHigh = 0;
	data.u8bit.byteLow 			= pHead->profileLength[0];
	data.u8bit.byteMidLow 	= pHead->profileLength[1];
	data.u8bit.byteMidHigh 	= pHead->profileLength[2];

	if(data.u32bit != 0xFFFFFF)
		data.u32bit += 3;

	headerOSTC3.profileLength[0] = data.u8bit.byteLow;
	headerOSTC3.profileLength[1] = data.u8bit.byteMidLow;
	headerOSTC3.profileLength[2] = data.u8bit.byteMidHigh;

	memcpy(headerOSTC3.gasordil,						pHead->gasordil,								 20);

	if(pHead->logbookProfileVersion == LOGBOOK_VERSION)
	{
		headerOSTC3.logbookProfileVersion = LOGBOOK_VERSION_OSTC3;
		memcpy(headerOSTC3.personalDiveCount,	&pHead->personalDiveCount,				2);
		headerOSTC3.safetyDistance_10cm = 0;

		for(int i=0;i<5;i++)
		{
			if(!pHead->gasordil[i].note.ub.active)
				headerOSTC3.gasordil[3 + (i*4)] = 0;
			else if(pHead->gasordil[i].note.ub.first)
			{
        /* depth = 0, note = 1 */
				headerOSTC3.gasordil[2 + (i*4)] = 0;
        headerOSTC3.gasordil[3 + (i*4)] = 1;
			}
			else if( pHead->gasordil[i].depth_meter)
			{
        /* note = 3 */
				headerOSTC3.gasordil[3 + (i*4)] = 3;
			}
		}
	}
	else
	{
		headerOSTC3.logbookProfileVersion = 0xFF;
		headerOSTC3.personalDiveCount[0] = 0xFF;
		headerOSTC3.personalDiveCount[1] = 0xFF;
		headerOSTC3.safetyDistance_10cm = 0xFF;
	}

	headerOSTC3.dateYear = pHead->dateYear;
	headerOSTC3.dateMonth = pHead->dateMonth;
	headerOSTC3.dateDay = pHead->dateDay;
	headerOSTC3.timeHour = pHead->timeHour;
	headerOSTC3.timeMinute = pHead->timeMinute;


	memcpy(headerOSTC3.maxDepth,						&pHead->maxDepth,									2);
	memcpy(headerOSTC3.diveTimeMinutes,			&pHead->diveTimeMinutes,					2);

	headerOSTC3.diveTimeSeconds = pHead->diveTimeSeconds;

	memcpy(headerOSTC3.minTemp,							&pHead->minTemp,									2);
	memcpy(headerOSTC3.surfacePressure_mbar,&pHead->surfacePressure_mbar,			2);
	memcpy(headerOSTC3.desaturationTime,		&pHead->desaturationTime,					2);

	headerOSTC3.firmwareVersionHigh = pHead->firmwareVersionHigh;
	headerOSTC3.firmwareVersionLow =	pHead->firmwareVersionLow;

	memcpy(headerOSTC3.batteryVoltage,			&pHead->batteryVoltage,						2);

	headerOSTC3.samplingRate = pHead->samplingRate;

	memcpy(headerOSTC3.cnsAtBeginning,			&pHead->cnsAtBeginning,						2);

	headerOSTC3.gfAtBeginning = pHead->gfAtBeginning;
	headerOSTC3.gfAtEnd = pHead->gfAtEnd;

	memcpy(headerOSTC3.setpoint,						pHead->setpoint,								 10);

	headerOSTC3.salinity = pHead->salinity;

	memcpy(headerOSTC3.maxCNS,							&pHead->maxCNS,										2);
	memcpy(headerOSTC3.averageDepth_mbar,		&pHead->averageDepth_mbar,				2);
	memcpy(headerOSTC3.total_diveTime_seconds,&pHead->total_diveTime_seconds,	2);

	headerOSTC3.gfLow_or_Vpm_conservatism = pHead->gfLow_or_Vpm_conservatism;
	headerOSTC3.gfHigh = pHead->gfHigh;
	headerOSTC3.decoModel = pHead->decoModel;

	memcpy(headerOSTC3.diveNumber,					&pHead->diveNumber,								2);

	headerOSTC3.diveMode = pHead->diveMode;
	headerOSTC3.CCRmode = pHead->CCRmode;

	memcpy(headerOSTC3.n2CompartDesatTime_min,pHead->n2CompartDesatTime_min, 16);
	memcpy(headerOSTC3.n2Compartments,			pHead->n2Compartments,					 64);
	memcpy(headerOSTC3.heCompartDesatTime_min,pHead->heCompartDesatTime_min, 16);
	memcpy(headerOSTC3.heCompartments,			pHead->heCompartments,					 64);

	headerOSTC3.lastDecostop_m = pHead->lastDecostop_m;

	memcpy(headerOSTC3.hwHudBattery_mV,		&pHead->hwHudBattery_mV,						2);

	headerOSTC3.hwHudLastStatus = pHead->hwHudLastStatus;

	memcpy(headerOSTC3.batteryGaugeRegisters,&pHead->batteryGaugeRegisters,		6);


	memcpy(headerOSTC3.diveHeaderEnd,			&pHead->diveHeaderEnd,							2);

	return &headerOSTC3;
}


/********************************************************************************
	* @brief   logbook_build_ostc3header_compact. /
  * @author  heinrichs weikamp gmbh
  * @version V0.0.1
  * @date    31-Juli-2015
*********************************************************************************/
SLogbookHeaderOSTC3compact * logbook_build_ostc3header_compact(SLogbookHeader* pHead)
{
	convert_Type data;

	data.u8bit.byteHigh = 0;
	data.u8bit.byteLow 			= pHead->profileLength[0];
	data.u8bit.byteMidLow 	= pHead->profileLength[1];
	data.u8bit.byteMidHigh 	= pHead->profileLength[2];

	if(data.u32bit != 0xFFFFFF)
	{
		data.u32bit += 3;

		headerOSTC3compact.profileLength[0] = data.u8bit.byteLow;
		headerOSTC3compact.profileLength[1] = data.u8bit.byteMidLow;
		headerOSTC3compact.profileLength[2] = data.u8bit.byteMidHigh;

		headerOSTC3compact.dateYear = pHead->dateYear;
		headerOSTC3compact.dateMonth = pHead->dateMonth;
		headerOSTC3compact.dateDay = pHead->dateDay;
		headerOSTC3compact.timeHour = pHead->timeHour;
		headerOSTC3compact.timeMinute = pHead->timeMinute;

		memcpy(headerOSTC3compact.maxDepth,					&pHead->maxDepth,									2);
		memcpy(headerOSTC3compact.diveTimeMinutes,	&pHead->diveTimeMinutes,					2);

		headerOSTC3compact.diveTimeSeconds = pHead->diveTimeSeconds;


		headerOSTC3compact.totalDiveNumberLow = pHead->diveNumber & 0xFF;
		headerOSTC3compact.totalDiveNumberHigh = (uint8_t)(pHead->diveNumber/256);
		headerOSTC3compact.profileVersion = 0x24; // Logbook-Profile version, 0x24 = date and time is start not end
	}
	else		
	{
		memset(&headerOSTC3compact, 0xFF, sizeof(SLogbookHeaderOSTC3compact));
	}
	return &headerOSTC3compact;
}


/**
  ******************************************************************************
  * @brief   logbook_readSampleData. /  Reads sample data of whole logbook entry
  * @author  Peter Ryser
  * @version V0.0.1
  * @date    22-April-2014
  ******************************************************************************
	*
  * @param  uint8_t StepBackwards: witch lookbook entry?
  * @param  uint16_t length : maxlength of output arrays
  * @param  int32_t* depth : output  array
  * @param  int16_t * gasid : output  array
  * @param  int32_t* temperature : output  array
  * @param  int32_t* ppo2 : output  array
  * @param  int32_t* cns : output  array
  * @return length of output
  */
void logbook_recover_brokenlog(uint8_t headerId)
{
    int16_t retVal;
    int32_t depthVal = 0;
    int16_t  gasidVal = 0;
    int16_t setPointVal = 0;
    int16_t bailoutVal = 0;
    int32_t temperatureVal = 0;
    int32_t sensor1Val = 0;
    int32_t sensor2Val = 0;
    int32_t sensor3Val = 0;
    int32_t cnsVal = 0;
     SManualGas manualGasVal;

		//uint16_t* ppo2, uint16_t* cns#
     uint32_t bytesRead = 0;

    ext_flash_read_block_start();
    ext_flash_read_next_sample_part((uint8_t*)&smallHeader,  sizeof(SSmallHeader));
    bytesRead += sizeof(SSmallHeader);

    clear_divisor();


    int sampleCounter = 0;
    int maxdepth = 0;
    uint32_t avrdepth = 0;
    while (true)
    {

        ext_flash_set_entry_point();
        divisorBackup = divisor;
				retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL);
        if(retVal == 0)
        {
          //Error try to read again!!!
          ext_flash_reopen_read_sample_at_entry_point();
          divisor = divisorBackup;
					retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL);

          if(retVal == 0)
          {
              //Error try to read again!!!
              ext_flash_reopen_read_sample_at_entry_point();
              divisor = divisorBackup;
							retVal = readSample(&depthVal,&gasidVal, &setPointVal, &temperatureVal, &sensor1Val, &sensor2Val, &sensor3Val, &cnsVal, &manualGasVal, &bailoutVal, NULL);

              if(retVal == 0)
              {
                ext_flash_reopen_read_sample_at_entry_point();
                break;
              }

          }
        }
        if(depthVal > maxdepth)
          maxdepth = depthVal;
        avrdepth += depthVal;
        sampleCounter++;
        bytesRead +=retVal;
    }
    avrdepth/= sampleCounter;
    ext_flash_close_read_sample();
    SLogbookHeader header;

    ext_flash_read_dive_header2((uint8_t*) &header, headerId, false);
    header.total_diveTime_seconds = sampleCounter * header.samplingRate;
    header.diveTimeMinutes = header.total_diveTime_seconds /60;
    header.diveTimeSeconds = header.total_diveTime_seconds - header.diveTimeMinutes * 60;
    header.maxDepth = maxdepth;
    header.averageDepth_mbar = avrdepth;
    SSettings *	settings = settingsGetPointer();
    settings->lastDiveLogId = headerId;
    ext_flash_close_new_dive_log((uint8_t *)&header);
}

/************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/