Mercurial > public > ostc4
annotate Discovery/Src/settings.c @ 864:fa431d42b5fb
Fix incorrect logging of bailout to Open Circuit when using the best gas.
This happened because the starting gas used for 'best gas' calculation
was a diluent - in most cases not a problem as the same gas is also
used as a bailout gas. Now use the 'first' open circuit gas configured as the
starting point.
Also fixes the problem of a custom bailout gas not being logged as such,
and consequently not being shown as bailout in the on-device log.
| author | heinrichsweikamp |
|---|---|
| date | Mon, 22 Jul 2024 16:38:36 +0200 |
| parents | 7322adb00305 |
| children | b7d93ff6b3b2 |
| rev | line source |
|---|---|
| 38 | 1 /////////////////////////////////////////////////////////////////////////////// |
| 2 /// -*- coding: UTF-8 -*- | |
| 3 /// | |
| 4 /// \file Discovery/Src/settings.c | |
| 5 /// \brief settingsHelperButtonSens_translate_hwOS_values_to_percentage. | |
| 6 /// \author Heinrichs Weikamp gmbh | |
| 7 /// \date 6-March-2017 | |
| 8 /// | |
| 9 /// \details | |
| 10 /// | |
| 11 /// $Id$ | |
| 12 /////////////////////////////////////////////////////////////////////////////// | |
| 13 /// \par Copyright (c) 2014-2018 Heinrichs Weikamp gmbh | |
| 14 /// | |
| 15 /// This program is free software: you can redistribute it and/or modify | |
| 16 /// it under the terms of the GNU General Public License as published by | |
| 17 /// the Free Software Foundation, either version 3 of the License, or | |
| 18 /// (at your option) any later version. | |
| 19 /// | |
| 20 /// This program is distributed in the hope that it will be useful, | |
| 21 /// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 22 /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 23 /// GNU General Public License for more details. | |
| 24 /// | |
| 25 /// You should have received a copy of the GNU General Public License | |
| 26 /// along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 27 ////////////////////////////////////////////////////////////////////////////// | |
| 28 | |
| 29 #include <string.h> | |
|
765
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
30 |
| 38 | 31 #include "settings.h" |
| 32 #include "firmwareEraseProgram.h" // for HARDWAREDATA_ADDRESS | |
| 33 #include "externLogbookFlash.h" // for SAMPLESTART and SAMPLESTOP | |
| 34 #include "text_multilanguage.h" // for LANGUAGE_END | |
| 35 #include "tHome.h" // for CVIEW_END | |
|
389
ebc2b571a0b9
Fix case for case sensitive OS
Jan Mulder <jan@jlmulder.nl>
parents:
382
diff
changeset
|
36 #include "motion.h" |
|
443
a5101c688b49
Introduced enum for lower left corner view selection:
ideenmodellierer
parents:
439
diff
changeset
|
37 #include "t7.h" |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
38 #include "data_central.h" |
| 38 | 39 |
| 662 | 40 static uint8_t settingsWarning = 0; /* Active if setting values have been corrected */ |
| 820 | 41 static SSettingsStatus SettingsStatus; /* Structure containing number of corrections and first occurrence */ |
| 662 | 42 |
| 38 | 43 SSettings Settings; |
| 44 | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
45 const uint8_t RTErequiredHigh = 3; |
| 801 | 46 const uint8_t RTErequiredLow = 2; |
| 38 | 47 |
| 75 | 48 const uint8_t FONTrequiredHigh = 1; |
| 49 const uint8_t FONTrequiredLow = 0; | |
| 38 | 50 |
| 51 uint8_t RTEactualHigh = 0; | |
| 52 uint8_t RTEactualLow = 0; | |
| 53 | |
| 54 // =============================================================================== | |
| 55 // SFirmwareData FirmwareData | |
| 56 /// @brief internal counter is for changes after last release | |
| 57 /// use date and info as well for this purpose | |
| 58 /// | |
| 59 // =============================================================================== | |
| 60 | |
| 61 const SFirmwareData firmware_FirmwareData __attribute__( (section(".firmware_firmware_data")) ) = | |
| 62 { | |
| 63 .versionFirst = 1, | |
| 695 | 64 .versionSecond = 6, |
| 820 | 65 .versionThird = 5, |
| 762 | 66 .versionBeta = 0, |
| 38 | 67 |
| 68 /* 4 bytes with trailing 0 */ | |
|
55
a7683f9765da
Italian activated (needs some fine tuning), special characters (?,?,?,?,? and others) currently not working...
heinrichsweikamp
parents:
48
diff
changeset
|
69 .signature = "mh", |
| 38 | 70 |
| 762 | 71 .release_year = 23, |
| 820 | 72 .release_month = 8, |
| 73 .release_day = 26, | |
| 38 | 74 .release_sub = 0, |
| 75 | |
| 76 /* max 48 with trailing 0 */ | |
| 77 //release_info ="12345678901234567890123456789012345678901" | |
|
286
733877ab87d9
Minor: Some Texts fixed, allign RTErequired* values with RTE firmware
heinrichsweikamp
parents:
274
diff
changeset
|
78 .release_info ="gcc_2nd", |
| 38 | 79 |
| 80 /* for safety reasons and coming functions */ | |
| 81 .magic[0] = FIRMWARE_MAGIC_FIRST, | |
| 82 .magic[1] = FIRMWARE_MAGIC_SECOND, | |
| 83 .magic[2] = FIRMWARE_MAGIC_FIRMWARE, /* the magic byte */ | |
| 84 .magic[3] = FIRMWARE_MAGIC_END | |
| 85 }; | |
| 86 | |
| 87 | |
| 88 /* always adjust check_and_correct_settings() accordingly | |
| 89 * There might even be entries with fixed values that have no range | |
| 90 */ | |
| 91 const SSettings SettingsStandard = { | |
| 820 | 92 .header = 0xFFFF0028, |
| 38 | 93 .warning_blink_dsec = 8 * 2, |
| 94 .lastDiveLogId = 0, | |
| 662 | 95 .logFlashNextSampleStartAddress = SAMPLESTART, |
| 38 | 96 |
| 97 .gas[0].oxygen_percentage = 21, | |
| 98 .gas[1].oxygen_percentage = 21, | |
| 99 .gas[2].oxygen_percentage = 21, | |
| 100 .gas[3].oxygen_percentage = 21, | |
| 101 .gas[4].oxygen_percentage = 21, | |
| 102 .gas[5].oxygen_percentage = 21, | |
| 103 .gas[6].oxygen_percentage = 21, | |
| 104 .gas[7].oxygen_percentage = 21, | |
| 105 .gas[8].oxygen_percentage = 21, | |
| 106 .gas[9].oxygen_percentage = 21, | |
| 107 .gas[10].oxygen_percentage = 21, | |
| 108 .gas[0].helium_percentage = 0, | |
| 109 .gas[1].helium_percentage = 0, | |
| 110 .gas[2].helium_percentage = 0, | |
| 111 .gas[3].helium_percentage = 0, | |
| 112 .gas[4].helium_percentage = 0, | |
| 113 .gas[5].helium_percentage = 0, | |
| 114 .gas[6].helium_percentage = 0, | |
| 115 .gas[7].helium_percentage = 0, | |
| 116 .gas[8].helium_percentage = 0, | |
| 117 .gas[9].helium_percentage = 0, | |
| 118 .gas[10].helium_percentage = 0, | |
| 119 .gas[0].depth_meter = 0, | |
| 120 .gas[1].depth_meter = 0, | |
| 121 .gas[2].depth_meter = 0, | |
| 122 .gas[3].depth_meter = 0, | |
| 123 .gas[4].depth_meter = 0, | |
| 124 .gas[5].depth_meter = 0, | |
| 125 .gas[6].depth_meter = 0, | |
| 126 .gas[7].depth_meter = 0, | |
| 127 .gas[8].depth_meter = 0, | |
| 128 .gas[9].depth_meter = 0, | |
| 129 .gas[10].depth_meter = 0, | |
| 130 .gas[0].depth_meter_travel = 0, | |
| 131 .gas[1].depth_meter_travel = 0, | |
| 132 .gas[2].depth_meter_travel = 0, | |
| 133 .gas[3].depth_meter_travel = 0, | |
| 134 .gas[4].depth_meter_travel = 0, | |
| 135 .gas[5].depth_meter_travel = 0, | |
| 136 .gas[6].depth_meter_travel = 0, | |
| 137 .gas[7].depth_meter_travel = 0, | |
| 138 .gas[8].depth_meter_travel = 0, | |
| 139 .gas[9].depth_meter_travel = 0, | |
| 140 .gas[10].depth_meter_travel = 0, | |
| 141 .gas[0].note.uw = 0, | |
| 142 .gas[1].note.ub.first = 1, | |
| 143 .gas[1].note.ub.active = 1, | |
| 144 .gas[1].note.ub.deco = 0, | |
| 145 .gas[1].note.ub.travel = 0, | |
| 146 .gas[2].note.uw = 0, | |
| 147 .gas[3].note.uw = 0, | |
| 148 .gas[4].note.uw = 0, | |
| 149 .gas[5].note.uw = 0, | |
| 150 .gas[6].note.ub.first = 1, | |
| 151 .gas[6].note.ub.active = 1, | |
| 152 .gas[6].note.ub.deco = 0, | |
| 153 .gas[6].note.ub.travel = 0, | |
| 154 .gas[7].note.uw = 0, | |
| 155 .gas[8].note.uw = 0, | |
| 156 .gas[9].note.uw = 0, | |
| 157 .gas[10].note.uw = 0, | |
| 158 .gas[0].bottle_size_liter = 0, | |
| 159 .gas[1].bottle_size_liter = 0, | |
| 160 .gas[2].bottle_size_liter = 0, | |
| 161 .gas[3].bottle_size_liter = 0, | |
| 162 .gas[4].bottle_size_liter = 0, | |
| 163 .gas[5].bottle_size_liter = 0, | |
| 164 .gas[6].bottle_size_liter = 0, | |
| 165 .gas[7].bottle_size_liter = 0, | |
| 166 .gas[8].bottle_size_liter = 0, | |
| 167 .gas[9].bottle_size_liter = 0, | |
| 168 .gas[10].bottle_size_liter = 0, | |
| 169 /* | |
| 170 .gas[0].bottle_wireless_status = 0, | |
| 171 .gas[1].bottle_wireless_status = 0, | |
| 172 .gas[2].bottle_wireless_status = 0, | |
| 173 .gas[3].bottle_wireless_status = 0, | |
| 174 .gas[4].bottle_wireless_status = 0, | |
| 175 .gas[5].bottle_wireless_status = 0, | |
| 176 .gas[6].bottle_wireless_status = 0, | |
| 177 .gas[7].bottle_wireless_status = 0, | |
| 178 .gas[8].bottle_wireless_status = 0, | |
| 179 .gas[9].bottle_wireless_status = 0, | |
| 180 .gas[10].bottle_wireless_status = 0, | |
| 181 */ | |
| 182 .gas[0].bottle_wireless_id = 0, | |
| 183 .gas[1].bottle_wireless_id = 0, | |
| 184 .gas[2].bottle_wireless_id = 0, | |
| 185 .gas[3].bottle_wireless_id = 0, | |
| 186 .gas[4].bottle_wireless_id = 0, | |
| 187 .gas[5].bottle_wireless_id = 0, | |
| 188 .gas[6].bottle_wireless_id = 0, | |
| 189 .gas[7].bottle_wireless_id = 0, | |
| 190 .gas[8].bottle_wireless_id = 0, | |
| 191 .gas[9].bottle_wireless_id = 0, | |
| 192 .gas[10].bottle_wireless_id = 0, | |
| 193 .setpoint[0].setpoint_cbar = 100, | |
| 194 .setpoint[1].setpoint_cbar = 70, | |
| 195 .setpoint[2].setpoint_cbar = 90, | |
| 196 .setpoint[3].setpoint_cbar = 100, | |
| 197 .setpoint[4].setpoint_cbar = 120, | |
| 198 .setpoint[5].setpoint_cbar = 140, | |
| 199 .setpoint[0].depth_meter = 0, | |
| 200 .setpoint[1].depth_meter = 0, | |
| 201 .setpoint[2].depth_meter = 0, | |
| 202 .setpoint[3].depth_meter = 0, | |
| 203 .setpoint[4].depth_meter = 0, | |
| 204 .setpoint[5].depth_meter = 0, | |
| 205 .setpoint[0].note.uw = 0, | |
| 206 .setpoint[1].note.ub.active = 1, | |
| 207 .setpoint[1].note.ub.first = 1, | |
| 208 .setpoint[2].note.ub.active = 1, | |
| 209 .setpoint[2].note.ub.first = 0, | |
| 210 .setpoint[3].note.ub.active = 1, | |
| 211 .setpoint[3].note.ub.first = 0, | |
| 212 .setpoint[4].note.ub.active = 1, | |
| 213 .setpoint[4].note.ub.first = 0, | |
| 214 .setpoint[5].note.ub.active = 1, | |
| 215 .setpoint[5].note.ub.first = 0, | |
| 216 | |
| 217 .CCR_Mode = CCRMODE_Sensors, | |
| 218 .dive_mode = DIVEMODE_OC, | |
| 219 .deco_type.ub.standard = GF_MODE, | |
| 220 .deco_type.ub.alternative = GF_MODE, | |
| 221 .ppO2_max_deco = 160, | |
| 222 .ppO2_max_std = 140, | |
| 223 .ppO2_min = 15, | |
| 224 .CNS_max = 90, | |
| 225 .ascent_MeterPerMinute_max = 30, | |
| 662 | 226 .ascent_MeterPerMinute_showGraph = 30, |
| 38 | 227 .future_TTS = 5, |
| 228 .GF_high = 85, | |
| 229 .GF_low = 30, | |
| 230 .aGF_high = 95, | |
| 231 .aGF_low = 95, | |
| 232 .VPM_conservatism.ub.standard = 2, | |
| 233 .VPM_conservatism.ub.alternative = 0, | |
| 234 .safetystopDuration = 1, | |
| 235 .AtemMinutenVolumenLiter = 25, | |
| 236 .ReserveFractionDenominator = 4, | |
| 237 .salinity = 0, | |
| 238 .last_stop_depth_meter = 3, | |
| 239 .stop_increment_depth_meter = 3, | |
| 240 .brightness = 1, | |
| 241 .date_format = DDMMYY, | |
| 242 .selected_language = 0, /* 0 = LANGUAGE_English */ | |
| 243 .customtext = " <your name>\n" " <address>", | |
| 244 .timeoutSurfacemode = 120, | |
| 245 .timeoutMenuSurface = 120,//240, | |
| 246 .timeoutMenuDive = 120,//20, | |
| 247 .timeoutMenuEdit = 120,//40, | |
| 248 .timeoutInfo = 120,//60, | |
| 249 .timeoutInfoCompass = 60, | |
| 250 .design = 7, | |
| 251 .timeoutDiveReachedZeroDepth = 300, | |
| 252 .divetimeToCreateLogbook = 60, | |
| 253 .serialHigh = 0, | |
| 254 .serialLow = 2, | |
| 255 /* | |
| 256 .firmwareVersion16to32bit.ub.first = 0, | |
| 257 .firmwareVersion16to32bit.ub.second = 6, | |
| 258 .firmwareVersion16to32bit.ub.third = 0, | |
| 259 .firmwareVersion16to32bit.ub.betaFlag = 0, | |
| 260 */ | |
| 261 .backup_localtime_rtc_tr = 0, | |
| 262 .backup_localtime_rtc_dr = 0, | |
| 263 .totalDiveCounter = 0, | |
| 264 .personalDiveCount = 0, | |
| 265 .showDebugInfo = 0, | |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
266 .ButtonResponsiveness[0] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306 |
|
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
267 .ButtonResponsiveness[1] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306 |
|
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
268 .ButtonResponsiveness[2] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306 |
|
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
269 .ButtonResponsiveness[3] = DEFAULT_BUTTONRESPONSIVENESS_GUI, // new hw 170306 |
| 38 | 270 .nonMetricalSystem = 0, |
| 271 .fallbackToFixedSetpoint = 1, | |
| 272 .bluetoothActive = 0, | |
| 273 .safetystopDepth = 5, | |
| 274 .updateSettingsAllowedFromHeader = 0xFFFF0002, | |
| 662 | 275 .pscr_lung_ratio = 10, |
| 276 .pscr_o2_drop = 4, | |
| 277 .co2_sensor_active = 0, | |
| 38 | 278 .ppo2sensors_deactivated = 0, |
| 279 .tX_colorscheme = 0, | |
|
443
a5101c688b49
Introduced enum for lower left corner view selection:
ideenmodellierer
parents:
439
diff
changeset
|
280 .tX_userselectedLeftLowerCornerPrimary = LLC_Temperature, |
| 38 | 281 .tX_userselectedLeftLowerCornerTimeout = 0, |
| 282 .tX_customViewPrimary = 1, | |
| 283 .tX_customViewTimeout = 0, | |
| 284 .timeoutEnterButtonSelectDive = 10, | |
| 285 .logbookOffset = 0, | |
| 286 .alwaysShowPPO2 = 0, | |
| 287 .extraDisplay = EXTRADISPLAY_BIGFONT, | |
| 288 .display_toogle_desc = 200, | |
| 289 .offsetPressure_mbar = 0, | |
| 290 .offsetTemperature_centigrad = 0, | |
| 291 .gasConsumption_travel_l_min = 30, | |
| 292 .gasConsumption_bottom_l_min = 30, | |
| 293 .gasConsumption_deco_l_min = 20, | |
| 294 .debugModeOnStart = 0, | |
| 295 .compassBearing = 0, | |
| 296 .lastKnownBatteryPercentage = 0, | |
| 297 .buttonBalance[0] = 3, | |
| 298 .buttonBalance[1] = 3, | |
| 299 .buttonBalance[2] = 3, | |
| 300 .firmwareVersion[0] = 0,//FirmwareData.firmwareVersion16to32bit.ub.first, | |
| 301 .firmwareVersion[1] = 0,//FirmwareData.firmwareVersion16to32bit.ub.second, | |
| 302 .firmwareVersion[2] = 0,//FirmwareData.firmwareVersion16to32bit.ub.third, | |
| 303 .firmwareVersion[3] = 0,//FirmwareData.firmwareVersion16to32bit.ub.betaFlag, | |
| 304 .timeoutSurfacemodeWithSensors = 600, | |
| 305 .VPM_model = 0, | |
| 306 .GF_model = 0, | |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
307 .FactoryButtonBase = DEFAULT_BUTTONRESPONSIVENESS_GUI, |
| 38 | 308 .FactoryButtonBalance[0] = 3, |
| 309 .FactoryButtonBalance[1] = 3, | |
| 310 .FactoryButtonBalance[2] = 3, | |
|
111
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
311 .FlipDisplay = 0, |
|
210
b2a9e9b02df0
New feature: make selected customviews persistent
Jan Mulder <jlmulder@xs4all.nl>
parents:
172
diff
changeset
|
312 .cv_configuration = 0xFFFFFFFF, |
|
375
4bb5ceebfaf9
Use Enum values for initialization and setting check:
ideenmodellierer
parents:
372
diff
changeset
|
313 .MotionDetection = MOTION_DETECT_OFF, |
|
498
4811f3dfaa52
Added dew parameter to enable selection of customer BigFont screens to be displayed
Ideenmodellierer
parents:
492
diff
changeset
|
314 .cv_config_BigScreen = 0xFFFFFFFF, |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
315 .compassInertia = 0, |
|
541
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
316 .tX_customViewPrimaryBF = CVIEW_T3_Decostop, |
| 546 | 317 .viewPortMode = 0, |
| 318 .viewRoll = 0, | |
| 319 .viewPitch = 0, | |
| 320 .viewYaw = 0, | |
|
560
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
321 .ppo2sensors_source = 0, |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
322 .ppo2sensors_calibCoeff[0] = 0.0, |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
323 .ppo2sensors_calibCoeff[1] = 0.0, |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
324 .ppo2sensors_calibCoeff[2] = 0.0, |
| 567 | 325 .amPMTime = 0, |
| 650 | 326 .autoSetpoint = 0, |
| 710 | 327 .scrubTimerMax_Obsolete = 0, |
| 328 .scrubTimerCur_Obsolete = 0, | |
|
654
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
329 .scrubTimerMode = SCRUB_TIMER_OFF, |
| 733 | 330 .ext_sensor_map[0] = SENSOR_OPTIC, |
| 331 .ext_sensor_map[1] = SENSOR_OPTIC, | |
| 332 .ext_sensor_map[2] = SENSOR_OPTIC, | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
333 .ext_sensor_map[3] = SENSOR_NONE, |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
334 .ext_sensor_map[4] = SENSOR_NONE, |
| 796 | 335 .ext_sensor_map[5] = SENSOR_NONE, |
| 336 .ext_sensor_map[6] = SENSOR_NONE, | |
| 337 .ext_sensor_map[7] = SENSOR_NONE, | |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
338 .buttonLockActive = 0, |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
339 .compassDeclinationDeg = 0, |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
340 .delaySetpointLow = false, |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
341 .timerDurationS = 180, |
| 38 | 342 }; |
| 343 | |
| 344 /* Private function prototypes -----------------------------------------------*/ | |
| 345 uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to); | |
| 346 | |
| 347 /* Functions -----------------------------------------------------------------*/ | |
| 348 | |
| 349 | |
| 350 // =============================================================================== | |
| 351 // set_new_settings_missing_in_ext_flash | |
| 352 /// @brief Add all the new setting variables of this version | |
| 353 /// or/and change what has changed in the meantime | |
| 354 /// | |
| 355 /// Additionally update the serial number if written via bluetooth | |
| 356 /// | |
| 357 // =============================================================================== | |
| 820 | 358 SSettings* pSettings; |
| 38 | 359 void set_new_settings_missing_in_ext_flash(void) |
| 360 { | |
| 820 | 361 uint32_t tmp = 0; |
| 362 | |
| 38 | 363 // never delete this part setting the serial |
| 364 if(hardwareDataGetPointer()->secondarySerial != 0xFFFF) | |
| 365 { | |
| 366 settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->secondarySerial / 256); | |
| 367 settingsGetPointer()->serialLow = (hardwareDataGetPointer()->secondarySerial & 0xFF); | |
| 368 } | |
| 369 else | |
| 370 if(hardwareDataGetPointer()->primarySerial != 0xFFFF) | |
| 371 { | |
| 372 settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->primarySerial / 256); | |
| 373 settingsGetPointer()->serialLow = (hardwareDataGetPointer()->primarySerial & 0xFF); | |
| 374 } | |
| 375 else | |
| 376 { | |
| 377 settingsGetPointer()->serialHigh = 0; | |
| 378 settingsGetPointer()->serialLow = 0; | |
| 379 } | |
| 380 | |
| 381 settingsGetPointer()->firmwareVersion[0] = firmware_FirmwareData.versionFirst; | |
| 382 settingsGetPointer()->firmwareVersion[1] = firmware_FirmwareData.versionSecond; | |
| 383 settingsGetPointer()->firmwareVersion[2] = firmware_FirmwareData.versionThird; | |
| 384 settingsGetPointer()->firmwareVersion[3] = firmware_FirmwareData.versionBeta; | |
| 385 | |
| 820 | 386 pSettings = settingsGetPointer(); |
| 38 | 387 const SSettings* pStandard = settingsGetPointerStandard(); |
| 388 | |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
389 /* Pointing to the old header data => set new data depending on what had been added since last version */ |
| 38 | 390 switch(pSettings->header) |
| 391 { | |
| 392 case 0xFFFF0000: | |
| 393 case 0xFFFF0001: | |
| 394 case 0xFFFF0002: | |
| 395 case 0xFFFF0003: | |
| 396 case 0xFFFF0004: | |
| 397 case 0xFFFF0005: | |
| 398 pSettings->ppo2sensors_deactivated = pStandard->ppo2sensors_deactivated; | |
| 399 pSettings->tX_colorscheme = pStandard->tX_colorscheme; | |
| 400 pSettings->tX_userselectedLeftLowerCornerPrimary = pStandard->tX_userselectedLeftLowerCornerPrimary; | |
| 401 pSettings->tX_userselectedLeftLowerCornerTimeout = pStandard->tX_userselectedLeftLowerCornerTimeout; | |
| 402 pSettings->tX_customViewPrimary = pStandard->tX_customViewPrimary; | |
| 403 pSettings->tX_customViewTimeout = pStandard->tX_customViewTimeout; | |
| 404 // no break | |
| 405 case 0xFFFF0006: | |
| 406 pSettings->timeoutEnterButtonSelectDive = pStandard->timeoutEnterButtonSelectDive; | |
| 407 pSettings->ButtonResponsiveness[0] = pStandard->ButtonResponsiveness[0]; | |
| 408 pSettings->ButtonResponsiveness[1] = pStandard->ButtonResponsiveness[1]; | |
| 409 pSettings->ButtonResponsiveness[2] = pStandard->ButtonResponsiveness[2]; | |
| 410 pSettings->ButtonResponsiveness[3] = pStandard->ButtonResponsiveness[3]; | |
| 411 pSettings->timeoutSurfacemode = pStandard->timeoutSurfacemode; | |
| 412 pSettings->timeoutMenuSurface = pStandard->timeoutMenuSurface; | |
| 413 pSettings->timeoutMenuDive = pStandard->timeoutMenuDive; | |
| 414 pSettings->timeoutMenuEdit = pStandard->timeoutMenuEdit; | |
| 415 pSettings->timeoutInfo = pStandard->timeoutInfo; | |
| 416 pSettings->timeoutInfoCompass = pStandard->timeoutInfoCompass; | |
| 417 pSettings->timeoutDiveReachedZeroDepth = pStandard->timeoutDiveReachedZeroDepth; | |
| 418 pSettings->divetimeToCreateLogbook = pStandard->divetimeToCreateLogbook; | |
| 419 pSettings->safetystopDuration = pStandard->safetystopDuration; // change from on/off to minutes | |
| 420 // no break | |
| 421 case 0xFFFF0007: | |
| 422 case 0xFFFF0008: | |
| 423 pSettings->alwaysShowPPO2 = pStandard->alwaysShowPPO2; | |
| 424 pSettings->logbookOffset = pStandard->logbookOffset; | |
| 425 // no break | |
| 426 case 0xFFFF0009: | |
| 427 pSettings->extraDisplay = pStandard->extraDisplay; | |
| 428 // no break | |
| 429 case 0xFFFF000A: | |
| 430 pSettings->display_toogle_desc = pStandard->display_toogle_desc; | |
| 431 // no break | |
| 432 case 0xFFFF000B: | |
| 433 pSettings->offsetPressure_mbar = pStandard->offsetPressure_mbar; | |
| 434 pSettings->offsetTemperature_centigrad = pStandard->offsetTemperature_centigrad; | |
| 435 pSettings->gasConsumption_travel_l_min = pStandard->gasConsumption_travel_l_min; | |
| 436 pSettings->gasConsumption_bottom_l_min = pStandard->gasConsumption_bottom_l_min; | |
| 437 pSettings->gasConsumption_deco_l_min = pStandard->gasConsumption_deco_l_min; | |
| 438 // no break | |
| 439 case 0xFFFF000C: | |
| 440 memcpy(pSettings->customtext, " hwOS 4\n\r" " welcome\n\r", 60); | |
| 441 // no break | |
| 442 case 0xFFFF000D: // nothing to do from 0xFFFF000D to 0xFFFF000E, just about header :-) | |
| 443 case 0xFFFF000E: | |
| 444 pSettings->debugModeOnStart = 0; | |
| 445 // no break | |
| 446 case 0xFFFF000F: | |
| 447 pSettings->compassBearing = 0; | |
| 448 // no break | |
| 449 case 0xFFFF0011: | |
| 450 pSettings->lastKnownBatteryPercentage = 0; | |
| 451 // no break | |
| 452 case 0xFFFF0012: | |
| 453 pSettings->buttonBalance[0] = 3; | |
| 454 pSettings->buttonBalance[1] = 3; | |
| 455 pSettings->buttonBalance[2] = 3; | |
| 456 // no break | |
| 457 case 0xFFFF0013: | |
| 458 case 0xFFFF0014: | |
| 459 pSettings->timeoutSurfacemodeWithSensors = pStandard->timeoutSurfacemodeWithSensors; | |
| 460 // no break | |
| 461 case 0xFFFF0015: | |
| 462 pSettings->ButtonResponsiveness[3] = pStandard->ButtonResponsiveness[3]; | |
| 463 settingsHelperButtonSens_keepPercentageValues(settingsHelperButtonSens_translate_hwOS_values_to_percentage(pSettings->ButtonResponsiveness[3]), pSettings->ButtonResponsiveness); | |
| 464 pSettings->VPM_model = 0; | |
| 465 pSettings->GF_model = 0; | |
| 466 // no break | |
| 467 case 0xFFFF0016: | |
| 468 pSettings->FactoryButtonBase = pStandard->FactoryButtonBase; | |
| 469 pSettings->FactoryButtonBalance[0] = pStandard->FactoryButtonBalance[0]; | |
| 470 pSettings->FactoryButtonBalance[1] = pStandard->FactoryButtonBalance[1]; | |
| 471 pSettings->FactoryButtonBalance[2] = pStandard->FactoryButtonBalance[2]; | |
| 472 // no break | |
|
111
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
473 case 0xFFFF0017: |
|
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
474 pSettings->FlipDisplay = 0; |
|
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
475 // no break |
|
210
b2a9e9b02df0
New feature: make selected customviews persistent
Jan Mulder <jlmulder@xs4all.nl>
parents:
172
diff
changeset
|
476 case 0xFFFF0018: |
|
b2a9e9b02df0
New feature: make selected customviews persistent
Jan Mulder <jlmulder@xs4all.nl>
parents:
172
diff
changeset
|
477 pSettings->cv_configuration = 0xFFFFFFFF; |
|
b2a9e9b02df0
New feature: make selected customviews persistent
Jan Mulder <jlmulder@xs4all.nl>
parents:
172
diff
changeset
|
478 // no break |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
479 case 0xFFFF0019: |
|
375
4bb5ceebfaf9
Use Enum values for initialization and setting check:
ideenmodellierer
parents:
372
diff
changeset
|
480 pSettings->MotionDetection = MOTION_DETECT_OFF; |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
481 // no break |
|
498
4811f3dfaa52
Added dew parameter to enable selection of customer BigFont screens to be displayed
Ideenmodellierer
parents:
492
diff
changeset
|
482 case 0xFFFF001A: |
| 505 | 483 /* deactivate new views => to be activated by customer */ |
|
498
4811f3dfaa52
Added dew parameter to enable selection of customer BigFont screens to be displayed
Ideenmodellierer
parents:
492
diff
changeset
|
484 pSettings->cv_config_BigScreen = 0xFFFFFFFF; |
| 820 | 485 pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_Navigation + LEGACY_T3_START_ID_PRE_TIMER); |
| 486 pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_DepthData + LEGACY_T3_START_ID_PRE_TIMER); | |
|
498
4811f3dfaa52
Added dew parameter to enable selection of customer BigFont screens to be displayed
Ideenmodellierer
parents:
492
diff
changeset
|
487 // no break |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
488 case 0xFFFF001B: |
|
541
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
489 pSettings->compassInertia = 0; /* no inertia */ |
|
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
490 pSettings->tX_customViewPrimaryBF = CVIEW_T3_Decostop; |
| 820 | 491 pSettings->cv_config_BigScreen &= pSettings->cv_configuration ^= 1 << (CVIEW_T3_DecoTTS + LEGACY_T3_START_ID_PRE_TIMER); |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
492 // no break |
| 546 | 493 case 0xFFFF001C: |
| 494 pSettings->viewPortMode = 0; | |
| 495 pSettings->viewRoll = 0; | |
| 496 pSettings->viewPitch = 0; | |
| 497 pSettings->viewYaw = 0; | |
| 498 // no break | |
|
560
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
499 case 0xFFFF001D: |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
500 pSettings->ppo2sensors_source = O2_SENSOR_SOURCE_OPTIC; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
501 pSettings->ppo2sensors_calibCoeff[0] = 0.0; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
502 pSettings->ppo2sensors_calibCoeff[1] = 0.0; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
503 pSettings->ppo2sensors_calibCoeff[2] = 0.0; |
| 662 | 504 pSettings->amPMTime = 0; |
|
560
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
505 // no break |
| 662 | 506 case 0xFFFF001E: |
| 507 pSettings->autoSetpoint = 0; | |
| 710 | 508 pSettings->scrubTimerMax_Obsolete = 0; |
| 509 pSettings->scrubTimerCur_Obsolete = 0; | |
| 662 | 510 pSettings->scrubTimerMode = SCRUB_TIMER_OFF; |
| 511 // no break | |
| 512 case 0xFFFF001F: | |
| 513 pSettings->pscr_lung_ratio = 10; | |
| 514 pSettings->pscr_o2_drop = 4; | |
| 515 // no break | |
| 516 case 0xFFFF0020: | |
| 517 pSettings->co2_sensor_active = 0; | |
| 518 // no break; | |
| 687 | 519 case 0xFFFF0021: |
| 520 pSettings->ext_uart_protocol = 0; | |
| 521 // no break; | |
| 710 | 522 case 0xFFFF0022: |
| 523 pSettings->scubberActiveId = 0; | |
| 524 pSettings->scrubberData[0].TimerCur = pSettings->scrubTimerCur_Obsolete; | |
| 525 pSettings->scrubberData[0].TimerMax = pSettings->scrubTimerMax_Obsolete; | |
| 526 pSettings->scrubberData[0].lastDive.WeekDay = 0; | |
| 527 pSettings->scrubberData[0].lastDive.Month = 0; | |
| 528 pSettings->scrubberData[0].lastDive.Date = 0; | |
| 529 pSettings->scrubberData[0].lastDive.Year = 0; | |
| 530 | |
| 531 pSettings->scrubberData[1].TimerCur = 0; | |
| 532 pSettings->scrubberData[1].TimerMax = 0; | |
| 533 pSettings->scrubberData[1].lastDive.WeekDay = 0; | |
| 534 pSettings->scrubberData[1].lastDive.Month = 0; | |
| 535 pSettings->scrubberData[1].lastDive.Date = 0; | |
| 536 pSettings->scrubberData[1].lastDive.Year = 0; | |
| 537 // no break; | |
| 733 | 538 case 0xFFFF0023: pSettings->ext_sensor_map[0] = SENSOR_OPTIC; |
| 539 pSettings->ext_sensor_map[1] = SENSOR_OPTIC; | |
| 540 pSettings->ext_sensor_map[2] = SENSOR_OPTIC; | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
541 pSettings->ext_sensor_map[3] = SENSOR_NONE; |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
542 pSettings->ext_sensor_map[4] = SENSOR_NONE; |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
543 // no break; |
|
740
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
544 case 0xFFFF0024: pSettings->buttonLockActive = 0; |
|
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
545 // no break; |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
546 case 0xFFFF0025: |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
547 pSettings->compassDeclinationDeg = pStandard->compassDeclinationDeg; |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
548 pSettings->delaySetpointLow = pStandard->delaySetpointLow; |
|
792
25103f5c7e29
Avoid a configuration warning after the firmware upgrade by disabling automatic setpoint switching. This makes sure the user's automatic setpoint configuration is not overwritten by the validity checks if the settings are not in the correct spots for the new configuration. Users will have to manually re-create the automatic setpoint switching configuration in the new format;
heinrichsweikamp
parents:
788
diff
changeset
|
549 // Disable auto setpoint to avoid a configuration warning being triggered by the new auto setpoint validation |
|
25103f5c7e29
Avoid a configuration warning after the firmware upgrade by disabling automatic setpoint switching. This makes sure the user's automatic setpoint configuration is not overwritten by the validity checks if the settings are not in the correct spots for the new configuration. Users will have to manually re-create the automatic setpoint switching configuration in the new format;
heinrichsweikamp
parents:
788
diff
changeset
|
550 // This ensures that users don't lose setpoint information if it is not in the right spot for the new configuration |
|
25103f5c7e29
Avoid a configuration warning after the firmware upgrade by disabling automatic setpoint switching. This makes sure the user's automatic setpoint configuration is not overwritten by the validity checks if the settings are not in the correct spots for the new configuration. Users will have to manually re-create the automatic setpoint switching configuration in the new format;
heinrichsweikamp
parents:
788
diff
changeset
|
551 pSettings->autoSetpoint = false; |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
552 |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
553 pSettings->timerDurationS = pStandard->timerDurationS; |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
554 |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
555 // no break; |
| 796 | 556 case 0xFFFF0026: |
| 557 pSettings->ext_sensor_map[0] = pSettings->ext_sensor_map_Obsolete[0]; | |
| 558 pSettings->ext_sensor_map[1] = pSettings->ext_sensor_map_Obsolete[1]; | |
| 559 pSettings->ext_sensor_map[2] = pSettings->ext_sensor_map_Obsolete[2]; | |
| 560 pSettings->ext_sensor_map[3] = pSettings->ext_sensor_map_Obsolete[3]; | |
| 561 pSettings->ext_sensor_map[4] = pSettings->ext_sensor_map_Obsolete[4]; | |
| 562 pSettings->ext_sensor_map[5] = SENSOR_NONE; | |
| 563 pSettings->ext_sensor_map[6] = SENSOR_NONE; | |
| 564 pSettings->ext_sensor_map[7] = SENSOR_NONE; | |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
565 |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
566 // no break; |
| 820 | 567 case 0xFFFF0027: |
| 568 tmp = pSettings->cv_config_BigScreen & 0x00000007; /* position of first three view is keeps the same */ | |
| 569 /* Identify from which data version was in use before the update */ | |
| 570 if(pSettings->tX_customViewPrimaryBF == LEGACY_CV_END_POST_TIMER) /* data version after introduction of timer (ID shift problem) */ | |
| 571 { | |
| 572 pSettings->tX_customViewPrimaryBF = CVIEW_T3_Decostop; | |
| 573 } | |
| 574 else | |
| 575 { | |
| 576 if(pSettings->tX_customViewPrimaryBF >= 3) | |
| 577 { | |
| 578 pSettings->tX_customViewPrimaryBF -= LEGACY_T3_START_ID_PRE_TIMER - 3; | |
| 579 } | |
| 580 } | |
| 581 pSettings->cv_config_BigScreen = pSettings->cv_config_BigScreen >> (LEGACY_T3_START_ID_PRE_TIMER - 3); | |
| 582 pSettings->cv_config_BigScreen &= ~0x00000007; /* just to be sure: clear lower three bits */ | |
| 583 pSettings->cv_config_BigScreen |= tmp; | |
| 584 | |
| 585 // no break; | |
| 38 | 586 default: |
|
210
b2a9e9b02df0
New feature: make selected customviews persistent
Jan Mulder <jlmulder@xs4all.nl>
parents:
172
diff
changeset
|
587 pSettings->header = pStandard->header; |
| 38 | 588 break; // no break before!! |
| 589 } | |
| 590 } | |
| 591 | |
| 592 | |
| 593 uint8_t newFirmwareVersionCheckViaSettings(void) | |
| 594 { | |
| 595 SSettings* pSettings = settingsGetPointer(); | |
| 596 | |
| 597 if(pSettings->header < 0xFFFF0014) // for the versions without firmwareVersion[] | |
| 598 return 1; | |
| 599 | |
| 600 if(pSettings->firmwareVersion[0] != firmware_FirmwareData.versionFirst) | |
| 601 return 1; | |
| 602 if(pSettings->firmwareVersion[1] != firmware_FirmwareData.versionSecond) | |
| 603 return 1; | |
| 604 if(pSettings->firmwareVersion[2] != firmware_FirmwareData.versionThird) | |
| 605 return 1; | |
| 606 if(pSettings->firmwareVersion[3] != firmware_FirmwareData.versionBeta) | |
| 607 return 1; | |
| 608 | |
| 609 return 0; | |
| 610 } | |
| 611 | |
| 612 | |
|
765
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
613 void set_settings_button_to_factory_with_individual_buttonBalance(void) |
| 38 | 614 { |
|
765
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
615 bool factoryBalanceSettingsValid = true; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
616 unsigned i = 0; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
617 while (factoryBalanceSettingsValid && i < 3) { |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
618 if (Settings.FactoryButtonBalance[i] < 2 || Settings.FactoryButtonBalance[i] > 5) { |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
619 factoryBalanceSettingsValid = false; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
620 } |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
621 |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
622 i++; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
623 } |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
624 if (factoryBalanceSettingsValid) { |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
625 for (i = 0; i < 3; i++) { |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
626 Settings.buttonBalance[i] = Settings.FactoryButtonBalance[i]; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
627 } |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
628 } |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
629 |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
630 uint8_t buttonResponsiveness = Settings.FactoryButtonBase; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
631 if (buttonResponsiveness < 70 || buttonResponsiveness > 110) { |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
632 buttonResponsiveness = SettingsStandard.ButtonResponsiveness[3]; |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
633 } |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
634 |
|
da8126d5ea9f
After a firmware update, use the factory settings for button sensitivity if these exist, the default settings otherwise.
heinrichsweikamp
parents:
762
diff
changeset
|
635 settingsHelperButtonSens_keepPercentageValues(buttonResponsiveness, settingsGetPointer()->ButtonResponsiveness); |
| 38 | 636 } |
| 637 | |
| 638 | |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
639 bool checkAndFixSetpointSettings(void) |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
640 { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
641 SSettings *settings = settingsGetPointer(); |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
642 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
643 bool fixed = false; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
644 if (settings->autoSetpoint) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
645 SSetpointLine *setpointLow = &settings->setpoint[SETPOINT_INDEX_AUTO_LOW]; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
646 if (setpointLow->setpoint_cbar >= 100) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
647 setpointLow->setpoint_cbar = 70; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
648 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
649 fixed = true; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
650 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
651 if (setpointLow->depth_meter == 0 || setpointLow->depth_meter > 100) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
652 setpointLow->depth_meter = 2; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
653 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
654 fixed = true; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
655 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
656 SSetpointLine *setpointHigh = &settings->setpoint[SETPOINT_INDEX_AUTO_HIGH]; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
657 if (setpointHigh->setpoint_cbar <= setpointLow->setpoint_cbar) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
658 setpointHigh->setpoint_cbar = 130; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
659 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
660 fixed = true; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
661 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
662 if (setpointHigh->depth_meter <= setpointLow->depth_meter) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
663 setpointHigh->depth_meter = setpointLow->depth_meter + 6; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
664 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
665 fixed = true; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
666 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
667 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
668 SSetpointLine *setpointDeco = &settings->setpoint[SETPOINT_INDEX_AUTO_DECO]; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
669 if (setpointDeco->note.ub.active) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
670 if (setpointDeco->setpoint_cbar == setpointHigh->setpoint_cbar || setpointDeco->setpoint_cbar == setpointLow->setpoint_cbar) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
671 setpointDeco->setpoint_cbar = 10 * (setpointHigh->setpoint_cbar / 10) - 10; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
672 if (setpointDeco->setpoint_cbar == setpointLow->setpoint_cbar) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
673 setpointDeco->setpoint_cbar += 5; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
674 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
675 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
676 fixed = true; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
677 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
678 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
679 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
680 |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
681 return fixed; |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
682 } |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
683 |
| 820 | 684 static void setFirstCorrection(uint8_t Id) |
| 685 { | |
| 686 if(SettingsStatus.FirstCorrection == 0xFF) | |
| 687 { | |
| 688 SettingsStatus.FirstCorrection = Id; | |
| 689 } | |
| 690 } | |
| 691 | |
| 692 void get_CorrectionStatus(SSettingsStatus* Status) | |
| 693 { | |
| 694 if(Status != NULL) | |
| 695 { | |
| 696 memcpy(Status, &SettingsStatus,2); | |
| 697 } | |
| 698 } | |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
699 |
| 38 | 700 uint8_t check_and_correct_settings(void) |
| 701 { | |
| 702 uint32_t corrections = 0; | |
| 703 uint8_t firstGasFoundOC = 0; | |
| 704 uint8_t firstGasFoundCCR = 0; | |
| 820 | 705 uint8_t parameterId = 0; |
| 38 | 706 |
| 662 | 707 |
| 708 settingsWarning = 0; /* reset warning indicator */ | |
| 820 | 709 SettingsStatus.FirstCorrection = 0xFF; |
| 662 | 710 |
| 38 | 711 /* uint32_t header; |
| 712 */ | |
| 713 | |
| 714 /* uint8_t warning_blink_dsec; 1/10 seconds | |
| 715 */ | |
| 716 if((Settings.warning_blink_dsec < 1) || (Settings.warning_blink_dsec > 100)) | |
| 717 { | |
| 718 Settings.warning_blink_dsec = SettingsStandard.warning_blink_dsec; | |
| 719 corrections++; | |
| 820 | 720 setFirstCorrection(parameterId); |
| 38 | 721 } |
| 820 | 722 parameterId++; |
| 38 | 723 /* uint8_t lastDiveLogId; |
| 724 */ | |
| 725 | |
| 726 /* uint32_t logFlashNextSampleStartAddress; | |
| 727 */ | |
| 728 if((Settings.logFlashNextSampleStartAddress < SAMPLESTART) || (Settings.logFlashNextSampleStartAddress > SAMPLESTOP)) | |
| 729 { | |
| 730 Settings.logFlashNextSampleStartAddress = SAMPLESTART; | |
| 731 corrections++; | |
| 820 | 732 setFirstCorrection(parameterId); |
| 38 | 733 } |
| 820 | 734 parameterId++; |
| 38 | 735 |
| 736 /* uint8_t dive_mode; has to before the gases | |
| 737 */ | |
| 738 if( (Settings.dive_mode != DIVEMODE_OC) && | |
| 739 (Settings.dive_mode != DIVEMODE_CCR) && | |
| 740 (Settings.dive_mode != DIVEMODE_Gauge) && | |
| 662 | 741 (Settings.dive_mode != DIVEMODE_Apnea) && |
| 742 (Settings.dive_mode != DIVEMODE_PSCR)) | |
| 38 | 743 { |
| 744 Settings.dive_mode = DIVEMODE_OC; | |
| 745 corrections++; | |
| 820 | 746 setFirstCorrection(parameterId); |
| 38 | 747 } |
| 820 | 748 parameterId++; |
| 38 | 749 |
| 750 /* SGasLine gas[1 + (2*NUM_GASES)]; | |
| 751 */ | |
| 752 for(int i=1; i<=2*NUM_GASES;i++) | |
| 753 { | |
| 754 if(Settings.gas[i].oxygen_percentage < 4) | |
| 755 { | |
| 756 Settings.gas[i].oxygen_percentage = 4; | |
| 757 corrections++; | |
| 820 | 758 setFirstCorrection(parameterId); |
| 38 | 759 } |
| 760 if(Settings.gas[i].oxygen_percentage > 100) | |
| 761 { | |
| 762 Settings.gas[i].oxygen_percentage = 100; | |
| 763 corrections++; | |
| 820 | 764 setFirstCorrection(parameterId); |
| 38 | 765 } |
| 766 if((Settings.gas[i].oxygen_percentage + Settings.gas[i].helium_percentage) > 100) | |
| 767 { | |
| 768 Settings.gas[i].helium_percentage = 100 - Settings.gas[i].oxygen_percentage; | |
| 769 corrections++; | |
| 820 | 770 setFirstCorrection(parameterId); |
| 38 | 771 } |
| 772 if(Settings.gas[i].note.ub.deco) | |
| 773 { | |
| 774 if(Settings.gas[i].note.ub.active != 1) | |
| 775 { | |
| 776 Settings.gas[i].note.ub.active = 1; | |
| 777 corrections++; | |
| 820 | 778 setFirstCorrection(parameterId); |
| 38 | 779 } |
| 780 if(Settings.gas[i].note.ub.travel == 1) | |
| 781 { | |
| 782 Settings.gas[i].note.ub.travel = 0; | |
| 783 corrections++; | |
| 820 | 784 setFirstCorrection(parameterId); |
| 38 | 785 } |
| 786 } | |
| 787 if(Settings.gas[i].note.ub.travel) | |
| 788 { | |
| 789 if(Settings.gas[i].note.ub.active != 1) | |
| 790 { | |
| 791 Settings.gas[i].note.ub.active = 1; | |
| 792 corrections++; | |
| 820 | 793 setFirstCorrection(parameterId); |
| 38 | 794 } |
| 795 if(Settings.gas[i].note.ub.deco == 1) | |
| 796 { | |
| 797 Settings.gas[i].note.ub.deco = 0; | |
| 798 corrections++; | |
| 820 | 799 setFirstCorrection(parameterId); |
| 38 | 800 } |
| 801 } | |
| 802 if(Settings.gas[i].note.ub.first) | |
| 803 { | |
| 662 | 804 if(Settings.gas[i].note.ub.active != 1) |
| 38 | 805 { |
| 662 | 806 Settings.gas[i].note.ub.active = 1; |
| 38 | 807 corrections++; |
| 820 | 808 setFirstCorrection(parameterId); |
| 38 | 809 } |
| 810 if(Settings.gas[i].note.ub.travel == 1) | |
| 811 { | |
| 812 Settings.gas[i].note.ub.travel = 0; | |
| 813 corrections++; | |
| 820 | 814 setFirstCorrection(parameterId); |
| 38 | 815 } |
| 816 if(Settings.gas[i].note.ub.deco == 1) | |
| 817 { | |
| 818 Settings.gas[i].note.ub.deco = 0; | |
| 819 corrections++; | |
| 820 | 820 setFirstCorrection(parameterId); |
| 38 | 821 } |
| 822 if((i<=NUM_GASES) && (!firstGasFoundOC)) | |
| 823 firstGasFoundOC = 1; | |
| 824 else | |
| 825 if((i>NUM_GASES) && (!firstGasFoundCCR)) | |
| 826 firstGasFoundCCR = 1; | |
| 827 else | |
| 828 Settings.gas[i].note.ub.first = 0; | |
| 829 } | |
| 830 if(Settings.gas[i].bottle_size_liter > 40) | |
| 831 { | |
| 832 Settings.gas[i].bottle_size_liter = 40; | |
| 833 corrections++; | |
| 820 | 834 setFirstCorrection(parameterId); |
| 38 | 835 } |
| 836 if(Settings.gas[i].depth_meter > 250) | |
| 837 { | |
| 838 Settings.gas[i].depth_meter = 250; | |
| 839 corrections++; | |
| 820 | 840 setFirstCorrection(parameterId); |
| 38 | 841 } |
| 842 if(Settings.gas[i].depth_meter_travel > 250) | |
| 843 { | |
| 844 Settings.gas[i].depth_meter_travel = 250; | |
| 845 corrections++; | |
| 820 | 846 setFirstCorrection(parameterId); |
| 38 | 847 } |
| 848 /*if(Settings.gas[i].note.ub.senderCode) | |
| 849 { | |
| 850 } | |
| 851 if(Settings.gas[i].bottle_wireless_id) | |
| 852 { | |
| 853 } | |
| 854 */ | |
| 855 } // for(int i=1; i<=2*NUM_GASES;i++) | |
| 820 | 856 parameterId++; |
| 38 | 857 if(!firstGasFoundOC) |
| 858 { | |
| 859 Settings.gas[1].note.ub.active = 1; | |
| 860 Settings.gas[1].note.ub.first = 1; | |
| 861 Settings.gas[1].note.ub.travel = 0; | |
| 862 Settings.gas[1].note.ub.deco = 0; | |
| 662 | 863 corrections++; |
| 820 | 864 setFirstCorrection(parameterId); |
| 38 | 865 } |
| 820 | 866 parameterId++; |
| 38 | 867 if(!firstGasFoundCCR) |
| 868 { | |
| 869 Settings.gas[1 + NUM_GASES].note.ub.active = 1; | |
| 870 Settings.gas[1 + NUM_GASES].note.ub.first = 1; | |
| 871 Settings.gas[1 + NUM_GASES].note.ub.travel = 0; | |
| 872 Settings.gas[1 + NUM_GASES].note.ub.deco = 0; | |
| 662 | 873 corrections++; |
| 820 | 874 setFirstCorrection(parameterId); |
| 38 | 875 } |
| 820 | 876 parameterId++; |
| 38 | 877 /* SSetpointLine setpoint[1 + NUM_GASES]; |
| 878 */ | |
| 879 for(int i=1; i<=NUM_GASES;i++) | |
| 880 { | |
| 652 | 881 if(Settings.setpoint[i].setpoint_cbar < MIN_PPO2_SP_CBAR) |
| 38 | 882 { |
| 652 | 883 Settings.setpoint[i].setpoint_cbar = MIN_PPO2_SP_CBAR; |
| 38 | 884 corrections++; |
| 820 | 885 setFirstCorrection(parameterId); |
| 38 | 886 } |
| 887 if(Settings.setpoint[i].setpoint_cbar > 160) | |
| 888 { | |
| 889 Settings.setpoint[i].setpoint_cbar = 160; | |
| 890 corrections++; | |
| 820 | 891 setFirstCorrection(parameterId); |
| 38 | 892 } |
| 893 if(Settings.setpoint[i].depth_meter > 250) | |
| 894 { | |
| 895 Settings.setpoint[i].depth_meter = 250; | |
| 896 corrections++; | |
| 820 | 897 setFirstCorrection(parameterId); |
| 38 | 898 } |
| 899 } // for(int i=1; i<=NUM_GASES;i++) | |
| 820 | 900 parameterId++; |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
901 if (checkAndFixSetpointSettings()) { |
|
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
902 corrections++; |
| 820 | 903 setFirstCorrection(parameterId); |
|
788
4abfb8a2a435
Define explicit setpoints for low / high / deco. Add an option to delay the switch to SPlow until all decompression has been cleared. (mikeller)
heinrichsweikamp
parents:
776
diff
changeset
|
904 } |
| 820 | 905 parameterId++; |
| 38 | 906 /* uint8_t CCR_Mode; |
| 907 */ | |
| 908 if( (Settings.CCR_Mode != CCRMODE_Sensors) && | |
| 662 | 909 (Settings.CCR_Mode != CCRMODE_Simulation) && |
| 38 | 910 (Settings.CCR_Mode != CCRMODE_FixedSetpoint)) |
| 911 { | |
| 912 Settings.CCR_Mode = CCRMODE_FixedSetpoint; | |
| 913 corrections++; | |
| 820 | 914 setFirstCorrection(parameterId); |
| 38 | 915 } |
| 820 | 916 parameterId++; |
| 38 | 917 /* split2x4_Type deco_type; |
| 918 */ | |
| 919 if( (Settings.deco_type.ub.standard != GF_MODE) && | |
| 920 (Settings.deco_type.ub.standard != VPM_MODE)) | |
| 921 { | |
| 922 Settings.deco_type.ub.standard = VPM_MODE; | |
| 923 corrections++; | |
| 820 | 924 setFirstCorrection(parameterId); |
| 38 | 925 } |
| 820 | 926 parameterId++; |
| 38 | 927 if(Settings.deco_type.ub.alternative != GF_MODE) |
| 928 { | |
| 929 Settings.deco_type.ub.alternative = GF_MODE; | |
| 930 corrections++; | |
| 820 | 931 setFirstCorrection(parameterId); |
| 38 | 932 } |
| 820 | 933 parameterId++; |
| 38 | 934 /* uint8_t ppO2_max_deco; |
| 935 */ | |
| 936 if(Settings.ppO2_max_deco > 190) | |
| 937 { | |
| 938 Settings.ppO2_max_deco = 190; | |
| 939 corrections++; | |
| 820 | 940 setFirstCorrection(parameterId); |
| 38 | 941 } |
| 820 | 942 parameterId++; |
| 38 | 943 if(Settings.ppO2_max_deco < 100) |
| 944 { | |
| 945 Settings.ppO2_max_deco = 100; | |
| 946 corrections++; | |
| 820 | 947 setFirstCorrection(parameterId); |
| 38 | 948 } |
| 820 | 949 parameterId++; |
| 38 | 950 |
| 951 /* uint8_t ppO2_max_std; | |
| 952 */ | |
| 953 if(Settings.ppO2_max_std > 190) | |
| 954 { | |
| 955 Settings.ppO2_max_std = 190; | |
| 956 corrections++; | |
| 820 | 957 setFirstCorrection(parameterId); |
| 38 | 958 } |
| 820 | 959 parameterId++; |
| 38 | 960 if(Settings.ppO2_max_std < 100) |
| 961 { | |
| 962 Settings.ppO2_max_std = 100; | |
| 963 corrections++; | |
| 820 | 964 setFirstCorrection(parameterId); |
| 38 | 965 } |
| 820 | 966 parameterId++; |
| 38 | 967 /* uint8_t ppO2_min; |
| 968 */ | |
| 969 if(Settings.ppO2_min != 15) | |
| 970 { | |
| 971 Settings.ppO2_min = 15; | |
| 972 corrections++; | |
| 820 | 973 setFirstCorrection(parameterId); |
| 38 | 974 } |
| 820 | 975 parameterId++; |
| 38 | 976 /* uint8_t CNS_max; |
| 977 */ | |
| 978 if(Settings.CNS_max != 90) | |
| 979 { | |
| 980 Settings.CNS_max = 90; | |
| 981 corrections++; | |
| 820 | 982 setFirstCorrection(parameterId); |
| 38 | 983 } |
| 820 | 984 parameterId++; |
| 38 | 985 /* uint8_t ascent_MeterPerMinute_max; |
| 986 */ | |
| 987 if(Settings.ascent_MeterPerMinute_max != 30) | |
| 988 { | |
| 989 Settings.ascent_MeterPerMinute_max = 30; | |
| 990 corrections++; | |
| 820 | 991 setFirstCorrection(parameterId); |
| 38 | 992 } |
| 820 | 993 parameterId++; |
| 38 | 994 /* uint8_t ascent_MeterPerMinute_showGraph; |
| 995 */ | |
| 996 if(Settings.ascent_MeterPerMinute_showGraph != 30) | |
| 997 { | |
| 998 Settings.ascent_MeterPerMinute_showGraph = 30; | |
| 999 corrections++; | |
| 820 | 1000 setFirstCorrection(parameterId); |
| 38 | 1001 } |
| 820 | 1002 parameterId++; |
| 38 | 1003 /* uint8_t future_TTS; |
| 1004 */ | |
| 1005 if(Settings.future_TTS > 15) | |
| 1006 { | |
| 1007 Settings.future_TTS = 15; | |
| 1008 corrections++; | |
| 820 | 1009 setFirstCorrection(parameterId); |
| 38 | 1010 } |
| 820 | 1011 parameterId++; |
| 38 | 1012 /* uint8_t GF_high; |
| 1013 */ | |
| 1014 if(Settings.GF_high > 99) | |
| 1015 { | |
| 1016 Settings.GF_high = 99; | |
| 1017 corrections++; | |
| 820 | 1018 setFirstCorrection(parameterId); |
| 38 | 1019 } |
| 820 | 1020 parameterId++; |
| 38 | 1021 if(Settings.GF_high < 45) |
| 1022 { | |
| 1023 Settings.GF_high = 45; | |
| 1024 corrections++; | |
| 820 | 1025 setFirstCorrection(parameterId); |
| 38 | 1026 } |
| 820 | 1027 parameterId++; |
| 38 | 1028 /* uint8_t GF_low; |
| 1029 */ | |
| 1030 if(Settings.GF_low > 99) | |
| 1031 { | |
| 1032 Settings.GF_low = 99; | |
| 1033 corrections++; | |
| 820 | 1034 setFirstCorrection(parameterId); |
| 38 | 1035 } |
| 820 | 1036 parameterId++; |
| 38 | 1037 if(Settings.GF_low < 10) |
| 1038 { | |
| 1039 Settings.GF_low = 10; | |
| 1040 corrections++; | |
| 820 | 1041 setFirstCorrection(parameterId); |
| 38 | 1042 } |
| 820 | 1043 parameterId++; |
| 38 | 1044 if(Settings.GF_low > Settings.GF_high) |
| 1045 { | |
| 1046 Settings.GF_low = Settings.GF_high; | |
| 1047 corrections++; | |
| 820 | 1048 setFirstCorrection(parameterId); |
| 38 | 1049 } |
| 820 | 1050 parameterId++; |
| 38 | 1051 /* uint8_t aGF_high; |
| 1052 */ | |
| 1053 if(Settings.aGF_high > 99) | |
| 1054 { | |
| 1055 Settings.aGF_high = 99; | |
| 1056 corrections++; | |
| 820 | 1057 setFirstCorrection(parameterId); |
| 38 | 1058 } |
| 820 | 1059 parameterId++; |
| 38 | 1060 if(Settings.aGF_high < 45) |
| 1061 { | |
| 1062 Settings.aGF_high = 45; | |
| 1063 corrections++; | |
| 820 | 1064 setFirstCorrection(parameterId); |
| 38 | 1065 } |
| 820 | 1066 parameterId++; |
| 38 | 1067 /* uint8_t aGF_low; |
| 1068 */ | |
| 1069 if(Settings.aGF_low > 99) | |
| 1070 { | |
| 1071 Settings.aGF_low = 99; | |
| 1072 corrections++; | |
| 820 | 1073 setFirstCorrection(parameterId); |
| 38 | 1074 } |
| 820 | 1075 parameterId++; |
| 38 | 1076 if(Settings.aGF_low < 10) |
| 1077 { | |
| 1078 Settings.aGF_low = 10; | |
| 1079 corrections++; | |
| 820 | 1080 setFirstCorrection(parameterId); |
| 38 | 1081 } |
| 820 | 1082 parameterId++; |
| 38 | 1083 if(Settings.aGF_low > Settings.aGF_high) |
| 1084 { | |
| 1085 Settings.aGF_low = Settings.aGF_high; | |
| 1086 corrections++; | |
| 820 | 1087 setFirstCorrection(parameterId); |
| 38 | 1088 } |
| 820 | 1089 parameterId++; |
| 38 | 1090 /* split2x4_Type VPM_conservatism; |
| 1091 */ | |
| 1092 if(Settings.VPM_conservatism.ub.standard > 5) | |
| 1093 { | |
| 1094 Settings.VPM_conservatism.ub.standard = 5; | |
| 1095 corrections++; | |
| 820 | 1096 setFirstCorrection(parameterId); |
| 38 | 1097 } |
| 820 | 1098 parameterId++; |
| 38 | 1099 if(Settings.VPM_conservatism.ub.alternative > 5) |
| 1100 { | |
| 1101 Settings.VPM_conservatism.ub.alternative = 5; | |
| 1102 corrections++; | |
| 820 | 1103 setFirstCorrection(parameterId); |
| 38 | 1104 } |
| 820 | 1105 parameterId++; |
| 38 | 1106 /* uint8_t safetystopDuration; |
| 1107 */ | |
| 1108 if(Settings.safetystopDuration > 5) | |
| 1109 { | |
| 1110 Settings.safetystopDuration = 5; | |
| 1111 corrections++; | |
| 820 | 1112 setFirstCorrection(parameterId); |
| 38 | 1113 } |
| 820 | 1114 parameterId++; |
| 38 | 1115 /* uint8_t AtemMinutenVolumenLiter; |
| 1116 */ | |
| 1117 if(Settings.AtemMinutenVolumenLiter != 25) | |
| 1118 { | |
| 1119 Settings.AtemMinutenVolumenLiter = 25; | |
| 1120 corrections++; | |
| 820 | 1121 setFirstCorrection(parameterId); |
| 38 | 1122 } |
| 820 | 1123 parameterId++; |
| 38 | 1124 /* uint8_t ReserveFractionDenominator; |
| 1125 */ | |
| 1126 if(Settings.ReserveFractionDenominator != 4) | |
| 1127 { | |
| 1128 Settings.ReserveFractionDenominator = 4; | |
| 1129 corrections++; | |
| 820 | 1130 setFirstCorrection(parameterId); |
| 38 | 1131 } |
| 820 | 1132 parameterId++; |
| 38 | 1133 /* uint8_t salinity; |
| 1134 */ | |
| 1135 if(Settings.salinity > 4) | |
| 1136 { | |
| 1137 Settings.salinity = 4; | |
| 1138 corrections++; | |
| 820 | 1139 setFirstCorrection(parameterId); |
| 38 | 1140 } |
| 820 | 1141 parameterId++; |
| 38 | 1142 /* uint8_t last_stop_depth_meter; |
| 1143 */ | |
| 1144 if(Settings.last_stop_depth_meter > 9) | |
| 1145 { | |
| 1146 Settings.last_stop_depth_meter = 9; | |
| 1147 corrections++; | |
| 820 | 1148 setFirstCorrection(parameterId); |
| 38 | 1149 } |
| 820 | 1150 parameterId++; |
| 38 | 1151 if(Settings.last_stop_depth_meter < 3) |
| 1152 { | |
| 1153 Settings.last_stop_depth_meter = 3; | |
| 1154 corrections++; | |
| 820 | 1155 setFirstCorrection(parameterId); |
| 38 | 1156 } |
| 820 | 1157 parameterId++; |
| 38 | 1158 /* uint8_t stop_increment_depth_meter; |
| 1159 */ | |
| 1160 if(Settings.stop_increment_depth_meter != 3) | |
| 1161 { | |
| 1162 Settings.stop_increment_depth_meter = 3; | |
| 1163 corrections++; | |
| 820 | 1164 setFirstCorrection(parameterId); |
| 38 | 1165 } |
| 820 | 1166 parameterId++; |
| 38 | 1167 /* uint8_t brightness; |
| 1168 */ | |
| 1169 if(Settings.brightness > 4) | |
| 1170 { | |
| 1171 Settings.brightness = 4; | |
| 1172 corrections++; | |
| 820 | 1173 setFirstCorrection(parameterId); |
| 38 | 1174 } |
| 820 | 1175 parameterId++; |
| 38 | 1176 /* uint8_t date_format; |
| 1177 */ | |
| 1178 if( (Settings.date_format != DDMMYY) && | |
| 1179 (Settings.date_format != MMDDYY) && | |
| 1180 (Settings.date_format != YYMMDD)) | |
| 1181 { | |
| 1182 Settings.date_format = DDMMYY; | |
| 1183 corrections++; | |
| 820 | 1184 setFirstCorrection(parameterId); |
| 38 | 1185 } |
| 820 | 1186 parameterId++; |
| 38 | 1187 /* uint8_t selected_language; |
| 1188 */ | |
| 1189 if(Settings.selected_language >= LANGUAGE_END) | |
| 1190 { | |
| 1191 Settings.selected_language = LANGUAGE_English; | |
| 1192 corrections++; | |
| 820 | 1193 setFirstCorrection(parameterId); |
| 38 | 1194 } |
| 820 | 1195 parameterId++; |
| 38 | 1196 /* char customtext[60]; |
| 1197 */ | |
| 1198 if(Settings.customtext[59] != 0) | |
| 1199 { | |
| 1200 Settings.customtext[59] = 0; | |
| 1201 corrections++; | |
| 820 | 1202 setFirstCorrection(parameterId); |
| 38 | 1203 } |
| 820 | 1204 parameterId++; |
| 38 | 1205 /* uint16_t timeoutSurfacemode; |
| 1206 */ | |
| 1207 if( (Settings.timeoutSurfacemode != 20) && // Quick Sleep Option | |
| 1208 (Settings.timeoutSurfacemode != 120)) | |
| 1209 { | |
| 1210 Settings.timeoutSurfacemode = 120; | |
| 1211 corrections++; | |
| 820 | 1212 setFirstCorrection(parameterId); |
| 38 | 1213 } |
| 820 | 1214 parameterId++; |
| 38 | 1215 /* uint8_t timeoutMenuSurface; |
| 1216 */ | |
| 1217 if(Settings.timeoutMenuSurface != 120) | |
| 1218 { | |
| 1219 Settings.timeoutMenuSurface = 120; | |
| 1220 corrections++; | |
| 820 | 1221 setFirstCorrection(parameterId); |
| 38 | 1222 } |
| 820 | 1223 parameterId++; |
| 38 | 1224 /* uint8_t timeoutMenuDive; |
| 1225 */ | |
| 1226 if(Settings.timeoutMenuDive != 120) | |
| 1227 { | |
| 1228 Settings.timeoutMenuDive = 120; | |
| 1229 corrections++; | |
| 820 | 1230 setFirstCorrection(parameterId); |
| 38 | 1231 } |
| 820 | 1232 parameterId++; |
| 38 | 1233 /* uint8_t timeoutMenuEdit; |
| 1234 */ | |
| 1235 if(Settings.timeoutMenuEdit != 120) | |
| 1236 { | |
| 1237 Settings.timeoutMenuEdit = 120; | |
| 1238 corrections++; | |
| 820 | 1239 setFirstCorrection(parameterId); |
| 38 | 1240 } |
| 820 | 1241 parameterId++; |
| 38 | 1242 /* uint8_t timeoutInfo; |
| 1243 */ | |
| 1244 if(Settings.timeoutInfo != 120) | |
| 1245 { | |
| 1246 Settings.timeoutInfo = 120; | |
| 1247 corrections++; | |
| 820 | 1248 setFirstCorrection(parameterId); |
| 38 | 1249 } |
| 820 | 1250 parameterId++; |
| 38 | 1251 /* uint8_t timeoutInfoCompass; |
| 1252 */ | |
| 1253 if(Settings.timeoutInfoCompass != 60) | |
| 1254 { | |
| 1255 Settings.timeoutInfoCompass = 60; | |
| 1256 corrections++; | |
| 820 | 1257 setFirstCorrection(parameterId); |
| 38 | 1258 } |
| 820 | 1259 parameterId++; |
| 38 | 1260 /* uint8_t design; |
| 1261 */ | |
| 1262 if(Settings.design != 7) | |
| 1263 { | |
| 1264 Settings.design = 7; | |
| 1265 corrections++; | |
| 820 | 1266 setFirstCorrection(parameterId); |
| 38 | 1267 } |
| 820 | 1268 parameterId++; |
| 38 | 1269 /* uint16_t timeoutDiveReachedZeroDepth; |
| 1270 */ | |
| 1271 if(Settings.timeoutDiveReachedZeroDepth != 300) | |
| 1272 { | |
| 1273 Settings.timeoutDiveReachedZeroDepth = 300; | |
| 1274 corrections++; | |
| 820 | 1275 setFirstCorrection(parameterId); |
| 38 | 1276 } |
| 820 | 1277 parameterId++; |
| 38 | 1278 /* uint16_t divetimeToCreateLogbook; |
| 1279 */ | |
| 1280 if(Settings.divetimeToCreateLogbook != 60) | |
| 1281 { | |
| 1282 Settings.divetimeToCreateLogbook = 60; | |
| 1283 corrections++; | |
| 820 | 1284 setFirstCorrection(parameterId); |
| 38 | 1285 } |
| 820 | 1286 parameterId++; |
| 38 | 1287 /* uint8_t serialHigh; |
| 1288 */ | |
| 1289 | |
| 1290 /* uint8_t serialLow; | |
| 1291 */ | |
| 1292 | |
| 1293 /* SUFirmware firmwareVersion16to32bit; | |
| 1294 */ | |
| 1295 | |
| 1296 /* uint32_t backup_localtime_rtc_tr; | |
| 1297 */ | |
| 1298 | |
| 1299 /* uint32_t backup_localtime_rtc_dr; | |
| 1300 */ | |
| 1301 | |
| 1302 /* uint16_t totalDiveCounter; | |
| 1303 */ | |
| 1304 | |
| 1305 /* uint16_t personalDiveCount; | |
| 1306 */ | |
| 1307 | |
| 1308 /* uint8_t showDebugInfo; | |
| 1309 */ | |
|
492
4ce932235578
Added compiler switch for existing debug view parameter
Ideenmodellierer
parents:
488
diff
changeset
|
1310 |
|
4ce932235578
Added compiler switch for existing debug view parameter
Ideenmodellierer
parents:
488
diff
changeset
|
1311 #ifdef HAVE_DEBUG_VIEW |
| 38 | 1312 if(Settings.showDebugInfo > 1) |
| 1313 { | |
| 1314 Settings.showDebugInfo = 0; | |
| 1315 corrections++; | |
| 1316 } | |
|
492
4ce932235578
Added compiler switch for existing debug view parameter
Ideenmodellierer
parents:
488
diff
changeset
|
1317 #else |
|
4ce932235578
Added compiler switch for existing debug view parameter
Ideenmodellierer
parents:
488
diff
changeset
|
1318 Settings.showDebugInfo = 0; |
|
4ce932235578
Added compiler switch for existing debug view parameter
Ideenmodellierer
parents:
488
diff
changeset
|
1319 #endif |
| 38 | 1320 |
| 1321 /* uint8_t ButtonResponsiveness[4]; | |
| 1322 */ | |
| 1323 // Base value, index 3 | |
| 93 | 1324 if(Settings.ButtonResponsiveness[3] < MIN_BUTTONRESPONSIVENESS_GUI) |
| 38 | 1325 { |
| 93 | 1326 Settings.ButtonResponsiveness[3] = MIN_BUTTONRESPONSIVENESS_GUI; |
| 38 | 1327 corrections++; |
| 820 | 1328 setFirstCorrection(parameterId); |
| 38 | 1329 } |
| 1330 else | |
| 151 | 1331 if(Settings.ButtonResponsiveness[3] > MAX_BUTTONRESPONSIVENESS_GUI) |
| 38 | 1332 { |
| 151 | 1333 Settings.ButtonResponsiveness[3] = MAX_BUTTONRESPONSIVENESS_GUI; |
| 38 | 1334 corrections++; |
| 820 | 1335 setFirstCorrection(parameterId); |
| 38 | 1336 } |
| 820 | 1337 parameterId++; |
| 38 | 1338 // flex values 0, 1, 2 |
| 1339 for(int i=0; i<3;i++) | |
| 1340 { | |
| 93 | 1341 if(Settings.ButtonResponsiveness[i] < MIN_BUTTONRESPONSIVENESS) // 50-10 //Fix for broken buttons. :) |
| 38 | 1342 { |
| 93 | 1343 Settings.ButtonResponsiveness[i] = MIN_BUTTONRESPONSIVENESS; |
| 38 | 1344 corrections++; |
| 820 | 1345 setFirstCorrection(parameterId); |
| 38 | 1346 } |
| 1347 else | |
| 93 | 1348 if(Settings.ButtonResponsiveness[i] > MAX_BUTTONRESPONSIVENESS) // 110+20 |
| 38 | 1349 { |
| 93 | 1350 Settings.ButtonResponsiveness[i] = MAX_BUTTONRESPONSIVENESS; |
| 38 | 1351 corrections++; |
| 820 | 1352 setFirstCorrection(parameterId); |
| 38 | 1353 } |
| 1354 } | |
| 820 | 1355 parameterId++; |
| 38 | 1356 /* uint8_t buttonBalance[3]; |
| 1357 */ | |
| 1358 for(int i=0; i<3;i++) | |
| 1359 { | |
| 1360 if(Settings.buttonBalance[i] < 2) // 2 = -10 | |
| 1361 { | |
| 1362 Settings.buttonBalance[i] = 2; | |
| 1363 corrections++; | |
| 820 | 1364 setFirstCorrection(parameterId); |
| 38 | 1365 } |
| 1366 else | |
| 1367 if(Settings.buttonBalance[i] > 5) // 3 = 0, 4 = +10, 5 = +20 | |
| 1368 { | |
| 1369 Settings.buttonBalance[i] = 5; | |
| 1370 corrections++; | |
| 820 | 1371 setFirstCorrection(parameterId); |
| 38 | 1372 } |
| 1373 } | |
| 820 | 1374 parameterId++; |
| 38 | 1375 /* uint8_t nonMetricalSystem; |
| 1376 */ | |
| 1377 if(Settings.nonMetricalSystem > 1) | |
| 1378 { | |
| 1379 Settings.nonMetricalSystem = 1; | |
| 1380 corrections++; | |
| 820 | 1381 setFirstCorrection(parameterId); |
| 38 | 1382 } |
| 820 | 1383 parameterId++; |
| 38 | 1384 /* uint8_t fallbackToFixedSetpoint; |
| 1385 */ | |
| 1386 if(Settings.fallbackToFixedSetpoint > 1) | |
| 1387 { | |
| 1388 Settings.fallbackToFixedSetpoint = 1; | |
| 1389 corrections++; | |
| 820 | 1390 setFirstCorrection(parameterId); |
| 38 | 1391 } |
| 820 | 1392 parameterId++; |
| 38 | 1393 /* uint8_t bluetoothActive; |
| 1394 */ | |
| 1395 if(Settings.bluetoothActive > 1) | |
| 1396 { | |
| 1397 Settings.bluetoothActive = 1; | |
| 1398 corrections++; | |
| 820 | 1399 setFirstCorrection(parameterId); |
| 38 | 1400 } |
| 820 | 1401 parameterId++; |
| 38 | 1402 /* uint8_t safetystopDepth; |
| 1403 */ | |
| 1404 if(Settings.safetystopDepth > 6) | |
| 1405 { | |
| 1406 Settings.safetystopDepth = 6; | |
| 1407 corrections++; | |
| 820 | 1408 setFirstCorrection(parameterId); |
| 38 | 1409 } |
| 820 | 1410 parameterId++; |
| 38 | 1411 if(Settings.safetystopDepth < 3) |
| 1412 { | |
| 1413 Settings.safetystopDepth = 3; | |
| 1414 corrections++; | |
| 820 | 1415 setFirstCorrection(parameterId); |
| 38 | 1416 } |
| 820 | 1417 parameterId++; |
| 38 | 1418 /* uint32_t updateSettingsAllowedFromHeader; |
| 1419 */ | |
| 1420 | |
| 1421 /* uint8_t ppo2sensors_deactivated; | |
| 1422 */ | |
| 1423 if(Settings.ppo2sensors_deactivated > (1+2+4)) | |
| 1424 { | |
| 1425 Settings.ppo2sensors_deactivated = 0; | |
| 1426 corrections++; | |
| 820 | 1427 setFirstCorrection(parameterId); |
| 38 | 1428 } |
| 820 | 1429 parameterId++; |
| 38 | 1430 /* uint8_t tX_colorscheme; |
| 1431 */ | |
| 1432 if(Settings.tX_colorscheme > 3) | |
| 1433 { | |
| 1434 Settings.tX_colorscheme = 0; | |
| 1435 corrections++; | |
| 820 | 1436 setFirstCorrection(parameterId); |
| 38 | 1437 } |
| 820 | 1438 parameterId++; |
| 38 | 1439 /* uint8_t tX_userselectedLeftLowerCornerPrimary; |
| 1440 */ | |
|
443
a5101c688b49
Introduced enum for lower left corner view selection:
ideenmodellierer
parents:
439
diff
changeset
|
1441 if(Settings.tX_userselectedLeftLowerCornerPrimary >= LLC_END) |
| 38 | 1442 { |
|
443
a5101c688b49
Introduced enum for lower left corner view selection:
ideenmodellierer
parents:
439
diff
changeset
|
1443 Settings.tX_userselectedLeftLowerCornerPrimary = LLC_Temperature; |
| 38 | 1444 corrections++; |
| 820 | 1445 setFirstCorrection(parameterId); |
| 38 | 1446 } |
| 820 | 1447 parameterId++; |
| 38 | 1448 /* uint8_t tX_userselectedLeftLowerCornerTimeout; |
| 1449 */ | |
| 1450 if(Settings.tX_userselectedLeftLowerCornerTimeout > 60) | |
| 1451 { | |
| 1452 Settings.tX_userselectedLeftLowerCornerTimeout = 0; | |
| 1453 corrections++; | |
| 820 | 1454 setFirstCorrection(parameterId); |
| 38 | 1455 } |
| 820 | 1456 parameterId++; |
| 38 | 1457 /* uint8_t tX_customViewPrimary; |
| 1458 */ | |
| 1459 if(Settings.tX_customViewPrimary >= CVIEW_END) | |
| 1460 { | |
| 1461 Settings.tX_customViewPrimary = 1; | |
| 1462 corrections++; | |
| 820 | 1463 setFirstCorrection(parameterId); |
| 38 | 1464 } |
| 820 | 1465 parameterId++; |
| 38 | 1466 /* uint8_t tX_customViewTimeout; |
| 1467 */ | |
| 1468 if(Settings.tX_customViewTimeout > 60) | |
| 1469 { | |
| 1470 Settings.tX_customViewTimeout = 0; | |
| 1471 corrections++; | |
| 820 | 1472 setFirstCorrection(parameterId); |
| 38 | 1473 } |
| 820 | 1474 parameterId++; |
| 38 | 1475 /* uint8_t timeoutEnterButtonSelectDive; |
| 1476 */ | |
| 1477 if(Settings.timeoutEnterButtonSelectDive != 10) | |
| 1478 { | |
| 1479 Settings.timeoutEnterButtonSelectDive = 10; | |
| 1480 corrections++; | |
| 820 | 1481 setFirstCorrection(parameterId); |
| 38 | 1482 } |
| 820 | 1483 parameterId++; |
| 38 | 1484 /* uint8_t logbookOffset; |
| 1485 */ | |
| 1486 if(Settings.logbookOffset > 9000) | |
| 1487 { | |
| 1488 Settings.logbookOffset = 0; | |
| 1489 corrections++; | |
| 820 | 1490 setFirstCorrection(parameterId); |
| 38 | 1491 } |
| 820 | 1492 parameterId++; |
| 38 | 1493 /* uint8_t alwaysShowPPO2; |
| 1494 */ | |
| 1495 if(Settings.alwaysShowPPO2 > 1) | |
| 1496 { | |
| 1497 Settings.alwaysShowPPO2 = 0; | |
| 1498 corrections++; | |
| 820 | 1499 setFirstCorrection(parameterId); |
| 38 | 1500 } |
| 820 | 1501 parameterId++; |
| 38 | 1502 /* uint8_t extraDisplay; |
| 1503 */ | |
| 1504 if(Settings.extraDisplay >= EXTRADISPLAY_END) | |
| 1505 { | |
| 1506 Settings.extraDisplay = EXTRADISPLAY_BIGFONT; | |
| 1507 corrections++; | |
| 820 | 1508 setFirstCorrection(parameterId); |
| 38 | 1509 } |
| 820 | 1510 parameterId++; |
| 38 | 1511 /* int8_t offsetPressure_mbar; |
| 1512 */ | |
|
337
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
1513 if((Settings.offsetPressure_mbar > PRESSURE_OFFSET_LIMIT_MBAR) || |
|
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
1514 (Settings.offsetPressure_mbar < -1 * PRESSURE_OFFSET_LIMIT_MBAR)) |
| 38 | 1515 { |
| 1516 Settings.offsetPressure_mbar = 0; | |
| 1517 corrections++; | |
| 820 | 1518 setFirstCorrection(parameterId); |
| 38 | 1519 } |
| 820 | 1520 parameterId++; |
| 38 | 1521 /* int8_t offsetTemperature_centigrad; |
| 1522 */ | |
| 1523 if((Settings.offsetTemperature_centigrad > 20) || | |
| 1524 (Settings.offsetTemperature_centigrad < -20)) | |
| 1525 { | |
| 1526 Settings.offsetTemperature_centigrad = 0; | |
| 1527 corrections++; | |
| 820 | 1528 setFirstCorrection(parameterId); |
| 38 | 1529 } |
| 820 | 1530 parameterId++; |
| 38 | 1531 /* uint8_t gasConsumption_travel_l_min; |
| 1532 */ | |
| 1533 if((Settings.gasConsumption_travel_l_min < 5) || | |
| 1534 (Settings.gasConsumption_travel_l_min > 50)) | |
| 1535 { | |
| 1536 Settings.gasConsumption_travel_l_min = 20; | |
| 1537 corrections++; | |
| 820 | 1538 setFirstCorrection(parameterId); |
| 38 | 1539 } |
| 820 | 1540 parameterId++; |
| 38 | 1541 /* uint8_t gasConsumption_bottom_l_min; |
| 1542 */ | |
| 1543 if((Settings.gasConsumption_bottom_l_min < 5) || | |
| 1544 (Settings.gasConsumption_bottom_l_min > 50)) | |
| 1545 { | |
| 1546 Settings.gasConsumption_bottom_l_min = 20; | |
| 1547 corrections++; | |
| 820 | 1548 setFirstCorrection(parameterId); |
| 38 | 1549 } |
| 820 | 1550 parameterId++; |
| 38 | 1551 /* uint8_t gasConsumption_deco_l_min; |
| 1552 */ | |
| 1553 if((Settings.gasConsumption_deco_l_min < 5) || | |
| 1554 (Settings.gasConsumption_deco_l_min > 50)) | |
| 1555 { | |
| 1556 Settings.gasConsumption_deco_l_min = 20; | |
| 1557 corrections++; | |
| 820 | 1558 setFirstCorrection(parameterId); |
| 38 | 1559 } |
| 820 | 1560 parameterId++; |
| 38 | 1561 /* uint8_t showDebugInfo; |
| 1562 */ | |
| 1563 #ifdef BOOT16 | |
| 1564 Settings.showDebugInfo = 0; | |
| 1565 #else | |
| 1566 if(Settings.showDebugInfo > 1) | |
| 1567 Settings.showDebugInfo = 0; | |
| 1568 | |
| 1569 #endif | |
| 1570 | |
| 1571 /* uint8_t selected_language; | |
| 1572 */ | |
| 1573 #ifdef BOOT16 | |
| 1574 if(Settings.selected_language > 1) | |
| 1575 Settings.selected_language = 0; | |
| 1576 #else | |
| 1577 if(Settings.selected_language > 4) | |
| 1578 Settings.selected_language = 0; | |
| 1579 #endif | |
| 1580 | |
| 1581 | |
| 1582 /* uint8_t display_toogle_desc; 1/10 seconds | |
| 1583 */ | |
| 1584 if((Settings.display_toogle_desc < 20) || (Settings.display_toogle_desc > 600)) | |
| 1585 { | |
| 1586 Settings.display_toogle_desc = SettingsStandard.display_toogle_desc; | |
| 1587 corrections++; | |
| 820 | 1588 setFirstCorrection(parameterId); |
| 38 | 1589 } |
| 820 | 1590 parameterId++; |
| 38 | 1591 /* uint8_t debugModeOnStart; |
| 1592 */ | |
| 1593 if(Settings.debugModeOnStart > 1) | |
| 1594 { | |
| 1595 Settings.debugModeOnStart = 0; | |
| 1596 corrections++; | |
| 820 | 1597 setFirstCorrection(parameterId); |
| 38 | 1598 } |
| 820 | 1599 parameterId++; |
| 38 | 1600 |
| 1601 /* uint8_t IAmStolenPleaseKillMe; | |
| 1602 */ | |
| 1603 | |
| 1604 if(hardwareDataGetPointer()->primarySerial == 90) | |
| 1605 Settings.IAmStolenPleaseKillMe++; | |
| 1606 else | |
| 1607 Settings.IAmStolenPleaseKillMe = 0; | |
| 1608 | |
| 1609 | |
| 1610 /* uint8_t debugModeOnStart; | |
| 1611 */ | |
| 1612 if(Settings.compassBearing > 360) | |
| 1613 { | |
| 1614 Settings.compassBearing = 0; | |
| 1615 corrections++; | |
| 820 | 1616 setFirstCorrection(parameterId); |
| 38 | 1617 } |
| 1618 | |
| 820 | 1619 parameterId++; |
| 38 | 1620 /* uint8_t lastKnownBatteryPercentage; |
| 1621 */ | |
| 1622 if(Settings.lastKnownBatteryPercentage > 100) | |
| 1623 { | |
| 1624 Settings.lastKnownBatteryPercentage = 100; | |
| 1625 corrections++; | |
| 820 | 1626 setFirstCorrection(parameterId); |
| 38 | 1627 } |
| 820 | 1628 parameterId++; |
| 38 | 1629 /* uint8_t VPM_model |
| 1630 */ | |
| 1631 if((Settings.VPM_model != VPM_FROM_FORTRAN) && (Settings.VPM_model != VPM_BACHELORWORK)) | |
| 1632 { | |
| 1633 Settings.VPM_model = VPM_FROM_FORTRAN; | |
| 1634 corrections++; | |
| 820 | 1635 setFirstCorrection(parameterId); |
| 38 | 1636 } |
| 820 | 1637 parameterId++; |
| 38 | 1638 /* uint8_t Buehlmann_model |
| 1639 */ | |
| 1640 if((Settings.GF_model != BUEHLMANN_OSTC4) && (Settings.GF_model != BUEHLMANN_hwOS)) | |
| 1641 { | |
| 1642 Settings.GF_model = BUEHLMANN_OSTC4; | |
| 1643 corrections++; | |
| 820 | 1644 setFirstCorrection(parameterId); |
| 38 | 1645 } |
| 820 | 1646 parameterId++; |
|
111
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
1647 if(Settings.FlipDisplay > 1) /* only boolean values allowed */ |
|
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
1648 { |
|
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
1649 Settings.FlipDisplay = 0; |
|
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
1650 corrections++; |
| 820 | 1651 setFirstCorrection(parameterId); |
|
111
38785aa95837
Added new nvm parameter"FlipDisplay" indicating the screen orientation
Ideenmodellierer
parents:
75
diff
changeset
|
1652 } |
| 820 | 1653 parameterId++; |
| 522 | 1654 #ifdef ENABLE_MOTION_CONTROL |
|
375
4bb5ceebfaf9
Use Enum values for initialization and setting check:
ideenmodellierer
parents:
372
diff
changeset
|
1655 if(Settings.MotionDetection >= MOTION_DETECT_END) |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
1656 { |
|
375
4bb5ceebfaf9
Use Enum values for initialization and setting check:
ideenmodellierer
parents:
372
diff
changeset
|
1657 Settings.MotionDetection = MOTION_DETECT_OFF; |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
1658 corrections++; |
| 820 | 1659 setFirstCorrection(parameterId); |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
1660 } |
| 522 | 1661 #else |
| 1662 Settings.MotionDetection = MOTION_DETECT_OFF; | |
|
550
af1c3e3abd5f
Make sure motion detection settings are set to default values:
Ideenmodellierer
parents:
546
diff
changeset
|
1663 Settings.viewPortMode = 0; |
|
af1c3e3abd5f
Make sure motion detection settings are set to default values:
Ideenmodellierer
parents:
546
diff
changeset
|
1664 Settings.viewRoll = 0.0; |
|
af1c3e3abd5f
Make sure motion detection settings are set to default values:
Ideenmodellierer
parents:
546
diff
changeset
|
1665 Settings.viewPitch = 0.0; |
|
af1c3e3abd5f
Make sure motion detection settings are set to default values:
Ideenmodellierer
parents:
546
diff
changeset
|
1666 Settings.viewYaw = 0.0; |
| 522 | 1667 #endif |
| 820 | 1668 parameterId++; |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
1669 if(Settings.compassInertia > MAX_COMPASS_COMP) |
|
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
1670 { |
|
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
1671 Settings.compassInertia = 0; |
|
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
1672 corrections++; |
| 820 | 1673 setFirstCorrection(parameterId); |
|
539
d784f281833a
Added inertia simulation for compass heading:
Ideenmodellierer
parents:
533
diff
changeset
|
1674 } |
| 820 | 1675 parameterId++; |
|
541
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
1676 if(Settings.tX_customViewPrimaryBF > CVIEW_T3_END) |
|
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
1677 { |
|
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
1678 Settings.tX_customViewPrimaryBF = CVIEW_T3_Decostop; |
|
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
1679 corrections++; |
| 820 | 1680 setFirstCorrection(parameterId); |
|
541
6fbf7cd391cb
Added default view selection and auto return to view to t3 visualization:
Ideenmodellierer
parents:
539
diff
changeset
|
1681 } |
| 820 | 1682 parameterId++; |
| 546 | 1683 if(Settings.viewPortMode > MAX_VIEWPORT_MODE) |
| 1684 { | |
| 1685 Settings.viewPortMode = 0; | |
| 1686 corrections++; | |
| 820 | 1687 setFirstCorrection(parameterId); |
| 546 | 1688 } |
| 820 | 1689 parameterId++; |
|
560
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1690 if(Settings.ppo2sensors_source >= O2_SENSOR_SOURCE_MAX) |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1691 { |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1692 Settings.ppo2sensors_source = O2_SENSOR_SOURCE_OPTIC; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1693 Settings.ppo2sensors_calibCoeff[0] = 0.0; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1694 Settings.ppo2sensors_calibCoeff[1] = 0.0; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1695 Settings.ppo2sensors_calibCoeff[2] = 0.0; |
|
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1696 corrections++; |
| 820 | 1697 setFirstCorrection(parameterId); |
|
560
5d80bb8d22cb
Added O2 sensor source and calibration parameters to setting structure
Ideenmodellierer
parents:
550
diff
changeset
|
1698 } |
| 820 | 1699 parameterId++; |
| 567 | 1700 if(Settings.amPMTime > 1) /* only boolean values allowed */ |
| 1701 { | |
| 1702 Settings.amPMTime = 0; | |
| 1703 corrections++; | |
| 820 | 1704 setFirstCorrection(parameterId); |
| 567 | 1705 } |
| 820 | 1706 parameterId++; |
| 650 | 1707 if(Settings.autoSetpoint > 1) /* only boolean values allowed */ |
| 1708 { | |
| 1709 Settings.autoSetpoint = 0; | |
| 1710 corrections++; | |
| 820 | 1711 setFirstCorrection(parameterId); |
| 650 | 1712 } |
| 820 | 1713 parameterId++; |
| 710 | 1714 if(Settings.scubberActiveId > 1) |
| 1715 { | |
| 1716 Settings.scubberActiveId = 0; | |
| 1717 corrections++; | |
| 820 | 1718 setFirstCorrection(parameterId); |
| 710 | 1719 } |
| 820 | 1720 parameterId++; |
| 761 | 1721 if((Settings.scrubberData[0].TimerMax > MAX_SCRUBBER_TIME) || Settings.scrubberData[0].TimerCur < MIN_SCRUBBER_TIME || Settings.scrubberData[0].TimerCur > (int16_t)MAX_SCRUBBER_TIME) |
| 650 | 1722 { |
| 710 | 1723 Settings.scrubberData[0].TimerMax = 0; |
| 1724 Settings.scrubberData[0].TimerCur = 0; | |
| 1725 corrections++; | |
| 820 | 1726 setFirstCorrection(parameterId); |
| 710 | 1727 } |
| 820 | 1728 parameterId++; |
| 761 | 1729 if((Settings.scrubberData[1].TimerMax > MAX_SCRUBBER_TIME) || Settings.scrubberData[1].TimerCur < MIN_SCRUBBER_TIME || Settings.scrubberData[1].TimerCur > (int16_t)MAX_SCRUBBER_TIME) |
| 710 | 1730 { |
| 1731 Settings.scrubberData[1].TimerMax = 0; | |
| 1732 Settings.scrubberData[1].TimerCur = 0; | |
| 650 | 1733 corrections++; |
| 820 | 1734 setFirstCorrection(parameterId); |
| 650 | 1735 } |
| 820 | 1736 parameterId++; |
|
654
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
1737 if(Settings.scrubTimerMode > SCRUB_TIMER_END) |
|
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
1738 { |
|
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
1739 Settings.scrubTimerMode = SCRUB_TIMER_OFF; |
|
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
1740 corrections++; |
| 820 | 1741 setFirstCorrection(parameterId); |
|
654
890440ab993a
Introduced new menu tab for addition CCR options:
Ideenmodellierer
parents:
652
diff
changeset
|
1742 } |
| 820 | 1743 parameterId++; |
| 662 | 1744 if((Settings.pscr_lung_ratio > PSCR_MAX_LUNG_RATIO) || (Settings.pscr_lung_ratio < PSCR_MIN_LUNG_RATIO)) |
| 1745 { | |
| 1746 Settings.pscr_lung_ratio = 10; | |
| 1747 corrections++; | |
| 820 | 1748 setFirstCorrection(parameterId); |
| 662 | 1749 } |
| 820 | 1750 parameterId++; |
| 662 | 1751 if(Settings.pscr_o2_drop > PSCR_MAX_O2_DROP) |
| 1752 { | |
| 1753 Settings.pscr_o2_drop = 4; | |
| 1754 corrections++; | |
| 820 | 1755 setFirstCorrection(parameterId); |
| 662 | 1756 } |
| 820 | 1757 parameterId++; |
| 662 | 1758 if(Settings.co2_sensor_active > 1) |
| 1759 { | |
| 1760 Settings.co2_sensor_active = 0; | |
| 1761 corrections++; | |
| 820 | 1762 setFirstCorrection(parameterId); |
| 662 | 1763 } |
| 820 | 1764 parameterId++; |
| 710 | 1765 if(Settings.ext_uart_protocol > UART_MAX_PROTOCOL) |
| 687 | 1766 { |
| 1767 Settings.ext_uart_protocol = 0; | |
| 1768 corrections++; | |
| 820 | 1769 setFirstCorrection(parameterId); |
| 687 | 1770 } |
| 820 | 1771 parameterId++; |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1772 if((Settings.ext_sensor_map[0] >= SENSOR_END) |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1773 || (Settings.ext_sensor_map[1] >= SENSOR_END) |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1774 || (Settings.ext_sensor_map[2] >= SENSOR_END) |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1775 || (Settings.ext_sensor_map[3] >= SENSOR_END) |
| 796 | 1776 || (Settings.ext_sensor_map[4] >= SENSOR_END) |
| 1777 || (Settings.ext_sensor_map[5] >= SENSOR_END) | |
| 1778 || (Settings.ext_sensor_map[6] >= SENSOR_END) | |
| 1779 || (Settings.ext_sensor_map[7] >= SENSOR_END)) | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1780 { |
| 733 | 1781 Settings.ext_sensor_map[0] = SENSOR_OPTIC; |
| 1782 Settings.ext_sensor_map[1] = SENSOR_OPTIC; | |
| 1783 Settings.ext_sensor_map[2] = SENSOR_OPTIC; | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1784 Settings.ext_sensor_map[3] = SENSOR_NONE; |
|
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1785 Settings.ext_sensor_map[4] = SENSOR_NONE; |
| 796 | 1786 Settings.ext_sensor_map[5] = SENSOR_NONE; |
| 1787 Settings.ext_sensor_map[6] = SENSOR_NONE; | |
| 1788 Settings.ext_sensor_map[7] = SENSOR_NONE; | |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1789 corrections++; |
| 820 | 1790 setFirstCorrection(parameterId); |
|
728
5143e927219f
Added sensor map to Firmware <=> RTE inferface:
Ideenmodellierer
parents:
715
diff
changeset
|
1791 } |
| 820 | 1792 parameterId++; |
|
740
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
1793 if(Settings.buttonLockActive > 1) |
|
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
1794 { |
|
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
1795 Settings.buttonLockActive = 1; |
|
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
1796 corrections++; |
| 820 | 1797 setFirstCorrection(parameterId); |
|
740
5078da3845c0
Added button lock after wakeup in surface mode:
Ideenmodellierer
parents:
733
diff
changeset
|
1798 } |
| 820 | 1799 parameterId++; |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1800 if (Settings.compassDeclinationDeg > 99) { |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1801 Settings.compassDeclinationDeg = 99; |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1802 |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1803 corrections++; |
| 820 | 1804 setFirstCorrection(parameterId); |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1805 } else if (Settings.compassDeclinationDeg < -99) { |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1806 Settings.compassDeclinationDeg = -99; |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1807 |
|
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1808 corrections++; |
| 820 | 1809 setFirstCorrection(parameterId); |
|
776
45b8f3c2acce
Add support for a configurable compass declination in a range of -99 to 99 degrees.
heinrichsweikamp
parents:
768
diff
changeset
|
1810 } |
| 820 | 1811 parameterId++; |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1812 if (Settings.timerDurationS > 599) { |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1813 Settings.timerDurationS = 599; |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1814 |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1815 corrections++; |
| 820 | 1816 setFirstCorrection(parameterId); |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1817 } else if (Settings.timerDurationS < 1) { |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1818 Settings.timerDurationS = 1; |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1819 |
|
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1820 corrections++; |
| 820 | 1821 setFirstCorrection(parameterId); |
|
805
dd7ce655db26
Adds a simple countdown timer, available as a custom view in surface and dive mode.
heinrichsweikamp
parents:
801
diff
changeset
|
1822 } |
| 820 | 1823 parameterId++; |
| 662 | 1824 if(corrections) |
| 1825 { | |
| 1826 settingsWarning = 1; | |
| 1827 } | |
| 1828 else | |
| 1829 | |
| 38 | 1830 if(corrections > 255) |
| 662 | 1831 { |
| 1832 corrections = 255; | |
| 1833 } | |
| 1834 | |
| 820 | 1835 SettingsStatus.Corrections = corrections; |
| 662 | 1836 return (uint8_t)corrections; |
| 38 | 1837 } |
| 1838 | |
| 1839 | |
| 1840 /* always at 0x8080000, do not move -> bootloader access */ | |
| 1841 const SFirmwareData* firmwareDataGetPointer(void) | |
| 1842 { | |
| 1843 return &firmware_FirmwareData; | |
| 1844 } | |
| 1845 | |
| 1846 | |
| 1847 #ifndef SPECIALPROGRAMM | |
| 1848 const SHardwareData* hardwareDataGetPointer(void) | |
| 1849 { | |
| 1850 return (SHardwareData *)HARDWAREDATA_ADDRESS; | |
| 1851 } | |
| 1852 #endif | |
| 1853 | |
| 1854 const SSettings* settingsGetPointerStandard(void) | |
| 1855 { | |
| 1856 return &SettingsStandard; | |
| 1857 } | |
| 1858 | |
| 1859 | |
| 1860 void hardwareBatchCode(uint8_t *high, uint8_t *low) | |
| 1861 { | |
| 1862 if(high) | |
| 1863 { | |
| 1864 *high = (uint8_t)((hardwareDataGetPointer()->production_year - 16) * 16); | |
| 1865 *high += hardwareDataGetPointer()->production_month; | |
| 1866 if(low) | |
| 1867 { | |
| 1868 *low = (uint8_t)(hardwareDataGetPointer()->production_day * 8); | |
| 1869 } | |
| 1870 } | |
| 1871 } | |
| 1872 | |
| 1873 | |
| 1874 uint8_t firmwareVersion_16bit_high(void) | |
| 1875 { | |
|
319
d8e86af78474
bugfix: correct packed main version number in dive header
Jan Mulder <jlmulder@xs4all.nl>
parents:
286
diff
changeset
|
1876 return ((firmware_FirmwareData.versionFirst & 0x1F) << 3) + ((firmware_FirmwareData.versionSecond & 0x1C) >> 2); |
| 38 | 1877 } |
| 1878 | |
| 1879 uint8_t firmwareVersion_16bit_low(void) | |
| 1880 { | |
| 1881 return ((firmware_FirmwareData.versionSecond & 0x03) << 6) + ((firmware_FirmwareData.versionThird & 0x1F) << 1) + (firmware_FirmwareData.versionBeta & 0x01); | |
| 1882 } | |
| 1883 | |
|
368
50ea68c7a153
Added menu item for motion detection. There are several possibility to use motion detection for user action input. To select of the a new menu entry has been added to the Sys2 =>Custom View Menu (Variables in german)
ideenmodellierer
parents:
324
diff
changeset
|
1884 inline SSettings* settingsGetPointer(void) |
| 38 | 1885 { |
| 1886 return &Settings; | |
| 1887 } | |
| 1888 | |
| 1889 | |
| 1890 // =============================================================================== | |
| 1891 // set_settings_to_Standard | |
| 1892 /// @brief This function overwrites the current settings of the system | |
| 1893 /// with the EXCEPTION of the personalDiveCount | |
| 1894 /// | |
| 1895 /// It additionally calls set_new_settings_missing_in_ext_flash() and | |
| 1896 /// check_and_correct_settings(), even so this shouldn't be necessary. | |
| 1897 /// It is called on every start and from Reset All. | |
| 1898 /// | |
| 1899 /// 160622 added lastDiveLogIdBackup | |
| 1900 /// | |
| 1901 // =============================================================================== | |
| 1902 void set_settings_to_Standard(void) | |
| 1903 { | |
| 1904 SSettings *pSettings; | |
| 1905 const SSettings *pSettingsStandard; | |
| 1906 uint16_t personalDiveCountBackup; | |
| 1907 uint8_t lastDiveLogIdBackup; | |
| 1908 pSettings = settingsGetPointer(); | |
| 1909 pSettingsStandard = settingsGetPointerStandard(); | |
| 1910 | |
| 1911 personalDiveCountBackup = pSettings->personalDiveCount; | |
| 1912 lastDiveLogIdBackup = pSettings->lastDiveLogId; | |
| 1913 memcpy(pSettings,pSettingsStandard,sizeof(*pSettings)); | |
| 1914 pSettings->personalDiveCount = personalDiveCountBackup; | |
| 1915 pSettings->lastDiveLogId = lastDiveLogIdBackup; | |
| 1916 | |
| 1917 pSettings->firmwareVersion[0] = firmware_FirmwareData.versionFirst; | |
| 1918 pSettings->firmwareVersion[1] = firmware_FirmwareData.versionSecond; | |
| 1919 pSettings->firmwareVersion[2] = firmware_FirmwareData.versionThird; | |
| 1920 pSettings->firmwareVersion[3] = firmware_FirmwareData.versionBeta; | |
| 1921 | |
| 1922 set_new_settings_missing_in_ext_flash(); | |
| 1923 check_and_correct_settings(); | |
| 1924 // has to be called too: createDiveSettings(); | |
| 1925 } | |
| 1926 | |
| 1927 | |
| 1928 // =============================================================================== | |
| 1929 // mod_settings_for_first_start_with_empty_ext_flash | |
| 1930 /// @brief This function overwrites some settings of the system | |
| 1931 /// It is called on every start. | |
| 1932 /// Those settings will be overwriten by ext_flash_read_settings() | |
| 1933 /// Will be kept if ext_flash_read_settings() is invalid because | |
| 1934 /// it is still empty. | |
| 1935 /// | |
| 1936 // =============================================================================== | |
| 1937 void mod_settings_for_first_start_with_empty_ext_flash(void) | |
| 1938 { | |
| 1939 settingsGetPointer()->debugModeOnStart = 1; // | |
| 1940 } | |
| 1941 | |
| 1942 | |
| 1943 | |
| 1944 // =============================================================================== | |
| 1945 // hwOS4_to_hwOS_GasType | |
| 1946 /// @brief Helper for get gas / diluent | |
| 1947 /// | |
| 1948 // =============================================================================== | |
| 1949 uint8_t hwOS4_to_hwOS_GasType(uint8_t inOSTC4style) | |
| 1950 { | |
| 1951 switch(inOSTC4style) | |
| 1952 { | |
| 1953 case (1+2): // first | |
| 1954 case (2): // first | |
| 1955 return 1; // hwOS style first | |
| 1956 case (1+4): // deco | |
| 1957 case (4): // deco | |
| 1958 return 3; // hwOS style deco | |
| 1959 case (1+8): // travel | |
| 1960 case (8): // travel | |
| 1961 return 2; // hwOS style travel | |
| 1962 default: | |
| 1963 return 0; // hwOS style Disabled | |
| 1964 } | |
| 1965 } | |
| 1966 | |
| 1967 | |
| 1968 // =============================================================================== | |
| 1969 // hwOS_to_hwOS4_GasType | |
| 1970 /// @brief Helper for set gas / diluent | |
| 1971 /// | |
| 1972 // =============================================================================== | |
| 1973 uint8_t hwOS_to_hwOS4_GasType(uint8_t inOSTC4style) | |
| 1974 { | |
| 1975 switch(inOSTC4style) | |
| 1976 { | |
| 1977 case (1): // first | |
| 1978 return 1+2; // hwOS4 style first | |
| 1979 case (2): // travel (normal for diluent) | |
| 1980 return 1+8; // hwOS4 style travel | |
| 1981 case (3): // deco | |
| 1982 return 1+4; // hwOS4 style deco | |
| 1983 default: | |
| 1984 return 0; // hwOS4 style inactive | |
| 1985 } | |
| 1986 } | |
| 1987 | |
| 1988 | |
| 1989 | |
| 1990 // =============================================================================== | |
| 1991 // setGas | |
| 1992 /// @brief This function overwrites one gas, including mode and deco depth, | |
| 1993 /// it returns 0x4D prompt which is not used by writeData() that calls it. | |
| 1994 /// | |
| 1995 /// @param i the gas id from 1 to 5 for OC and 6 to 10 for CCR, 0 is the extra gas | |
| 1996 /// @param *data 5 bytes with the first the command to call setGas and the four | |
| 1997 /// following bytes to define oxygen, helium, mode and deco depth | |
| 1998 /// | |
| 1999 /// @return 0x4D (prompt that is not used) | |
| 2000 // =============================================================================== | |
| 2001 uint8_t setGas(int i,uint8_t * data) | |
| 2002 { | |
| 2003 if(!checkValue(data[1],4,100)) | |
| 2004 return ERROR_; | |
| 2005 if(!checkValue(data[4],0,250)) | |
| 2006 return ERROR_; | |
| 2007 | |
| 2008 Settings.gas[i].oxygen_percentage = data[1]; | |
| 2009 Settings.gas[i].helium_percentage = data[2]; | |
| 2010 Settings.gas[i].note.uw = hwOS_to_hwOS4_GasType(data[3]); | |
| 2011 Settings.gas[i].depth_meter = data[4]; | |
| 2012 return 0x4d; | |
| 2013 } | |
| 2014 | |
| 2015 | |
| 2016 uint8_t getGas(int i,uint8_t * data) | |
| 2017 { | |
| 2018 data[0] = Settings.gas[i].oxygen_percentage; | |
| 2019 data[1] = Settings.gas[i].helium_percentage; | |
| 2020 data[2] = hwOS4_to_hwOS_GasType(Settings.gas[i].note.uw); | |
| 2021 data[3] = Settings.gas[i].depth_meter; | |
| 2022 return 0x4d; | |
| 2023 } | |
| 2024 | |
| 2025 uint8_t setDiluent(int i,uint8_t * data) | |
| 2026 { | |
| 2027 if(!checkValue(data[1],4,100)) | |
| 2028 return ERROR_; | |
| 2029 if(!checkValue(data[4],0,250)) | |
| 2030 return ERROR_; | |
| 2031 | |
| 2032 Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage = data[1]; | |
| 2033 Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage = data[2]; | |
| 2034 Settings.gas[NUM_OFFSET_DILUENT + i].note.uw = hwOS_to_hwOS4_GasType(data[3]); | |
| 2035 Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter = data[4]; | |
| 2036 return 0x4d; | |
| 2037 } | |
| 2038 | |
| 2039 uint8_t getDiluent(int i,uint8_t * data) | |
| 2040 { | |
| 2041 data[0] = Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage; | |
| 2042 data[1] = Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage; | |
| 2043 data[2] = hwOS4_to_hwOS_GasType(Settings.gas[NUM_OFFSET_DILUENT + i].note.uw); | |
| 2044 data[3] = Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter; | |
| 2045 return 0x4d; | |
| 2046 } | |
| 2047 | |
| 2048 uint8_t setSetpoint(int i,uint8_t * data) | |
| 2049 { | |
| 2050 if(!checkValue(data[1],50,160)) | |
| 2051 return ERROR_; | |
| 2052 if(!checkValue(data[2],0,250)) | |
| 2053 return ERROR_; | |
| 2054 | |
| 2055 Settings.setpoint[i].setpoint_cbar = data[1]; | |
| 2056 Settings.setpoint[i].depth_meter = data[2]; | |
| 2057 return 0x4d; | |
| 2058 } | |
| 2059 | |
| 2060 uint8_t getSetpoint(int i,uint8_t * data) | |
| 2061 { | |
| 2062 data[0] = Settings.setpoint[i].setpoint_cbar; | |
| 2063 data[1] = Settings.setpoint[i].depth_meter; | |
| 2064 return 0x4d; | |
| 2065 } | |
| 2066 | |
| 2067 uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to) | |
| 2068 { | |
| 2069 if(value >= from && value <= to) | |
| 2070 return 1; | |
| 2071 return 0; | |
| 2072 } | |
| 2073 | |
| 2074 uint8_t writeData(uint8_t * data) | |
| 2075 { | |
| 2076 uint32_t newSensitivity; | |
| 2077 uint16_t newDuration, newOffset; | |
| 2078 uint8_t newStopDepth; | |
| 2079 | |
| 2080 switch(data[0]) | |
| 2081 { | |
| 2082 case 0x10: | |
| 2083 return setGas(1,data); | |
| 2084 case 0x11: | |
| 2085 return setGas(2,data); | |
| 2086 case 0x12: | |
| 2087 return setGas(3,data); | |
| 2088 case 0x13: | |
| 2089 return setGas(4,data); | |
| 2090 case 0x14: | |
| 2091 return setGas(5,data); | |
| 2092 case 0x15: | |
| 2093 return setDiluent(1,data); | |
| 2094 case 0x16: | |
| 2095 return setDiluent(2,data); | |
| 2096 case 0x17: | |
| 2097 return setDiluent(3,data); | |
| 2098 case 0x18: | |
| 2099 return setDiluent(4,data); | |
| 2100 case 0x19: | |
| 2101 return setDiluent(5,data); | |
| 2102 case 0x1A: | |
| 2103 return setSetpoint(1,data); | |
| 2104 case 0x1B: | |
| 2105 return setSetpoint(2,data); | |
| 2106 case 0x1C: | |
| 2107 return setSetpoint(3,data); | |
| 2108 case 0x1D: | |
| 2109 return setSetpoint(4,data); | |
| 2110 case 0x1E: | |
| 2111 return setSetpoint(5,data); | |
| 2112 case 0x1F: | |
| 2113 if(!checkValue(data[2],0,1)) | |
| 2114 return ERROR_; | |
| 2115 Settings.CCR_Mode = data[1]; | |
| 2116 break; | |
| 2117 case 0x20: | |
| 2118 if(!checkValue(data[1],0,3)) | |
| 2119 return ERROR_; | |
| 2120 Settings.dive_mode = data[1]; | |
| 2121 break; | |
| 2122 case 0x21: | |
| 2123 if(!checkValue(data[1],1,2)) | |
| 2124 return ERROR_; | |
| 2125 Settings.deco_type.ub.standard = data[1] & 0x0F; | |
| 2126 //Settings.deco_type.ub.alternative = (data[1] & 0xF0) >> 4; | |
| 2127 break; | |
| 2128 case 0x22: | |
| 2129 if(!checkValue(data[1],100,190)) | |
| 2130 return ERROR_; | |
| 2131 Settings.ppO2_max_std = data[1]; | |
| 2132 break; | |
| 2133 case 0x23: | |
| 2134 if(!checkValue(data[1],15,15)) | |
| 2135 return ERROR_; | |
| 2136 Settings.ppO2_min = data[1]; | |
| 2137 break; | |
| 2138 case 0x24: | |
| 2139 if(!checkValue(data[1],0,15)) | |
| 2140 return ERROR_; | |
| 2141 Settings.future_TTS = data[1]; | |
| 2142 break; | |
| 2143 case 0x25: | |
| 2144 if(!checkValue(data[1],10,99)) | |
| 2145 return ERROR_; | |
| 2146 Settings.GF_low = data[1]; | |
| 2147 break; | |
| 2148 case 0x26: | |
| 2149 if(!checkValue(data[1],45,99)) | |
| 2150 return ERROR_; | |
| 2151 Settings.GF_high = data[1]; | |
| 2152 break; | |
| 2153 case 0x27: | |
| 2154 if(!checkValue(data[1],10,99)) | |
| 2155 return ERROR_; | |
| 2156 Settings.aGF_low = data[1]; | |
| 2157 break; | |
| 2158 case 0x28: | |
| 2159 if(!checkValue(data[1],45,99)) | |
| 2160 return ERROR_; | |
| 2161 Settings.aGF_high = data[1]; | |
| 2162 break; | |
| 2163 case 0x29: | |
| 2164 if(!checkValue(data[1],0,5)) | |
| 2165 return ERROR_; | |
| 2166 Settings.VPM_conservatism.ub.standard = data[1]; | |
| 2167 break; | |
| 2168 case 0x2A: | |
| 2169 case 0x2B: | |
| 2170 return ERROR_; | |
| 2171 case 0x2C: | |
| 2172 if(!checkValue(data[1],3,9)) | |
| 2173 return ERROR_; | |
| 2174 Settings.last_stop_depth_meter = data[1]; | |
| 2175 break; | |
| 2176 case 0x2D: | |
| 2177 if(!checkValue(data[1],0,4)) | |
| 2178 return ERROR_; | |
| 2179 Settings.brightness = data[1]; | |
| 2180 break; | |
| 2181 case 0x2E: | |
| 2182 if(!checkValue(data[1],0,1)) | |
| 2183 return ERROR_; | |
| 2184 Settings.nonMetricalSystem = data[1]; | |
| 2185 break; | |
| 2186 case 0x2F: | |
| 2187 return ERROR_; | |
| 2188 case 0x30: | |
| 2189 if(!checkValue(data[1],0,4)) | |
| 2190 return ERROR_; | |
| 2191 Settings.salinity = data[1]; | |
| 2192 break; | |
| 2193 case 0x31: | |
| 2194 if(!checkValue(data[1],0,3)) | |
| 2195 return ERROR_; | |
| 2196 Settings.tX_colorscheme = data[1]; | |
| 2197 GFX_use_colorscheme(Settings.tX_colorscheme); | |
| 2198 break; | |
| 2199 case 0x32: | |
| 2200 if(!checkValue(data[1],0,4)) | |
| 2201 return ERROR_; | |
| 2202 Settings.selected_language = data[1]; | |
| 2203 break; | |
| 2204 case 0x33: | |
| 2205 if(!checkValue(data[1],0,2)) | |
| 2206 return ERROR_; | |
| 2207 Settings.date_format = data[1]; | |
| 2208 break; | |
| 2209 case 0x34: | |
| 2210 return ERROR_; | |
| 2211 case 0x35: | |
| 2212 if(data[1] & 0x80) | |
| 2213 { | |
| 2214 data[1] = ~(data[1]); | |
|
337
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
2215 if(!checkValue(data[1],0,PRESSURE_OFFSET_LIMIT_MBAR)) |
| 38 | 2216 return ERROR_; |
| 2217 Settings.offsetPressure_mbar = 0 - data[1]; | |
| 2218 } | |
| 2219 else | |
| 2220 { | |
|
337
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
2221 if(!checkValue(data[1],0,PRESSURE_OFFSET_LIMIT_MBAR)) |
| 38 | 2222 return ERROR_; |
| 2223 Settings.offsetPressure_mbar = data[1]; | |
| 2224 } | |
| 2225 break; | |
| 2226 case 0x36: | |
| 2227 if(!checkValue(data[1],0,1)) | |
| 2228 return ERROR_; | |
| 2229 if(data[1]) | |
| 2230 Settings.safetystopDuration = settingsGetPointerStandard()->safetystopDuration; | |
| 2231 else | |
| 2232 Settings.safetystopDuration = 0; | |
| 2233 break; | |
| 2234 case 0x37: | |
| 2235 return ERROR_; | |
| 2236 case 0x38: | |
| 2237 if(!checkValue(data[1],0,1)) | |
| 2238 return ERROR_; | |
| 2239 Settings.fallbackToFixedSetpoint = data[1]; | |
| 2240 break; | |
| 2241 case 0x39: | |
| 2242 return ERROR_; | |
| 2243 case 0x3A: | |
| 2244 if(!checkValue(data[1],70,110)) | |
| 2245 return ERROR_; | |
| 2246 newSensitivity = data[1]; | |
| 2247 settingsHelperButtonSens_keepPercentageValues(newSensitivity, settingsGetPointer()->ButtonResponsiveness); | |
| 2248 setButtonResponsiveness(Settings.ButtonResponsiveness); | |
| 2249 break; | |
| 2250 case 0x3B: | |
| 2251 // value between 0 and 127 | |
| 2252 if(buttonBalanceTranslatorHexToArray(data[1], settingsGetPointer()->buttonBalance)) | |
| 2253 { | |
| 2254 settingsHelperButtonSens_keepPercentageValues(settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness); | |
| 2255 } | |
| 2256 else // value >= 128 (bit 7 set) factory reset | |
| 2257 { | |
| 2258 getButtonFactorDefaults(&settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->buttonBalance); | |
| 2259 settingsHelperButtonSens_keepPercentageValues(settingsGetPointerStandard()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness); | |
| 2260 } | |
| 2261 // valid for both: | |
| 2262 setButtonResponsiveness(Settings.ButtonResponsiveness); | |
| 2263 break; | |
| 2264 case 0x3C: | |
| 2265 if(!checkValue(data[1],5,50)) | |
| 2266 return ERROR_; | |
| 2267 Settings.gasConsumption_bottom_l_min = data[1]; | |
| 2268 break; | |
| 2269 case 0x3D: | |
| 2270 if(!checkValue(data[1],5,50)) | |
| 2271 return ERROR_; | |
| 2272 Settings.gasConsumption_deco_l_min = data[1]; | |
| 2273 break; | |
| 2274 case 0x3E: | |
| 2275 if(!checkValue(data[1],5,50)) | |
| 2276 return ERROR_; | |
| 2277 Settings.gasConsumption_travel_l_min = data[1]; | |
| 2278 break; | |
| 2279 case 0x3F: | |
| 2280 case 0x40: | |
| 2281 return ERROR_; | |
| 2282 case 0x41: | |
| 2283 if(!checkValue(data[1],0,1)) | |
| 2284 return ERROR_; | |
| 2285 Settings.alwaysShowPPO2 = data[1]; | |
| 2286 break; | |
| 2287 case 0x42: | |
| 2288 if(data[1] & 0x80) | |
| 2289 { | |
| 2290 data[1] = ~(data[1]); | |
| 2291 if(!checkValue(data[1],0,20)) | |
| 2292 return ERROR_; | |
| 2293 Settings.offsetTemperature_centigrad = 0 - data[1]; | |
| 2294 } | |
| 2295 else | |
| 2296 { | |
| 2297 if(!checkValue(data[1],0,20)) | |
| 2298 return ERROR_; | |
| 2299 Settings.offsetTemperature_centigrad = data[1]; | |
| 2300 } | |
| 2301 break; | |
| 2302 case 0x43: | |
| 2303 if(!checkValue(data[1],60,255)) | |
| 2304 return ERROR_; | |
| 2305 newDuration = (uint16_t)data[1] + 59; | |
| 2306 newDuration /= 60; | |
| 2307 Settings.safetystopDuration = (uint8_t)newDuration; | |
| 2308 break; | |
| 2309 case 0x44: | |
| 2310 if(!checkValue(data[1],21,61)) | |
| 2311 return ERROR_; | |
| 2312 newStopDepth = data[1] + 9; | |
| 2313 if(newStopDepth > 60) | |
| 2314 newStopDepth = 60; | |
| 2315 newStopDepth /= 10; | |
| 2316 Settings.safetystopDepth = newStopDepth; | |
| 2317 break; | |
| 2318 case 0x45: | |
| 2319 case 0x46: | |
| 2320 return ERROR_; | |
| 2321 case 0x47: | |
| 2322 newOffset = data[2] * 256; | |
| 2323 newOffset += data[1]; | |
| 2324 if(newOffset > 9000) | |
| 2325 return ERROR_; | |
| 2326 Settings.logbookOffset = newOffset; | |
| 2327 break; | |
| 2328 case 0x70: | |
| 2329 if(!checkValue(data[1],0,1)) | |
| 2330 return ERROR_; | |
| 2331 Settings.showDebugInfo = data[1]; | |
| 2332 break; | |
| 2333 case 0x71: | |
| 2334 if(!checkValue(data[1],0,(EXTRADISPLAY_END - 1))) | |
| 2335 return ERROR_; | |
| 2336 Settings.extraDisplay = data[1]; | |
| 2337 break; | |
| 2338 case 0x72: | |
| 2339 if(!checkValue(data[1],0,8)) | |
| 2340 return ERROR_; | |
| 2341 Settings.tX_customViewPrimary = data[1]; | |
| 2342 break; | |
| 2343 case 0x73: | |
| 2344 if(!checkValue(data[1],0,20)) | |
| 2345 return ERROR_; | |
| 2346 Settings.tX_customViewTimeout = data[1]; | |
| 2347 break; | |
| 2348 case 0x74: | |
| 2349 if(!checkValue(data[1],1,7)) | |
| 2350 return ERROR_; | |
| 2351 Settings.tX_userselectedLeftLowerCornerPrimary = data[1]; | |
| 2352 break; | |
| 2353 case 0x75: | |
| 2354 if(!checkValue(data[1],0,20)) | |
| 2355 return ERROR_; | |
| 2356 Settings.tX_userselectedLeftLowerCornerTimeout = data[1]; | |
| 2357 break; | |
| 2358 } | |
| 2359 return 0; | |
| 2360 } | |
| 2361 | |
| 2362 | |
| 2363 uint8_t readDataLimits__8and16BitValues_4and7BytesOutput(uint8_t what, uint8_t * data) | |
| 2364 { | |
| 2365 enum JeanDoParameterType { | |
| 2366 PARAM_UNKNOWN = 0, | |
| 2367 PARAM_INT15 = 1, | |
| 2368 PARAM_INT8, | |
| 2369 PARAM_DECI, | |
| 2370 PARAM_CENTI, | |
| 2371 PARAM_MILI, | |
| 2372 PARAM_PERCENT, | |
| 2373 PARAM_SEC, | |
| 2374 PARAM_COLOR, | |
| 2375 PARAM_BOOL, | |
| 2376 PARAM_ENUM, | |
| 2377 PARAM_SIGNED = 128, | |
| 2378 PARAM_SDECI = PARAM_SIGNED|PARAM_DECI, | |
| 2379 PARAM_SSEC = PARAM_SIGNED|PARAM_SEC, | |
| 2380 PARAM_SINT = PARAM_SIGNED|PARAM_INT8 | |
| 2381 }; | |
| 2382 | |
| 2383 // uint32_t buttonSensitivity; | |
| 2384 uint16_t newDuration; | |
| 2385 | |
| 2386 uint8_t datacounter = 0; | |
| 2387 | |
| 2388 data[0] = 0; | |
| 2389 data[1] = 0; | |
| 2390 data[2] = 0; | |
| 2391 data[3] = 0; | |
| 2392 datacounter = 0; | |
| 2393 | |
| 2394 switch(what) | |
| 2395 { | |
| 2396 case 0x10: | |
| 2397 case 0x11: | |
| 2398 case 0x12: | |
| 2399 case 0x13: | |
| 2400 case 0x14: | |
| 2401 data[datacounter++] = PARAM_INT8; | |
| 2402 data[datacounter++] = 4; | |
| 2403 data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage; | |
| 2404 data[datacounter++] = 100; | |
| 2405 break; | |
| 2406 | |
| 2407 case 0x15: | |
| 2408 case 0x16: | |
| 2409 case 0x17: | |
| 2410 case 0x18: | |
| 2411 case 0x19: | |
| 2412 data[datacounter++] = PARAM_INT8; | |
| 2413 data[datacounter++] = 4; | |
| 2414 data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage; | |
| 2415 data[datacounter++] = 100; | |
| 2416 break; | |
| 2417 | |
| 2418 case 0x1A: | |
| 2419 case 0x1B: | |
| 2420 case 0x1C: | |
| 2421 case 0x1D: | |
| 2422 case 0x1E: | |
| 2423 data[datacounter++] = PARAM_CENTI; | |
| 2424 data[datacounter++] = 50; | |
| 2425 data[datacounter++] = settingsGetPointerStandard()->setpoint[1].setpoint_cbar; | |
| 2426 data[datacounter++] = 160; | |
| 2427 break; | |
| 2428 | |
| 2429 case 0x1F: | |
| 2430 data[datacounter++] = PARAM_ENUM; | |
| 2431 data[datacounter++] = 0; | |
| 2432 data[datacounter++] = settingsGetPointerStandard()->CCR_Mode; | |
| 2433 data[datacounter++] = 1; | |
| 2434 break; | |
| 2435 | |
| 2436 case 0x20: | |
| 2437 data[datacounter++] = PARAM_ENUM; | |
| 2438 data[datacounter++] = 0; | |
| 2439 data[datacounter++] = settingsGetPointerStandard()->dive_mode; | |
| 2440 data[datacounter++] = 3; | |
| 2441 break; | |
| 2442 | |
| 2443 case 0x21: | |
| 2444 data[datacounter++] = PARAM_ENUM; | |
| 2445 data[datacounter++] = 1; | |
| 2446 data[datacounter++] = settingsGetPointerStandard()->deco_type.ub.standard; | |
| 2447 data[datacounter++] = 2; | |
| 2448 break; | |
| 2449 | |
| 2450 case 0x22: | |
| 2451 data[datacounter++] = PARAM_CENTI; | |
| 2452 data[datacounter++] = 100; | |
| 2453 data[datacounter++] = settingsGetPointerStandard()->ppO2_max_std; | |
| 2454 data[datacounter++] = 190; | |
| 2455 break; | |
| 2456 | |
| 2457 case 0x23: | |
| 2458 data[datacounter++] = PARAM_CENTI; | |
| 2459 data[datacounter++] = 15; | |
| 2460 data[datacounter++] = settingsGetPointerStandard()->ppO2_min; | |
| 2461 data[datacounter++] = 15; | |
| 2462 break; | |
| 2463 | |
| 2464 case 0x24: | |
| 2465 data[datacounter++] = PARAM_INT8; // minutes | |
| 2466 data[datacounter++] = 0; | |
| 2467 data[datacounter++] = settingsGetPointerStandard()->future_TTS; | |
| 2468 data[datacounter++] = 15; | |
| 2469 break; | |
| 2470 | |
| 2471 case 0x25: | |
| 2472 data[datacounter++] = PARAM_PERCENT; | |
| 2473 data[datacounter++] = 10; | |
| 2474 data[datacounter++] = settingsGetPointerStandard()->GF_low; | |
| 2475 data[datacounter++] = 99; | |
| 2476 break; | |
| 2477 | |
| 2478 case 0x26: | |
| 2479 data[datacounter++] = PARAM_PERCENT; | |
| 2480 data[datacounter++] = 45; | |
| 2481 data[datacounter++] = settingsGetPointerStandard()->GF_high; | |
| 2482 data[datacounter++] = 99; | |
| 2483 break; | |
| 2484 | |
| 2485 case 0x27: | |
| 2486 data[datacounter++] = PARAM_PERCENT; | |
| 2487 data[datacounter++] = 10; | |
| 2488 data[datacounter++] = settingsGetPointerStandard()->aGF_low; | |
| 2489 data[datacounter++] = 99; | |
| 2490 break; | |
| 2491 | |
| 2492 case 0x28: | |
| 2493 data[datacounter++] = PARAM_PERCENT; | |
| 2494 data[datacounter++] = 45; | |
| 2495 data[datacounter++] = settingsGetPointerStandard()->aGF_high; | |
| 2496 data[datacounter++] = 99; | |
| 2497 break; | |
| 2498 | |
| 2499 case 0x29: | |
| 2500 data[datacounter++] = PARAM_INT8; // conservatism +0 .. +5 | |
| 2501 data[datacounter++] = 0; | |
| 2502 data[datacounter++] = settingsGetPointerStandard()->VPM_conservatism.ub.standard; | |
| 2503 data[datacounter++] = 5; | |
| 2504 break; | |
| 2505 | |
| 2506 case 0x2A: | |
| 2507 case 0x2B: | |
| 2508 data[datacounter++] = PARAM_PERCENT; | |
| 2509 data[datacounter++] = 100; | |
| 2510 data[datacounter++] = 100;// saturation, desaturation, settingsGetPointerStandard()->; | |
| 2511 data[datacounter++] = 100; | |
| 2512 break; | |
| 2513 | |
| 2514 case 0x2C: | |
| 2515 data[datacounter++] = PARAM_INT8; | |
| 2516 data[datacounter++] = 3; | |
| 2517 data[datacounter++] = settingsGetPointerStandard()->last_stop_depth_meter; | |
| 2518 data[datacounter++] = 9; | |
| 2519 break; | |
| 2520 | |
| 2521 case 0x2D: | |
| 2522 data[datacounter++] = PARAM_ENUM; | |
| 2523 data[datacounter++] = 0; | |
| 2524 data[datacounter++] = settingsGetPointerStandard()->brightness; | |
| 2525 data[datacounter++] = 4; | |
| 2526 break; | |
| 2527 | |
| 2528 case 0x2E: | |
| 2529 data[datacounter++] = PARAM_ENUM; | |
| 2530 data[datacounter++] = 0; | |
| 2531 data[datacounter++] = settingsGetPointerStandard()->nonMetricalSystem; | |
| 2532 data[datacounter++] = 1; | |
| 2533 break; | |
| 2534 | |
| 2535 case 0x2F: | |
| 2536 data[datacounter++] = PARAM_INT8; // Sampling rate logbook | |
| 2537 data[datacounter++] = 2; | |
| 2538 data[datacounter++] = 2; | |
| 2539 data[datacounter++] = 2; | |
| 2540 break; | |
| 2541 | |
| 2542 case 0x30: | |
| 2543 data[datacounter++] = PARAM_PERCENT; | |
| 2544 data[datacounter++] = 0; | |
| 2545 data[datacounter++] = settingsGetPointerStandard()->salinity; | |
| 2546 data[datacounter++] = 4; | |
| 2547 break; | |
| 2548 | |
| 2549 case 0x31: | |
| 2550 data[datacounter++] = PARAM_INT8; | |
| 2551 data[datacounter++] = 0; | |
| 2552 data[datacounter++] = settingsGetPointerStandard()->tX_colorscheme; | |
| 2553 data[datacounter++] = 3; | |
| 2554 break; | |
| 2555 | |
| 2556 case 0x32: | |
| 2557 data[datacounter++] = PARAM_ENUM; | |
| 2558 data[datacounter++] = 0; | |
| 2559 data[datacounter++] = settingsGetPointerStandard()->selected_language; | |
| 2560 data[datacounter++] = 1; | |
| 2561 break; | |
| 2562 | |
| 2563 case 0x33: | |
| 2564 data[datacounter++] = PARAM_ENUM; | |
| 2565 data[datacounter++] = 0; | |
| 2566 data[datacounter++] = settingsGetPointerStandard()->date_format; | |
| 2567 data[datacounter++] = 2; | |
| 2568 break; | |
| 2569 | |
| 2570 case 0x34: | |
| 2571 data[datacounter++] = PARAM_UNKNOWN ; | |
| 2572 data[datacounter++] = 0; | |
| 2573 data[datacounter++] = 0; // compass gain, is unknown,, settingsGetPointerStandard()->; | |
| 2574 data[datacounter++] = 0; | |
| 2575 break; | |
| 2576 | |
| 2577 case 0x35: | |
| 2578 data[datacounter++] = PARAM_SINT; | |
|
337
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
2579 data[datacounter++] = (uint8_t)(256 - PRESSURE_OFFSET_LIMIT_MBAR); // == -20 |
| 38 | 2580 if(settingsGetPointerStandard()->offsetPressure_mbar < 0) |
| 2581 data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetPressure_mbar); | |
| 2582 else | |
| 2583 data[datacounter++] = settingsGetPointerStandard()->offsetPressure_mbar; | |
|
337
38367bb982b8
Set Max value for pressure offset to 50mBar (20mBar before)
ideenmodellierer
parents:
334
diff
changeset
|
2584 data[datacounter++] = PRESSURE_OFFSET_LIMIT_MBAR; |
| 38 | 2585 break; |
| 2586 | |
| 2587 case 0x36: | |
| 2588 data[datacounter++] = PARAM_BOOL; | |
| 2589 data[datacounter++] = 0; | |
| 2590 if(settingsGetPointerStandard()->safetystopDuration) | |
| 2591 data[datacounter++] = 1; | |
| 2592 else | |
| 2593 data[datacounter++] = 0; | |
| 2594 data[datacounter++] = 1; | |
| 2595 break; | |
| 2596 | |
| 2597 case 0x37: | |
| 2598 data[datacounter++] = PARAM_UNKNOWN ; | |
| 2599 data[datacounter++] = 0; | |
| 2600 data[datacounter++] = 0; // Set calibration gas, not possible with optical | |
| 2601 data[datacounter++] = 0; | |
| 2602 break; | |
| 2603 | |
| 2604 case 0x38: | |
| 2605 data[datacounter++] = PARAM_BOOL; | |
| 2606 data[datacounter++] = 0; | |
| 2607 data[datacounter++] = settingsGetPointerStandard()->fallbackToFixedSetpoint; | |
| 2608 data[datacounter++] = 1; | |
| 2609 break; | |
| 2610 | |
| 2611 case 0x39: | |
| 2612 data[datacounter++] = PARAM_BOOL; | |
| 2613 data[datacounter++] = 0; | |
| 2614 data[datacounter++] = 0; // flipscreen, not yet :-) settingsGetPointerStandard()->; | |
| 2615 data[datacounter++] = 0; | |
| 2616 break; | |
| 2617 | |
| 2618 case 0x3A: | |
| 2619 data[datacounter++] = PARAM_PERCENT; | |
| 2620 data[datacounter++] = 70; | |
| 2621 data[datacounter++] = settingsGetPointerStandard()->ButtonResponsiveness[3]; | |
| 2622 data[datacounter++] = 110; | |
| 2623 break; | |
| 2624 | |
| 2625 case 0x3B: | |
| 2626 data[datacounter++] = PARAM_UNKNOWN; | |
| 2627 data[datacounter++] = 0; | |
| 2628 data[datacounter++] = buttonBalanceTranslateArrayOutHex(settingsGetPointerStandard()->buttonBalance); | |
| 2629 data[datacounter++] = 128; | |
| 2630 break; | |
| 2631 | |
| 2632 case 0x3C: | |
| 2633 data[datacounter++] = PARAM_INT8; | |
| 2634 data[datacounter++] = 5; | |
| 2635 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_bottom_l_min; | |
| 2636 data[datacounter++] = 50; | |
| 2637 break; | |
| 2638 | |
| 2639 case 0x3D: | |
| 2640 data[datacounter++] = PARAM_INT8; | |
| 2641 data[datacounter++] = 5; | |
| 2642 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_deco_l_min; | |
| 2643 data[datacounter++] = 50; | |
| 2644 break; | |
| 2645 | |
| 2646 case 0x3E: | |
| 2647 data[datacounter++] = PARAM_INT8; | |
| 2648 data[datacounter++] = 5; | |
| 2649 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_travel_l_min; | |
| 2650 data[datacounter++] = 50; | |
| 2651 break; | |
| 2652 | |
| 2653 case 0x3F: | |
| 2654 data[datacounter++] = PARAM_UNKNOWN; | |
| 2655 data[datacounter++] = 0; | |
| 2656 data[datacounter++] = 0; // Dynamic ascend rate, not yet :-) settingsGetPointerStandard()->; | |
| 2657 data[datacounter++] = 0; | |
| 2658 break; | |
| 2659 | |
| 2660 case 0x40: | |
| 2661 data[datacounter++] = PARAM_BOOL; | |
| 2662 data[datacounter++] = 1; | |
| 2663 data[datacounter++] = 1; // Graphical speed indicator; | |
| 2664 data[datacounter++] = 1; | |
| 2665 break; | |
| 2666 | |
| 2667 case 0x41: | |
| 2668 data[datacounter++] = PARAM_BOOL; | |
| 2669 data[datacounter++] = 0; | |
| 2670 data[datacounter++] = settingsGetPointerStandard()->alwaysShowPPO2; | |
| 2671 data[datacounter++] = 1; | |
| 2672 break; | |
| 2673 | |
| 2674 case 0x42: | |
| 2675 data[datacounter++] = PARAM_SIGNED|PARAM_CENTI; | |
| 2676 data[datacounter++] = (uint8_t)(256 - 20); // == -20 | |
| 2677 if(settingsGetPointerStandard()->offsetTemperature_centigrad < 0) | |
| 2678 data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetTemperature_centigrad); | |
| 2679 else | |
| 2680 data[datacounter++] = settingsGetPointerStandard()->offsetTemperature_centigrad; | |
| 2681 data[datacounter++] = 20; | |
| 2682 break; | |
| 2683 | |
| 2684 case 0x43: | |
| 2685 newDuration = settingsGetPointerStandard()->safetystopDuration; | |
| 2686 newDuration *= 60; | |
| 2687 if(newDuration > 255) | |
| 2688 newDuration = 255; | |
| 2689 data[datacounter++] = PARAM_INT8; | |
| 2690 data[datacounter++] = 60; // coud be 1 minute instead | |
| 2691 data[datacounter++] = (uint8_t)newDuration; | |
| 2692 data[datacounter++] = 255; // could be 5 minutes instead | |
| 2693 break; | |
| 2694 | |
| 2695 case 0x44: | |
| 2696 data[datacounter++] = PARAM_INT8; | |
| 2697 data[datacounter++] = 30; // coud be 3 meter instead | |
| 2698 data[datacounter++] = settingsGetPointerStandard()->safetystopDepth * 10; | |
| 2699 data[datacounter++] = 60; // could be 6 meter instead | |
| 2700 break; | |
| 2701 | |
| 2702 case 0x45: | |
| 2703 case 0x46: | |
| 2704 data[datacounter++] = PARAM_UNKNOWN; | |
| 2705 data[datacounter++] = 0; | |
| 2706 data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth | |
| 2707 data[datacounter++] = 0; | |
| 2708 break; | |
| 2709 | |
| 2710 case 0x47: | |
| 2711 data[datacounter++] = PARAM_INT15; | |
| 2712 data[datacounter++] = 0; | |
| 2713 data[datacounter++] = 0; | |
| 2714 data[datacounter++] = settingsGetPointerStandard()->logbookOffset & 0xFF; | |
| 2715 data[datacounter++] = settingsGetPointerStandard()->logbookOffset / 0xFF; | |
| 2716 data[datacounter++] = 9000 & 0xFF; | |
| 2717 data[datacounter++] = 9000 / 0xFF; | |
| 2718 break; | |
| 2719 | |
| 2720 case 0x70: | |
| 2721 data[datacounter++] = PARAM_BOOL; | |
| 2722 data[datacounter++] = 0; | |
| 2723 data[datacounter++] = settingsGetPointerStandard()->showDebugInfo; | |
| 2724 data[datacounter++] = 1; | |
| 2725 break; | |
| 2726 | |
| 2727 case 0x71: | |
| 2728 data[datacounter++] = PARAM_ENUM; | |
| 2729 data[datacounter++] = 0; | |
| 2730 data[datacounter++] = settingsGetPointerStandard()->extraDisplay; | |
| 2731 data[datacounter++] = (EXTRADISPLAY_END - 1); | |
| 2732 break; | |
| 2733 | |
| 2734 case 0x72: | |
| 2735 data[datacounter++] = PARAM_ENUM; | |
| 2736 data[datacounter++] = 0; | |
| 2737 data[datacounter++] = settingsGetPointerStandard()->tX_customViewPrimary; | |
| 2738 data[datacounter++] = 8; | |
| 2739 break; | |
| 2740 | |
| 2741 case 0x73: | |
| 2742 data[datacounter++] = PARAM_INT8; | |
| 2743 data[datacounter++] = 0; | |
| 2744 data[datacounter++] = settingsGetPointerStandard()->tX_customViewTimeout; | |
| 2745 data[datacounter++] = 60; | |
| 2746 break; | |
| 2747 | |
| 2748 case 0x74: | |
| 2749 data[datacounter++] = PARAM_ENUM; | |
| 2750 data[datacounter++] = 1; | |
| 2751 data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerPrimary; | |
| 2752 data[datacounter++] = 7; | |
| 2753 break; | |
| 2754 | |
| 2755 case 0x75: | |
| 2756 data[datacounter++] = PARAM_INT8; | |
| 2757 data[datacounter++] = 0; | |
| 2758 data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerTimeout; | |
| 2759 data[datacounter++] = 60; | |
| 2760 break; | |
| 2761 } | |
| 2762 | |
| 2763 if(datacounter == 0) | |
| 2764 { | |
| 2765 data[datacounter++] = PARAM_UNKNOWN; | |
| 2766 data[datacounter++] = 0; | |
| 2767 data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth | |
| 2768 data[datacounter++] = 0; | |
| 2769 } | |
| 2770 | |
| 2771 return datacounter; | |
| 2772 } | |
| 2773 | |
| 2774 | |
| 2775 uint8_t readData(uint8_t what, uint8_t * data) | |
| 2776 { | |
| 2777 data[0] = 0; | |
| 2778 data[1] = 0; | |
| 2779 data[2] = 0; | |
| 2780 data[3] = 0; | |
| 2781 switch(what) | |
| 2782 { | |
| 2783 case 0x10: | |
| 2784 return getGas(1,data); | |
| 2785 case 0x11: | |
| 2786 return getGas(2,data); | |
| 2787 case 0x12: | |
| 2788 return getGas(3,data); | |
| 2789 case 0x13: | |
| 2790 return getGas(4,data); | |
| 2791 case 0x14: | |
| 2792 return getGas(5,data); | |
| 2793 case 0x15: | |
| 2794 return getDiluent(1,data); | |
| 2795 case 0x16: | |
| 2796 return getDiluent(2,data); | |
| 2797 case 0x17: | |
| 2798 return getDiluent(3,data); | |
| 2799 case 0x18: | |
| 2800 return getDiluent(4,data); | |
| 2801 case 0x19: | |
| 2802 return getDiluent(5,data); | |
| 2803 case 0x1A: | |
| 2804 return getSetpoint(1,data); | |
| 2805 case 0x1B: | |
| 2806 return getSetpoint(2,data); | |
| 2807 case 0x1C: | |
| 2808 return getSetpoint(3,data); | |
| 2809 case 0x1D: | |
| 2810 return getSetpoint(4,data); | |
| 2811 case 0x1E: | |
| 2812 return getSetpoint(5,data); | |
| 2813 case 0x1F: | |
| 2814 data[0] = Settings.CCR_Mode; | |
| 2815 break; | |
| 2816 case 0x20: | |
| 2817 data[0] = Settings.dive_mode; | |
| 2818 break; | |
| 2819 case 0x21: | |
| 2820 data[0] = Settings.deco_type.ub.standard; | |
| 2821 break; | |
| 2822 case 0x22: | |
| 2823 data[0] = Settings.ppO2_max_std; | |
| 2824 break; | |
| 2825 case 0x23: | |
| 2826 data[0] = Settings.ppO2_min; | |
| 2827 break; | |
| 2828 case 0x24: | |
| 2829 data[0] = Settings.future_TTS; | |
| 2830 break; | |
| 2831 case 0x25: | |
| 2832 data[0] = Settings.GF_low; | |
| 2833 break; | |
| 2834 case 0x26: | |
| 2835 data[0] = Settings.GF_high; | |
| 2836 break; | |
| 2837 case 0x27: | |
| 2838 data[0] = Settings.aGF_low; | |
| 2839 break; | |
| 2840 case 0x28: | |
| 2841 data[0] = Settings.aGF_high; | |
| 2842 break; | |
| 2843 case 0x29: | |
| 2844 data[0] = Settings.VPM_conservatism.ub.standard; | |
| 2845 break; | |
| 2846 case 0x2A: | |
| 2847 case 0x2B: | |
| 2848 data[0] = 100; | |
| 2849 break; | |
| 2850 case 0x2C: | |
| 2851 data[0] = Settings.last_stop_depth_meter; | |
| 2852 break; | |
| 2853 case 0x2D: | |
| 2854 data[0] = Settings.brightness; | |
| 2855 break; | |
| 2856 case 0x2E: | |
| 2857 data[0] = Settings.nonMetricalSystem; | |
| 2858 break; | |
| 2859 case 0x2F: | |
| 2860 data[0] = 0; // 0 == 2 sec sampling rate | |
| 2861 break; | |
| 2862 case 0x30: | |
| 2863 data[0] = Settings.salinity; | |
| 2864 break; | |
| 2865 case 0x31: | |
| 2866 data[0] = Settings.tX_colorscheme; | |
| 2867 break; | |
| 2868 case 0x32: | |
| 2869 data[0] = Settings.selected_language; | |
| 2870 break; | |
| 2871 case 0x33: | |
| 2872 data[0] = Settings.date_format; | |
| 2873 break; | |
| 2874 case 0x34: | |
| 2875 data[0] = 7; // gain should be always 7 as far as I understand the code in RTE | |
| 2876 break; | |
| 2877 case 0x35: | |
| 2878 data[0] = Settings.offsetPressure_mbar; | |
| 2879 break; | |
| 2880 case 0x36: | |
| 2881 if(Settings.safetystopDepth) | |
| 2882 data[0] = 1; | |
| 2883 else | |
| 2884 data[0] = 0; | |
| 2885 break; | |
| 2886 case 0x37: | |
| 2887 data[0] = 0; // calibration gas %O2 -> 0 no gas :-) | |
| 2888 break; | |
| 2889 case 0x38: | |
| 2890 data[0] = Settings.fallbackToFixedSetpoint; | |
| 2891 break; | |
| 2892 case 0x39: | |
| 2893 data[0] = 0; // flip screen | |
| 2894 break; | |
| 2895 case 0x3A: | |
| 2896 data[0] = Settings.ButtonResponsiveness[3]; | |
| 2897 break; | |
| 2898 case 0x3B: | |
| 2899 data[0] = buttonBalanceTranslateArrayOutHex(settingsGetPointer()->buttonBalance); | |
| 2900 break; | |
| 2901 case 0x3C: | |
| 2902 data[0] = Settings.gasConsumption_bottom_l_min; | |
| 2903 break; | |
| 2904 case 0x3D: | |
| 2905 data[0] = Settings.gasConsumption_deco_l_min; | |
| 2906 break; | |
| 2907 case 0x3E: | |
| 2908 data[0] = Settings.gasConsumption_travel_l_min; | |
| 2909 break; | |
| 2910 case 0x3F: | |
| 2911 data[0] = 0; // fixed ascend rate 10 m/min | |
| 2912 break; | |
| 2913 case 0x40: | |
| 2914 data[0] = 1; // graphical speed indicator | |
| 2915 break; | |
| 2916 case 0x41: | |
| 2917 data[0] = Settings.alwaysShowPPO2; | |
| 2918 break; | |
| 2919 case 0x42: | |
| 2920 data[0] = Settings.offsetTemperature_centigrad; | |
| 2921 break; | |
| 2922 case 0x43: | |
| 2923 if(Settings.safetystopDuration > 4) | |
| 2924 data[0] = 255; // seconds | |
| 2925 else | |
| 2926 data[0] = 60 * Settings.safetystopDuration; | |
| 2927 break; | |
| 2928 case 0x44: | |
| 2929 data[0] = Settings.safetystopDepth * 10; // cbar instead of meter | |
| 2930 break; | |
| 2931 case 0x45: | |
| 2932 if(Settings.safetystopDepth == 3) | |
| 2933 data[0] = 20; // cbar | |
| 2934 else | |
| 2935 data[0] = 30; // cbar | |
| 2936 break; | |
| 2937 case 0x46: | |
| 2938 data[0] = 10; // reset at 10 meter as far as I understood | |
| 2939 break; | |
| 2940 case 0x47: | |
| 2941 data[0] = Settings.logbookOffset & 0xFF; | |
| 2942 data[1] = Settings.logbookOffset / 0xFF; | |
| 2943 break; | |
| 2944 case 0x70: | |
| 2945 data[0] = Settings.showDebugInfo; | |
| 2946 break; | |
| 2947 case 0x71: | |
| 2948 data[0] = Settings.extraDisplay; | |
| 2949 break; | |
| 2950 case 0x72: | |
| 2951 data[0] = Settings.tX_customViewPrimary; | |
| 2952 break; | |
| 2953 case 0x73: | |
| 2954 data[0] = Settings.tX_customViewTimeout; | |
| 2955 break; | |
| 2956 case 0x74: | |
| 2957 data[0] = Settings.tX_userselectedLeftLowerCornerPrimary; | |
| 2958 break; | |
| 2959 case 0x75: | |
| 2960 data[0] = Settings.tX_userselectedLeftLowerCornerTimeout; | |
| 2961 break; | |
| 2962 } | |
| 2963 return 0x4D; | |
| 2964 } | |
| 2965 | |
| 2966 | |
| 2967 uint8_t RTEminimum_required_high(void) | |
| 2968 { | |
| 2969 return RTErequiredHigh; | |
| 2970 } | |
| 2971 uint8_t RTEminimum_required_low(void) | |
| 2972 { | |
| 2973 return RTErequiredLow; | |
| 2974 } | |
| 2975 | |
| 2976 uint8_t FONTminimum_required_high(void) | |
| 2977 { | |
| 2978 return FONTrequiredHigh; | |
| 2979 } | |
| 2980 uint8_t FONTminimum_required_low(void) | |
| 2981 { | |
| 2982 return FONTrequiredLow; | |
| 2983 } | |
| 2984 | |
| 2985 | |
| 2986 void setActualRTEversion(uint8_t high, uint8_t low) | |
| 2987 { | |
| 2988 RTEactualHigh = high; | |
| 2989 RTEactualLow = low; | |
| 2990 } | |
| 2991 | |
| 2992 | |
| 2993 void getActualRTEandFONTversion(uint8_t *RTEhigh, uint8_t *RTElow, uint8_t *FONThigh, uint8_t *FONTlow) | |
| 2994 { | |
| 2995 if(RTEhigh && RTElow) | |
| 2996 { | |
| 2997 *RTEhigh = RTEactualHigh; | |
| 2998 *RTElow = RTEactualLow; | |
| 2999 } | |
| 3000 if(FONThigh && FONTlow) | |
| 3001 { | |
| 3002 *FONThigh = *(uint8_t *)0x08132000; | |
| 3003 *FONTlow = *(uint8_t *)0x08132001; | |
| 3004 } | |
| 3005 } | |
| 3006 | |
| 3007 | |
| 3008 uint8_t getLicence(void) | |
| 3009 { | |
| 3010 return hardwareDataGetPointer()->primaryLicence; | |
| 3011 } | |
| 3012 | |
| 3013 | |
| 3014 void firmwareGetDate(RTC_DateTypeDef *SdateOutput) | |
| 3015 { | |
| 3016 SdateOutput->Year = firmwareDataGetPointer()->release_year; | |
| 3017 SdateOutput->Month = firmwareDataGetPointer()->release_month; | |
| 3018 SdateOutput->Date = firmwareDataGetPointer()->release_day; | |
| 3019 } | |
| 3020 | |
| 3021 | |
| 3022 // this should use device specific values stored in OTPROG ROM soon | |
| 3023 void getButtonFactorDefaults(uint8_t* basePercentage, uint8_t* buttonBalanceArray) | |
| 3024 { | |
| 3025 *basePercentage = settingsGetPointerStandard()->ButtonResponsiveness[3]; | |
| 3026 | |
| 3027 for(int i=0;i<3;i++) | |
| 3028 { | |
| 3029 buttonBalanceArray[i] = settingsGetPointerStandard()->buttonBalance[i]; | |
| 3030 } | |
| 3031 } | |
| 3032 | |
| 3033 | |
| 3034 uint8_t buttonBalanceTranslatorHexToArray(uint8_t hexValue, uint8_t* outputArray) | |
| 3035 { | |
| 3036 if(hexValue > 127) | |
| 3037 return 0; | |
| 3038 // internal order: 0 = right, 1 = center, 2 = left | |
| 3039 // external order: Factory,left,center,right | |
| 3040 outputArray[0] = 2 + (hexValue & 0x03); | |
| 3041 hexValue /= 4; | |
| 3042 outputArray[1] = 2 + (hexValue & 0x03); | |
| 3043 hexValue /= 4; | |
| 3044 outputArray[2] = 2 + (hexValue & 0x03); | |
| 3045 | |
| 3046 return 1; | |
| 3047 } | |
| 3048 | |
| 3049 | |
| 3050 uint8_t buttonBalanceTranslateArrayOutHex(const uint8_t* inputArray) | |
| 3051 { | |
| 3052 uint8_t hexValue = 0; | |
| 3053 | |
| 3054 if(inputArray[2] > 2) | |
| 3055 { | |
| 3056 hexValue += inputArray[2] - 2; | |
| 3057 } | |
| 3058 hexValue *= 4; | |
| 3059 | |
| 3060 if(inputArray[1] > 2) | |
| 3061 { | |
| 3062 hexValue += inputArray[1] - 2; | |
| 3063 } | |
| 3064 hexValue *= 4; | |
| 3065 if(inputArray[0] > 2) | |
| 3066 { | |
| 3067 hexValue += inputArray[0] - 2; | |
| 3068 } | |
| 3069 return hexValue; | |
| 3070 } | |
| 3071 | |
| 3072 void settingsWriteFactoryDefaults(uint8_t inputValueRaw, uint8_t *inputBalanceArray) | |
| 3073 { | |
| 3074 if((inputValueRaw >= 70) && (inputValueRaw <= 110)) | |
| 3075 { | |
| 3076 Settings.FactoryButtonBase = inputValueRaw; | |
| 3077 } | |
| 3078 for(int i=0;i<3;i++) | |
| 3079 { | |
| 3080 if((inputBalanceArray[i] >= 2) && (inputBalanceArray[i] <= 5)) | |
| 3081 { | |
| 3082 Settings.FactoryButtonBalance[i] = inputBalanceArray[i]; | |
| 3083 } | |
| 3084 } | |
| 3085 } | |
| 3086 | |
| 3087 | |
| 3088 /** | |
| 3089 ****************************************************************************** | |
| 3090 * @brief settingsHelperButtonSens. / make 32 bit input to three buttons + storage value in [3] | |
| 3091 * @author heinrichs weikamp gmbh | |
| 3092 * @version V 01 | |
| 3093 * @date 19-Sept-2016 | |
| 3094 ****************************************************************************** | |
| 3095 * | |
| 3096 * @param inputValueRaw: | |
| 3097 * @param outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance | |
| 3098 * @retval None | |
| 3099 */ | |
| 3100 void settingsHelperButtonSens_keepPercentageValues(uint32_t inputValueRaw, uint8_t *outArray4Values) | |
| 3101 { | |
| 3102 uint32_t newSensitivity; | |
| 3103 | |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3104 if(inputValueRaw > MAX_BUTTONRESPONSIVENESS) |
| 38 | 3105 { |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3106 inputValueRaw = MAX_BUTTONRESPONSIVENESS; |
| 38 | 3107 } |
| 3108 else | |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3109 if(inputValueRaw < MIN_BUTTONRESPONSIVENESS) |
| 38 | 3110 { |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3111 inputValueRaw = MIN_BUTTONRESPONSIVENESS; |
| 38 | 3112 } |
| 3113 | |
| 3114 // the unbalanced value | |
| 3115 outArray4Values[3] = inputValueRaw; | |
| 3116 | |
| 3117 // the balanced values | |
| 3118 for(int i=0;i<3;i++) | |
| 3119 { | |
| 3120 newSensitivity = inputValueRaw; | |
| 3121 switch(settingsGetPointer()->buttonBalance[i]) | |
| 3122 { | |
| 3123 case 1: // should not be an option hw 170508 | |
| 3124 newSensitivity -= 20; | |
| 3125 break; | |
| 3126 case 2: | |
| 3127 newSensitivity -= 10; | |
| 3128 break; | |
| 3129 default: | |
| 3130 break; | |
| 3131 case 4: | |
| 3132 newSensitivity += 10; | |
| 3133 break; | |
| 3134 case 5: | |
| 3135 newSensitivity += 20; | |
| 3136 break; | |
| 3137 } | |
| 3138 | |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3139 if(newSensitivity > MAX_BUTTONRESPONSIVENESS) |
| 38 | 3140 { |
|
92
be35821a4974
Stable to test. button sensitiveness fix. + global_constants.
Dmitry Romanov <kitt@bk.ru>
parents:
91
diff
changeset
|
3141 newSensitivity = MAX_BUTTONRESPONSIVENESS; |
| 38 | 3142 } |
| 3143 outArray4Values[i] = newSensitivity; | |
| 3144 } | |
| 3145 } | |
| 3146 | |
| 3147 | |
| 3148 /** | |
| 3149 ****************************************************************************** | |
| 3150 * @brief settingsHelperButtonSens_translate_to_hwOS_values. / make 32 bit input to three buttons + storage value in [3] | |
| 3151 * @author heinrichs weikamp gmbh | |
| 3152 * @version V 01 | |
| 3153 * @date 19-Sept-2016 | |
| 3154 ****************************************************************************** | |
| 3155 * | |
| 3156 * @param inputValueRaw: | |
| 3157 * @param outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance | |
| 3158 * @retval None | |
| 3159 */ | |
| 3160 void settingsHelperButtonSens_original_translate_to_hwOS_values(const uint32_t inputValueRaw, uint8_t *outArray4Values) | |
| 3161 { | |
| 3162 uint32_t newSensitivity; | |
| 3163 | |
| 3164 for(int i=0;i<3;i++) | |
| 3165 { | |
| 3166 newSensitivity = inputValueRaw; | |
| 3167 switch(settingsGetPointer()->buttonBalance[i]) | |
| 3168 { | |
| 3169 case 1: | |
| 3170 newSensitivity -= 20; | |
| 3171 break; | |
| 3172 case 2: | |
| 3173 newSensitivity -= 10; | |
| 3174 break; | |
| 3175 default: | |
| 3176 break; | |
| 3177 case 4: | |
| 3178 newSensitivity += 10; | |
| 3179 break; | |
| 3180 case 5: | |
| 3181 newSensitivity += 20; | |
| 3182 break; | |
| 3183 } | |
| 3184 | |
| 3185 if(newSensitivity > 100) | |
| 3186 { | |
| 3187 if(newSensitivity <= 105) | |
| 3188 newSensitivity = 10; | |
| 3189 else | |
| 3190 newSensitivity = 7; | |
| 3191 } | |
| 3192 else | |
| 3193 { | |
| 3194 newSensitivity *= 24; | |
| 3195 newSensitivity = 2400 - newSensitivity; | |
| 3196 newSensitivity /= 10; | |
| 3197 | |
| 3198 newSensitivity += 15; | |
| 3199 if(newSensitivity > 255) | |
| 3200 newSensitivity = 255; | |
| 3201 } | |
| 3202 outArray4Values[i] = newSensitivity; | |
| 3203 } | |
| 3204 | |
| 3205 // the unbalanced value | |
| 3206 newSensitivity = inputValueRaw; | |
| 3207 if(newSensitivity > 100) | |
| 3208 { | |
| 3209 if(newSensitivity <= 105) | |
| 3210 newSensitivity = 10; | |
| 3211 else | |
| 3212 newSensitivity = 7; | |
| 3213 } | |
| 3214 else | |
| 3215 { | |
| 3216 newSensitivity *= 24; | |
| 3217 newSensitivity = 2400 - newSensitivity; | |
| 3218 newSensitivity /= 10; | |
| 3219 | |
| 3220 newSensitivity += 15; | |
| 3221 if(newSensitivity > 255) | |
| 3222 newSensitivity = 255; | |
| 3223 } | |
| 3224 outArray4Values[3] = newSensitivity; | |
| 3225 } | |
| 3226 | |
| 3227 | |
| 3228 /** | |
| 3229 ****************************************************************************** | |
| 3230 * @brief settingsHelperButtonSens_translate_percentage_to_hwOS_values. | |
| 3231 * @author heinrichs weikamp gmbh | |
| 3232 * @version V 01 | |
| 3233 * @date 6-March-2017 | |
| 3234 ****************************************************************************** | |
| 3235 * | |
| 3236 * @param inputValuePercentage with buttonBalance included | |
| 3237 * @retval PIC compatible value | |
| 3238 */ | |
| 3239 uint8_t settingsHelperButtonSens_translate_percentage_to_hwOS_values(uint8_t inputValuePercentage) | |
| 3240 { | |
| 3241 uint32_t newSensitivity = inputValuePercentage; | |
| 3242 | |
| 3243 if(newSensitivity > 100) | |
| 3244 { | |
| 3245 if(newSensitivity <= 105) | |
| 3246 newSensitivity = 10; | |
| 3247 else | |
| 3248 newSensitivity = 7; | |
| 3249 } | |
| 3250 else | |
| 3251 { | |
| 3252 newSensitivity *= 24; | |
| 3253 newSensitivity = 2400 - newSensitivity; | |
| 3254 newSensitivity /= 10; | |
| 3255 | |
| 3256 newSensitivity += 15; | |
| 3257 if(newSensitivity > 255) | |
| 3258 newSensitivity = 255; | |
| 3259 } | |
| 3260 return (uint8_t)newSensitivity; | |
| 3261 } | |
| 3262 | |
| 3263 | |
| 3264 /** | |
| 3265 ****************************************************************************** | |
| 3266 * @brief settingsHelperButtonSens_translate_hwOS_values_to_percentage. | |
| 3267 * @author heinrichs weikamp gmbh | |
| 3268 * @version V 01 | |
| 3269 * @date 6-March-2017 | |
| 3270 ****************************************************************************** | |
| 3271 * | |
| 3272 * @param PIC compatible value | |
| 3273 * @retval Percentage | |
| 3274 */ | |
| 3275 uint8_t settingsHelperButtonSens_translate_hwOS_values_to_percentage(uint8_t inputValuePIC) | |
| 3276 { | |
| 3277 if(inputValuePIC >= 15) | |
| 3278 { | |
| 3279 return(uint8_t)((25500 - (inputValuePIC)*100) / 240); | |
| 3280 } | |
| 3281 else | |
| 3282 { | |
| 3283 if(inputValuePIC >= 10) | |
| 3284 { | |
| 3285 return 105; | |
| 3286 } | |
| 3287 else | |
| 3288 { | |
| 3289 return 110; | |
| 3290 } | |
| 3291 } | |
| 3292 } | |
| 662 | 3293 |
| 3294 void reset_SettingWarning() | |
| 3295 { | |
| 3296 settingsWarning = 0; | |
| 3297 } | |
| 3298 inline uint8_t isSettingsWarning() | |
| 3299 { | |
| 3300 return settingsWarning; | |
| 3301 } |