view Discovery/Src/settings.c @ 899:2225c467f1e9 Evo_2_23

Added data path and visualization for position data: The GNSS data exchange is now initialized and triggered on a cyclic basis (once a second). RTE verion has been increased because of interface change. For now only the position data is shown in a T7 surface views. The functionality may be switched on/off using the compile switch ENABLE_GNSS.
author Ideenmodellierer
date Mon, 30 Sep 2024 21:56:05 +0200
parents 608d3e918146
children
line wrap: on
line source

///////////////////////////////////////////////////////////////////////////////
/// -*- coding: UTF-8 -*-
///
/// \file   Discovery/Src/settings.c
/// \brief  settingsHelperButtonSens_translate_hwOS_values_to_percentage.
/// \author Heinrichs Weikamp gmbh
/// \date   6-March-2017
///
/// \details
///
/// $Id$
///////////////////////////////////////////////////////////////////////////////
/// \par Copyright (c) 2014-2018 Heinrichs Weikamp gmbh
///
///     This program is free software: you can redistribute it and/or modify
///     it under the terms of the GNU General Public License as published by
///     the Free Software Foundation, either version 3 of the License, or
///     (at your option) any later version.
///
///     This program is distributed in the hope that it will be useful,
///     but WITHOUT ANY WARRANTY; without even the implied warranty of
///     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
///     GNU General Public License for more details.
///
///     You should have received a copy of the GNU General Public License
///     along with this program.  If not, see <http://www.gnu.org/licenses/>.
//////////////////////////////////////////////////////////////////////////////

#include <string.h>

#include "settings.h"
#include "firmwareEraseProgram.h" // for HARDWAREDATA_ADDRESS
#include "externLogbookFlash.h" // for SAMPLESTART and SAMPLESTOP
#include "text_multilanguage.h" // for LANGUAGE_END
#include "tHome.h" // for CVIEW_END
#include "motion.h"
#include "t7.h"
#include "data_central.h"

static uint8_t settingsWarning = 0;		/* Active if setting values have been corrected */
static SSettingsStatus SettingsStatus;  /* Structure containing number of corrections and first occurrence */

SSettings Settings;

const uint8_t RTErequiredHigh = 3;
const uint8_t RTErequiredLow = 4;

const uint8_t FONTrequiredHigh = 1;
const uint8_t FONTrequiredLow =	0;

uint8_t RTEactualHigh = 0;
uint8_t RTEactualLow = 0;

//  ===============================================================================
//  SFirmwareData FirmwareData
/// @brief	internal counter is for changes after last release
///					use date and info as well for this purpose
///
//  ===============================================================================

const SFirmwareData firmware_FirmwareData __attribute__( (section(".firmware_firmware_data")) ) =
{
    .versionFirst   = 1,
    .versionSecond 	= 6,
    .versionThird   = 7,
    .versionBeta    = 1,

    /* 4 bytes with trailing 0 */
    .signature = "mh",

    .release_year = 23,
    .release_month = 8,
    .release_day = 26,
    .release_sub = 0,

    /* max 48 with trailing 0 */
    //release_info ="12345678901234567890123456789012345678901"
    .release_info  ="gcc_2nd",

    /* for safety reasons and coming functions */
    .magic[0] = FIRMWARE_MAGIC_FIRST,
    .magic[1] = FIRMWARE_MAGIC_SECOND,
    .magic[2] = FIRMWARE_MAGIC_FIRMWARE, /* the magic byte */
    .magic[3] = FIRMWARE_MAGIC_END
};


/* always adjust check_and_correct_settings() accordingly
 * There might even be entries with fixed values that have no range
 */
const SSettings SettingsStandard = {
    .header = 0xFFFF002B,
    .warning_blink_dsec = 8 * 2,
    .lastDiveLogId = 0,
    .logFlashNextSampleStartAddress = SAMPLESTART,

    .gas[0].oxygen_percentage = 21,
    .gas[1].oxygen_percentage = 21,
    .gas[2].oxygen_percentage = 21,
    .gas[3].oxygen_percentage = 21,
    .gas[4].oxygen_percentage = 21,
    .gas[5].oxygen_percentage = 21,
    .gas[6].oxygen_percentage = 21,
    .gas[7].oxygen_percentage = 21,
    .gas[8].oxygen_percentage = 21,
    .gas[9].oxygen_percentage = 21,
    .gas[10].oxygen_percentage = 21,
    .gas[0].helium_percentage = 0,
    .gas[1].helium_percentage = 0,
    .gas[2].helium_percentage = 0,
    .gas[3].helium_percentage = 0,
    .gas[4].helium_percentage = 0,
    .gas[5].helium_percentage = 0,
    .gas[6].helium_percentage = 0,
    .gas[7].helium_percentage = 0,
    .gas[8].helium_percentage = 0,
    .gas[9].helium_percentage = 0,
    .gas[10].helium_percentage = 0,
    .gas[0].depth_meter = 0,
    .gas[1].depth_meter = 0,
    .gas[2].depth_meter = 0,
    .gas[3].depth_meter = 0,
    .gas[4].depth_meter = 0,
    .gas[5].depth_meter = 0,
    .gas[6].depth_meter = 0,
    .gas[7].depth_meter = 0,
    .gas[8].depth_meter = 0,
    .gas[9].depth_meter = 0,
    .gas[10].depth_meter = 0,
    .gas[0].depth_meter_travel = 0,
    .gas[1].depth_meter_travel = 0,
    .gas[2].depth_meter_travel = 0,
    .gas[3].depth_meter_travel = 0,
    .gas[4].depth_meter_travel = 0,
    .gas[5].depth_meter_travel = 0,
    .gas[6].depth_meter_travel = 0,
    .gas[7].depth_meter_travel = 0,
    .gas[8].depth_meter_travel = 0,
    .gas[9].depth_meter_travel = 0,
    .gas[10].depth_meter_travel = 0,
    .gas[0].note.uw = 0,
    .gas[1].note.ub.first = 1,
    .gas[1].note.ub.active = 1,
    .gas[1].note.ub.deco = 0,
    .gas[1].note.ub.travel = 0,
    .gas[2].note.uw = 0,
    .gas[3].note.uw = 0,
    .gas[4].note.uw = 0,
    .gas[5].note.uw = 0,
    .gas[6].note.ub.first = 1,
    .gas[6].note.ub.active = 1,
    .gas[6].note.ub.deco = 0,
    .gas[6].note.ub.travel = 0,
    .gas[7].note.uw = 0,
    .gas[8].note.uw = 0,
    .gas[9].note.uw = 0,
    .gas[10].note.uw = 0,
    .gas[0].bottle_size_liter = 0,
    .gas[1].bottle_size_liter = 0,
    .gas[2].bottle_size_liter = 0,
    .gas[3].bottle_size_liter = 0,
    .gas[4].bottle_size_liter = 0,
    .gas[5].bottle_size_liter = 0,
    .gas[6].bottle_size_liter = 0,
    .gas[7].bottle_size_liter = 0,
    .gas[8].bottle_size_liter = 0,
    .gas[9].bottle_size_liter = 0,
    .gas[10].bottle_size_liter = 0,
/*
    .gas[0].bottle_wireless_status = 0,
    .gas[1].bottle_wireless_status = 0,
    .gas[2].bottle_wireless_status = 0,
    .gas[3].bottle_wireless_status = 0,
    .gas[4].bottle_wireless_status = 0,
    .gas[5].bottle_wireless_status = 0,
    .gas[6].bottle_wireless_status = 0,
    .gas[7].bottle_wireless_status = 0,
    .gas[8].bottle_wireless_status = 0,
    .gas[9].bottle_wireless_status = 0,
    .gas[10].bottle_wireless_status = 0,
*/
    .gas[0].bottle_wireless_id = 0,
    .gas[1].bottle_wireless_id = 0,
    .gas[2].bottle_wireless_id = 0,
    .gas[3].bottle_wireless_id = 0,
    .gas[4].bottle_wireless_id = 0,
    .gas[5].bottle_wireless_id = 0,
    .gas[6].bottle_wireless_id = 0,
    .gas[7].bottle_wireless_id = 0,
    .gas[8].bottle_wireless_id = 0,
    .gas[9].bottle_wireless_id = 0,
    .gas[10].bottle_wireless_id = 0,
    .setpoint[0].setpoint_cbar = 100,
    .setpoint[1].setpoint_cbar = 70,
    .setpoint[2].setpoint_cbar = 90,
    .setpoint[3].setpoint_cbar = 100,
    .setpoint[4].setpoint_cbar = 120,
    .setpoint[5].setpoint_cbar = 140,
    .setpoint[0].depth_meter = 0,
    .setpoint[1].depth_meter = 0,
    .setpoint[2].depth_meter = 0,
    .setpoint[3].depth_meter = 0,
    .setpoint[4].depth_meter = 0,
    .setpoint[5].depth_meter = 0,
    .setpoint[0].note.uw = 0,
    .setpoint[1].note.ub.active = 1,
    .setpoint[1].note.ub.first = 1,
    .setpoint[2].note.ub.active = 1,
    .setpoint[2].note.ub.first = 0,
    .setpoint[3].note.ub.active = 1,
    .setpoint[3].note.ub.first = 0,
    .setpoint[4].note.ub.active = 1,
    .setpoint[4].note.ub.first = 0,
    .setpoint[5].note.ub.active = 1,
    .setpoint[5].note.ub.first = 0,

    .CCR_Mode = CCRMODE_Sensors,
    .dive_mode = DIVEMODE_OC,
    .deco_type.ub.standard = GF_MODE,
    .deco_type.ub.alternative = GF_MODE,
    .ppO2_max_deco = 160,
    .ppO2_max_std = 140,
    .ppO2_min = 15,
    .CNS_max = 90,
    .ascent_MeterPerMinute_max = 30,
    .ascent_MeterPerMinute_showGraph = 30,
    .future_TTS = 5,
    .GF_high = 85,
    .GF_low = 30,
    .aGF_high = 95,
    .aGF_low = 95,
    .VPM_conservatism.ub.standard = 2,
    .VPM_conservatism.ub.alternative = 0,
    .safetystopDuration = 1,
    .AtemMinutenVolumenLiter = 25,
    .ReserveFractionDenominator = 4,
    .salinity = 0,
    .last_stop_depth_meter = 3,
    .stop_increment_depth_meter = 3,
    .brightness = 1,
    .date_format = DDMMYY,
    .selected_language = 0, /* 0 = LANGUAGE_English */
    .customtext = " <your name>\n" " <address>",
    .timeoutSurfacemode = 120,
    .timeoutMenuSurface = 120,//240,
    .timeoutMenuDive = 120,//20,
    .timeoutMenuEdit = 120,//40,
    .timeoutInfo = 120,//60,
    .timeoutInfoCompass = 60,
    .design = 7,
    .timeoutDiveReachedZeroDepth = 300,
    .divetimeToCreateLogbook = 60,
    .serialHigh = 0,
    .serialLow = 2,
/*
    .firmwareVersion16to32bit.ub.first 		= 0,
    .firmwareVersion16to32bit.ub.second 	= 6,
    .firmwareVersion16to32bit.ub.third 		= 0,
    .firmwareVersion16to32bit.ub.betaFlag = 0,
*/
    .backup_localtime_rtc_tr = 0,
    .backup_localtime_rtc_dr = 0,
    .totalDiveCounter = 0,
    .personalDiveCount = 0,
    .showDebugInfo = 0,
    .ButtonResponsiveness[0] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306
    .ButtonResponsiveness[1] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306
    .ButtonResponsiveness[2] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306
    .ButtonResponsiveness[3] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306
    .nonMetricalSystem = 0,
    .fallbackToFixedSetpoint = 1,
    .bluetoothActive = 0,
    .safetystopDepth = 5,
    .updateSettingsAllowedFromHeader = 0xFFFF0002,
	.pscr_lung_ratio = 10,
	.pscr_o2_drop = 4,
	.co2_sensor_active = 0,
    .ppo2sensors_deactivated = 0,
    .tX_colorscheme  = 0,
    .tX_userselectedLeftLowerCornerPrimary = LLC_Temperature,
    .tX_userselectedLeftLowerCornerTimeout = 0,
    .tX_customViewPrimary = 1,
    .tX_customViewTimeout = 0,
    .timeoutEnterButtonSelectDive = 10,
    .logbookOffset = 0,
    .alwaysShowPPO2 = 0,
    .extraDisplay = EXTRADISPLAY_BIGFONT,
    .display_toogle_desc = 200,
    .offsetPressure_mbar = 0,
    .offsetTemperature_centigrad = 0,
    .gasConsumption_travel_l_min = 30,
    .gasConsumption_bottom_l_min = 30,
    .gasConsumption_deco_l_min = 20,
    .debugModeOnStart = 0,
    .compassBearing = 0,
    .lastKnownBatteryPercentage = 0,
    .buttonBalance[0] = 3,
    .buttonBalance[1] = 3,
    .buttonBalance[2] = 3,
    .firmwareVersion[0] = 0,//FirmwareData.firmwareVersion16to32bit.ub.first,
    .firmwareVersion[1] = 0,//FirmwareData.firmwareVersion16to32bit.ub.second,
    .firmwareVersion[2] = 0,//FirmwareData.firmwareVersion16to32bit.ub.third,
    .firmwareVersion[3] = 0,//FirmwareData.firmwareVersion16to32bit.ub.betaFlag,
    .timeoutSurfacemodeWithSensors = 600,
    .VPM_model = 0,
    .GF_model = 0,
    .FactoryButtonBase = DEFAULT_BUTTONRESPONSIVENESS_GUI,
    .FactoryButtonBalance[0] = 3,
    .FactoryButtonBalance[1] = 3,
    .FactoryButtonBalance[2] = 3,
	.FlipDisplay = 0,
	.cv_configuration = 0xFFFFFFFF,
	.MotionDetection = MOTION_DETECT_OFF,
	.cv_config_BigScreen = 0xFFFFFFFF,
	.compassInertia = 0,
	.tX_customViewPrimaryBF = CVIEW_T3_Decostop,
	.viewPortMode = 0,
	.viewRoll = 0,
	.viewPitch = 0,
	.viewYaw = 0,
	.ppo2sensors_source = 0,
	.ppo2sensors_calibCoeff[0] = 0.0,
	.ppo2sensors_calibCoeff[1] = 0.0,
	.ppo2sensors_calibCoeff[2] = 0.0,
	.amPMTime = 0,
	.autoSetpoint = 0,
	.scrubTimerMax_Obsolete = 0,
	.scrubTimerCur_Obsolete = 0,
	.scrubTimerMode = SCRUB_TIMER_OFF,
	.ext_sensor_map[0] = SENSOR_OPTIC,
	.ext_sensor_map[1] = SENSOR_OPTIC,
	.ext_sensor_map[2] = SENSOR_OPTIC,
	.ext_sensor_map[3] = SENSOR_NONE,
	.ext_sensor_map[4] = SENSOR_NONE,
	.ext_sensor_map[5] = SENSOR_NONE,
	.ext_sensor_map[6] = SENSOR_NONE,
	.ext_sensor_map[7] = SENSOR_NONE,
	.buttonLockActive = 0,
    .compassDeclinationDeg = 0,
    .delaySetpointLow = false,
    .timerDurationS = 180,
	.cvAutofocus = 0,
	.slowExitTime = 0
};

/* Private function prototypes -----------------------------------------------*/
uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to);

/* Functions -----------------------------------------------------------------*/


//  ===============================================================================
//	set_new_settings_missing_in_ext_flash
/// @brief	Add all the new setting variables of this version
///					or/and change what has changed in the meantime
///
///					Additionally update the serial number if written via bluetooth
///
//  ===============================================================================
SSettings* pSettings;
void set_new_settings_missing_in_ext_flash(void)
{
	uint32_t tmp = 0;

    // never delete this part setting the serial
    if(hardwareDataGetPointer()->secondarySerial != 0xFFFF)
    {
        settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->secondarySerial / 256);
        settingsGetPointer()->serialLow  = (hardwareDataGetPointer()->secondarySerial & 0xFF);
    }
    else
    if(hardwareDataGetPointer()->primarySerial != 0xFFFF)
    {
        settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->primarySerial / 256);
        settingsGetPointer()->serialLow  = (hardwareDataGetPointer()->primarySerial & 0xFF);
    }
    else
    {
        settingsGetPointer()->serialHigh = 0;
        settingsGetPointer()->serialLow  = 0;
    }

    settingsGetPointer()->firmwareVersion[0] = firmware_FirmwareData.versionFirst;
    settingsGetPointer()->firmwareVersion[1] = firmware_FirmwareData.versionSecond;
    settingsGetPointer()->firmwareVersion[2] = firmware_FirmwareData.versionThird;
    settingsGetPointer()->firmwareVersion[3] = firmware_FirmwareData.versionBeta;

    pSettings = settingsGetPointer();
    const SSettings* pStandard = settingsGetPointerStandard();

    /* Pointing to the old header data => set new data depending on what had been added since last version */
    switch(pSettings->header)
    {
    case 0xFFFF0000:
    case 0xFFFF0001:
    case 0xFFFF0002:
    case 0xFFFF0003:
    case 0xFFFF0004:
    case 0xFFFF0005:
        pSettings->ppo2sensors_deactivated          = pStandard->ppo2sensors_deactivated;
        pSettings->tX_colorscheme                   = pStandard->tX_colorscheme;
        pSettings->tX_userselectedLeftLowerCornerPrimary = pStandard->tX_userselectedLeftLowerCornerPrimary;
        pSettings->tX_userselectedLeftLowerCornerTimeout = pStandard->tX_userselectedLeftLowerCornerTimeout;
        pSettings->tX_customViewPrimary             = pStandard->tX_customViewPrimary;
        pSettings->tX_customViewTimeout             = pStandard->tX_customViewTimeout;
        // no break
    case 0xFFFF0006:
        pSettings->timeoutEnterButtonSelectDive     = pStandard->timeoutEnterButtonSelectDive;
        pSettings->ButtonResponsiveness[0]          = pStandard->ButtonResponsiveness[0];
        pSettings->ButtonResponsiveness[1]          = pStandard->ButtonResponsiveness[1];
        pSettings->ButtonResponsiveness[2]          = pStandard->ButtonResponsiveness[2];
        pSettings->ButtonResponsiveness[3]          = pStandard->ButtonResponsiveness[3];
        pSettings->timeoutSurfacemode               = pStandard->timeoutSurfacemode;
        pSettings->timeoutMenuSurface               = pStandard->timeoutMenuSurface;
        pSettings->timeoutMenuDive                  = pStandard->timeoutMenuDive;
        pSettings->timeoutMenuEdit                  = pStandard->timeoutMenuEdit;
        pSettings->timeoutInfo                      = pStandard->timeoutInfo;
        pSettings->timeoutInfoCompass               = pStandard->timeoutInfoCompass;
        pSettings->timeoutDiveReachedZeroDepth      = pStandard->timeoutDiveReachedZeroDepth;
        pSettings->divetimeToCreateLogbook          = pStandard->divetimeToCreateLogbook;
        pSettings->safetystopDuration               = pStandard->safetystopDuration; // change from on/off to minutes
        // no break
    case 0xFFFF0007:
    case 0xFFFF0008:
        pSettings->alwaysShowPPO2                   = pStandard->alwaysShowPPO2;
        pSettings->logbookOffset                    = pStandard->logbookOffset;
        // no break
    case 0xFFFF0009:
        pSettings->extraDisplay                     = pStandard->extraDisplay;
        // no break
    case 0xFFFF000A:
        pSettings->display_toogle_desc              = pStandard->display_toogle_desc;
        // no break
    case 0xFFFF000B:
        pSettings->offsetPressure_mbar              = pStandard->offsetPressure_mbar;
        pSettings->offsetTemperature_centigrad      = pStandard->offsetTemperature_centigrad;
        pSettings->gasConsumption_travel_l_min      = pStandard->gasConsumption_travel_l_min;
        pSettings->gasConsumption_bottom_l_min      = pStandard->gasConsumption_bottom_l_min;
        pSettings->gasConsumption_deco_l_min        = pStandard->gasConsumption_deco_l_min;
        // no break
    case 0xFFFF000C:
        memcpy(pSettings->customtext, " hwOS 4\n\r" " welcome\n\r", 60);
        // no break
    case 0xFFFF000D: // nothing to do from 0xFFFF000D to 0xFFFF000E, just about header :-)
    case 0xFFFF000E:
        pSettings->debugModeOnStart                 = 0;
        // no break
    case 0xFFFF000F:
        pSettings->compassBearing                   = 0;
        // no break
    case 0xFFFF0011:
        pSettings->lastKnownBatteryPercentage       = 0;
        // no break
    case 0xFFFF0012:
        pSettings->buttonBalance[0]                 = 3;
        pSettings->buttonBalance[1]                 = 3;
        pSettings->buttonBalance[2]                 = 3;
        // no break
    case 0xFFFF0013:
    case 0xFFFF0014:
        pSettings->timeoutSurfacemodeWithSensors    = pStandard->timeoutSurfacemodeWithSensors;
        // no break
    case 0xFFFF0015:
        pSettings->ButtonResponsiveness[3]          = pStandard->ButtonResponsiveness[3];
        settingsHelperButtonSens_keepPercentageValues(settingsHelperButtonSens_translate_hwOS_values_to_percentage(pSettings->ButtonResponsiveness[3]), pSettings->ButtonResponsiveness);
        pSettings->VPM_model = 0;
        pSettings->GF_model = 0;
        // no break
    case 0xFFFF0016:
        pSettings->FactoryButtonBase                = pStandard->FactoryButtonBase;
        pSettings->FactoryButtonBalance[0]          = pStandard->FactoryButtonBalance[0];
        pSettings->FactoryButtonBalance[1]          = pStandard->FactoryButtonBalance[1];
        pSettings->FactoryButtonBalance[2]          = pStandard->FactoryButtonBalance[2];
        // no break
    case 0xFFFF0017:
    	pSettings->FlipDisplay = 0;
    	// no break
    case 0xFFFF0018:
    	pSettings->cv_configuration = 0xFFFFFFFF;
    	// no break
    case 0xFFFF0019:
    	pSettings->MotionDetection = MOTION_DETECT_OFF;
    	// no break
    case 0xFFFF001A:
    	/* deactivate new views => to be activated by customer */
        pSettings->cv_config_BigScreen = 0xFFFFFFFF;
        pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_Navigation + LEGACY_T3_START_ID_PRE_TIMER);
        pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_DepthData + LEGACY_T3_START_ID_PRE_TIMER);
        // no break
    case 0xFFFF001B:
    	pSettings->compassInertia = 0; 			/* no inertia */
    	pSettings->tX_customViewPrimaryBF = CVIEW_T3_Decostop;
    	pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_DecoTTS + LEGACY_T3_START_ID_PRE_TIMER);
        // no break
    case 0xFFFF001C:
    	pSettings->viewPortMode = 0;
    	pSettings->viewRoll = 0;
    	pSettings->viewPitch = 0;
    	pSettings->viewYaw = 0;
    	// no break
    case 0xFFFF001D:
    	pSettings->ppo2sensors_source = O2_SENSOR_SOURCE_OPTIC;
    	pSettings->ppo2sensors_calibCoeff[0] = 0.0;
    	pSettings->ppo2sensors_calibCoeff[1] = 0.0;
    	pSettings->ppo2sensors_calibCoeff[2] = 0.0;
    	pSettings->amPMTime = 0;
    	// no break
    case 0xFFFF001E:
    	pSettings->autoSetpoint = 0;
    	pSettings->scrubTimerMax_Obsolete = 0;
    	pSettings->scrubTimerCur_Obsolete = 0;
    	pSettings->scrubTimerMode = SCRUB_TIMER_OFF;
    	// no break
    case 0xFFFF001F:
    	pSettings->pscr_lung_ratio = 10;
    	pSettings->pscr_o2_drop = 4;
    	// no break
    case 0xFFFF0020:
    	pSettings->co2_sensor_active = 0;
    	// no break;
    case 0xFFFF0021:
    	pSettings->ext_uart_protocol = 0;
    	// no break;
    case 0xFFFF0022:
    	pSettings->scubberActiveId = 0;
    	pSettings->scrubberData[0].TimerCur = pSettings->scrubTimerCur_Obsolete;
    	pSettings->scrubberData[0].TimerMax = pSettings->scrubTimerMax_Obsolete;
    	pSettings->scrubberData[0].lastDive.WeekDay = 0;
    	pSettings->scrubberData[0].lastDive.Month = 0;
    	pSettings->scrubberData[0].lastDive.Date = 0;
    	pSettings->scrubberData[0].lastDive.Year = 0;

    	pSettings->scrubberData[1].TimerCur = 0;
    	pSettings->scrubberData[1].TimerMax = 0;
    	pSettings->scrubberData[1].lastDive.WeekDay = 0;
    	pSettings->scrubberData[1].lastDive.Month = 0;
    	pSettings->scrubberData[1].lastDive.Date = 0;
    	pSettings->scrubberData[1].lastDive.Year = 0;
    	// no break;
    case 0xFFFF0023: pSettings->ext_sensor_map[0] = SENSOR_OPTIC;
    				 pSettings->ext_sensor_map[1] = SENSOR_OPTIC;
    				 pSettings->ext_sensor_map[2] = SENSOR_OPTIC;
    				 pSettings->ext_sensor_map[3] = SENSOR_NONE;
    				 pSettings->ext_sensor_map[4] = SENSOR_NONE;
    	// no break;
    case 0xFFFF0024: pSettings->buttonLockActive = 0;
    	// no break;
    case 0xFFFF0025:
        pSettings->compassDeclinationDeg = pStandard->compassDeclinationDeg;
        pSettings->delaySetpointLow = pStandard->delaySetpointLow;
        // Disable auto setpoint to avoid a configuration warning being triggered by the new auto setpoint validation
        // This ensures that users don't lose setpoint information if it is not in the right spot for the new configuration
        pSettings->autoSetpoint = false;

        pSettings->timerDurationS = pStandard->timerDurationS;

    	// no break;
    case 0xFFFF0026:
    	pSettings->ext_sensor_map[0] = pSettings->ext_sensor_map_Obsolete[0];
    	pSettings->ext_sensor_map[1] = pSettings->ext_sensor_map_Obsolete[1];
    	pSettings->ext_sensor_map[2] = pSettings->ext_sensor_map_Obsolete[2];
    	pSettings->ext_sensor_map[3] = pSettings->ext_sensor_map_Obsolete[3];
    	pSettings->ext_sensor_map[4] = pSettings->ext_sensor_map_Obsolete[4];
    	pSettings->ext_sensor_map[5] = SENSOR_NONE;
    	pSettings->ext_sensor_map[6] = SENSOR_NONE;
    	pSettings->ext_sensor_map[7] = SENSOR_NONE;

        // no break;
    case 0xFFFF0027:
    	tmp = pSettings->cv_config_BigScreen & 0x00000007;				/* position of first three view is keeps the same */
    	/* Identify from which data version was in use before the update */
    	if(pSettings->tX_customViewPrimaryBF == LEGACY_CV_END_POST_TIMER)	/* data version after introduction of timer (ID shift problem) */
    	{
    		pSettings->tX_customViewPrimaryBF = CVIEW_T3_Decostop;
    	}
    	else
    	{
    		if(pSettings->tX_customViewPrimaryBF >= 3)
    		{
    			pSettings->tX_customViewPrimaryBF -= LEGACY_T3_START_ID_PRE_TIMER - 3;
    		}
    	}
    	pSettings->cv_config_BigScreen = pSettings->cv_config_BigScreen >> (LEGACY_T3_START_ID_PRE_TIMER - 3);
    	pSettings->cv_config_BigScreen &= ~0x00000007;		/* just to be sure: clear lower three bits */
    	pSettings->cv_config_BigScreen |= tmp;
    	// no break;
    case 0xFFFF0028:						/* In previous version deco gases were automatically used for deco calculation */
        for(tmp=1; tmp<=2*NUM_GASES; tmp++) /* This is now handled by an additional parameter. Set it to true to maintain same behavior as before */
        {
            if(Settings.gas[tmp].note.ub.deco)
            {
            	Settings.gas[tmp].note.ub.decocalc = 1;
            }
            else
            {
            	Settings.gas[tmp].note.ub.decocalc = 0;
            }
        }
    	// no break;
    case 0xFFFF0029:
    	Settings.cvAutofocus = 0;
    	// no break;
    case 0xFFFF002A:
    	Settings.slowExitTime = 0;
    	// no break;
    default:
        pSettings->header = pStandard->header;
        break; // no break before!!
    }
}


uint8_t newFirmwareVersionCheckViaSettings(void)
{
    SSettings* pSettings = settingsGetPointer();

    if(pSettings->header < 0xFFFF0014) // for the versions without firmwareVersion[]
        return 1;

    if(pSettings->firmwareVersion[0] != firmware_FirmwareData.versionFirst)
        return 1;
    if(pSettings->firmwareVersion[1] != firmware_FirmwareData.versionSecond)
        return 1;
    if(pSettings->firmwareVersion[2] != firmware_FirmwareData.versionThird)
        return 1;
    if(pSettings->firmwareVersion[3] != firmware_FirmwareData.versionBeta)
        return 1;

    return 0;
}


void set_settings_button_to_factory_with_individual_buttonBalance(void)
{
    bool factoryBalanceSettingsValid = true;
    unsigned i = 0;
    while (factoryBalanceSettingsValid && i < 3) {
        if (Settings.FactoryButtonBalance[i] < 2 || Settings.FactoryButtonBalance[i] > 5) {
            factoryBalanceSettingsValid = false;
        }

        i++;
    }
    if (factoryBalanceSettingsValid) {
        for (i = 0; i < 3; i++) {
            Settings.buttonBalance[i] = Settings.FactoryButtonBalance[i];
        }
    }

    uint8_t buttonResponsiveness = Settings.FactoryButtonBase;
    if (buttonResponsiveness < 70 || buttonResponsiveness > 110) {
        buttonResponsiveness = SettingsStandard.ButtonResponsiveness[3];
    }

    settingsHelperButtonSens_keepPercentageValues(buttonResponsiveness, settingsGetPointer()->ButtonResponsiveness);
}


bool checkAndFixSetpointSettings(void)
{
    SSettings *settings = settingsGetPointer();

    bool fixed = false;
    if (settings->autoSetpoint) {
        SSetpointLine *setpointLow = &settings->setpoint[SETPOINT_INDEX_AUTO_LOW];
        if (setpointLow->setpoint_cbar >= 100) {
            setpointLow->setpoint_cbar = 70;

            fixed = true;
        }
        if (setpointLow->depth_meter == 0 || setpointLow->depth_meter > 100) {
            setpointLow->depth_meter = 2;

            fixed = true;
        }
        SSetpointLine *setpointHigh = &settings->setpoint[SETPOINT_INDEX_AUTO_HIGH];
        if (setpointHigh->setpoint_cbar <= setpointLow->setpoint_cbar) {
            setpointHigh->setpoint_cbar = 130;

            fixed = true;
        }
        if (setpointHigh->depth_meter <= setpointLow->depth_meter) {
            setpointHigh->depth_meter = setpointLow->depth_meter + 6;

            fixed = true;
        }

        SSetpointLine *setpointDeco = &settings->setpoint[SETPOINT_INDEX_AUTO_DECO];
        if (setpointDeco->note.ub.active) {
            if (setpointDeco->setpoint_cbar == setpointHigh->setpoint_cbar || setpointDeco->setpoint_cbar == setpointLow->setpoint_cbar) {
                setpointDeco->setpoint_cbar = 10 * (setpointHigh->setpoint_cbar / 10) - 10;
                if (setpointDeco->setpoint_cbar == setpointLow->setpoint_cbar) {
                    setpointDeco->setpoint_cbar += 5;
                }

                fixed = true;
            }
        }
    }

    return fixed;
}

static void setFirstCorrection(uint8_t Id)
{
	if(SettingsStatus.FirstCorrection == 0xFF)
	{
		SettingsStatus.FirstCorrection = Id;
	}
}

void get_CorrectionStatus(SSettingsStatus* Status)
{
	if(Status != NULL)
	{
		memcpy(Status, &SettingsStatus,2);
	}
}

uint8_t check_and_correct_settings(void)
{
    uint32_t corrections = 0;
    uint8_t firstGasFoundOC = 0;
    uint8_t firstGasFoundCCR = 0;
    uint8_t parameterId = 0;


    settingsWarning = 0; /* reset warning indicator */
    SettingsStatus.FirstCorrection = 0xFF;

/*	uint32_t header;
 */

/*	uint8_t warning_blink_dsec; 1/10 seconds
 */
        if((Settings.warning_blink_dsec < 1) || (Settings.warning_blink_dsec > 100))
        {
            Settings.warning_blink_dsec = SettingsStandard.warning_blink_dsec;
            corrections++;
            setFirstCorrection(parameterId);
        }
        parameterId++;
/*	uint8_t lastDiveLogId;
 */

/*	uint32_t logFlashNextSampleStartAddress;
 */
        if((Settings.logFlashNextSampleStartAddress < SAMPLESTART) || (Settings.logFlashNextSampleStartAddress > SAMPLESTOP))
        {
            Settings.logFlashNextSampleStartAddress = SAMPLESTART;
            corrections++;
            setFirstCorrection(parameterId);
        }
        parameterId++;

/*	uint8_t dive_mode; has to before the gases
 */
    if(	(Settings.dive_mode != DIVEMODE_OC) 		&&
            (Settings.dive_mode != DIVEMODE_CCR)  	&&
            (Settings.dive_mode != DIVEMODE_Gauge)	&&
            (Settings.dive_mode != DIVEMODE_Apnea)	&&
			(Settings.dive_mode != DIVEMODE_PSCR))
    {
        Settings.dive_mode = DIVEMODE_OC;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;

/*	SGasLine gas[1 + (2*NUM_GASES)];
 */
    for(int i=1; i<=2*NUM_GASES;i++)
    {
        if(Settings.gas[i].oxygen_percentage < 4)
        {
            Settings.gas[i].oxygen_percentage = 4;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.gas[i].oxygen_percentage > 100)
        {
            Settings.gas[i].oxygen_percentage = 100;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if((Settings.gas[i].oxygen_percentage + Settings.gas[i].helium_percentage) > 100)
        {
            Settings.gas[i].helium_percentage = 100 - Settings.gas[i].oxygen_percentage;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.gas[i].note.ub.deco)
        {
            if(Settings.gas[i].note.ub.active != 1)
            {
                Settings.gas[i].note.ub.active = 1;
                corrections++;
                setFirstCorrection(parameterId);
            }
            if(Settings.gas[i].note.ub.travel == 1)
            {
                Settings.gas[i].note.ub.travel = 0;
                corrections++;
                setFirstCorrection(parameterId);
            }
        }
        if(Settings.gas[i].note.ub.travel)
        {
            if(Settings.gas[i].note.ub.active != 1)
            {
                Settings.gas[i].note.ub.active = 1;
                corrections++;
                setFirstCorrection(parameterId);
            }
            if(Settings.gas[i].note.ub.deco == 1)
            {
                Settings.gas[i].note.ub.deco = 0;
                corrections++;
                setFirstCorrection(parameterId);
            }
        }
        if(Settings.gas[i].note.ub.first)
        {
            if(Settings.gas[i].note.ub.active != 1)
            {
                Settings.gas[i].note.ub.active = 1;
                corrections++;
                setFirstCorrection(parameterId);
            }
            if(Settings.gas[i].note.ub.travel == 1)
            {
                Settings.gas[i].note.ub.travel = 0;
                corrections++;
                setFirstCorrection(parameterId);
            }
            if(Settings.gas[i].note.ub.deco == 1)
            {
                Settings.gas[i].note.ub.deco = 0;
                corrections++;
                setFirstCorrection(parameterId);
            }
            if((i<=NUM_GASES) && (!firstGasFoundOC))
                firstGasFoundOC = 1;
            else
            if((i>NUM_GASES) && (!firstGasFoundCCR))
                firstGasFoundCCR = 1;
            else
                Settings.gas[i].note.ub.first = 0;
        }
        if(Settings.gas[i].bottle_size_liter > 40)
        {
            Settings.gas[i].bottle_size_liter = 40;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.gas[i].depth_meter > 250)
        {
            Settings.gas[i].depth_meter = 250;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.gas[i].depth_meter_travel > 250)
        {
            Settings.gas[i].depth_meter_travel = 250;
            corrections++;
            setFirstCorrection(parameterId);
        }
        /*if(Settings.gas[i].note.ub.senderCode)
        {
        }
        if(Settings.gas[i].bottle_wireless_id)
        {
        }
        */
    } // for(int i=1; i<=2*NUM_GASES;i++)
    parameterId++;
    if(!firstGasFoundOC)
    {
        Settings.gas[1].note.ub.active = 1;
        Settings.gas[1].note.ub.first = 1;
        Settings.gas[1].note.ub.travel = 0;
        Settings.gas[1].note.ub.deco = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(!firstGasFoundCCR)
    {
        Settings.gas[1 + NUM_GASES].note.ub.active = 1;
        Settings.gas[1 + NUM_GASES].note.ub.first = 1;
        Settings.gas[1 + NUM_GASES].note.ub.travel = 0;
        Settings.gas[1 + NUM_GASES].note.ub.deco = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	SSetpointLine setpoint[1 + NUM_GASES];
 */
    for(int i=1; i<=NUM_GASES;i++)
    {
        if(Settings.setpoint[i].setpoint_cbar < MIN_PPO2_SP_CBAR)
        {
            Settings.setpoint[i].setpoint_cbar = MIN_PPO2_SP_CBAR;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.setpoint[i].setpoint_cbar > 160)
        {
            Settings.setpoint[i].setpoint_cbar = 160;
            corrections++;
            setFirstCorrection(parameterId);
        }
        if(Settings.setpoint[i].depth_meter > 250)
        {
            Settings.setpoint[i].depth_meter = 250;
            corrections++;
            setFirstCorrection(parameterId);
        }
    }	// for(int i=1; i<=NUM_GASES;i++)
    parameterId++;
    if (checkAndFixSetpointSettings()) {
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t CCR_Mode;
 */
    if(	(Settings.CCR_Mode != CCRMODE_Sensors) &&
    		(Settings.CCR_Mode != CCRMODE_Simulation) &&
            (Settings.CCR_Mode != CCRMODE_FixedSetpoint))
    {
        Settings.CCR_Mode = CCRMODE_FixedSetpoint;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	split2x4_Type deco_type;
 */
    if(	(Settings.deco_type.ub.standard != GF_MODE) &&
            (Settings.deco_type.ub.standard != VPM_MODE))
    {
        Settings.deco_type.ub.standard = VPM_MODE;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.deco_type.ub.alternative != GF_MODE)
    {
        Settings.deco_type.ub.alternative = GF_MODE;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t ppO2_max_deco;
 */
    if(Settings.ppO2_max_deco > 190)
    {
        Settings.ppO2_max_deco = 190;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.ppO2_max_deco < 100)
    {
        Settings.ppO2_max_deco = 100;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;

/*	uint8_t ppO2_max_std;
 */
    if(Settings.ppO2_max_std > 190)
    {
        Settings.ppO2_max_std = 190;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.ppO2_max_std < 100)
    {
        Settings.ppO2_max_std = 100;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t ppO2_min;
 */
    if(Settings.ppO2_min != 15)
    {
        Settings.ppO2_min = 15;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t CNS_max;
 */
    if(Settings.CNS_max != 90)
    {
        Settings.CNS_max = 90;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*  uint8_t ascent_MeterPerMinute_max;
 */
    if(Settings.ascent_MeterPerMinute_max != 30)
    {
        Settings.ascent_MeterPerMinute_max = 30;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t ascent_MeterPerMinute_showGraph;
 */
    if(Settings.ascent_MeterPerMinute_showGraph != 30)
    {
        Settings.ascent_MeterPerMinute_showGraph = 30;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t future_TTS;
 */
    if(Settings.future_TTS > 15)
    {
        Settings.future_TTS = 15;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t GF_high;
 */
    if(Settings.GF_high > 99)
    {
        Settings.GF_high = 99;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.GF_high < 45)
    {
        Settings.GF_high = 45;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t GF_low;
 */
    if(Settings.GF_low > 99)
    {
        Settings.GF_low = 99;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.GF_low < 10)
    {
        Settings.GF_low = 10;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.GF_low > Settings.GF_high)
    {
        Settings.GF_low = Settings.GF_high;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t aGF_high;
 */
    if(Settings.aGF_high > 99)
    {
        Settings.aGF_high = 99;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.aGF_high < 45)
    {
        Settings.aGF_high = 45;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t aGF_low;
 */
    if(Settings.aGF_low > 99)
    {
        Settings.aGF_low = 99;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.aGF_low < 10)
    {
        Settings.aGF_low = 10;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.aGF_low > Settings.aGF_high)
    {
        Settings.aGF_low = Settings.aGF_high;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	split2x4_Type VPM_conservatism;
 */
    if(Settings.VPM_conservatism.ub.standard > 5)
    {
        Settings.VPM_conservatism.ub.standard = 5;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.VPM_conservatism.ub.alternative > 5)
    {
        Settings.VPM_conservatism.ub.alternative = 5;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t safetystopDuration;
 */
    if(Settings.safetystopDuration > 5)
    {
        Settings.safetystopDuration = 5;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t AtemMinutenVolumenLiter;
 */
    if(Settings.AtemMinutenVolumenLiter != 25)
    {
        Settings.AtemMinutenVolumenLiter = 25;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t ReserveFractionDenominator;
 */
    if(Settings.ReserveFractionDenominator != 4)
    {
        Settings.ReserveFractionDenominator = 4;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t salinity;
 */
    if(Settings.salinity > 4)
    {
        Settings.salinity = 4;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t last_stop_depth_meter;
 */
    if(Settings.last_stop_depth_meter > 9)
    {
        Settings.last_stop_depth_meter = 9;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.last_stop_depth_meter < 3)
    {
        Settings.last_stop_depth_meter = 3;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t stop_increment_depth_meter;
 */
    if(Settings.stop_increment_depth_meter != 3)
    {
        Settings.stop_increment_depth_meter = 3;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t brightness;
 */
    if(Settings.brightness > 4)
    {
        Settings.brightness = 4;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t date_format;
 */
    if(	(Settings.date_format != DDMMYY) &&
            (Settings.date_format != MMDDYY) &&
            (Settings.date_format != YYMMDD))
    {
        Settings.date_format = DDMMYY;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t selected_language;
 */
    if(Settings.selected_language >= LANGUAGE_END)
    {
        Settings.selected_language = LANGUAGE_English;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	char customtext[60];
 */
    if(Settings.customtext[59] != 0)
    {
        Settings.customtext[59] = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint16_t timeoutSurfacemode;
 */
    if(	(Settings.timeoutSurfacemode != 20) &&  // Quick Sleep Option
            (Settings.timeoutSurfacemode != 120))
    {
        Settings.timeoutSurfacemode = 120;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutMenuSurface;
 */
    if(Settings.timeoutMenuSurface != 120)
    {
        Settings.timeoutMenuSurface = 120;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutMenuDive;
 */
    if(Settings.timeoutMenuDive != 120)
    {
        Settings.timeoutMenuDive = 120;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutMenuEdit;
 */
    if(Settings.timeoutMenuEdit != 120)
    {
        Settings.timeoutMenuEdit = 120;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutInfo;
 */
    if(Settings.timeoutInfo != 120)
    {
        Settings.timeoutInfo = 120;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutInfoCompass;
 */
    if(Settings.timeoutInfoCompass != 60)
    {
        Settings.timeoutInfoCompass = 60;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t design;
 */
    if(Settings.design != 7)
    {
        Settings.design = 7;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint16_t timeoutDiveReachedZeroDepth;
 */
    if(Settings.timeoutDiveReachedZeroDepth != 300)
    {
        Settings.timeoutDiveReachedZeroDepth = 300;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint16_t divetimeToCreateLogbook;
 */
    if(Settings.divetimeToCreateLogbook != 60)
    {
        Settings.divetimeToCreateLogbook = 60;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.slowExitTime > 9)
    {
        Settings.divetimeToCreateLogbook = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t serialHigh;
 */

/*	uint8_t serialLow;
 */

/*	SUFirmware firmwareVersion16to32bit;
 */

/*	uint32_t backup_localtime_rtc_tr;
 */

/*	uint32_t backup_localtime_rtc_dr;
 */

/*	uint16_t totalDiveCounter;
 */

/*	uint16_t personalDiveCount;
 */

/*	uint8_t showDebugInfo;
 */

#ifdef HAVE_DEBUG_VIEW
    if(Settings.showDebugInfo > 1)
    {
        Settings.showDebugInfo = 0;
        corrections++;
    }
#else
    Settings.showDebugInfo = 0;
#endif

/*	uint8_t ButtonResponsiveness[4];
 */
    // Base value, index 3
    if(Settings.ButtonResponsiveness[3] < MIN_BUTTONRESPONSIVENESS_GUI)
    {
        Settings.ButtonResponsiveness[3] = MIN_BUTTONRESPONSIVENESS_GUI;
        corrections++;
        setFirstCorrection(parameterId);
    }
    else
    if(Settings.ButtonResponsiveness[3] > MAX_BUTTONRESPONSIVENESS_GUI)
    {
        Settings.ButtonResponsiveness[3] = MAX_BUTTONRESPONSIVENESS_GUI;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    // flex values 0, 1, 2
    for(int i=0; i<3;i++)
    {
        if(Settings.ButtonResponsiveness[i] < MIN_BUTTONRESPONSIVENESS) // 50-10  //Fix for broken buttons. :)
        {
            Settings.ButtonResponsiveness[i] = MIN_BUTTONRESPONSIVENESS;
            corrections++;
            setFirstCorrection(parameterId);
        }
        else
        if(Settings.ButtonResponsiveness[i] > MAX_BUTTONRESPONSIVENESS) // 110+20
        {
            Settings.ButtonResponsiveness[i] = MAX_BUTTONRESPONSIVENESS;
            corrections++;
            setFirstCorrection(parameterId);
        }
    }
    parameterId++;
/*	uint8_t buttonBalance[3];
 */
    for(int i=0; i<3;i++)
    {
        if(Settings.buttonBalance[i] < 2) // 2 = -10
        {
            Settings.buttonBalance[i] = 2;
            corrections++;
            setFirstCorrection(parameterId);
        }
        else
        if(Settings.buttonBalance[i] > 5) // 3 = 0, 4 = +10, 5 = +20
        {
            Settings.buttonBalance[i] = 5;
            corrections++;
            setFirstCorrection(parameterId);
        }
    }
    parameterId++;
/*	uint8_t nonMetricalSystem;
 */
    if(Settings.nonMetricalSystem > 1)
    {
        Settings.nonMetricalSystem = 1;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t fallbackToFixedSetpoint;
 */
    if(Settings.fallbackToFixedSetpoint > 1)
    {
        Settings.fallbackToFixedSetpoint = 1;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t bluetoothActive;
 */
    if(Settings.bluetoothActive > 1)
    {
        Settings.bluetoothActive = 1;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t safetystopDepth;
 */
    if(Settings.safetystopDepth > 6)
    {
        Settings.safetystopDepth = 6;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.safetystopDepth < 3)
    {
        Settings.safetystopDepth = 3;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint32_t updateSettingsAllowedFromHeader;
 */

/*	uint8_t ppo2sensors_deactivated;
 */
    if(Settings.ppo2sensors_deactivated > (1+2+4))
    {
        Settings.ppo2sensors_deactivated = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t tX_colorscheme;
 */
    if(Settings.tX_colorscheme > 3)
    {
        Settings.tX_colorscheme = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t tX_userselectedLeftLowerCornerPrimary;
 */
    if(Settings.tX_userselectedLeftLowerCornerPrimary >= LLC_END)
    {
        Settings.tX_userselectedLeftLowerCornerPrimary = LLC_Temperature;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t tX_userselectedLeftLowerCornerTimeout;
 */
    if(Settings.tX_userselectedLeftLowerCornerTimeout > 60)
    {
        Settings.tX_userselectedLeftLowerCornerTimeout = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t tX_customViewPrimary;
 */
    if(Settings.tX_customViewPrimary >= CVIEW_END)
    {
        Settings.tX_customViewPrimary = 1;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t tX_customViewTimeout;
 */
    if(Settings.tX_customViewTimeout > 60)
    {
        Settings.tX_customViewTimeout = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t timeoutEnterButtonSelectDive;
 */
    if(Settings.timeoutEnterButtonSelectDive != 10)
    {
        Settings.timeoutEnterButtonSelectDive = 10;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t logbookOffset;
 */
    if(Settings.logbookOffset > 9000)
    {
        Settings.logbookOffset = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t alwaysShowPPO2;
 */
    if(Settings.alwaysShowPPO2 > 1)
    {
        Settings.alwaysShowPPO2 = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t extraDisplay;
 */
    if(Settings.extraDisplay >= EXTRADISPLAY_END)
    {
        Settings.extraDisplay = EXTRADISPLAY_BIGFONT;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	int8_t offsetPressure_mbar;
 */
    if((Settings.offsetPressure_mbar > PRESSURE_OFFSET_LIMIT_MBAR) ||
         (Settings.offsetPressure_mbar < -1 * PRESSURE_OFFSET_LIMIT_MBAR))
    {
        Settings.offsetPressure_mbar = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	int8_t offsetTemperature_centigrad;
 */
    if((Settings.offsetTemperature_centigrad > 20) ||
         (Settings.offsetTemperature_centigrad < -20))
    {
        Settings.offsetTemperature_centigrad = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t gasConsumption_travel_l_min;
 */
    if((Settings.gasConsumption_travel_l_min < 5) ||
         (Settings.gasConsumption_travel_l_min > 50))
    {
        Settings.gasConsumption_travel_l_min = 20;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t gasConsumption_bottom_l_min;
 */
    if((Settings.gasConsumption_bottom_l_min < 5) ||
         (Settings.gasConsumption_bottom_l_min > 50))
    {
        Settings.gasConsumption_bottom_l_min = 20;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t gasConsumption_deco_l_min;
 */
    if((Settings.gasConsumption_deco_l_min < 5) ||
         (Settings.gasConsumption_deco_l_min > 50))
    {
        Settings.gasConsumption_deco_l_min = 20;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t showDebugInfo;
 */
#ifdef BOOT16
        Settings.showDebugInfo = 0;
#else
        if(Settings.showDebugInfo > 1)
            Settings.showDebugInfo = 0;

#endif

/*	uint8_t selected_language;
 */
#ifdef BOOT16
        if(Settings.selected_language > 1)
            Settings.selected_language = 0;
#else
        if(Settings.selected_language > 4)
            Settings.selected_language = 0;
#endif


/*	uint8_t display_toogle_desc; 1/10 seconds
 */
        if((Settings.display_toogle_desc < 20) || (Settings.display_toogle_desc > 600))
        {
            Settings.display_toogle_desc = SettingsStandard.display_toogle_desc;
            corrections++;
            setFirstCorrection(parameterId);
        }
        parameterId++;
/*	uint8_t debugModeOnStart;
 */
    if(Settings.debugModeOnStart > 1)
    {
        Settings.debugModeOnStart = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;

/*	uint8_t IAmStolenPleaseKillMe;
 */

    if(hardwareDataGetPointer()->primarySerial == 90)
        Settings.IAmStolenPleaseKillMe++;
    else
        Settings.IAmStolenPleaseKillMe = 0;


/*	uint8_t debugModeOnStart;
 */
    if(Settings.compassBearing > 360)
    {
        Settings.compassBearing = 0;
        corrections++;
        setFirstCorrection(parameterId);
    }

    parameterId++;
/*	uint8_t lastKnownBatteryPercentage;
 */
    if(Settings.lastKnownBatteryPercentage > 100)
    {
        Settings.lastKnownBatteryPercentage = 100;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t VPM_model
 */
    if((Settings.VPM_model !=  VPM_FROM_FORTRAN) && (Settings.VPM_model !=  VPM_BACHELORWORK))
    {
        Settings.VPM_model = VPM_FROM_FORTRAN;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
/*	uint8_t Buehlmann_model
 */
    if((Settings.GF_model !=  BUEHLMANN_OSTC4) && (Settings.GF_model !=  BUEHLMANN_hwOS))
    {
        Settings.GF_model = BUEHLMANN_OSTC4;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.FlipDisplay > 1) /* only boolean values allowed */
   	{
    	Settings.FlipDisplay = 0;
	    corrections++;
	    setFirstCorrection(parameterId);
   	}
    parameterId++;
#ifdef ENABLE_MOTION_CONTROL
    if(Settings.MotionDetection >= MOTION_DETECT_END)
   	{
    	Settings.MotionDetection = MOTION_DETECT_OFF;
	    corrections++;
	    setFirstCorrection(parameterId);
   	}
#else
    Settings.MotionDetection = MOTION_DETECT_OFF;
    Settings.viewPortMode = 0;
    Settings.viewRoll = 0.0;
    Settings.viewPitch = 0.0;
    Settings.viewYaw = 0.0;
#endif
    parameterId++;
    if(Settings.compassInertia > MAX_COMPASS_COMP)
   	{
    	Settings.compassInertia = 0;
	    corrections++;
	    setFirstCorrection(parameterId);
   	}
    parameterId++;
    if(Settings.tX_customViewPrimaryBF > CVIEW_T3_END)
    {
    	Settings.tX_customViewPrimaryBF = CVIEW_T3_Decostop;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.viewPortMode > MAX_VIEWPORT_MODE)
    {
    	Settings.viewPortMode = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.ppo2sensors_source >= O2_SENSOR_SOURCE_MAX)
    {
    	Settings.ppo2sensors_source = O2_SENSOR_SOURCE_OPTIC;
    	Settings.ppo2sensors_calibCoeff[0] = 0.0;
    	Settings.ppo2sensors_calibCoeff[1] = 0.0;
    	Settings.ppo2sensors_calibCoeff[2] = 0.0;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.amPMTime > 1) /* only boolean values allowed */
    {
    	Settings.amPMTime = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.autoSetpoint > 1) /* only boolean values allowed */
    {
    	Settings.autoSetpoint = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.scubberActiveId > 1)
    {
    	Settings.scubberActiveId = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if((Settings.scrubberData[0].TimerMax > MAX_SCRUBBER_TIME) || Settings.scrubberData[0].TimerCur < MIN_SCRUBBER_TIME || Settings.scrubberData[0].TimerCur > (int16_t)MAX_SCRUBBER_TIME)
    {
    	Settings.scrubberData[0].TimerMax = 0;
    	Settings.scrubberData[0].TimerCur = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if((Settings.scrubberData[1].TimerMax > MAX_SCRUBBER_TIME) || Settings.scrubberData[1].TimerCur < MIN_SCRUBBER_TIME || Settings.scrubberData[1].TimerCur > (int16_t)MAX_SCRUBBER_TIME)
    {
    	Settings.scrubberData[1].TimerMax = 0;
    	Settings.scrubberData[1].TimerCur = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.scrubTimerMode > SCRUB_TIMER_END)
    {
    	Settings.scrubTimerMode = SCRUB_TIMER_OFF;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if((Settings.pscr_lung_ratio > PSCR_MAX_LUNG_RATIO) || (Settings.pscr_lung_ratio < PSCR_MIN_LUNG_RATIO))
    {
    	Settings.pscr_lung_ratio = 10;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.pscr_o2_drop > PSCR_MAX_O2_DROP)
    {
    	Settings.pscr_o2_drop = 4;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.co2_sensor_active > 1)
    {
    	Settings.co2_sensor_active = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.ext_uart_protocol > UART_MAX_PROTOCOL)
    {
    	Settings.ext_uart_protocol = 0;
    	corrections++;
    	setFirstCorrection(parameterId);
    }
    parameterId++;
    if((Settings.ext_sensor_map[0] >= SENSOR_END)
    		|| (Settings.ext_sensor_map[1] >= SENSOR_END)
			|| (Settings.ext_sensor_map[2] >= SENSOR_END)
			|| (Settings.ext_sensor_map[3] >= SENSOR_END)
			|| (Settings.ext_sensor_map[4] >= SENSOR_END)
			|| (Settings.ext_sensor_map[5] >= SENSOR_END)
			|| (Settings.ext_sensor_map[6] >= SENSOR_END)
			|| (Settings.ext_sensor_map[7] >= SENSOR_END))
    {
    	Settings.ext_sensor_map[0] = SENSOR_OPTIC;
    	Settings.ext_sensor_map[1] = SENSOR_OPTIC;
    	Settings.ext_sensor_map[2] = SENSOR_OPTIC;
    	Settings.ext_sensor_map[3] = SENSOR_NONE;
    	Settings.ext_sensor_map[4] = SENSOR_NONE;
    	Settings.ext_sensor_map[5] = SENSOR_NONE;
    	Settings.ext_sensor_map[6] = SENSOR_NONE;
    	Settings.ext_sensor_map[7] = SENSOR_NONE;
       	corrections++;
       	setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.buttonLockActive > 1)
    {
        Settings.buttonLockActive = 1;
        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if (Settings.compassDeclinationDeg > 99) {
        Settings.compassDeclinationDeg = 99;

        corrections++;
        setFirstCorrection(parameterId);
    } else if (Settings.compassDeclinationDeg < -99) {
        Settings.compassDeclinationDeg = -99;

        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if (Settings.timerDurationS > 599) {
        Settings.timerDurationS = 599;

        corrections++;
        setFirstCorrection(parameterId);
    } else if (Settings.timerDurationS < 1) {
        Settings.timerDurationS = 1;

        corrections++;
        setFirstCorrection(parameterId);
    }
    parameterId++;
    if(Settings.cvAutofocus > 1)
    {
    	 corrections++;
    	 Settings.cvAutofocus = 0;
    }
    parameterId++;
    if(corrections)
    {
    	settingsWarning = 1;
    }
    else

    if(corrections > 255)
    {
    	corrections = 255;
    }

    SettingsStatus.Corrections = corrections;
    return (uint8_t)corrections;
}

#ifndef BOOTLOADER_STANDALONE
/* always at 0x8080000, do not move -> bootloader access */
const SFirmwareData* firmwareDataGetPointer(void)
{
    return &firmware_FirmwareData;
}


#ifndef SPECIALPROGRAMM
const SHardwareData* hardwareDataGetPointer(void)
{
    return (SHardwareData *)HARDWAREDATA_ADDRESS;
}
#endif
#endif
const SSettings* settingsGetPointerStandard(void)
{
    return &SettingsStandard;
}


void hardwareBatchCode(uint8_t *high, uint8_t *low)
{
    if(high)
    {
        *high = (uint8_t)((hardwareDataGetPointer()->production_year - 16) * 16);
        *high += hardwareDataGetPointer()->production_month;
        if(low)
        {
            *low = (uint8_t)(hardwareDataGetPointer()->production_day * 8);
        }
    }
}


uint8_t firmwareVersion_16bit_high(void)
{
    return ((firmware_FirmwareData.versionFirst & 0x1F)  << 3)	+ ((firmware_FirmwareData.versionSecond & 0x1C) >> 2);
}

uint8_t firmwareVersion_16bit_low(void)
{
    return ((firmware_FirmwareData.versionSecond & 0x03)  << 6)	+ ((firmware_FirmwareData.versionThird & 0x1F) << 1) + (firmware_FirmwareData.versionBeta & 0x01);
}

inline SSettings* settingsGetPointer(void)
{
    return &Settings;
}


//  ===============================================================================
//  set_settings_to_Standard
/// @brief	This function overwrites the current settings of the system
///					with the EXCEPTION of the personalDiveCount
///
///					It additionally calls set_new_settings_missing_in_ext_flash() and
///					check_and_correct_settings(), even so this shouldn't be necessary.
///					It is called on every start and from Reset All.
///
///					160622 added lastDiveLogIdBackup
///
//  ===============================================================================
void set_settings_to_Standard(void)
{
    SSettings *pSettings;
    const SSettings *pSettingsStandard;
    uint16_t personalDiveCountBackup;
    uint8_t lastDiveLogIdBackup;
    pSettings = settingsGetPointer();
    pSettingsStandard = settingsGetPointerStandard();

    personalDiveCountBackup = pSettings->personalDiveCount;
    lastDiveLogIdBackup = pSettings->lastDiveLogId;
    memcpy(pSettings,pSettingsStandard,sizeof(*pSettings));
    pSettings->personalDiveCount = personalDiveCountBackup;
    pSettings->lastDiveLogId = lastDiveLogIdBackup;

    pSettings->firmwareVersion[0] = firmware_FirmwareData.versionFirst;
    pSettings->firmwareVersion[1] = firmware_FirmwareData.versionSecond;
    pSettings->firmwareVersion[2] = firmware_FirmwareData.versionThird;
    pSettings->firmwareVersion[3] = firmware_FirmwareData.versionBeta;

    set_new_settings_missing_in_ext_flash();
    check_and_correct_settings();
    // has to be called too: createDiveSettings();
}


//  ===============================================================================
//  mod_settings_for_first_start_with_empty_ext_flash
/// @brief	This function overwrites some settings of the system
///					It is called on every start.
///					Those settings will be overwriten by ext_flash_read_settings()
///					Will be kept if ext_flash_read_settings() is invalid because
///					it is still empty.
///
//  ===============================================================================
void mod_settings_for_first_start_with_empty_ext_flash(void)
{
    settingsGetPointer()->debugModeOnStart = 1; //
}



//  ===============================================================================
//  hwOS4_to_hwOS_GasType
/// @brief	Helper for get gas / diluent
///
//  ===============================================================================
uint8_t hwOS4_to_hwOS_GasType(uint8_t inOSTC4style)
{
    switch(inOSTC4style)
    {
        case (1+2): // first
        case (2): 	// first
            return 1; // hwOS style first
        case (1+4): // deco
        case (4): 	// deco
            return 3; // hwOS style deco
        case (1+8): // travel
        case (8): 	// travel
            return 2; // hwOS style travel
        default:
            return 0; // hwOS style Disabled
    }
}


//  ===============================================================================
//  hwOS_to_hwOS4_GasType
/// @brief	Helper for set gas / diluent
///
//  ===============================================================================
uint8_t hwOS_to_hwOS4_GasType(uint8_t inOSTC4style)
{
    switch(inOSTC4style)
    {
        case (1): 		// first
            return 1+2; // hwOS4 style first
        case (2): 		// travel (normal for diluent)
            return 1+8; // hwOS4 style travel
        case (3): 		// deco
            return 1+4; // hwOS4 style deco
        default:
            return 0; 	// hwOS4 style inactive
    }
}



//  ===============================================================================
//  setGas
/// @brief	This function overwrites one gas, including mode and deco depth,
///					it returns 0x4D prompt which is not used by writeData() that calls it.
///
/// @param	i the gas id from 1 to 5 for OC and 6 to 10 for CCR, 0 is the extra gas
/// @param	*data 5 bytes with the first the command to call setGas and the four
///					following bytes to define oxygen, helium, mode and deco depth
///
///	@return	0x4D (prompt that is not used)
//  ===============================================================================
uint8_t setGas(int  i,uint8_t * data)
{
        if(!checkValue(data[1],4,100))
            return ERROR_;
        if(!checkValue(data[4],0,250))
            return ERROR_;

        Settings.gas[i].oxygen_percentage = data[1];
        Settings.gas[i].helium_percentage  = data[2];
        Settings.gas[i].note.uw  = hwOS_to_hwOS4_GasType(data[3]);
        Settings.gas[i].depth_meter  = data[4];
        return 0x4d;
}


uint8_t getGas(int  i,uint8_t * data)
{
    data[0] = Settings.gas[i].oxygen_percentage;
    data[1] = Settings.gas[i].helium_percentage;
    data[2] = hwOS4_to_hwOS_GasType(Settings.gas[i].note.uw);
    data[3] = Settings.gas[i].depth_meter;
    return 0x4d;
}

uint8_t setDiluent(int  i,uint8_t * data)
{
        if(!checkValue(data[1],4,100))
            return ERROR_;
        if(!checkValue(data[4],0,250))
            return ERROR_;

    Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage = data[1];
    Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage = data[2];
    Settings.gas[NUM_OFFSET_DILUENT + i].note.uw = hwOS_to_hwOS4_GasType(data[3]);
    Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter = data[4];
    return 0x4d;
}

uint8_t getDiluent(int  i,uint8_t * data)
{
    data[0] = Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage;
    data[1] = Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage;
    data[2] = hwOS4_to_hwOS_GasType(Settings.gas[NUM_OFFSET_DILUENT + i].note.uw);
    data[3] = Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter;
    return 0x4d;
}

uint8_t setSetpoint(int  i,uint8_t * data)
{
        if(!checkValue(data[1],50,160))
            return ERROR_;
        if(!checkValue(data[2],0,250))
            return ERROR_;

    Settings.setpoint[i].setpoint_cbar = data[1];
    Settings.setpoint[i].depth_meter = data[2];
    return 0x4d;
}

uint8_t getSetpoint(int  i,uint8_t * data)
{
    data[0] = Settings.setpoint[i].setpoint_cbar;
    data[1] = Settings.setpoint[i].depth_meter;
    return 0x4d;
}

uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to)
{
    if(value >= from && value <= to)
        return 1;
    return 0;
}

uint8_t writeData(uint8_t * data)
{
        uint32_t newSensitivity;
        uint16_t newDuration, newOffset;
        uint8_t newStopDepth;

    switch(data[0])
    {
    case 0x10:
        return setGas(1,data);
    case 0x11:
        return setGas(2,data);
    case 0x12:
        return setGas(3,data);
    case 0x13:
        return setGas(4,data);
    case 0x14:
        return setGas(5,data);
    case 0x15:
        return setDiluent(1,data);
    case 0x16:
        return setDiluent(2,data);
    case 0x17:
        return setDiluent(3,data);
    case 0x18:
        return setDiluent(4,data);
    case 0x19:
        return setDiluent(5,data);
    case 0x1A:
        return setSetpoint(1,data);
    case 0x1B:
        return setSetpoint(2,data);
    case 0x1C:
        return setSetpoint(3,data);
    case 0x1D:
        return setSetpoint(4,data);
    case 0x1E:
        return setSetpoint(5,data);
    case 0x1F:
        if(!checkValue(data[2],0,1))
            return ERROR_;
        Settings.CCR_Mode = data[1];
        break;
     case 0x20:
         if(!checkValue(data[1],0,3))
            return ERROR_;
        Settings.dive_mode = data[1];
        break;
      case 0x21:
        if(!checkValue(data[1],1,2))
            return ERROR_;
        Settings.deco_type.ub.standard = data[1] & 0x0F;
        //Settings.deco_type.ub.alternative = (data[1] & 0xF0) >> 4;
        break;
      case 0x22:
        if(!checkValue(data[1],100,190))
           return ERROR_;
        Settings.ppO2_max_std = data[1];
        break;
      case 0x23:
        if(!checkValue(data[1],15,15))
           return ERROR_;
        Settings.ppO2_min = data[1];
        break;
     case 0x24:
        if(!checkValue(data[1],0,15))
           return ERROR_;
        Settings.future_TTS = data[1];
        break;
     case 0x25:
        if(!checkValue(data[1],10,99))
            return ERROR_;
        Settings.GF_low = data[1];
        break;
     case 0x26:
        if(!checkValue(data[1],45,99))
            return ERROR_;
        Settings.GF_high = data[1];
        break;
    case 0x27:
        if(!checkValue(data[1],10,99))
            return ERROR_;
        Settings.aGF_low = data[1];
        break;
     case 0x28:
        if(!checkValue(data[1],45,99))
            return ERROR_;
        Settings.aGF_high = data[1];
        break;
    case 0x29:
        if(!checkValue(data[1],0,5))
            return ERROR_;
        Settings.VPM_conservatism.ub.standard = data[1];
        break;
    case 0x2A:
    case 0x2B:
                return ERROR_;
        case 0x2C:
        if(!checkValue(data[1],3,9))
            return ERROR_;
        Settings.last_stop_depth_meter = data[1];
        break;
        case 0x2D:
        if(!checkValue(data[1],0,4))
            return ERROR_;
        Settings.brightness = data[1];
        break;
        case 0x2E:
        if(!checkValue(data[1],0,1))
            return ERROR_;
        Settings.nonMetricalSystem = data[1];
        break;
    case 0x2F:
                return ERROR_;
        case 0x30:
        if(!checkValue(data[1],0,4))
            return ERROR_;
        Settings.salinity = data[1];
        break;
        case 0x31:
        if(!checkValue(data[1],0,3))
            return ERROR_;
        Settings.tX_colorscheme = data[1];
                GFX_use_colorscheme(Settings.tX_colorscheme);
        break;
        case 0x32:
        if(!checkValue(data[1],0,4))
            return ERROR_;
        Settings.selected_language = data[1];
        break;
        case 0x33:
        if(!checkValue(data[1],0,2))
            return ERROR_;
        Settings.date_format = data[1];
        break;
        case 0x34:
                return ERROR_;
        case 0x35:
                if(data[1] & 0x80)
                {
                    data[1] = ~(data[1]);
                    if(!checkValue(data[1],0,PRESSURE_OFFSET_LIMIT_MBAR))
                            return ERROR_;
                    Settings.offsetPressure_mbar = 0 - data[1];
                }
                else
                {
                    if(!checkValue(data[1],0,PRESSURE_OFFSET_LIMIT_MBAR))
                            return ERROR_;
                    Settings.offsetPressure_mbar = data[1];
                }
                break;
        case 0x36:
        if(!checkValue(data[1],0,1))
            return ERROR_;
                if(data[1])
                    Settings.safetystopDuration = settingsGetPointerStandard()->safetystopDuration;
                else
                    Settings.safetystopDuration = 0;
        break;
        case 0x37:
                return ERROR_;
        case 0x38:
        if(!checkValue(data[1],0,1))
            return ERROR_;
        Settings.fallbackToFixedSetpoint = data[1];
        break;
        case 0x39:
                return ERROR_;
        case 0x3A:
        if(!checkValue(data[1],70,110))
            return ERROR_;
                newSensitivity = data[1];
                settingsHelperButtonSens_keepPercentageValues(newSensitivity, settingsGetPointer()->ButtonResponsiveness);
                setButtonResponsiveness(Settings.ButtonResponsiveness);
        break;
        case 0x3B:
                // value between 0 and 127
                if(buttonBalanceTranslatorHexToArray(data[1], settingsGetPointer()->buttonBalance))
                {
                    settingsHelperButtonSens_keepPercentageValues(settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness);
                }
                else // value >= 128 (bit 7 set) factory reset
                {
                    getButtonFactorDefaults(&settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->buttonBalance);
                    settingsHelperButtonSens_keepPercentageValues(settingsGetPointerStandard()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness);
                }
                // valid for both:
                setButtonResponsiveness(Settings.ButtonResponsiveness);
                break;
        case 0x3C:
        if(!checkValue(data[1],5,50))
            return ERROR_;
        Settings.gasConsumption_bottom_l_min = data[1];
        break;
        case 0x3D:
        if(!checkValue(data[1],5,50))
            return ERROR_;
        Settings.gasConsumption_deco_l_min = data[1];
        break;
        case 0x3E:
        if(!checkValue(data[1],5,50))
            return ERROR_;
        Settings.gasConsumption_travel_l_min = data[1];
        break;
        case 0x3F:
        case 0x40:
                return ERROR_;
        case 0x41:
        if(!checkValue(data[1],0,1))
            return ERROR_;
        Settings.alwaysShowPPO2 = data[1];
        break;
        case 0x42:
                if(data[1] & 0x80)
                {
                    data[1] = ~(data[1]);
                    if(!checkValue(data[1],0,20))
                            return ERROR_;
                    Settings.offsetTemperature_centigrad = 0 - data[1];
                }
                else
                {
                    if(!checkValue(data[1],0,20))
                            return ERROR_;
                    Settings.offsetTemperature_centigrad = data[1];
                }
                break;
        case 0x43:
        if(!checkValue(data[1],60,255))
            return ERROR_;
                newDuration = (uint16_t)data[1] + 59;
                newDuration /= 60;
        Settings.safetystopDuration = (uint8_t)newDuration;
        break;
        case 0x44:
        if(!checkValue(data[1],21,61))
            return ERROR_;
                newStopDepth = data[1] + 9;
                if(newStopDepth > 60)
                    newStopDepth = 60;
                newStopDepth /= 10;
        Settings.safetystopDepth = newStopDepth;
        break;
        case 0x45:
        case 0x46:
                return ERROR_;
        case 0x47:
                newOffset = data[2] * 256;
                newOffset += data[1];
                if(newOffset > 9000)
            return ERROR_;
                Settings.logbookOffset = newOffset;
                break;
        case 0x70:
        if(!checkValue(data[1],0,1))
            return ERROR_;
        Settings.showDebugInfo = data[1];
        break;
        case 0x71:
        if(!checkValue(data[1],0,(EXTRADISPLAY_END - 1)))
            return ERROR_;
        Settings.extraDisplay = data[1];
        break;
        case 0x72:
        if(!checkValue(data[1],0,8))
            return ERROR_;
        Settings.tX_customViewPrimary = data[1];
        break;
        case 0x73:
        if(!checkValue(data[1],0,20))
            return ERROR_;
        Settings.tX_customViewTimeout = data[1];
        break;
        case 0x74:
        if(!checkValue(data[1],1,7))
            return ERROR_;
        Settings.tX_userselectedLeftLowerCornerPrimary = data[1];
        break;
        case 0x75:
        if(!checkValue(data[1],0,20))
            return ERROR_;
        Settings.tX_userselectedLeftLowerCornerTimeout = data[1];
        break;
    }
    return 0;
}


uint8_t readDataLimits__8and16BitValues_4and7BytesOutput(uint8_t what, uint8_t * data)
{
    enum JeanDoParameterType {
        PARAM_UNKNOWN = 0,
        PARAM_INT15 = 1,
        PARAM_INT8,
        PARAM_DECI,
        PARAM_CENTI,
        PARAM_MILI,
        PARAM_PERCENT,
        PARAM_SEC,
        PARAM_COLOR,
        PARAM_BOOL,
        PARAM_ENUM,
        PARAM_SIGNED = 128,
        PARAM_SDECI = PARAM_SIGNED|PARAM_DECI,
        PARAM_SSEC = PARAM_SIGNED|PARAM_SEC,
        PARAM_SINT = PARAM_SIGNED|PARAM_INT8
    };

//		uint32_t buttonSensitivity;
        uint16_t newDuration;

        uint8_t datacounter = 0;

    data[0] = 0;
    data[1] = 0;
    data[2] = 0;
    data[3] = 0;
        datacounter = 0;

    switch(what)
    {
    case 0x10:
    case 0x11:
    case 0x12:
    case 0x13:
    case 0x14:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 4;
        data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage;
        data[datacounter++] = 100;
        break;

    case 0x15:
    case 0x16:
    case 0x17:
    case 0x18:
    case 0x19:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 4;
        data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage;
        data[datacounter++] = 100;
        break;

    case 0x1A:
    case 0x1B:
    case 0x1C:
    case 0x1D:
    case 0x1E:
        data[datacounter++] = PARAM_CENTI;
        data[datacounter++] = 50;
        data[datacounter++] = settingsGetPointerStandard()->setpoint[1].setpoint_cbar;
        data[datacounter++] = 160;
        break;

    case 0x1F:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->CCR_Mode;
        data[datacounter++] = 1;
        break;

    case 0x20:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->dive_mode;
        data[datacounter++] = 3;
        break;

    case 0x21:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 1;
        data[datacounter++] = settingsGetPointerStandard()->deco_type.ub.standard;
        data[datacounter++] = 2;
        break;

    case 0x22:
        data[datacounter++] = PARAM_CENTI;
        data[datacounter++] = 100;
        data[datacounter++] = settingsGetPointerStandard()->ppO2_max_std;
        data[datacounter++] = 190;
        break;

    case 0x23:
        data[datacounter++] = PARAM_CENTI;
        data[datacounter++] = 15;
        data[datacounter++] = settingsGetPointerStandard()->ppO2_min;
        data[datacounter++] = 15;
        break;

    case 0x24:
        data[datacounter++] = PARAM_INT8; // minutes
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->future_TTS;
        data[datacounter++] = 15;
        break;

    case 0x25:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 10;
        data[datacounter++] = settingsGetPointerStandard()->GF_low;
        data[datacounter++] = 99;
        break;

    case 0x26:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 45;
        data[datacounter++] = settingsGetPointerStandard()->GF_high;
        data[datacounter++] = 99;
        break;

    case 0x27:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 10;
        data[datacounter++] = settingsGetPointerStandard()->aGF_low;
        data[datacounter++] = 99;
        break;

    case 0x28:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 45;
        data[datacounter++] = settingsGetPointerStandard()->aGF_high;
        data[datacounter++] = 99;
        break;

    case 0x29:
        data[datacounter++] = PARAM_INT8; // conservatism +0 .. +5
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->VPM_conservatism.ub.standard;
        data[datacounter++] = 5;
        break;

    case 0x2A:
    case 0x2B:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 100;
        data[datacounter++] = 100;// saturation, desaturation, settingsGetPointerStandard()->;
        data[datacounter++] = 100;
        break;

        case 0x2C:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 3;
        data[datacounter++] = settingsGetPointerStandard()->last_stop_depth_meter;
        data[datacounter++] = 9;
        break;

        case 0x2D:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->brightness;
        data[datacounter++] = 4;
        break;

    case 0x2E:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->nonMetricalSystem;
        data[datacounter++] = 1;
        break;

    case 0x2F:
        data[datacounter++] = PARAM_INT8; // Sampling rate logbook
        data[datacounter++] = 2;
        data[datacounter++] = 2;
        data[datacounter++] = 2;
        break;

    case 0x30:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->salinity;
        data[datacounter++] = 4;
        break;

    case 0x31:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->tX_colorscheme;
        data[datacounter++] = 3;
        break;

    case 0x32:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->selected_language;
        data[datacounter++] = 1;
        break;

    case 0x33:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->date_format;
        data[datacounter++] = 2;
        break;

    case 0x34:
        data[datacounter++] = PARAM_UNKNOWN ;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // compass gain, is unknown,, settingsGetPointerStandard()->;
        data[datacounter++] = 0;
        break;

    case 0x35:
        data[datacounter++] =  PARAM_SINT;
        data[datacounter++] = (uint8_t)(256 - PRESSURE_OFFSET_LIMIT_MBAR); // == -20
        if(settingsGetPointerStandard()->offsetPressure_mbar < 0)
            data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetPressure_mbar);
        else
            data[datacounter++] = settingsGetPointerStandard()->offsetPressure_mbar;
        data[datacounter++] = PRESSURE_OFFSET_LIMIT_MBAR;
        break;

    case 0x36:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 0;
        if(settingsGetPointerStandard()->safetystopDuration)
            data[datacounter++] = 1;
        else
            data[datacounter++] = 0;
        data[datacounter++] = 1;
        break;

    case 0x37:
        data[datacounter++] = PARAM_UNKNOWN ;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // Set calibration gas, not possible with optical
        data[datacounter++] = 0;
        break;

    case 0x38:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->fallbackToFixedSetpoint;
        data[datacounter++] = 1;
        break;

    case 0x39:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // flipscreen, not yet :-) settingsGetPointerStandard()->;
        data[datacounter++] = 0;
        break;

    case 0x3A:
        data[datacounter++] = PARAM_PERCENT;
        data[datacounter++] = 70;
        data[datacounter++] = settingsGetPointerStandard()->ButtonResponsiveness[3];
        data[datacounter++] = 110;
        break;

    case 0x3B:
        data[datacounter++] = PARAM_UNKNOWN;
        data[datacounter++] = 0;
        data[datacounter++] = buttonBalanceTranslateArrayOutHex(settingsGetPointerStandard()->buttonBalance);
        data[datacounter++] = 128;
        break;

    case 0x3C:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 5;
        data[datacounter++] = settingsGetPointerStandard()->gasConsumption_bottom_l_min;
        data[datacounter++] = 50;
        break;

    case 0x3D:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 5;
        data[datacounter++] = settingsGetPointerStandard()->gasConsumption_deco_l_min;
        data[datacounter++] = 50;
        break;

    case 0x3E:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 5;
        data[datacounter++] = settingsGetPointerStandard()->gasConsumption_travel_l_min;
        data[datacounter++] = 50;
        break;

    case 0x3F:
        data[datacounter++] = PARAM_UNKNOWN;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // Dynamic ascend rate,  not yet :-) settingsGetPointerStandard()->;
        data[datacounter++] = 0;
        break;

    case 0x40:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 1;
        data[datacounter++] = 1; // Graphical speed indicator;
        data[datacounter++] = 1;
        break;

    case 0x41:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->alwaysShowPPO2;
        data[datacounter++] = 1;
        break;

    case 0x42:
        data[datacounter++] = PARAM_SIGNED|PARAM_CENTI;
        data[datacounter++] = (uint8_t)(256 - 20); // == -20
        if(settingsGetPointerStandard()->offsetTemperature_centigrad < 0)
            data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetTemperature_centigrad);
        else
            data[datacounter++] = settingsGetPointerStandard()->offsetTemperature_centigrad;
        data[datacounter++] = 20;
        break;

    case 0x43:
        newDuration = settingsGetPointerStandard()->safetystopDuration;
        newDuration *= 60;
        if(newDuration > 255)
            newDuration = 255;
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 60; // coud be 1 minute instead
        data[datacounter++] = (uint8_t)newDuration;
        data[datacounter++] = 255; // could be 5 minutes instead
        break;

    case 0x44:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 30; // coud be 3 meter instead
        data[datacounter++] = settingsGetPointerStandard()->safetystopDepth * 10;
        data[datacounter++] = 60; // could be 6 meter instead
        break;

    case 0x45:
    case 0x46:
        data[datacounter++] = PARAM_UNKNOWN;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth
        data[datacounter++] = 0;
        break;

    case 0x47:
        data[datacounter++] = PARAM_INT15;
        data[datacounter++] = 0;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->logbookOffset & 0xFF;
        data[datacounter++] = settingsGetPointerStandard()->logbookOffset / 0xFF;
        data[datacounter++] = 9000 & 0xFF;
        data[datacounter++] = 9000 / 0xFF;
        break;

    case 0x70:
        data[datacounter++] = PARAM_BOOL;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->showDebugInfo;
        data[datacounter++] = 1;
        break;

    case 0x71:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->extraDisplay;
        data[datacounter++] = (EXTRADISPLAY_END - 1);
        break;

    case 0x72:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->tX_customViewPrimary;
        data[datacounter++] = 8;
        break;

    case 0x73:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->tX_customViewTimeout;
        data[datacounter++] = 60;
        break;

    case 0x74:
        data[datacounter++] = PARAM_ENUM;
        data[datacounter++] = 1;
        data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerPrimary;
        data[datacounter++] = 7;
        break;

    case 0x75:
        data[datacounter++] = PARAM_INT8;
        data[datacounter++] = 0;
        data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerTimeout;
        data[datacounter++] = 60;
        break;
    }

    if(datacounter == 0)
    {
        data[datacounter++] = PARAM_UNKNOWN;
        data[datacounter++] = 0;
        data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth
        data[datacounter++] = 0;
    }

    return datacounter;
}


uint8_t readData(uint8_t what, uint8_t * data)
{
    data[0] = 0;
    data[1] = 0;
    data[2] = 0;
    data[3] = 0;
    switch(what)
    {
    case 0x10:
        return getGas(1,data);
    case 0x11:
        return getGas(2,data);
    case 0x12:
        return getGas(3,data);
    case 0x13:
        return getGas(4,data);
    case 0x14:
        return getGas(5,data);
    case 0x15:
        return getDiluent(1,data);
    case 0x16:
        return getDiluent(2,data);
    case 0x17:
        return getDiluent(3,data);
    case 0x18:
        return getDiluent(4,data);
    case 0x19:
        return getDiluent(5,data);
    case 0x1A:
        return getSetpoint(1,data);
    case 0x1B:
        return getSetpoint(2,data);
    case 0x1C:
        return getSetpoint(3,data);
    case 0x1D:
        return getSetpoint(4,data);
    case 0x1E:
        return getSetpoint(5,data);
    case 0x1F:
        data[0] = Settings.CCR_Mode;
        break;
     case 0x20:
        data[0] = Settings.dive_mode;
        break;
      case 0x21:
        data[0] = Settings.deco_type.ub.standard;
        break;
      case 0x22:
        data[0] = Settings.ppO2_max_std;
        break;
      case 0x23:
        data[0] = Settings.ppO2_min;
        break;
     case 0x24:
        data[0] = Settings.future_TTS;
        break;
     case 0x25:
        data[0] = Settings.GF_low;
        break;
     case 0x26:
        data[0] = Settings.GF_high;
        break;
    case 0x27:
        data[0] = Settings.aGF_low;
        break;
     case 0x28:
        data[0] = Settings.aGF_high;
        break;
    case 0x29:
        data[0] = Settings.VPM_conservatism.ub.standard;
                break;
    case 0x2A:
    case 0x2B:
        data[0] = 100;
        break;
     case 0x2C:
        data[0] = Settings.last_stop_depth_meter;
        break;
     case 0x2D:
        data[0] = Settings.brightness;
        break;
     case 0x2E:
        data[0] = Settings.nonMetricalSystem;
        break;
     case 0x2F:
        data[0] = 0; // 0 == 2 sec sampling rate
        break;
     case 0x30:
        data[0] = Settings.salinity;
        break;
     case 0x31:
        data[0] = Settings.tX_colorscheme;
        break;
     case 0x32:
        data[0] = Settings.selected_language;
        break;
     case 0x33:
        data[0] = Settings.date_format;
        break;
     case 0x34:
        data[0] = 7; // gain should be always 7 as far as I understand the code in RTE
        break;
     case 0x35:
        data[0] = Settings.offsetPressure_mbar;
        break;
     case 0x36:
        if(Settings.safetystopDepth)
            data[0] = 1;
        else
            data[0] = 0;
        break;
     case 0x37:
        data[0] = 0; // calibration gas %O2 -> 0 no gas :-)
        break;
     case 0x38:
        data[0] = Settings.fallbackToFixedSetpoint;
        break;
     case 0x39:
        data[0] = 0; // flip screen
        break;
     case 0x3A:
        data[0] = Settings.ButtonResponsiveness[3];
        break;
     case 0x3B:
        data[0] = buttonBalanceTranslateArrayOutHex(settingsGetPointer()->buttonBalance);
        break;
     case 0x3C:
        data[0] = Settings.gasConsumption_bottom_l_min;
        break;
     case 0x3D:
        data[0] = Settings.gasConsumption_deco_l_min;
        break;
     case 0x3E:
        data[0] = Settings.gasConsumption_travel_l_min;
        break;
     case 0x3F:
        data[0] = 0; // fixed ascend rate 10 m/min
        break;
     case 0x40:
        data[0] = 1; // graphical speed indicator
        break;
     case 0x41:
        data[0] = Settings.alwaysShowPPO2;
        break;
     case 0x42:
        data[0] = Settings.offsetTemperature_centigrad;
        break;
     case 0x43:
        if(Settings.safetystopDuration > 4)
            data[0] = 255; // seconds
        else
            data[0] = 60 * Settings.safetystopDuration;
        break;
     case 0x44:
        data[0] = Settings.safetystopDepth * 10; // cbar instead of meter
        break;
     case 0x45:
        if(Settings.safetystopDepth == 3)
            data[0] = 20; // cbar
        else
            data[0] = 30; // cbar
        break;
     case 0x46:
        data[0] = 10; // reset at 10 meter as far as I understood
        break;
     case 0x47:
        data[0] = Settings.logbookOffset & 0xFF;
        data[1] = Settings.logbookOffset / 0xFF;
        break;
     case 0x70:
        data[0] = Settings.showDebugInfo;
        break;
     case 0x71:
        data[0] = Settings.extraDisplay;
        break;
     case 0x72:
        data[0] = Settings.tX_customViewPrimary;
        break;
     case 0x73:
        data[0] = Settings.tX_customViewTimeout;
        break;
     case 0x74:
        data[0] = Settings.tX_userselectedLeftLowerCornerPrimary;
        break;
     case 0x75:
        data[0] = Settings.tX_userselectedLeftLowerCornerTimeout;
        break;
        }
    return 0x4D;
}


uint8_t RTEminimum_required_high(void)
{
    return RTErequiredHigh;
}
uint8_t RTEminimum_required_low(void)
{
    return RTErequiredLow;
}

uint8_t FONTminimum_required_high(void)
{
    return FONTrequiredHigh;
}
uint8_t FONTminimum_required_low(void)
{
    return FONTrequiredLow;
}


void setActualRTEversion(uint8_t high, uint8_t low)
{
    RTEactualHigh = high;
    RTEactualLow = low;
}

#ifndef BOOTLOADER_STANDALONE
void getActualRTEandFONTversion(uint8_t *RTEhigh, uint8_t *RTElow, uint8_t *FONThigh, uint8_t *FONTlow)
{
    if(RTEhigh && RTElow)
    {
        *RTEhigh = RTEactualHigh;
        *RTElow = RTEactualLow;
    }
    if(FONThigh && FONTlow)
    {
        *FONThigh = *(uint8_t *)0x08132000;
        *FONTlow = *(uint8_t *)0x08132001;
    }
}


uint8_t getLicence(void)
{
    return hardwareDataGetPointer()->primaryLicence;
}
#endif

void firmwareGetDate(RTC_DateTypeDef *SdateOutput)
{
    SdateOutput->Year = firmwareDataGetPointer()->release_year;
    SdateOutput->Month = firmwareDataGetPointer()->release_month;
    SdateOutput->Date = firmwareDataGetPointer()->release_day;
}


// this should use device specific values stored in OTPROG ROM soon
void getButtonFactorDefaults(uint8_t* basePercentage, uint8_t* buttonBalanceArray)
{
    *basePercentage = settingsGetPointerStandard()->ButtonResponsiveness[3];

    for(int i=0;i<3;i++)
    {
        buttonBalanceArray[i] = settingsGetPointerStandard()->buttonBalance[i];
    }
}


uint8_t buttonBalanceTranslatorHexToArray(uint8_t hexValue, uint8_t* outputArray)
{
    if(hexValue > 127)
        return 0;
    // internal order: 0 = right, 1 = center, 2 = left
    // external order: Factory,left,center,right
    outputArray[0] = 2 + (hexValue & 0x03);
    hexValue /= 4;
    outputArray[1] = 2 + (hexValue & 0x03);
    hexValue /= 4;
    outputArray[2] =  2 + (hexValue & 0x03);

    return 1;
}


uint8_t buttonBalanceTranslateArrayOutHex(const uint8_t* inputArray)
{
    uint8_t hexValue = 0;

    if(inputArray[2] > 2)
    {
        hexValue += inputArray[2] - 2;
    }
    hexValue *= 4;

    if(inputArray[1] > 2)
    {
        hexValue += inputArray[1] - 2;
    }
    hexValue *= 4;
    if(inputArray[0] > 2)
    {
        hexValue += inputArray[0] - 2;
    }
    return hexValue;
}

void settingsWriteFactoryDefaults(uint8_t inputValueRaw, uint8_t *inputBalanceArray)
{
    if((inputValueRaw >= 70) && (inputValueRaw <= 110))
    {
        Settings.FactoryButtonBase = inputValueRaw;
    }
    for(int i=0;i<3;i++)
    {
        if((inputBalanceArray[i] >= 2) && (inputBalanceArray[i] <= 5))
        {
            Settings.FactoryButtonBalance[i] = inputBalanceArray[i];
        }
    }
}


/**
  ******************************************************************************
  * @brief   settingsHelperButtonSens. /  make 32 bit input to three buttons + storage value in [3]
  * @author  heinrichs weikamp gmbh
  * @version V 01
  * @date    19-Sept-2016
  ******************************************************************************
    *
  * @param  inputValueRaw:
  * @param  outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance
  * @retval None
  */
void settingsHelperButtonSens_keepPercentageValues(uint32_t inputValueRaw, uint8_t *outArray4Values)
{
    uint32_t newSensitivity;

    if(inputValueRaw > MAX_BUTTONRESPONSIVENESS)
    {
            inputValueRaw = MAX_BUTTONRESPONSIVENESS;
    }
    else
    if(inputValueRaw < MIN_BUTTONRESPONSIVENESS)
    {
            inputValueRaw = MIN_BUTTONRESPONSIVENESS;
    }

    // the unbalanced value
    outArray4Values[3] = inputValueRaw;

    // the balanced values
    for(int i=0;i<3;i++)
    {
        newSensitivity = inputValueRaw;
        switch(settingsGetPointer()->buttonBalance[i])
        {
        case 1: // should not be an option hw 170508
            newSensitivity -= 20;
            break;
        case 2:
            newSensitivity -= 10;
            break;
        default:
            break;
        case 4:
            newSensitivity += 10;
            break;
        case 5:
            newSensitivity += 20;
            break;
        }

        if(newSensitivity > MAX_BUTTONRESPONSIVENESS)
        {
                newSensitivity = MAX_BUTTONRESPONSIVENESS;
        }
        outArray4Values[i] = newSensitivity;
    }
}


/**
  ******************************************************************************
  * @brief   settingsHelperButtonSens_translate_to_hwOS_values. /  make 32 bit input to three buttons + storage value in [3]
  * @author  heinrichs weikamp gmbh
  * @version V 01
  * @date    19-Sept-2016
  ******************************************************************************
    *
  * @param  inputValueRaw:
  * @param  outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance
  * @retval None
  */
void settingsHelperButtonSens_original_translate_to_hwOS_values(const uint32_t inputValueRaw, uint8_t *outArray4Values)
{
    uint32_t newSensitivity;

    for(int i=0;i<3;i++)
    {
        newSensitivity = inputValueRaw;
        switch(settingsGetPointer()->buttonBalance[i])
        {
        case 1:
            newSensitivity -= 20;
            break;
        case 2:
            newSensitivity -= 10;
            break;
        default:
            break;
        case 4:
            newSensitivity += 10;
            break;
        case 5:
            newSensitivity += 20;
            break;
        }

        if(newSensitivity > 100)
        {
            if(newSensitivity <= 105)
                newSensitivity = 10;
            else
                newSensitivity = 7;
        }
        else
        {
            newSensitivity *= 24;
            newSensitivity = 2400 - newSensitivity;
            newSensitivity /= 10;

            newSensitivity += 15;
            if(newSensitivity > 255)
                newSensitivity = 255;
        }
        outArray4Values[i] = newSensitivity;
    }

    // the unbalanced value
    newSensitivity = inputValueRaw;
    if(newSensitivity > 100)
    {
        if(newSensitivity <= 105)
            newSensitivity = 10;
        else
            newSensitivity = 7;
    }
    else
    {
        newSensitivity *= 24;
        newSensitivity = 2400 - newSensitivity;
        newSensitivity /= 10;

        newSensitivity += 15;
        if(newSensitivity > 255)
            newSensitivity = 255;
    }
    outArray4Values[3] = newSensitivity;
}


/**
  ******************************************************************************
  * @brief   settingsHelperButtonSens_translate_percentage_to_hwOS_values.
  * @author  heinrichs weikamp gmbh
  * @version V 01
  * @date    6-March-2017
  ******************************************************************************
    *
  * @param  inputValuePercentage with buttonBalance included
  * @retval PIC compatible value
  */
uint8_t settingsHelperButtonSens_translate_percentage_to_hwOS_values(uint8_t inputValuePercentage)
{
    uint32_t newSensitivity = inputValuePercentage;

    if(newSensitivity > 100)
    {
        if(newSensitivity <= 105)
            newSensitivity = 10;
        else
            newSensitivity = 7;
    }
    else
    {
        newSensitivity *= 24;
        newSensitivity = 2400 - newSensitivity;
        newSensitivity /= 10;

        newSensitivity += 15;
        if(newSensitivity > 255)
            newSensitivity = 255;
    }
    return (uint8_t)newSensitivity;
}


/**
  ******************************************************************************
  * @brief   settingsHelperButtonSens_translate_hwOS_values_to_percentage.
  * @author  heinrichs weikamp gmbh
  * @version V 01
  * @date    6-March-2017
  ******************************************************************************
    *
  * @param	PIC compatible value
  * @retval	Percentage
  */
uint8_t settingsHelperButtonSens_translate_hwOS_values_to_percentage(uint8_t inputValuePIC)
{
    if(inputValuePIC >= 15)
    {
        return(uint8_t)((25500 - (inputValuePIC)*100) / 240);
    }
    else
    {
        if(inputValuePIC >= 10)
        {
            return 105;
        }
        else
        {
            return 110;
        }
    }
}

void reset_SettingWarning()
{
	settingsWarning = 0;
}
inline uint8_t isSettingsWarning()
{
	return settingsWarning;
}