|
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>
|
|
|
30 #include "settings.h"
|
|
|
31 #include "firmwareEraseProgram.h" // for HARDWAREDATA_ADDRESS
|
|
|
32 #include "externLogbookFlash.h" // for SAMPLESTART and SAMPLESTOP
|
|
|
33 #include "text_multilanguage.h" // for LANGUAGE_END
|
|
|
34 #include "tHome.h" // for CVIEW_END
|
|
|
35
|
|
|
36 SSettings Settings;
|
|
|
37
|
|
|
38 const uint8_t RTErequiredHigh = 1;
|
|
|
39 const uint8_t RTErequiredLow = 1;
|
|
|
40
|
|
|
41 const uint8_t FONTrequiredHigh = 0;
|
|
|
42 const uint8_t FONTrequiredLow = 9;
|
|
|
43
|
|
|
44 uint8_t RTEactualHigh = 0;
|
|
|
45 uint8_t RTEactualLow = 0;
|
|
|
46
|
|
|
47 // ===============================================================================
|
|
|
48 // SFirmwareData FirmwareData
|
|
|
49 /// @brief internal counter is for changes after last release
|
|
|
50 /// use date and info as well for this purpose
|
|
|
51 ///
|
|
|
52 // ===============================================================================
|
|
|
53
|
|
|
54 const SFirmwareData firmware_FirmwareData __attribute__( (section(".firmware_firmware_data")) ) =
|
|
|
55 {
|
|
|
56 .versionFirst = 1,
|
|
|
57 .versionSecond = 3,
|
|
|
58 .versionThird = 2,
|
|
|
59 .versionBeta = 1,
|
|
|
60
|
|
|
61 /* 4 bytes with trailing 0 */
|
|
|
62 .signature = "cw",
|
|
|
63
|
|
|
64 .release_year = 17,
|
|
|
65 .release_month = 7,
|
|
|
66 .release_day = 4,
|
|
|
67 .release_sub = 0,
|
|
|
68
|
|
|
69 /* max 48 with trailing 0 */
|
|
|
70 //release_info ="12345678901234567890123456789012345678901"
|
|
|
71 .release_info ="going on",
|
|
|
72
|
|
|
73 /* for safety reasons and coming functions */
|
|
|
74 .magic[0] = FIRMWARE_MAGIC_FIRST,
|
|
|
75 .magic[1] = FIRMWARE_MAGIC_SECOND,
|
|
|
76 .magic[2] = FIRMWARE_MAGIC_FIRMWARE, /* the magic byte */
|
|
|
77 .magic[3] = FIRMWARE_MAGIC_END
|
|
|
78 };
|
|
|
79
|
|
|
80
|
|
|
81 /* always adjust check_and_correct_settings() accordingly
|
|
|
82 * There might even be entries with fixed values that have no range
|
|
|
83 */
|
|
|
84 const SSettings SettingsStandard = {
|
|
|
85 .header = 0xFFFF0017,
|
|
|
86 .warning_blink_dsec = 8 * 2,
|
|
|
87 .lastDiveLogId = 0,
|
|
|
88 .logFlashNextSampleStartAddress = 0,
|
|
|
89
|
|
|
90 .gas[0].oxygen_percentage = 21,
|
|
|
91 .gas[1].oxygen_percentage = 21,
|
|
|
92 .gas[2].oxygen_percentage = 21,
|
|
|
93 .gas[3].oxygen_percentage = 21,
|
|
|
94 .gas[4].oxygen_percentage = 21,
|
|
|
95 .gas[5].oxygen_percentage = 21,
|
|
|
96 .gas[6].oxygen_percentage = 21,
|
|
|
97 .gas[7].oxygen_percentage = 21,
|
|
|
98 .gas[8].oxygen_percentage = 21,
|
|
|
99 .gas[9].oxygen_percentage = 21,
|
|
|
100 .gas[10].oxygen_percentage = 21,
|
|
|
101 .gas[0].helium_percentage = 0,
|
|
|
102 .gas[1].helium_percentage = 0,
|
|
|
103 .gas[2].helium_percentage = 0,
|
|
|
104 .gas[3].helium_percentage = 0,
|
|
|
105 .gas[4].helium_percentage = 0,
|
|
|
106 .gas[5].helium_percentage = 0,
|
|
|
107 .gas[6].helium_percentage = 0,
|
|
|
108 .gas[7].helium_percentage = 0,
|
|
|
109 .gas[8].helium_percentage = 0,
|
|
|
110 .gas[9].helium_percentage = 0,
|
|
|
111 .gas[10].helium_percentage = 0,
|
|
|
112 .gas[0].depth_meter = 0,
|
|
|
113 .gas[1].depth_meter = 0,
|
|
|
114 .gas[2].depth_meter = 0,
|
|
|
115 .gas[3].depth_meter = 0,
|
|
|
116 .gas[4].depth_meter = 0,
|
|
|
117 .gas[5].depth_meter = 0,
|
|
|
118 .gas[6].depth_meter = 0,
|
|
|
119 .gas[7].depth_meter = 0,
|
|
|
120 .gas[8].depth_meter = 0,
|
|
|
121 .gas[9].depth_meter = 0,
|
|
|
122 .gas[10].depth_meter = 0,
|
|
|
123 .gas[0].depth_meter_travel = 0,
|
|
|
124 .gas[1].depth_meter_travel = 0,
|
|
|
125 .gas[2].depth_meter_travel = 0,
|
|
|
126 .gas[3].depth_meter_travel = 0,
|
|
|
127 .gas[4].depth_meter_travel = 0,
|
|
|
128 .gas[5].depth_meter_travel = 0,
|
|
|
129 .gas[6].depth_meter_travel = 0,
|
|
|
130 .gas[7].depth_meter_travel = 0,
|
|
|
131 .gas[8].depth_meter_travel = 0,
|
|
|
132 .gas[9].depth_meter_travel = 0,
|
|
|
133 .gas[10].depth_meter_travel = 0,
|
|
|
134 .gas[0].note.uw = 0,
|
|
|
135 .gas[1].note.ub.first = 1,
|
|
|
136 .gas[1].note.ub.active = 1,
|
|
|
137 .gas[1].note.ub.deco = 0,
|
|
|
138 .gas[1].note.ub.travel = 0,
|
|
|
139 .gas[2].note.uw = 0,
|
|
|
140 .gas[3].note.uw = 0,
|
|
|
141 .gas[4].note.uw = 0,
|
|
|
142 .gas[5].note.uw = 0,
|
|
|
143 .gas[6].note.ub.first = 1,
|
|
|
144 .gas[6].note.ub.active = 1,
|
|
|
145 .gas[6].note.ub.deco = 0,
|
|
|
146 .gas[6].note.ub.travel = 0,
|
|
|
147 .gas[7].note.uw = 0,
|
|
|
148 .gas[8].note.uw = 0,
|
|
|
149 .gas[9].note.uw = 0,
|
|
|
150 .gas[10].note.uw = 0,
|
|
|
151 .gas[0].bottle_size_liter = 0,
|
|
|
152 .gas[1].bottle_size_liter = 0,
|
|
|
153 .gas[2].bottle_size_liter = 0,
|
|
|
154 .gas[3].bottle_size_liter = 0,
|
|
|
155 .gas[4].bottle_size_liter = 0,
|
|
|
156 .gas[5].bottle_size_liter = 0,
|
|
|
157 .gas[6].bottle_size_liter = 0,
|
|
|
158 .gas[7].bottle_size_liter = 0,
|
|
|
159 .gas[8].bottle_size_liter = 0,
|
|
|
160 .gas[9].bottle_size_liter = 0,
|
|
|
161 .gas[10].bottle_size_liter = 0,
|
|
|
162 /*
|
|
|
163 .gas[0].bottle_wireless_status = 0,
|
|
|
164 .gas[1].bottle_wireless_status = 0,
|
|
|
165 .gas[2].bottle_wireless_status = 0,
|
|
|
166 .gas[3].bottle_wireless_status = 0,
|
|
|
167 .gas[4].bottle_wireless_status = 0,
|
|
|
168 .gas[5].bottle_wireless_status = 0,
|
|
|
169 .gas[6].bottle_wireless_status = 0,
|
|
|
170 .gas[7].bottle_wireless_status = 0,
|
|
|
171 .gas[8].bottle_wireless_status = 0,
|
|
|
172 .gas[9].bottle_wireless_status = 0,
|
|
|
173 .gas[10].bottle_wireless_status = 0,
|
|
|
174 */
|
|
|
175 .gas[0].bottle_wireless_id = 0,
|
|
|
176 .gas[1].bottle_wireless_id = 0,
|
|
|
177 .gas[2].bottle_wireless_id = 0,
|
|
|
178 .gas[3].bottle_wireless_id = 0,
|
|
|
179 .gas[4].bottle_wireless_id = 0,
|
|
|
180 .gas[5].bottle_wireless_id = 0,
|
|
|
181 .gas[6].bottle_wireless_id = 0,
|
|
|
182 .gas[7].bottle_wireless_id = 0,
|
|
|
183 .gas[8].bottle_wireless_id = 0,
|
|
|
184 .gas[9].bottle_wireless_id = 0,
|
|
|
185 .gas[10].bottle_wireless_id = 0,
|
|
|
186 .setpoint[0].setpoint_cbar = 100,
|
|
|
187 .setpoint[1].setpoint_cbar = 70,
|
|
|
188 .setpoint[2].setpoint_cbar = 90,
|
|
|
189 .setpoint[3].setpoint_cbar = 100,
|
|
|
190 .setpoint[4].setpoint_cbar = 120,
|
|
|
191 .setpoint[5].setpoint_cbar = 140,
|
|
|
192 .setpoint[0].depth_meter = 0,
|
|
|
193 .setpoint[1].depth_meter = 0,
|
|
|
194 .setpoint[2].depth_meter = 0,
|
|
|
195 .setpoint[3].depth_meter = 0,
|
|
|
196 .setpoint[4].depth_meter = 0,
|
|
|
197 .setpoint[5].depth_meter = 0,
|
|
|
198 .setpoint[0].note.uw = 0,
|
|
|
199 .setpoint[1].note.ub.active = 1,
|
|
|
200 .setpoint[1].note.ub.first = 1,
|
|
|
201 .setpoint[2].note.ub.active = 1,
|
|
|
202 .setpoint[2].note.ub.first = 0,
|
|
|
203 .setpoint[3].note.ub.active = 1,
|
|
|
204 .setpoint[3].note.ub.first = 0,
|
|
|
205 .setpoint[4].note.ub.active = 1,
|
|
|
206 .setpoint[4].note.ub.first = 0,
|
|
|
207 .setpoint[5].note.ub.active = 1,
|
|
|
208 .setpoint[5].note.ub.first = 0,
|
|
|
209
|
|
|
210 .CCR_Mode = CCRMODE_Sensors,
|
|
|
211 .dive_mode = DIVEMODE_OC,
|
|
|
212 .deco_type.ub.standard = GF_MODE,
|
|
|
213 .deco_type.ub.alternative = GF_MODE,
|
|
|
214 .ppO2_max_deco = 160,
|
|
|
215 .ppO2_max_std = 140,
|
|
|
216 .ppO2_min = 15,
|
|
|
217 .CNS_max = 90,
|
|
|
218 .ascent_MeterPerMinute_max = 30,
|
|
|
219 .ascent_MeterPerMinute_showGraph = 7,
|
|
|
220 .future_TTS = 5,
|
|
|
221 .GF_high = 85,
|
|
|
222 .GF_low = 30,
|
|
|
223 .aGF_high = 95,
|
|
|
224 .aGF_low = 95,
|
|
|
225 .VPM_conservatism.ub.standard = 2,
|
|
|
226 .VPM_conservatism.ub.alternative = 0,
|
|
|
227 .safetystopDuration = 1,
|
|
|
228 .AtemMinutenVolumenLiter = 25,
|
|
|
229 .ReserveFractionDenominator = 4,
|
|
|
230 .salinity = 0,
|
|
|
231 .last_stop_depth_meter = 3,
|
|
|
232 .stop_increment_depth_meter = 3,
|
|
|
233 .brightness = 1,
|
|
|
234 .date_format = DDMMYY,
|
|
|
235 .selected_language = 0, /* 0 = LANGUAGE_English */
|
|
|
236 .customtext = " <your name>\n" " <address>",
|
|
|
237 .timeoutSurfacemode = 120,
|
|
|
238 .timeoutMenuSurface = 120,//240,
|
|
|
239 .timeoutMenuDive = 120,//20,
|
|
|
240 .timeoutMenuEdit = 120,//40,
|
|
|
241 .timeoutInfo = 120,//60,
|
|
|
242 .timeoutInfoCompass = 60,
|
|
|
243 .design = 7,
|
|
|
244 .timeoutDiveReachedZeroDepth = 300,
|
|
|
245 .divetimeToCreateLogbook = 60,
|
|
|
246 .serialHigh = 0,
|
|
|
247 .serialLow = 2,
|
|
|
248 /*
|
|
|
249 .firmwareVersion16to32bit.ub.first = 0,
|
|
|
250 .firmwareVersion16to32bit.ub.second = 6,
|
|
|
251 .firmwareVersion16to32bit.ub.third = 0,
|
|
|
252 .firmwareVersion16to32bit.ub.betaFlag = 0,
|
|
|
253 */
|
|
|
254 .backup_localtime_rtc_tr = 0,
|
|
|
255 .backup_localtime_rtc_dr = 0,
|
|
|
256 .totalDiveCounter = 0,
|
|
|
257 .personalDiveCount = 0,
|
|
|
258 .showDebugInfo = 0,
|
|
|
259 .ButtonResponsiveness[0] = 90, // new hw 170306
|
|
|
260 .ButtonResponsiveness[1] = 90, // new hw 170306
|
|
|
261 .ButtonResponsiveness[2] = 90, // new hw 170306
|
|
|
262 .ButtonResponsiveness[3] = 90, // new hw 170306
|
|
|
263 .nonMetricalSystem = 0,
|
|
|
264 .fallbackToFixedSetpoint = 1,
|
|
|
265 .bluetoothActive = 0,
|
|
|
266 .safetystopDepth = 5,
|
|
|
267 .updateSettingsAllowedFromHeader = 0xFFFF0002,
|
|
|
268 .scooterControl = 0,
|
|
|
269 .scooterDrag = 2,
|
|
|
270 .scooterLoad = 2,
|
|
|
271 .scooterNumberOfBatteries = 1,
|
|
|
272 .scooterBattSize = 760,
|
|
|
273 .scooterSPARE1[0] = 0,
|
|
|
274 .scooterSPARE2[0] = 0,
|
|
|
275 .ppo2sensors_deactivated = 0,
|
|
|
276 .tX_colorscheme = 0,
|
|
|
277 .tX_userselectedLeftLowerCornerPrimary = 1,
|
|
|
278 .tX_userselectedLeftLowerCornerTimeout = 0,
|
|
|
279 .tX_customViewPrimary = 1,
|
|
|
280 .tX_customViewTimeout = 0,
|
|
|
281 .timeoutEnterButtonSelectDive = 10,
|
|
|
282 .logbookOffset = 0,
|
|
|
283 .alwaysShowPPO2 = 0,
|
|
|
284 .extraDisplay = EXTRADISPLAY_BIGFONT,
|
|
|
285 .display_toogle_desc = 200,
|
|
|
286 .offsetPressure_mbar = 0,
|
|
|
287 .offsetTemperature_centigrad = 0,
|
|
|
288 .gasConsumption_travel_l_min = 30,
|
|
|
289 .gasConsumption_bottom_l_min = 30,
|
|
|
290 .gasConsumption_deco_l_min = 20,
|
|
|
291 .debugModeOnStart = 0,
|
|
|
292 .compassBearing = 0,
|
|
|
293 .lastKnownBatteryPercentage = 0,
|
|
|
294 .buttonBalance[0] = 3,
|
|
|
295 .buttonBalance[1] = 3,
|
|
|
296 .buttonBalance[2] = 3,
|
|
|
297 .firmwareVersion[0] = 0,//FirmwareData.firmwareVersion16to32bit.ub.first,
|
|
|
298 .firmwareVersion[1] = 0,//FirmwareData.firmwareVersion16to32bit.ub.second,
|
|
|
299 .firmwareVersion[2] = 0,//FirmwareData.firmwareVersion16to32bit.ub.third,
|
|
|
300 .firmwareVersion[3] = 0,//FirmwareData.firmwareVersion16to32bit.ub.betaFlag,
|
|
|
301 .timeoutSurfacemodeWithSensors = 600,
|
|
|
302 .VPM_model = 0,
|
|
|
303 .GF_model = 0,
|
|
|
304 .FactoryButtonBase = 90,
|
|
|
305 .FactoryButtonBalance[0] = 3,
|
|
|
306 .FactoryButtonBalance[1] = 3,
|
|
|
307 .FactoryButtonBalance[2] = 3,
|
|
|
308 };
|
|
|
309
|
|
|
310 /* Private function prototypes -----------------------------------------------*/
|
|
|
311 uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to);
|
|
|
312
|
|
|
313 /* Functions -----------------------------------------------------------------*/
|
|
|
314
|
|
|
315
|
|
|
316 // ===============================================================================
|
|
|
317 // set_new_settings_missing_in_ext_flash
|
|
|
318 /// @brief Add all the new setting variables of this version
|
|
|
319 /// or/and change what has changed in the meantime
|
|
|
320 ///
|
|
|
321 /// Additionally update the serial number if written via bluetooth
|
|
|
322 ///
|
|
|
323 // ===============================================================================
|
|
|
324 void set_new_settings_missing_in_ext_flash(void)
|
|
|
325 {
|
|
|
326 // never delete this part setting the serial
|
|
|
327 if(hardwareDataGetPointer()->secondarySerial != 0xFFFF)
|
|
|
328 {
|
|
|
329 settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->secondarySerial / 256);
|
|
|
330 settingsGetPointer()->serialLow = (hardwareDataGetPointer()->secondarySerial & 0xFF);
|
|
|
331 }
|
|
|
332 else
|
|
|
333 if(hardwareDataGetPointer()->primarySerial != 0xFFFF)
|
|
|
334 {
|
|
|
335 settingsGetPointer()->serialHigh = (hardwareDataGetPointer()->primarySerial / 256);
|
|
|
336 settingsGetPointer()->serialLow = (hardwareDataGetPointer()->primarySerial & 0xFF);
|
|
|
337 }
|
|
|
338 else
|
|
|
339 {
|
|
|
340 settingsGetPointer()->serialHigh = 0;
|
|
|
341 settingsGetPointer()->serialLow = 0;
|
|
|
342 }
|
|
|
343
|
|
|
344 settingsGetPointer()->firmwareVersion[0] = firmware_FirmwareData.versionFirst;
|
|
|
345 settingsGetPointer()->firmwareVersion[1] = firmware_FirmwareData.versionSecond;
|
|
|
346 settingsGetPointer()->firmwareVersion[2] = firmware_FirmwareData.versionThird;
|
|
|
347 settingsGetPointer()->firmwareVersion[3] = firmware_FirmwareData.versionBeta;
|
|
|
348
|
|
|
349 SSettings* pSettings = settingsGetPointer();
|
|
|
350 const SSettings* pStandard = settingsGetPointerStandard();
|
|
|
351
|
|
|
352 pSettings->scooterControl = 0;
|
|
|
353
|
|
|
354 if((pSettings->serialHigh == 0) && (pSettings->serialLow == 25))
|
|
|
355 {
|
|
|
356 memcpy(pSettings->customtext, " Salom�\n\r" " Wiedmer\n\r", 60);
|
|
|
357 }
|
|
|
358
|
|
|
359 switch(pSettings->header)
|
|
|
360 {
|
|
|
361 case 0xFFFF0000:
|
|
|
362 case 0xFFFF0001:
|
|
|
363 case 0xFFFF0002:
|
|
|
364 case 0xFFFF0003:
|
|
|
365 case 0xFFFF0004:
|
|
|
366 case 0xFFFF0005:
|
|
|
367 pSettings->ppo2sensors_deactivated = pStandard->ppo2sensors_deactivated;
|
|
|
368 pSettings->tX_colorscheme = pStandard->tX_colorscheme;
|
|
|
369 pSettings->tX_userselectedLeftLowerCornerPrimary = pStandard->tX_userselectedLeftLowerCornerPrimary;
|
|
|
370 pSettings->tX_userselectedLeftLowerCornerTimeout = pStandard->tX_userselectedLeftLowerCornerTimeout;
|
|
|
371 pSettings->tX_customViewPrimary = pStandard->tX_customViewPrimary;
|
|
|
372 pSettings->tX_customViewTimeout = pStandard->tX_customViewTimeout;
|
|
|
373 // no break
|
|
|
374 case 0xFFFF0006:
|
|
|
375 pSettings->timeoutEnterButtonSelectDive = pStandard->timeoutEnterButtonSelectDive;
|
|
|
376 pSettings->ButtonResponsiveness[0] = pStandard->ButtonResponsiveness[0];
|
|
|
377 pSettings->ButtonResponsiveness[1] = pStandard->ButtonResponsiveness[1];
|
|
|
378 pSettings->ButtonResponsiveness[2] = pStandard->ButtonResponsiveness[2];
|
|
|
379 pSettings->ButtonResponsiveness[3] = pStandard->ButtonResponsiveness[3];
|
|
|
380 pSettings->timeoutSurfacemode = pStandard->timeoutSurfacemode;
|
|
|
381 pSettings->timeoutMenuSurface = pStandard->timeoutMenuSurface;
|
|
|
382 pSettings->timeoutMenuDive = pStandard->timeoutMenuDive;
|
|
|
383 pSettings->timeoutMenuEdit = pStandard->timeoutMenuEdit;
|
|
|
384 pSettings->timeoutInfo = pStandard->timeoutInfo;
|
|
|
385 pSettings->timeoutInfoCompass = pStandard->timeoutInfoCompass;
|
|
|
386 pSettings->timeoutDiveReachedZeroDepth = pStandard->timeoutDiveReachedZeroDepth;
|
|
|
387 pSettings->divetimeToCreateLogbook = pStandard->divetimeToCreateLogbook;
|
|
|
388 pSettings->safetystopDuration = pStandard->safetystopDuration; // change from on/off to minutes
|
|
|
389 // no break
|
|
|
390 case 0xFFFF0007:
|
|
|
391 case 0xFFFF0008:
|
|
|
392 pSettings->alwaysShowPPO2 = pStandard->alwaysShowPPO2;
|
|
|
393 pSettings->logbookOffset = pStandard->logbookOffset;
|
|
|
394 // no break
|
|
|
395 case 0xFFFF0009:
|
|
|
396 pSettings->extraDisplay = pStandard->extraDisplay;
|
|
|
397 // no break
|
|
|
398 case 0xFFFF000A:
|
|
|
399 pSettings->display_toogle_desc = pStandard->display_toogle_desc;
|
|
|
400 // no break
|
|
|
401 case 0xFFFF000B:
|
|
|
402 pSettings->offsetPressure_mbar = pStandard->offsetPressure_mbar;
|
|
|
403 pSettings->offsetTemperature_centigrad = pStandard->offsetTemperature_centigrad;
|
|
|
404 pSettings->gasConsumption_travel_l_min = pStandard->gasConsumption_travel_l_min;
|
|
|
405 pSettings->gasConsumption_bottom_l_min = pStandard->gasConsumption_bottom_l_min;
|
|
|
406 pSettings->gasConsumption_deco_l_min = pStandard->gasConsumption_deco_l_min;
|
|
|
407 // no break
|
|
|
408 case 0xFFFF000C:
|
|
|
409 memcpy(pSettings->customtext, " hwOS 4\n\r" " welcome\n\r", 60);
|
|
|
410 // no break
|
|
|
411 case 0xFFFF000D: // nothing to do from 0xFFFF000D to 0xFFFF000E, just about header :-)
|
|
|
412 case 0xFFFF000E:
|
|
|
413 pSettings->debugModeOnStart = 0;
|
|
|
414 // no break
|
|
|
415 case 0xFFFF000F:
|
|
|
416 pSettings->compassBearing = 0;
|
|
|
417 // no break
|
|
|
418 case 0xFFFF0010:
|
|
|
419 pSettings->scooterDrag = 2;
|
|
|
420 pSettings->scooterLoad = 2;
|
|
|
421 pSettings->scooterSPARE1[0] = 0;
|
|
|
422 pSettings->scooterSPARE2[0] = 0;
|
|
|
423 // no break
|
|
|
424 case 0xFFFF0011:
|
|
|
425 pSettings->scooterNumberOfBatteries = 1;
|
|
|
426 pSettings->scooterBattSize = 760;
|
|
|
427 pSettings->lastKnownBatteryPercentage = 0;
|
|
|
428 // no break
|
|
|
429 case 0xFFFF0012:
|
|
|
430 pSettings->buttonBalance[0] = 3;
|
|
|
431 pSettings->buttonBalance[1] = 3;
|
|
|
432 pSettings->buttonBalance[2] = 3;
|
|
|
433 // no break
|
|
|
434 case 0xFFFF0013:
|
|
|
435 case 0xFFFF0014:
|
|
|
436 pSettings->timeoutSurfacemodeWithSensors = pStandard->timeoutSurfacemodeWithSensors;
|
|
|
437 // no break
|
|
|
438 case 0xFFFF0015:
|
|
|
439 pSettings->ButtonResponsiveness[3] = pStandard->ButtonResponsiveness[3];
|
|
|
440 settingsHelperButtonSens_keepPercentageValues(settingsHelperButtonSens_translate_hwOS_values_to_percentage(pSettings->ButtonResponsiveness[3]), pSettings->ButtonResponsiveness);
|
|
|
441 pSettings->VPM_model = 0;
|
|
|
442 pSettings->GF_model = 0;
|
|
|
443 // no break
|
|
|
444 case 0xFFFF0016:
|
|
|
445 pSettings->FactoryButtonBase = pStandard->FactoryButtonBase;
|
|
|
446 pSettings->FactoryButtonBalance[0] = pStandard->FactoryButtonBalance[0];
|
|
|
447 pSettings->FactoryButtonBalance[1] = pStandard->FactoryButtonBalance[1];
|
|
|
448 pSettings->FactoryButtonBalance[2] = pStandard->FactoryButtonBalance[2];
|
|
|
449 // no break
|
|
|
450 default:
|
|
|
451 pSettings->header = pStandard->header;
|
|
|
452 break; // no break before!!
|
|
|
453 }
|
|
|
454 }
|
|
|
455
|
|
|
456
|
|
|
457 uint8_t newFirmwareVersionCheckViaSettings(void)
|
|
|
458 {
|
|
|
459 SSettings* pSettings = settingsGetPointer();
|
|
|
460
|
|
|
461 if(pSettings->header < 0xFFFF0014) // for the versions without firmwareVersion[]
|
|
|
462 return 1;
|
|
|
463
|
|
|
464 if(pSettings->firmwareVersion[0] != firmware_FirmwareData.versionFirst)
|
|
|
465 return 1;
|
|
|
466 if(pSettings->firmwareVersion[1] != firmware_FirmwareData.versionSecond)
|
|
|
467 return 1;
|
|
|
468 if(pSettings->firmwareVersion[2] != firmware_FirmwareData.versionThird)
|
|
|
469 return 1;
|
|
|
470 if(pSettings->firmwareVersion[3] != firmware_FirmwareData.versionBeta)
|
|
|
471 return 1;
|
|
|
472
|
|
|
473 return 0;
|
|
|
474 }
|
|
|
475
|
|
|
476
|
|
|
477 void set_settings_button_to_standard_with_individual_buttonBalance(void)
|
|
|
478 {
|
|
|
479 settingsHelperButtonSens_keepPercentageValues(SettingsStandard.ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness);
|
|
|
480 }
|
|
|
481
|
|
|
482
|
|
|
483 uint8_t check_and_correct_settings(void)
|
|
|
484 {
|
|
|
485 uint32_t corrections = 0;
|
|
|
486 uint8_t firstGasFoundOC = 0;
|
|
|
487 uint8_t firstGasFoundCCR = 0;
|
|
|
488
|
|
|
489 /* uint32_t header;
|
|
|
490 */
|
|
|
491
|
|
|
492 /* uint8_t warning_blink_dsec; 1/10 seconds
|
|
|
493 */
|
|
|
494 if((Settings.warning_blink_dsec < 1) || (Settings.warning_blink_dsec > 100))
|
|
|
495 {
|
|
|
496 Settings.warning_blink_dsec = SettingsStandard.warning_blink_dsec;
|
|
|
497 corrections++;
|
|
|
498 }
|
|
|
499
|
|
|
500 /* uint8_t lastDiveLogId;
|
|
|
501 */
|
|
|
502
|
|
|
503 /* uint32_t logFlashNextSampleStartAddress;
|
|
|
504 */
|
|
|
505 if((Settings.logFlashNextSampleStartAddress < SAMPLESTART) || (Settings.logFlashNextSampleStartAddress > SAMPLESTOP))
|
|
|
506 {
|
|
|
507 Settings.logFlashNextSampleStartAddress = SAMPLESTART;
|
|
|
508 corrections++;
|
|
|
509 }
|
|
|
510
|
|
|
511
|
|
|
512 /* uint8_t dive_mode; has to before the gases
|
|
|
513 */
|
|
|
514 if( (Settings.dive_mode != DIVEMODE_OC) &&
|
|
|
515 (Settings.dive_mode != DIVEMODE_CCR) &&
|
|
|
516 (Settings.dive_mode != DIVEMODE_Gauge) &&
|
|
|
517 (Settings.dive_mode != DIVEMODE_Apnea) )
|
|
|
518 {
|
|
|
519 Settings.dive_mode = DIVEMODE_OC;
|
|
|
520 corrections++;
|
|
|
521 }
|
|
|
522
|
|
|
523
|
|
|
524 /* SGasLine gas[1 + (2*NUM_GASES)];
|
|
|
525 */
|
|
|
526 for(int i=1; i<=2*NUM_GASES;i++)
|
|
|
527 {
|
|
|
528 if(Settings.gas[i].oxygen_percentage < 4)
|
|
|
529 {
|
|
|
530 Settings.gas[i].oxygen_percentage = 4;
|
|
|
531 corrections++;
|
|
|
532 }
|
|
|
533 if(Settings.gas[i].oxygen_percentage > 100)
|
|
|
534 {
|
|
|
535 Settings.gas[i].oxygen_percentage = 100;
|
|
|
536 corrections++;
|
|
|
537 }
|
|
|
538 if((Settings.gas[i].oxygen_percentage + Settings.gas[i].helium_percentage) > 100)
|
|
|
539 {
|
|
|
540 Settings.gas[i].helium_percentage = 100 - Settings.gas[i].oxygen_percentage;
|
|
|
541 corrections++;
|
|
|
542 }
|
|
|
543 if(Settings.gas[i].note.ub.deco)
|
|
|
544 {
|
|
|
545 if(Settings.gas[i].note.ub.active != 1)
|
|
|
546 {
|
|
|
547 Settings.gas[i].note.ub.active = 1;
|
|
|
548 corrections++;
|
|
|
549 }
|
|
|
550 if(Settings.gas[i].note.ub.travel == 1)
|
|
|
551 {
|
|
|
552 Settings.gas[i].note.ub.travel = 0;
|
|
|
553 corrections++;
|
|
|
554 }
|
|
|
555 }
|
|
|
556 if(Settings.gas[i].note.ub.travel)
|
|
|
557 {
|
|
|
558 if(Settings.gas[i].note.ub.active != 1)
|
|
|
559 {
|
|
|
560 Settings.gas[i].note.ub.active = 1;
|
|
|
561 corrections++;
|
|
|
562 }
|
|
|
563 if(Settings.gas[i].note.ub.deco == 1)
|
|
|
564 {
|
|
|
565 Settings.gas[i].note.ub.deco = 0;
|
|
|
566 corrections++;
|
|
|
567 }
|
|
|
568 }
|
|
|
569 if(Settings.gas[i].note.ub.first)
|
|
|
570 {
|
|
|
571 if(Settings.setpoint[i].note.ub.active != 1)
|
|
|
572 {
|
|
|
573 Settings.setpoint[i].note.ub.active = 1;
|
|
|
574 corrections++;
|
|
|
575 }
|
|
|
576 if(Settings.gas[i].note.ub.travel == 1)
|
|
|
577 {
|
|
|
578 Settings.gas[i].note.ub.travel = 0;
|
|
|
579 corrections++;
|
|
|
580 }
|
|
|
581 if(Settings.gas[i].note.ub.deco == 1)
|
|
|
582 {
|
|
|
583 Settings.gas[i].note.ub.deco = 0;
|
|
|
584 corrections++;
|
|
|
585 }
|
|
|
586 if((i<=NUM_GASES) && (!firstGasFoundOC))
|
|
|
587 firstGasFoundOC = 1;
|
|
|
588 else
|
|
|
589 if((i>NUM_GASES) && (!firstGasFoundCCR))
|
|
|
590 firstGasFoundCCR = 1;
|
|
|
591 else
|
|
|
592 Settings.gas[i].note.ub.first = 0;
|
|
|
593 }
|
|
|
594 if(Settings.gas[i].bottle_size_liter > 40)
|
|
|
595 {
|
|
|
596 Settings.gas[i].bottle_size_liter = 40;
|
|
|
597 corrections++;
|
|
|
598 }
|
|
|
599 if(Settings.gas[i].depth_meter > 250)
|
|
|
600 {
|
|
|
601 Settings.gas[i].depth_meter = 250;
|
|
|
602 corrections++;
|
|
|
603 }
|
|
|
604 if(Settings.gas[i].depth_meter_travel > 250)
|
|
|
605 {
|
|
|
606 Settings.gas[i].depth_meter_travel = 250;
|
|
|
607 corrections++;
|
|
|
608 }
|
|
|
609 /*if(Settings.gas[i].note.ub.senderCode)
|
|
|
610 {
|
|
|
611 }
|
|
|
612 if(Settings.gas[i].bottle_wireless_id)
|
|
|
613 {
|
|
|
614 }
|
|
|
615 */
|
|
|
616 } // for(int i=1; i<=2*NUM_GASES;i++)
|
|
|
617
|
|
|
618 if(!firstGasFoundOC)
|
|
|
619 {
|
|
|
620 Settings.gas[1].note.ub.active = 1;
|
|
|
621 Settings.gas[1].note.ub.first = 1;
|
|
|
622 Settings.gas[1].note.ub.travel = 0;
|
|
|
623 Settings.gas[1].note.ub.deco = 0;
|
|
|
624 }
|
|
|
625 if(!firstGasFoundCCR)
|
|
|
626 {
|
|
|
627 Settings.gas[1 + NUM_GASES].note.ub.active = 1;
|
|
|
628 Settings.gas[1 + NUM_GASES].note.ub.first = 1;
|
|
|
629 Settings.gas[1 + NUM_GASES].note.ub.travel = 0;
|
|
|
630 Settings.gas[1 + NUM_GASES].note.ub.deco = 0;
|
|
|
631 }
|
|
|
632 /* SSetpointLine setpoint[1 + NUM_GASES];
|
|
|
633 */
|
|
|
634 for(int i=1; i<=NUM_GASES;i++)
|
|
|
635 {
|
|
|
636 if(Settings.setpoint[i].setpoint_cbar < 50)
|
|
|
637 {
|
|
|
638 Settings.setpoint[i].setpoint_cbar = 50;
|
|
|
639 corrections++;
|
|
|
640 }
|
|
|
641 if(Settings.setpoint[i].setpoint_cbar > 160)
|
|
|
642 {
|
|
|
643 Settings.setpoint[i].setpoint_cbar = 160;
|
|
|
644 corrections++;
|
|
|
645 }
|
|
|
646 if(Settings.setpoint[i].depth_meter > 250)
|
|
|
647 {
|
|
|
648 Settings.setpoint[i].depth_meter = 250;
|
|
|
649 corrections++;
|
|
|
650 }
|
|
|
651 if(Settings.setpoint[i].note.ub.deco)
|
|
|
652 {
|
|
|
653 if(Settings.setpoint[i].note.ub.active != 1)
|
|
|
654 {
|
|
|
655 Settings.setpoint[i].note.ub.active = 1;
|
|
|
656 corrections++;
|
|
|
657 }
|
|
|
658 if(Settings.setpoint[i].note.ub.travel == 1)
|
|
|
659 {
|
|
|
660 Settings.setpoint[i].note.ub.travel = 0;
|
|
|
661 corrections++;
|
|
|
662 }
|
|
|
663 }
|
|
|
664 if(Settings.setpoint[i].note.ub.travel)
|
|
|
665 {
|
|
|
666 if(Settings.setpoint[i].note.ub.active != 1)
|
|
|
667 {
|
|
|
668 Settings.setpoint[i].note.ub.active = 1;
|
|
|
669 corrections++;
|
|
|
670 }
|
|
|
671 if(Settings.setpoint[i].note.ub.deco == 1)
|
|
|
672 {
|
|
|
673 Settings.setpoint[i].note.ub.deco = 0;
|
|
|
674 corrections++;
|
|
|
675 }
|
|
|
676 }
|
|
|
677 if(Settings.setpoint[i].note.ub.first)
|
|
|
678 {
|
|
|
679 if(Settings.setpoint[i].note.ub.active != 1)
|
|
|
680 {
|
|
|
681 Settings.setpoint[i].note.ub.active = 1;
|
|
|
682 corrections++;
|
|
|
683 }
|
|
|
684 if(Settings.setpoint[i].note.ub.travel == 1)
|
|
|
685 {
|
|
|
686 Settings.setpoint[i].note.ub.travel = 0;
|
|
|
687 corrections++;
|
|
|
688 }
|
|
|
689 if(Settings.setpoint[i].note.ub.deco == 1)
|
|
|
690 {
|
|
|
691 Settings.setpoint[i].note.ub.deco = 0;
|
|
|
692 corrections++;
|
|
|
693 }
|
|
|
694 }
|
|
|
695 } // for(int i=1; i<=NUM_GASES;i++)
|
|
|
696
|
|
|
697 /* uint8_t CCR_Mode;
|
|
|
698 */
|
|
|
699 if( (Settings.CCR_Mode != CCRMODE_Sensors) &&
|
|
|
700 (Settings.CCR_Mode != CCRMODE_FixedSetpoint))
|
|
|
701 {
|
|
|
702 Settings.CCR_Mode = CCRMODE_FixedSetpoint;
|
|
|
703 corrections++;
|
|
|
704 }
|
|
|
705
|
|
|
706 /* split2x4_Type deco_type;
|
|
|
707 */
|
|
|
708 if( (Settings.deco_type.ub.standard != GF_MODE) &&
|
|
|
709 (Settings.deco_type.ub.standard != VPM_MODE))
|
|
|
710 {
|
|
|
711 Settings.deco_type.ub.standard = VPM_MODE;
|
|
|
712 corrections++;
|
|
|
713 }
|
|
|
714 if(Settings.deco_type.ub.alternative != GF_MODE)
|
|
|
715 {
|
|
|
716 Settings.deco_type.ub.alternative = GF_MODE;
|
|
|
717 corrections++;
|
|
|
718 }
|
|
|
719
|
|
|
720 /* uint8_t ppO2_max_deco;
|
|
|
721 */
|
|
|
722 if(Settings.ppO2_max_deco > 190)
|
|
|
723 {
|
|
|
724 Settings.ppO2_max_deco = 190;
|
|
|
725 corrections++;
|
|
|
726 }
|
|
|
727 if(Settings.ppO2_max_deco < 100)
|
|
|
728 {
|
|
|
729 Settings.ppO2_max_deco = 100;
|
|
|
730 corrections++;
|
|
|
731 }
|
|
|
732
|
|
|
733 /* uint8_t ppO2_max_std;
|
|
|
734 */
|
|
|
735 if(Settings.ppO2_max_std > 190)
|
|
|
736 {
|
|
|
737 Settings.ppO2_max_std = 190;
|
|
|
738 corrections++;
|
|
|
739 }
|
|
|
740 if(Settings.ppO2_max_std < 100)
|
|
|
741 {
|
|
|
742 Settings.ppO2_max_std = 100;
|
|
|
743 corrections++;
|
|
|
744 }
|
|
|
745
|
|
|
746 /* uint8_t ppO2_min;
|
|
|
747 */
|
|
|
748 if(Settings.ppO2_min != 15)
|
|
|
749 {
|
|
|
750 Settings.ppO2_min = 15;
|
|
|
751 corrections++;
|
|
|
752 }
|
|
|
753
|
|
|
754 /* uint8_t CNS_max;
|
|
|
755 */
|
|
|
756 if(Settings.CNS_max != 90)
|
|
|
757 {
|
|
|
758 Settings.CNS_max = 90;
|
|
|
759 corrections++;
|
|
|
760 }
|
|
|
761
|
|
|
762 /* uint8_t ascent_MeterPerMinute_max;
|
|
|
763 */
|
|
|
764 if(Settings.ascent_MeterPerMinute_max != 30)
|
|
|
765 {
|
|
|
766 Settings.ascent_MeterPerMinute_max = 30;
|
|
|
767 corrections++;
|
|
|
768 }
|
|
|
769
|
|
|
770 /* uint8_t ascent_MeterPerMinute_showGraph;
|
|
|
771 */
|
|
|
772 if(Settings.ascent_MeterPerMinute_showGraph != 30)
|
|
|
773 {
|
|
|
774 Settings.ascent_MeterPerMinute_showGraph = 30;
|
|
|
775 corrections++;
|
|
|
776 }
|
|
|
777
|
|
|
778 /* uint8_t future_TTS;
|
|
|
779 */
|
|
|
780 if(Settings.future_TTS > 15)
|
|
|
781 {
|
|
|
782 Settings.future_TTS = 15;
|
|
|
783 corrections++;
|
|
|
784 }
|
|
|
785
|
|
|
786 /* uint8_t GF_high;
|
|
|
787 */
|
|
|
788 if(Settings.GF_high > 99)
|
|
|
789 {
|
|
|
790 Settings.GF_high = 99;
|
|
|
791 corrections++;
|
|
|
792 }
|
|
|
793 if(Settings.GF_high < 45)
|
|
|
794 {
|
|
|
795 Settings.GF_high = 45;
|
|
|
796 corrections++;
|
|
|
797 }
|
|
|
798
|
|
|
799 /* uint8_t GF_low;
|
|
|
800 */
|
|
|
801 if(Settings.GF_low > 99)
|
|
|
802 {
|
|
|
803 Settings.GF_low = 99;
|
|
|
804 corrections++;
|
|
|
805 }
|
|
|
806 if(Settings.GF_low < 10)
|
|
|
807 {
|
|
|
808 Settings.GF_low = 10;
|
|
|
809 corrections++;
|
|
|
810 }
|
|
|
811 if(Settings.GF_low > Settings.GF_high)
|
|
|
812 {
|
|
|
813 Settings.GF_low = Settings.GF_high;
|
|
|
814 corrections++;
|
|
|
815 }
|
|
|
816
|
|
|
817 /* uint8_t aGF_high;
|
|
|
818 */
|
|
|
819 if(Settings.aGF_high > 99)
|
|
|
820 {
|
|
|
821 Settings.aGF_high = 99;
|
|
|
822 corrections++;
|
|
|
823 }
|
|
|
824 if(Settings.aGF_high < 45)
|
|
|
825 {
|
|
|
826 Settings.aGF_high = 45;
|
|
|
827 corrections++;
|
|
|
828 }
|
|
|
829
|
|
|
830 /* uint8_t aGF_low;
|
|
|
831 */
|
|
|
832 if(Settings.aGF_low > 99)
|
|
|
833 {
|
|
|
834 Settings.aGF_low = 99;
|
|
|
835 corrections++;
|
|
|
836 }
|
|
|
837 if(Settings.aGF_low < 10)
|
|
|
838 {
|
|
|
839 Settings.aGF_low = 10;
|
|
|
840 corrections++;
|
|
|
841 }
|
|
|
842 if(Settings.aGF_low > Settings.aGF_high)
|
|
|
843 {
|
|
|
844 Settings.aGF_low = Settings.aGF_high;
|
|
|
845 corrections++;
|
|
|
846 }
|
|
|
847
|
|
|
848 /* split2x4_Type VPM_conservatism;
|
|
|
849 */
|
|
|
850 if(Settings.VPM_conservatism.ub.standard > 5)
|
|
|
851 {
|
|
|
852 Settings.VPM_conservatism.ub.standard = 5;
|
|
|
853 corrections++;
|
|
|
854 }
|
|
|
855 if(Settings.VPM_conservatism.ub.alternative > 5)
|
|
|
856 {
|
|
|
857 Settings.VPM_conservatism.ub.alternative = 5;
|
|
|
858 corrections++;
|
|
|
859 }
|
|
|
860
|
|
|
861 /* uint8_t safetystopDuration;
|
|
|
862 */
|
|
|
863 if(Settings.safetystopDuration > 5)
|
|
|
864 {
|
|
|
865 Settings.safetystopDuration = 5;
|
|
|
866 corrections++;
|
|
|
867 }
|
|
|
868
|
|
|
869 /* uint8_t AtemMinutenVolumenLiter;
|
|
|
870 */
|
|
|
871 if(Settings.AtemMinutenVolumenLiter != 25)
|
|
|
872 {
|
|
|
873 Settings.AtemMinutenVolumenLiter = 25;
|
|
|
874 corrections++;
|
|
|
875 }
|
|
|
876
|
|
|
877 /* uint8_t ReserveFractionDenominator;
|
|
|
878 */
|
|
|
879 if(Settings.ReserveFractionDenominator != 4)
|
|
|
880 {
|
|
|
881 Settings.ReserveFractionDenominator = 4;
|
|
|
882 corrections++;
|
|
|
883 }
|
|
|
884
|
|
|
885 /* uint8_t salinity;
|
|
|
886 */
|
|
|
887 if(Settings.salinity > 4)
|
|
|
888 {
|
|
|
889 Settings.salinity = 4;
|
|
|
890 corrections++;
|
|
|
891 }
|
|
|
892
|
|
|
893 /* uint8_t last_stop_depth_meter;
|
|
|
894 */
|
|
|
895 if(Settings.last_stop_depth_meter > 9)
|
|
|
896 {
|
|
|
897 Settings.last_stop_depth_meter = 9;
|
|
|
898 corrections++;
|
|
|
899 }
|
|
|
900 if(Settings.last_stop_depth_meter < 3)
|
|
|
901 {
|
|
|
902 Settings.last_stop_depth_meter = 3;
|
|
|
903 corrections++;
|
|
|
904 }
|
|
|
905
|
|
|
906 /* uint8_t stop_increment_depth_meter;
|
|
|
907 */
|
|
|
908 if(Settings.stop_increment_depth_meter != 3)
|
|
|
909 {
|
|
|
910 Settings.stop_increment_depth_meter = 3;
|
|
|
911 corrections++;
|
|
|
912 }
|
|
|
913
|
|
|
914 /* uint8_t brightness;
|
|
|
915 */
|
|
|
916 if(Settings.brightness > 4)
|
|
|
917 {
|
|
|
918 Settings.brightness = 4;
|
|
|
919 corrections++;
|
|
|
920 }
|
|
|
921
|
|
|
922 /* uint8_t date_format;
|
|
|
923 */
|
|
|
924 if( (Settings.date_format != DDMMYY) &&
|
|
|
925 (Settings.date_format != MMDDYY) &&
|
|
|
926 (Settings.date_format != YYMMDD))
|
|
|
927 {
|
|
|
928 Settings.date_format = DDMMYY;
|
|
|
929 corrections++;
|
|
|
930 }
|
|
|
931
|
|
|
932 /* uint8_t selected_language;
|
|
|
933 */
|
|
|
934 if(Settings.selected_language >= LANGUAGE_END)
|
|
|
935 {
|
|
|
936 Settings.selected_language = LANGUAGE_English;
|
|
|
937 corrections++;
|
|
|
938 }
|
|
|
939
|
|
|
940 /* char customtext[60];
|
|
|
941 */
|
|
|
942 if(Settings.customtext[59] != 0)
|
|
|
943 {
|
|
|
944 Settings.customtext[59] = 0;
|
|
|
945 corrections++;
|
|
|
946 }
|
|
|
947
|
|
|
948 /* uint16_t timeoutSurfacemode;
|
|
|
949 */
|
|
|
950 if( (Settings.timeoutSurfacemode != 20) && // Quick Sleep Option
|
|
|
951 (Settings.timeoutSurfacemode != 120))
|
|
|
952 {
|
|
|
953 Settings.timeoutSurfacemode = 120;
|
|
|
954 corrections++;
|
|
|
955 }
|
|
|
956
|
|
|
957 /* uint8_t timeoutMenuSurface;
|
|
|
958 */
|
|
|
959 if(Settings.timeoutMenuSurface != 120)
|
|
|
960 {
|
|
|
961 Settings.timeoutMenuSurface = 120;
|
|
|
962 corrections++;
|
|
|
963 }
|
|
|
964
|
|
|
965 /* uint8_t timeoutMenuDive;
|
|
|
966 */
|
|
|
967 if(Settings.timeoutMenuDive != 120)
|
|
|
968 {
|
|
|
969 Settings.timeoutMenuDive = 120;
|
|
|
970 corrections++;
|
|
|
971 }
|
|
|
972
|
|
|
973 /* uint8_t timeoutMenuEdit;
|
|
|
974 */
|
|
|
975 if(Settings.timeoutMenuEdit != 120)
|
|
|
976 {
|
|
|
977 Settings.timeoutMenuEdit = 120;
|
|
|
978 corrections++;
|
|
|
979 }
|
|
|
980
|
|
|
981 /* uint8_t timeoutInfo;
|
|
|
982 */
|
|
|
983 if(Settings.timeoutInfo != 120)
|
|
|
984 {
|
|
|
985 Settings.timeoutInfo = 120;
|
|
|
986 corrections++;
|
|
|
987 }
|
|
|
988
|
|
|
989 /* uint8_t timeoutInfoCompass;
|
|
|
990 */
|
|
|
991 if(Settings.timeoutInfoCompass != 60)
|
|
|
992 {
|
|
|
993 Settings.timeoutInfoCompass = 60;
|
|
|
994 corrections++;
|
|
|
995 }
|
|
|
996
|
|
|
997 /* uint8_t design;
|
|
|
998 */
|
|
|
999 if(Settings.design != 7)
|
|
|
1000 {
|
|
|
1001 Settings.design = 7;
|
|
|
1002 corrections++;
|
|
|
1003 }
|
|
|
1004
|
|
|
1005 /* uint16_t timeoutDiveReachedZeroDepth;
|
|
|
1006 */
|
|
|
1007 if(Settings.timeoutDiveReachedZeroDepth != 300)
|
|
|
1008 {
|
|
|
1009 Settings.timeoutDiveReachedZeroDepth = 300;
|
|
|
1010 corrections++;
|
|
|
1011 }
|
|
|
1012
|
|
|
1013 /* uint16_t divetimeToCreateLogbook;
|
|
|
1014 */
|
|
|
1015 if(Settings.divetimeToCreateLogbook != 60)
|
|
|
1016 {
|
|
|
1017 Settings.divetimeToCreateLogbook = 60;
|
|
|
1018 corrections++;
|
|
|
1019 }
|
|
|
1020
|
|
|
1021 /* uint8_t serialHigh;
|
|
|
1022 */
|
|
|
1023
|
|
|
1024 /* uint8_t serialLow;
|
|
|
1025 */
|
|
|
1026
|
|
|
1027 /* SUFirmware firmwareVersion16to32bit;
|
|
|
1028 */
|
|
|
1029
|
|
|
1030 /* uint32_t backup_localtime_rtc_tr;
|
|
|
1031 */
|
|
|
1032
|
|
|
1033 /* uint32_t backup_localtime_rtc_dr;
|
|
|
1034 */
|
|
|
1035
|
|
|
1036 /* uint16_t totalDiveCounter;
|
|
|
1037 */
|
|
|
1038
|
|
|
1039 /* uint16_t personalDiveCount;
|
|
|
1040 */
|
|
|
1041
|
|
|
1042 /* uint8_t showDebugInfo;
|
|
|
1043 */
|
|
|
1044 if(Settings.showDebugInfo > 1)
|
|
|
1045 {
|
|
|
1046 Settings.showDebugInfo = 0;
|
|
|
1047 corrections++;
|
|
|
1048 }
|
|
|
1049
|
|
|
1050 /* uint8_t ButtonResponsiveness[4];
|
|
|
1051 */
|
|
|
1052 // Base value, index 3
|
|
|
1053 if(Settings.ButtonResponsiveness[3] < 70)
|
|
|
1054 {
|
|
|
1055 Settings.ButtonResponsiveness[3] = 70;
|
|
|
1056 corrections++;
|
|
|
1057 }
|
|
|
1058 else
|
|
|
1059 if(Settings.ButtonResponsiveness[3] > 110)
|
|
|
1060 {
|
|
|
1061 Settings.ButtonResponsiveness[3] = 130;
|
|
|
1062 corrections++;
|
|
|
1063 }
|
|
|
1064 // flex values 0, 1, 2
|
|
|
1065 for(int i=0; i<3;i++)
|
|
|
1066 {
|
|
|
1067 if(Settings.ButtonResponsiveness[i] < 60) // 70-10
|
|
|
1068 {
|
|
|
1069 Settings.ButtonResponsiveness[i] = 70;
|
|
|
1070 corrections++;
|
|
|
1071 }
|
|
|
1072 else
|
|
|
1073 if(Settings.ButtonResponsiveness[i] > 130) // 110+20
|
|
|
1074 {
|
|
|
1075 Settings.ButtonResponsiveness[i] = 130;
|
|
|
1076 corrections++;
|
|
|
1077 }
|
|
|
1078 }
|
|
|
1079
|
|
|
1080 /* uint8_t buttonBalance[3];
|
|
|
1081 */
|
|
|
1082 for(int i=0; i<3;i++)
|
|
|
1083 {
|
|
|
1084 if(Settings.buttonBalance[i] < 2) // 2 = -10
|
|
|
1085 {
|
|
|
1086 Settings.buttonBalance[i] = 2;
|
|
|
1087 corrections++;
|
|
|
1088 }
|
|
|
1089 else
|
|
|
1090 if(Settings.buttonBalance[i] > 5) // 3 = 0, 4 = +10, 5 = +20
|
|
|
1091 {
|
|
|
1092 Settings.buttonBalance[i] = 5;
|
|
|
1093 corrections++;
|
|
|
1094 }
|
|
|
1095 }
|
|
|
1096
|
|
|
1097 /* uint8_t nonMetricalSystem;
|
|
|
1098 */
|
|
|
1099 if(Settings.nonMetricalSystem > 1)
|
|
|
1100 {
|
|
|
1101 Settings.nonMetricalSystem = 1;
|
|
|
1102 corrections++;
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 /* uint8_t fallbackToFixedSetpoint;
|
|
|
1106 */
|
|
|
1107 if(Settings.fallbackToFixedSetpoint > 1)
|
|
|
1108 {
|
|
|
1109 Settings.fallbackToFixedSetpoint = 1;
|
|
|
1110 corrections++;
|
|
|
1111 }
|
|
|
1112
|
|
|
1113 /* uint8_t bluetoothActive;
|
|
|
1114 */
|
|
|
1115 if(Settings.bluetoothActive > 1)
|
|
|
1116 {
|
|
|
1117 Settings.bluetoothActive = 1;
|
|
|
1118 corrections++;
|
|
|
1119 }
|
|
|
1120
|
|
|
1121 /* uint8_t safetystopDepth;
|
|
|
1122 */
|
|
|
1123 if(Settings.safetystopDepth > 6)
|
|
|
1124 {
|
|
|
1125 Settings.safetystopDepth = 6;
|
|
|
1126 corrections++;
|
|
|
1127 }
|
|
|
1128 if(Settings.safetystopDepth < 3)
|
|
|
1129 {
|
|
|
1130 Settings.safetystopDepth = 3;
|
|
|
1131 corrections++;
|
|
|
1132 }
|
|
|
1133
|
|
|
1134 /* uint32_t updateSettingsAllowedFromHeader;
|
|
|
1135 */
|
|
|
1136
|
|
|
1137 /* uint8_t scooterControl;
|
|
|
1138 */
|
|
|
1139 if(Settings.scooterControl > 1)
|
|
|
1140 {
|
|
|
1141 Settings.scooterControl = 1;
|
|
|
1142 corrections++;
|
|
|
1143 }
|
|
|
1144
|
|
|
1145 /* char scooterDeviceAddress[12];
|
|
|
1146 */
|
|
|
1147
|
|
|
1148 /* char scooterDeviceName[19];
|
|
|
1149 */
|
|
|
1150
|
|
|
1151 /* uint8_t ppo2sensors_deactivated;
|
|
|
1152 */
|
|
|
1153 if(Settings.ppo2sensors_deactivated > (1+2+4))
|
|
|
1154 {
|
|
|
1155 Settings.ppo2sensors_deactivated = 0;
|
|
|
1156 corrections++;
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 /* uint8_t tX_colorscheme;
|
|
|
1160 */
|
|
|
1161 if(Settings.tX_colorscheme > 3)
|
|
|
1162 {
|
|
|
1163 Settings.tX_colorscheme = 0;
|
|
|
1164 corrections++;
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 /* uint8_t tX_userselectedLeftLowerCornerPrimary;
|
|
|
1168 */
|
|
|
1169 if(Settings.tX_userselectedLeftLowerCornerPrimary > 7)
|
|
|
1170 {
|
|
|
1171 Settings.tX_userselectedLeftLowerCornerPrimary = 1;
|
|
|
1172 corrections++;
|
|
|
1173 }
|
|
|
1174
|
|
|
1175 /* uint8_t tX_userselectedLeftLowerCornerTimeout;
|
|
|
1176 */
|
|
|
1177 if(Settings.tX_userselectedLeftLowerCornerTimeout > 60)
|
|
|
1178 {
|
|
|
1179 Settings.tX_userselectedLeftLowerCornerTimeout = 0;
|
|
|
1180 corrections++;
|
|
|
1181 }
|
|
|
1182
|
|
|
1183 /* uint8_t tX_customViewPrimary;
|
|
|
1184 */
|
|
|
1185 if(Settings.tX_customViewPrimary >= CVIEW_END)
|
|
|
1186 {
|
|
|
1187 Settings.tX_customViewPrimary = 1;
|
|
|
1188 corrections++;
|
|
|
1189 }
|
|
|
1190
|
|
|
1191 /* uint8_t tX_customViewTimeout;
|
|
|
1192 */
|
|
|
1193 if(Settings.tX_customViewTimeout > 60)
|
|
|
1194 {
|
|
|
1195 Settings.tX_customViewTimeout = 0;
|
|
|
1196 corrections++;
|
|
|
1197 }
|
|
|
1198
|
|
|
1199 /* uint8_t timeoutEnterButtonSelectDive;
|
|
|
1200 */
|
|
|
1201 if(Settings.timeoutEnterButtonSelectDive != 10)
|
|
|
1202 {
|
|
|
1203 Settings.timeoutEnterButtonSelectDive = 10;
|
|
|
1204 corrections++;
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 /* uint8_t logbookOffset;
|
|
|
1208 */
|
|
|
1209 if(Settings.logbookOffset > 9000)
|
|
|
1210 {
|
|
|
1211 Settings.logbookOffset = 0;
|
|
|
1212 corrections++;
|
|
|
1213 }
|
|
|
1214
|
|
|
1215 /* uint8_t alwaysShowPPO2;
|
|
|
1216 */
|
|
|
1217 if(Settings.alwaysShowPPO2 > 1)
|
|
|
1218 {
|
|
|
1219 Settings.alwaysShowPPO2 = 0;
|
|
|
1220 corrections++;
|
|
|
1221 }
|
|
|
1222
|
|
|
1223 /* uint8_t extraDisplay;
|
|
|
1224 */
|
|
|
1225 if(Settings.extraDisplay >= EXTRADISPLAY_END)
|
|
|
1226 {
|
|
|
1227 Settings.extraDisplay = EXTRADISPLAY_BIGFONT;
|
|
|
1228 corrections++;
|
|
|
1229 }
|
|
|
1230
|
|
|
1231 /* int8_t offsetPressure_mbar;
|
|
|
1232 */
|
|
|
1233 if((Settings.offsetPressure_mbar > 20) ||
|
|
|
1234 (Settings.offsetPressure_mbar < -20))
|
|
|
1235 {
|
|
|
1236 Settings.offsetPressure_mbar = 0;
|
|
|
1237 corrections++;
|
|
|
1238 }
|
|
|
1239
|
|
|
1240 /* int8_t offsetTemperature_centigrad;
|
|
|
1241 */
|
|
|
1242 if((Settings.offsetTemperature_centigrad > 20) ||
|
|
|
1243 (Settings.offsetTemperature_centigrad < -20))
|
|
|
1244 {
|
|
|
1245 Settings.offsetTemperature_centigrad = 0;
|
|
|
1246 corrections++;
|
|
|
1247 }
|
|
|
1248
|
|
|
1249 /* uint8_t gasConsumption_travel_l_min;
|
|
|
1250 */
|
|
|
1251 if((Settings.gasConsumption_travel_l_min < 5) ||
|
|
|
1252 (Settings.gasConsumption_travel_l_min > 50))
|
|
|
1253 {
|
|
|
1254 Settings.gasConsumption_travel_l_min = 20;
|
|
|
1255 corrections++;
|
|
|
1256 }
|
|
|
1257
|
|
|
1258 /* uint8_t gasConsumption_bottom_l_min;
|
|
|
1259 */
|
|
|
1260 if((Settings.gasConsumption_bottom_l_min < 5) ||
|
|
|
1261 (Settings.gasConsumption_bottom_l_min > 50))
|
|
|
1262 {
|
|
|
1263 Settings.gasConsumption_bottom_l_min = 20;
|
|
|
1264 corrections++;
|
|
|
1265 }
|
|
|
1266
|
|
|
1267 /* uint8_t gasConsumption_deco_l_min;
|
|
|
1268 */
|
|
|
1269 if((Settings.gasConsumption_deco_l_min < 5) ||
|
|
|
1270 (Settings.gasConsumption_deco_l_min > 50))
|
|
|
1271 {
|
|
|
1272 Settings.gasConsumption_deco_l_min = 20;
|
|
|
1273 corrections++;
|
|
|
1274 }
|
|
|
1275
|
|
|
1276 /* uint8_t showDebugInfo;
|
|
|
1277 */
|
|
|
1278 #ifdef BOOT16
|
|
|
1279 Settings.showDebugInfo = 0;
|
|
|
1280 #else
|
|
|
1281 if(Settings.showDebugInfo > 1)
|
|
|
1282 Settings.showDebugInfo = 0;
|
|
|
1283
|
|
|
1284 #endif
|
|
|
1285
|
|
|
1286 /* uint8_t selected_language;
|
|
|
1287 */
|
|
|
1288 #ifdef BOOT16
|
|
|
1289 if(Settings.selected_language > 1)
|
|
|
1290 Settings.selected_language = 0;
|
|
|
1291 #else
|
|
|
1292 if(Settings.selected_language > 4)
|
|
|
1293 Settings.selected_language = 0;
|
|
|
1294 #endif
|
|
|
1295
|
|
|
1296
|
|
|
1297 /* uint8_t display_toogle_desc; 1/10 seconds
|
|
|
1298 */
|
|
|
1299 if((Settings.display_toogle_desc < 20) || (Settings.display_toogle_desc > 600))
|
|
|
1300 {
|
|
|
1301 Settings.display_toogle_desc = SettingsStandard.display_toogle_desc;
|
|
|
1302 corrections++;
|
|
|
1303 }
|
|
|
1304
|
|
|
1305 /* uint8_t debugModeOnStart;
|
|
|
1306 */
|
|
|
1307 if(Settings.debugModeOnStart > 1)
|
|
|
1308 {
|
|
|
1309 Settings.debugModeOnStart = 0;
|
|
|
1310 corrections++;
|
|
|
1311 }
|
|
|
1312
|
|
|
1313
|
|
|
1314 /* uint8_t IAmStolenPleaseKillMe;
|
|
|
1315 */
|
|
|
1316
|
|
|
1317 if(hardwareDataGetPointer()->primarySerial == 90)
|
|
|
1318 Settings.IAmStolenPleaseKillMe++;
|
|
|
1319 else
|
|
|
1320 Settings.IAmStolenPleaseKillMe = 0;
|
|
|
1321
|
|
|
1322
|
|
|
1323 /* uint8_t debugModeOnStart;
|
|
|
1324 */
|
|
|
1325 if(Settings.compassBearing > 360)
|
|
|
1326 {
|
|
|
1327 Settings.compassBearing = 0;
|
|
|
1328 corrections++;
|
|
|
1329 }
|
|
|
1330
|
|
|
1331 /* uint8_t scooterDrag;
|
|
|
1332 */
|
|
|
1333 if(Settings.scooterDrag > 3)
|
|
|
1334 {
|
|
|
1335 Settings.scooterDrag = 3;
|
|
|
1336 corrections++;
|
|
|
1337 }
|
|
|
1338
|
|
|
1339 /* uint8_t scooterLoad;
|
|
|
1340 */
|
|
|
1341 if(Settings.scooterLoad > 4)
|
|
|
1342 {
|
|
|
1343 Settings.scooterLoad = 4;
|
|
|
1344 corrections++;
|
|
|
1345 }
|
|
|
1346
|
|
|
1347 /* uint8_t scooterNumberOfBatteries;
|
|
|
1348 */
|
|
|
1349 if(Settings.scooterNumberOfBatteries > 3)
|
|
|
1350 {
|
|
|
1351 Settings.scooterNumberOfBatteries = 3;
|
|
|
1352 corrections++;
|
|
|
1353 }
|
|
|
1354
|
|
|
1355 /* uint16_t scooterBattSize;
|
|
|
1356 */
|
|
|
1357 if((Settings.scooterBattSize < 300) ||
|
|
|
1358 (Settings.scooterBattSize > 5000))
|
|
|
1359 {
|
|
|
1360 Settings.scooterBattSize = 700;
|
|
|
1361 corrections++;
|
|
|
1362 }
|
|
|
1363
|
|
|
1364
|
|
|
1365 /* uint8_t lastKnownBatteryPercentage;
|
|
|
1366 */
|
|
|
1367 if(Settings.lastKnownBatteryPercentage > 100)
|
|
|
1368 {
|
|
|
1369 Settings.lastKnownBatteryPercentage = 100;
|
|
|
1370 corrections++;
|
|
|
1371 }
|
|
|
1372
|
|
|
1373 /* uint8_t VPM_model
|
|
|
1374 */
|
|
|
1375 if((Settings.VPM_model != VPM_FROM_FORTRAN) && (Settings.VPM_model != VPM_BACHELORWORK))
|
|
|
1376 {
|
|
|
1377 Settings.VPM_model = VPM_FROM_FORTRAN;
|
|
|
1378 corrections++;
|
|
|
1379 }
|
|
|
1380
|
|
|
1381 /* uint8_t Buehlmann_model
|
|
|
1382 */
|
|
|
1383 if((Settings.GF_model != BUEHLMANN_OSTC4) && (Settings.GF_model != BUEHLMANN_hwOS))
|
|
|
1384 {
|
|
|
1385 Settings.GF_model = BUEHLMANN_OSTC4;
|
|
|
1386 corrections++;
|
|
|
1387 }
|
|
|
1388
|
|
|
1389
|
|
|
1390 if(corrections > 255)
|
|
|
1391 return 255;
|
|
|
1392 else
|
|
|
1393 return (uint8_t)corrections;
|
|
|
1394 }
|
|
|
1395
|
|
|
1396
|
|
|
1397 /* always at 0x8080000, do not move -> bootloader access */
|
|
|
1398 const SFirmwareData* firmwareDataGetPointer(void)
|
|
|
1399 {
|
|
|
1400 return &firmware_FirmwareData;
|
|
|
1401 }
|
|
|
1402
|
|
|
1403
|
|
|
1404 #ifndef SPECIALPROGRAMM
|
|
|
1405 const SHardwareData* hardwareDataGetPointer(void)
|
|
|
1406 {
|
|
|
1407 return (SHardwareData *)HARDWAREDATA_ADDRESS;
|
|
|
1408 }
|
|
|
1409 #endif
|
|
|
1410
|
|
|
1411 const SSettings* settingsGetPointerStandard(void)
|
|
|
1412 {
|
|
|
1413 return &SettingsStandard;
|
|
|
1414 }
|
|
|
1415
|
|
|
1416
|
|
|
1417 void hardwareBatchCode(uint8_t *high, uint8_t *low)
|
|
|
1418 {
|
|
|
1419 if(high)
|
|
|
1420 {
|
|
|
1421 *high = (uint8_t)((hardwareDataGetPointer()->production_year - 16) * 16);
|
|
|
1422 *high += hardwareDataGetPointer()->production_month;
|
|
|
1423 if(low)
|
|
|
1424 {
|
|
|
1425 *low = (uint8_t)(hardwareDataGetPointer()->production_day * 8);
|
|
|
1426 }
|
|
|
1427 }
|
|
|
1428 }
|
|
|
1429
|
|
|
1430
|
|
|
1431 uint8_t firmwareVersion_16bit_high(void)
|
|
|
1432 {
|
|
|
1433 return ((firmware_FirmwareData.versionFirst & 0x1F) << 3) + ((firmware_FirmwareData.versionSecond & 0x1C) >> 5);
|
|
|
1434 }
|
|
|
1435
|
|
|
1436 uint8_t firmwareVersion_16bit_low(void)
|
|
|
1437 {
|
|
|
1438 return ((firmware_FirmwareData.versionSecond & 0x03) << 6) + ((firmware_FirmwareData.versionThird & 0x1F) << 1) + (firmware_FirmwareData.versionBeta & 0x01);
|
|
|
1439 }
|
|
|
1440
|
|
|
1441 SSettings* settingsGetPointer(void)
|
|
|
1442 {
|
|
|
1443 return &Settings;
|
|
|
1444 }
|
|
|
1445
|
|
|
1446
|
|
|
1447 // ===============================================================================
|
|
|
1448 // set_settings_to_Standard
|
|
|
1449 /// @brief This function overwrites the current settings of the system
|
|
|
1450 /// with the EXCEPTION of the personalDiveCount
|
|
|
1451 ///
|
|
|
1452 /// It additionally calls set_new_settings_missing_in_ext_flash() and
|
|
|
1453 /// check_and_correct_settings(), even so this shouldn't be necessary.
|
|
|
1454 /// It is called on every start and from Reset All.
|
|
|
1455 ///
|
|
|
1456 /// 160622 added lastDiveLogIdBackup
|
|
|
1457 ///
|
|
|
1458 // ===============================================================================
|
|
|
1459 void set_settings_to_Standard(void)
|
|
|
1460 {
|
|
|
1461 SSettings *pSettings;
|
|
|
1462 const SSettings *pSettingsStandard;
|
|
|
1463 uint16_t personalDiveCountBackup;
|
|
|
1464 uint8_t lastDiveLogIdBackup;
|
|
|
1465 pSettings = settingsGetPointer();
|
|
|
1466 pSettingsStandard = settingsGetPointerStandard();
|
|
|
1467
|
|
|
1468 personalDiveCountBackup = pSettings->personalDiveCount;
|
|
|
1469 lastDiveLogIdBackup = pSettings->lastDiveLogId;
|
|
|
1470 memcpy(pSettings,pSettingsStandard,sizeof(*pSettings));
|
|
|
1471 pSettings->personalDiveCount = personalDiveCountBackup;
|
|
|
1472 pSettings->lastDiveLogId = lastDiveLogIdBackup;
|
|
|
1473
|
|
|
1474 pSettings->firmwareVersion[0] = firmware_FirmwareData.versionFirst;
|
|
|
1475 pSettings->firmwareVersion[1] = firmware_FirmwareData.versionSecond;
|
|
|
1476 pSettings->firmwareVersion[2] = firmware_FirmwareData.versionThird;
|
|
|
1477 pSettings->firmwareVersion[3] = firmware_FirmwareData.versionBeta;
|
|
|
1478
|
|
|
1479 set_new_settings_missing_in_ext_flash();
|
|
|
1480 check_and_correct_settings();
|
|
|
1481 // has to be called too: createDiveSettings();
|
|
|
1482 }
|
|
|
1483
|
|
|
1484
|
|
|
1485 // ===============================================================================
|
|
|
1486 // mod_settings_for_first_start_with_empty_ext_flash
|
|
|
1487 /// @brief This function overwrites some settings of the system
|
|
|
1488 /// It is called on every start.
|
|
|
1489 /// Those settings will be overwriten by ext_flash_read_settings()
|
|
|
1490 /// Will be kept if ext_flash_read_settings() is invalid because
|
|
|
1491 /// it is still empty.
|
|
|
1492 ///
|
|
|
1493 // ===============================================================================
|
|
|
1494 void mod_settings_for_first_start_with_empty_ext_flash(void)
|
|
|
1495 {
|
|
|
1496 settingsGetPointer()->debugModeOnStart = 1; //
|
|
|
1497 }
|
|
|
1498
|
|
|
1499
|
|
|
1500
|
|
|
1501 // ===============================================================================
|
|
|
1502 // hwOS4_to_hwOS_GasType
|
|
|
1503 /// @brief Helper for get gas / diluent
|
|
|
1504 ///
|
|
|
1505 // ===============================================================================
|
|
|
1506 uint8_t hwOS4_to_hwOS_GasType(uint8_t inOSTC4style)
|
|
|
1507 {
|
|
|
1508 switch(inOSTC4style)
|
|
|
1509 {
|
|
|
1510 case (1+2): // first
|
|
|
1511 case (2): // first
|
|
|
1512 return 1; // hwOS style first
|
|
|
1513 case (1+4): // deco
|
|
|
1514 case (4): // deco
|
|
|
1515 return 3; // hwOS style deco
|
|
|
1516 case (1+8): // travel
|
|
|
1517 case (8): // travel
|
|
|
1518 return 2; // hwOS style travel
|
|
|
1519 default:
|
|
|
1520 return 0; // hwOS style Disabled
|
|
|
1521 }
|
|
|
1522 }
|
|
|
1523
|
|
|
1524
|
|
|
1525 // ===============================================================================
|
|
|
1526 // hwOS_to_hwOS4_GasType
|
|
|
1527 /// @brief Helper for set gas / diluent
|
|
|
1528 ///
|
|
|
1529 // ===============================================================================
|
|
|
1530 uint8_t hwOS_to_hwOS4_GasType(uint8_t inOSTC4style)
|
|
|
1531 {
|
|
|
1532 switch(inOSTC4style)
|
|
|
1533 {
|
|
|
1534 case (1): // first
|
|
|
1535 return 1+2; // hwOS4 style first
|
|
|
1536 case (2): // travel (normal for diluent)
|
|
|
1537 return 1+8; // hwOS4 style travel
|
|
|
1538 case (3): // deco
|
|
|
1539 return 1+4; // hwOS4 style deco
|
|
|
1540 default:
|
|
|
1541 return 0; // hwOS4 style inactive
|
|
|
1542 }
|
|
|
1543 }
|
|
|
1544
|
|
|
1545
|
|
|
1546
|
|
|
1547 // ===============================================================================
|
|
|
1548 // setGas
|
|
|
1549 /// @brief This function overwrites one gas, including mode and deco depth,
|
|
|
1550 /// it returns 0x4D prompt which is not used by writeData() that calls it.
|
|
|
1551 ///
|
|
|
1552 /// @param i the gas id from 1 to 5 for OC and 6 to 10 for CCR, 0 is the extra gas
|
|
|
1553 /// @param *data 5 bytes with the first the command to call setGas and the four
|
|
|
1554 /// following bytes to define oxygen, helium, mode and deco depth
|
|
|
1555 ///
|
|
|
1556 /// @return 0x4D (prompt that is not used)
|
|
|
1557 // ===============================================================================
|
|
|
1558 uint8_t setGas(int i,uint8_t * data)
|
|
|
1559 {
|
|
|
1560 if(!checkValue(data[1],4,100))
|
|
|
1561 return ERROR_;
|
|
|
1562 if(!checkValue(data[4],0,250))
|
|
|
1563 return ERROR_;
|
|
|
1564
|
|
|
1565 Settings.gas[i].oxygen_percentage = data[1];
|
|
|
1566 Settings.gas[i].helium_percentage = data[2];
|
|
|
1567 Settings.gas[i].note.uw = hwOS_to_hwOS4_GasType(data[3]);
|
|
|
1568 Settings.gas[i].depth_meter = data[4];
|
|
|
1569 return 0x4d;
|
|
|
1570 }
|
|
|
1571
|
|
|
1572
|
|
|
1573 uint8_t getGas(int i,uint8_t * data)
|
|
|
1574 {
|
|
|
1575 data[0] = Settings.gas[i].oxygen_percentage;
|
|
|
1576 data[1] = Settings.gas[i].helium_percentage;
|
|
|
1577 data[2] = hwOS4_to_hwOS_GasType(Settings.gas[i].note.uw);
|
|
|
1578 data[3] = Settings.gas[i].depth_meter;
|
|
|
1579 return 0x4d;
|
|
|
1580 }
|
|
|
1581
|
|
|
1582 uint8_t setDiluent(int i,uint8_t * data)
|
|
|
1583 {
|
|
|
1584 if(!checkValue(data[1],4,100))
|
|
|
1585 return ERROR_;
|
|
|
1586 if(!checkValue(data[4],0,250))
|
|
|
1587 return ERROR_;
|
|
|
1588
|
|
|
1589 Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage = data[1];
|
|
|
1590 Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage = data[2];
|
|
|
1591 Settings.gas[NUM_OFFSET_DILUENT + i].note.uw = hwOS_to_hwOS4_GasType(data[3]);
|
|
|
1592 Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter = data[4];
|
|
|
1593 return 0x4d;
|
|
|
1594 }
|
|
|
1595
|
|
|
1596 uint8_t getDiluent(int i,uint8_t * data)
|
|
|
1597 {
|
|
|
1598 data[0] = Settings.gas[NUM_OFFSET_DILUENT + i].oxygen_percentage;
|
|
|
1599 data[1] = Settings.gas[NUM_OFFSET_DILUENT + i].helium_percentage;
|
|
|
1600 data[2] = hwOS4_to_hwOS_GasType(Settings.gas[NUM_OFFSET_DILUENT + i].note.uw);
|
|
|
1601 data[3] = Settings.gas[NUM_OFFSET_DILUENT + i].depth_meter;
|
|
|
1602 return 0x4d;
|
|
|
1603 }
|
|
|
1604
|
|
|
1605 uint8_t setSetpoint(int i,uint8_t * data)
|
|
|
1606 {
|
|
|
1607 if(!checkValue(data[1],50,160))
|
|
|
1608 return ERROR_;
|
|
|
1609 if(!checkValue(data[2],0,250))
|
|
|
1610 return ERROR_;
|
|
|
1611
|
|
|
1612 Settings.setpoint[i].setpoint_cbar = data[1];
|
|
|
1613 Settings.setpoint[i].depth_meter = data[2];
|
|
|
1614 return 0x4d;
|
|
|
1615 }
|
|
|
1616
|
|
|
1617 uint8_t getSetpoint(int i,uint8_t * data)
|
|
|
1618 {
|
|
|
1619 data[0] = Settings.setpoint[i].setpoint_cbar;
|
|
|
1620 data[1] = Settings.setpoint[i].depth_meter;
|
|
|
1621 return 0x4d;
|
|
|
1622 }
|
|
|
1623
|
|
|
1624 uint8_t checkValue(uint8_t value,uint8_t from, uint8_t to)
|
|
|
1625 {
|
|
|
1626 if(value >= from && value <= to)
|
|
|
1627 return 1;
|
|
|
1628 return 0;
|
|
|
1629 }
|
|
|
1630
|
|
|
1631 uint8_t writeData(uint8_t * data)
|
|
|
1632 {
|
|
|
1633 uint32_t newSensitivity;
|
|
|
1634 uint16_t newDuration, newOffset;
|
|
|
1635 uint8_t newStopDepth;
|
|
|
1636
|
|
|
1637 switch(data[0])
|
|
|
1638 {
|
|
|
1639 case 0x10:
|
|
|
1640 return setGas(1,data);
|
|
|
1641 case 0x11:
|
|
|
1642 return setGas(2,data);
|
|
|
1643 case 0x12:
|
|
|
1644 return setGas(3,data);
|
|
|
1645 case 0x13:
|
|
|
1646 return setGas(4,data);
|
|
|
1647 case 0x14:
|
|
|
1648 return setGas(5,data);
|
|
|
1649 case 0x15:
|
|
|
1650 return setDiluent(1,data);
|
|
|
1651 case 0x16:
|
|
|
1652 return setDiluent(2,data);
|
|
|
1653 case 0x17:
|
|
|
1654 return setDiluent(3,data);
|
|
|
1655 case 0x18:
|
|
|
1656 return setDiluent(4,data);
|
|
|
1657 case 0x19:
|
|
|
1658 return setDiluent(5,data);
|
|
|
1659 case 0x1A:
|
|
|
1660 return setSetpoint(1,data);
|
|
|
1661 case 0x1B:
|
|
|
1662 return setSetpoint(2,data);
|
|
|
1663 case 0x1C:
|
|
|
1664 return setSetpoint(3,data);
|
|
|
1665 case 0x1D:
|
|
|
1666 return setSetpoint(4,data);
|
|
|
1667 case 0x1E:
|
|
|
1668 return setSetpoint(5,data);
|
|
|
1669 case 0x1F:
|
|
|
1670 if(!checkValue(data[2],0,1))
|
|
|
1671 return ERROR_;
|
|
|
1672 Settings.CCR_Mode = data[1];
|
|
|
1673 break;
|
|
|
1674 case 0x20:
|
|
|
1675 if(!checkValue(data[1],0,3))
|
|
|
1676 return ERROR_;
|
|
|
1677 Settings.dive_mode = data[1];
|
|
|
1678 break;
|
|
|
1679 case 0x21:
|
|
|
1680 if(!checkValue(data[1],1,2))
|
|
|
1681 return ERROR_;
|
|
|
1682 Settings.deco_type.ub.standard = data[1] & 0x0F;
|
|
|
1683 //Settings.deco_type.ub.alternative = (data[1] & 0xF0) >> 4;
|
|
|
1684 break;
|
|
|
1685 case 0x22:
|
|
|
1686 if(!checkValue(data[1],100,190))
|
|
|
1687 return ERROR_;
|
|
|
1688 Settings.ppO2_max_std = data[1];
|
|
|
1689 break;
|
|
|
1690 case 0x23:
|
|
|
1691 if(!checkValue(data[1],15,15))
|
|
|
1692 return ERROR_;
|
|
|
1693 Settings.ppO2_min = data[1];
|
|
|
1694 break;
|
|
|
1695 case 0x24:
|
|
|
1696 if(!checkValue(data[1],0,15))
|
|
|
1697 return ERROR_;
|
|
|
1698 Settings.future_TTS = data[1];
|
|
|
1699 break;
|
|
|
1700 case 0x25:
|
|
|
1701 if(!checkValue(data[1],10,99))
|
|
|
1702 return ERROR_;
|
|
|
1703 Settings.GF_low = data[1];
|
|
|
1704 break;
|
|
|
1705 case 0x26:
|
|
|
1706 if(!checkValue(data[1],45,99))
|
|
|
1707 return ERROR_;
|
|
|
1708 Settings.GF_high = data[1];
|
|
|
1709 break;
|
|
|
1710 case 0x27:
|
|
|
1711 if(!checkValue(data[1],10,99))
|
|
|
1712 return ERROR_;
|
|
|
1713 Settings.aGF_low = data[1];
|
|
|
1714 break;
|
|
|
1715 case 0x28:
|
|
|
1716 if(!checkValue(data[1],45,99))
|
|
|
1717 return ERROR_;
|
|
|
1718 Settings.aGF_high = data[1];
|
|
|
1719 break;
|
|
|
1720 case 0x29:
|
|
|
1721 if(!checkValue(data[1],0,5))
|
|
|
1722 return ERROR_;
|
|
|
1723 Settings.VPM_conservatism.ub.standard = data[1];
|
|
|
1724 break;
|
|
|
1725 case 0x2A:
|
|
|
1726 case 0x2B:
|
|
|
1727 return ERROR_;
|
|
|
1728 case 0x2C:
|
|
|
1729 if(!checkValue(data[1],3,9))
|
|
|
1730 return ERROR_;
|
|
|
1731 Settings.last_stop_depth_meter = data[1];
|
|
|
1732 break;
|
|
|
1733 case 0x2D:
|
|
|
1734 if(!checkValue(data[1],0,4))
|
|
|
1735 return ERROR_;
|
|
|
1736 Settings.brightness = data[1];
|
|
|
1737 break;
|
|
|
1738 case 0x2E:
|
|
|
1739 if(!checkValue(data[1],0,1))
|
|
|
1740 return ERROR_;
|
|
|
1741 Settings.nonMetricalSystem = data[1];
|
|
|
1742 break;
|
|
|
1743 case 0x2F:
|
|
|
1744 return ERROR_;
|
|
|
1745 case 0x30:
|
|
|
1746 if(!checkValue(data[1],0,4))
|
|
|
1747 return ERROR_;
|
|
|
1748 Settings.salinity = data[1];
|
|
|
1749 break;
|
|
|
1750 case 0x31:
|
|
|
1751 if(!checkValue(data[1],0,3))
|
|
|
1752 return ERROR_;
|
|
|
1753 Settings.tX_colorscheme = data[1];
|
|
|
1754 GFX_use_colorscheme(Settings.tX_colorscheme);
|
|
|
1755 break;
|
|
|
1756 case 0x32:
|
|
|
1757 if(!checkValue(data[1],0,4))
|
|
|
1758 return ERROR_;
|
|
|
1759 Settings.selected_language = data[1];
|
|
|
1760 break;
|
|
|
1761 case 0x33:
|
|
|
1762 if(!checkValue(data[1],0,2))
|
|
|
1763 return ERROR_;
|
|
|
1764 Settings.date_format = data[1];
|
|
|
1765 break;
|
|
|
1766 case 0x34:
|
|
|
1767 return ERROR_;
|
|
|
1768 case 0x35:
|
|
|
1769 if(data[1] & 0x80)
|
|
|
1770 {
|
|
|
1771 data[1] = ~(data[1]);
|
|
|
1772 if(!checkValue(data[1],0,20))
|
|
|
1773 return ERROR_;
|
|
|
1774 Settings.offsetPressure_mbar = 0 - data[1];
|
|
|
1775 }
|
|
|
1776 else
|
|
|
1777 {
|
|
|
1778 if(!checkValue(data[1],0,20))
|
|
|
1779 return ERROR_;
|
|
|
1780 Settings.offsetPressure_mbar = data[1];
|
|
|
1781 }
|
|
|
1782 break;
|
|
|
1783 case 0x36:
|
|
|
1784 if(!checkValue(data[1],0,1))
|
|
|
1785 return ERROR_;
|
|
|
1786 if(data[1])
|
|
|
1787 Settings.safetystopDuration = settingsGetPointerStandard()->safetystopDuration;
|
|
|
1788 else
|
|
|
1789 Settings.safetystopDuration = 0;
|
|
|
1790 break;
|
|
|
1791 case 0x37:
|
|
|
1792 return ERROR_;
|
|
|
1793 case 0x38:
|
|
|
1794 if(!checkValue(data[1],0,1))
|
|
|
1795 return ERROR_;
|
|
|
1796 Settings.fallbackToFixedSetpoint = data[1];
|
|
|
1797 break;
|
|
|
1798 case 0x39:
|
|
|
1799 return ERROR_;
|
|
|
1800 case 0x3A:
|
|
|
1801 if(!checkValue(data[1],70,110))
|
|
|
1802 return ERROR_;
|
|
|
1803 newSensitivity = data[1];
|
|
|
1804 settingsHelperButtonSens_keepPercentageValues(newSensitivity, settingsGetPointer()->ButtonResponsiveness);
|
|
|
1805 setButtonResponsiveness(Settings.ButtonResponsiveness);
|
|
|
1806 break;
|
|
|
1807 case 0x3B:
|
|
|
1808 // value between 0 and 127
|
|
|
1809 if(buttonBalanceTranslatorHexToArray(data[1], settingsGetPointer()->buttonBalance))
|
|
|
1810 {
|
|
|
1811 settingsHelperButtonSens_keepPercentageValues(settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness);
|
|
|
1812 }
|
|
|
1813 else // value >= 128 (bit 7 set) factory reset
|
|
|
1814 {
|
|
|
1815 getButtonFactorDefaults(&settingsGetPointer()->ButtonResponsiveness[3], settingsGetPointer()->buttonBalance);
|
|
|
1816 settingsHelperButtonSens_keepPercentageValues(settingsGetPointerStandard()->ButtonResponsiveness[3], settingsGetPointer()->ButtonResponsiveness);
|
|
|
1817 }
|
|
|
1818 // valid for both:
|
|
|
1819 setButtonResponsiveness(Settings.ButtonResponsiveness);
|
|
|
1820 break;
|
|
|
1821 case 0x3C:
|
|
|
1822 if(!checkValue(data[1],5,50))
|
|
|
1823 return ERROR_;
|
|
|
1824 Settings.gasConsumption_bottom_l_min = data[1];
|
|
|
1825 break;
|
|
|
1826 case 0x3D:
|
|
|
1827 if(!checkValue(data[1],5,50))
|
|
|
1828 return ERROR_;
|
|
|
1829 Settings.gasConsumption_deco_l_min = data[1];
|
|
|
1830 break;
|
|
|
1831 case 0x3E:
|
|
|
1832 if(!checkValue(data[1],5,50))
|
|
|
1833 return ERROR_;
|
|
|
1834 Settings.gasConsumption_travel_l_min = data[1];
|
|
|
1835 break;
|
|
|
1836 case 0x3F:
|
|
|
1837 case 0x40:
|
|
|
1838 return ERROR_;
|
|
|
1839 case 0x41:
|
|
|
1840 if(!checkValue(data[1],0,1))
|
|
|
1841 return ERROR_;
|
|
|
1842 Settings.alwaysShowPPO2 = data[1];
|
|
|
1843 break;
|
|
|
1844 case 0x42:
|
|
|
1845 if(data[1] & 0x80)
|
|
|
1846 {
|
|
|
1847 data[1] = ~(data[1]);
|
|
|
1848 if(!checkValue(data[1],0,20))
|
|
|
1849 return ERROR_;
|
|
|
1850 Settings.offsetTemperature_centigrad = 0 - data[1];
|
|
|
1851 }
|
|
|
1852 else
|
|
|
1853 {
|
|
|
1854 if(!checkValue(data[1],0,20))
|
|
|
1855 return ERROR_;
|
|
|
1856 Settings.offsetTemperature_centigrad = data[1];
|
|
|
1857 }
|
|
|
1858 break;
|
|
|
1859 case 0x43:
|
|
|
1860 if(!checkValue(data[1],60,255))
|
|
|
1861 return ERROR_;
|
|
|
1862 newDuration = (uint16_t)data[1] + 59;
|
|
|
1863 newDuration /= 60;
|
|
|
1864 Settings.safetystopDuration = (uint8_t)newDuration;
|
|
|
1865 break;
|
|
|
1866 case 0x44:
|
|
|
1867 if(!checkValue(data[1],21,61))
|
|
|
1868 return ERROR_;
|
|
|
1869 newStopDepth = data[1] + 9;
|
|
|
1870 if(newStopDepth > 60)
|
|
|
1871 newStopDepth = 60;
|
|
|
1872 newStopDepth /= 10;
|
|
|
1873 Settings.safetystopDepth = newStopDepth;
|
|
|
1874 break;
|
|
|
1875 case 0x45:
|
|
|
1876 case 0x46:
|
|
|
1877 return ERROR_;
|
|
|
1878 case 0x47:
|
|
|
1879 newOffset = data[2] * 256;
|
|
|
1880 newOffset += data[1];
|
|
|
1881 if(newOffset > 9000)
|
|
|
1882 return ERROR_;
|
|
|
1883 Settings.logbookOffset = newOffset;
|
|
|
1884 break;
|
|
|
1885 case 0x70:
|
|
|
1886 if(!checkValue(data[1],0,1))
|
|
|
1887 return ERROR_;
|
|
|
1888 Settings.showDebugInfo = data[1];
|
|
|
1889 break;
|
|
|
1890 case 0x71:
|
|
|
1891 if(!checkValue(data[1],0,(EXTRADISPLAY_END - 1)))
|
|
|
1892 return ERROR_;
|
|
|
1893 Settings.extraDisplay = data[1];
|
|
|
1894 break;
|
|
|
1895 case 0x72:
|
|
|
1896 if(!checkValue(data[1],0,8))
|
|
|
1897 return ERROR_;
|
|
|
1898 Settings.tX_customViewPrimary = data[1];
|
|
|
1899 break;
|
|
|
1900 case 0x73:
|
|
|
1901 if(!checkValue(data[1],0,20))
|
|
|
1902 return ERROR_;
|
|
|
1903 Settings.tX_customViewTimeout = data[1];
|
|
|
1904 break;
|
|
|
1905 case 0x74:
|
|
|
1906 if(!checkValue(data[1],1,7))
|
|
|
1907 return ERROR_;
|
|
|
1908 Settings.tX_userselectedLeftLowerCornerPrimary = data[1];
|
|
|
1909 break;
|
|
|
1910 case 0x75:
|
|
|
1911 if(!checkValue(data[1],0,20))
|
|
|
1912 return ERROR_;
|
|
|
1913 Settings.tX_userselectedLeftLowerCornerTimeout = data[1];
|
|
|
1914 break;
|
|
|
1915 }
|
|
|
1916 return 0;
|
|
|
1917 }
|
|
|
1918
|
|
|
1919
|
|
|
1920 uint8_t readDataLimits__8and16BitValues_4and7BytesOutput(uint8_t what, uint8_t * data)
|
|
|
1921 {
|
|
|
1922 enum JeanDoParameterType {
|
|
|
1923 PARAM_UNKNOWN = 0,
|
|
|
1924 PARAM_INT15 = 1,
|
|
|
1925 PARAM_INT8,
|
|
|
1926 PARAM_DECI,
|
|
|
1927 PARAM_CENTI,
|
|
|
1928 PARAM_MILI,
|
|
|
1929 PARAM_PERCENT,
|
|
|
1930 PARAM_SEC,
|
|
|
1931 PARAM_COLOR,
|
|
|
1932 PARAM_BOOL,
|
|
|
1933 PARAM_ENUM,
|
|
|
1934 PARAM_SIGNED = 128,
|
|
|
1935 PARAM_SDECI = PARAM_SIGNED|PARAM_DECI,
|
|
|
1936 PARAM_SSEC = PARAM_SIGNED|PARAM_SEC,
|
|
|
1937 PARAM_SINT = PARAM_SIGNED|PARAM_INT8
|
|
|
1938 };
|
|
|
1939
|
|
|
1940 // uint32_t buttonSensitivity;
|
|
|
1941 uint16_t newDuration;
|
|
|
1942
|
|
|
1943 uint8_t datacounter = 0;
|
|
|
1944
|
|
|
1945 data[0] = 0;
|
|
|
1946 data[1] = 0;
|
|
|
1947 data[2] = 0;
|
|
|
1948 data[3] = 0;
|
|
|
1949 datacounter = 0;
|
|
|
1950
|
|
|
1951 switch(what)
|
|
|
1952 {
|
|
|
1953 case 0x10:
|
|
|
1954 case 0x11:
|
|
|
1955 case 0x12:
|
|
|
1956 case 0x13:
|
|
|
1957 case 0x14:
|
|
|
1958 data[datacounter++] = PARAM_INT8;
|
|
|
1959 data[datacounter++] = 4;
|
|
|
1960 data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage;
|
|
|
1961 data[datacounter++] = 100;
|
|
|
1962 break;
|
|
|
1963
|
|
|
1964 case 0x15:
|
|
|
1965 case 0x16:
|
|
|
1966 case 0x17:
|
|
|
1967 case 0x18:
|
|
|
1968 case 0x19:
|
|
|
1969 data[datacounter++] = PARAM_INT8;
|
|
|
1970 data[datacounter++] = 4;
|
|
|
1971 data[datacounter++] = settingsGetPointerStandard()->gas[1].oxygen_percentage;
|
|
|
1972 data[datacounter++] = 100;
|
|
|
1973 break;
|
|
|
1974
|
|
|
1975 case 0x1A:
|
|
|
1976 case 0x1B:
|
|
|
1977 case 0x1C:
|
|
|
1978 case 0x1D:
|
|
|
1979 case 0x1E:
|
|
|
1980 data[datacounter++] = PARAM_CENTI;
|
|
|
1981 data[datacounter++] = 50;
|
|
|
1982 data[datacounter++] = settingsGetPointerStandard()->setpoint[1].setpoint_cbar;
|
|
|
1983 data[datacounter++] = 160;
|
|
|
1984 break;
|
|
|
1985
|
|
|
1986 case 0x1F:
|
|
|
1987 data[datacounter++] = PARAM_ENUM;
|
|
|
1988 data[datacounter++] = 0;
|
|
|
1989 data[datacounter++] = settingsGetPointerStandard()->CCR_Mode;
|
|
|
1990 data[datacounter++] = 1;
|
|
|
1991 break;
|
|
|
1992
|
|
|
1993 case 0x20:
|
|
|
1994 data[datacounter++] = PARAM_ENUM;
|
|
|
1995 data[datacounter++] = 0;
|
|
|
1996 data[datacounter++] = settingsGetPointerStandard()->dive_mode;
|
|
|
1997 data[datacounter++] = 3;
|
|
|
1998 break;
|
|
|
1999
|
|
|
2000 case 0x21:
|
|
|
2001 data[datacounter++] = PARAM_ENUM;
|
|
|
2002 data[datacounter++] = 1;
|
|
|
2003 data[datacounter++] = settingsGetPointerStandard()->deco_type.ub.standard;
|
|
|
2004 data[datacounter++] = 2;
|
|
|
2005 break;
|
|
|
2006
|
|
|
2007 case 0x22:
|
|
|
2008 data[datacounter++] = PARAM_CENTI;
|
|
|
2009 data[datacounter++] = 100;
|
|
|
2010 data[datacounter++] = settingsGetPointerStandard()->ppO2_max_std;
|
|
|
2011 data[datacounter++] = 190;
|
|
|
2012 break;
|
|
|
2013
|
|
|
2014 case 0x23:
|
|
|
2015 data[datacounter++] = PARAM_CENTI;
|
|
|
2016 data[datacounter++] = 15;
|
|
|
2017 data[datacounter++] = settingsGetPointerStandard()->ppO2_min;
|
|
|
2018 data[datacounter++] = 15;
|
|
|
2019 break;
|
|
|
2020
|
|
|
2021 case 0x24:
|
|
|
2022 data[datacounter++] = PARAM_INT8; // minutes
|
|
|
2023 data[datacounter++] = 0;
|
|
|
2024 data[datacounter++] = settingsGetPointerStandard()->future_TTS;
|
|
|
2025 data[datacounter++] = 15;
|
|
|
2026 break;
|
|
|
2027
|
|
|
2028 case 0x25:
|
|
|
2029 data[datacounter++] = PARAM_PERCENT;
|
|
|
2030 data[datacounter++] = 10;
|
|
|
2031 data[datacounter++] = settingsGetPointerStandard()->GF_low;
|
|
|
2032 data[datacounter++] = 99;
|
|
|
2033 break;
|
|
|
2034
|
|
|
2035 case 0x26:
|
|
|
2036 data[datacounter++] = PARAM_PERCENT;
|
|
|
2037 data[datacounter++] = 45;
|
|
|
2038 data[datacounter++] = settingsGetPointerStandard()->GF_high;
|
|
|
2039 data[datacounter++] = 99;
|
|
|
2040 break;
|
|
|
2041
|
|
|
2042 case 0x27:
|
|
|
2043 data[datacounter++] = PARAM_PERCENT;
|
|
|
2044 data[datacounter++] = 10;
|
|
|
2045 data[datacounter++] = settingsGetPointerStandard()->aGF_low;
|
|
|
2046 data[datacounter++] = 99;
|
|
|
2047 break;
|
|
|
2048
|
|
|
2049 case 0x28:
|
|
|
2050 data[datacounter++] = PARAM_PERCENT;
|
|
|
2051 data[datacounter++] = 45;
|
|
|
2052 data[datacounter++] = settingsGetPointerStandard()->aGF_high;
|
|
|
2053 data[datacounter++] = 99;
|
|
|
2054 break;
|
|
|
2055
|
|
|
2056 case 0x29:
|
|
|
2057 data[datacounter++] = PARAM_INT8; // conservatism +0 .. +5
|
|
|
2058 data[datacounter++] = 0;
|
|
|
2059 data[datacounter++] = settingsGetPointerStandard()->VPM_conservatism.ub.standard;
|
|
|
2060 data[datacounter++] = 5;
|
|
|
2061 break;
|
|
|
2062
|
|
|
2063 case 0x2A:
|
|
|
2064 case 0x2B:
|
|
|
2065 data[datacounter++] = PARAM_PERCENT;
|
|
|
2066 data[datacounter++] = 100;
|
|
|
2067 data[datacounter++] = 100;// saturation, desaturation, settingsGetPointerStandard()->;
|
|
|
2068 data[datacounter++] = 100;
|
|
|
2069 break;
|
|
|
2070
|
|
|
2071 case 0x2C:
|
|
|
2072 data[datacounter++] = PARAM_INT8;
|
|
|
2073 data[datacounter++] = 3;
|
|
|
2074 data[datacounter++] = settingsGetPointerStandard()->last_stop_depth_meter;
|
|
|
2075 data[datacounter++] = 9;
|
|
|
2076 break;
|
|
|
2077
|
|
|
2078 case 0x2D:
|
|
|
2079 data[datacounter++] = PARAM_ENUM;
|
|
|
2080 data[datacounter++] = 0;
|
|
|
2081 data[datacounter++] = settingsGetPointerStandard()->brightness;
|
|
|
2082 data[datacounter++] = 4;
|
|
|
2083 break;
|
|
|
2084
|
|
|
2085 case 0x2E:
|
|
|
2086 data[datacounter++] = PARAM_ENUM;
|
|
|
2087 data[datacounter++] = 0;
|
|
|
2088 data[datacounter++] = settingsGetPointerStandard()->nonMetricalSystem;
|
|
|
2089 data[datacounter++] = 1;
|
|
|
2090 break;
|
|
|
2091
|
|
|
2092 case 0x2F:
|
|
|
2093 data[datacounter++] = PARAM_INT8; // Sampling rate logbook
|
|
|
2094 data[datacounter++] = 2;
|
|
|
2095 data[datacounter++] = 2;
|
|
|
2096 data[datacounter++] = 2;
|
|
|
2097 break;
|
|
|
2098
|
|
|
2099 case 0x30:
|
|
|
2100 data[datacounter++] = PARAM_PERCENT;
|
|
|
2101 data[datacounter++] = 0;
|
|
|
2102 data[datacounter++] = settingsGetPointerStandard()->salinity;
|
|
|
2103 data[datacounter++] = 4;
|
|
|
2104 break;
|
|
|
2105
|
|
|
2106 case 0x31:
|
|
|
2107 data[datacounter++] = PARAM_INT8;
|
|
|
2108 data[datacounter++] = 0;
|
|
|
2109 data[datacounter++] = settingsGetPointerStandard()->tX_colorscheme;
|
|
|
2110 data[datacounter++] = 3;
|
|
|
2111 break;
|
|
|
2112
|
|
|
2113 case 0x32:
|
|
|
2114 data[datacounter++] = PARAM_ENUM;
|
|
|
2115 data[datacounter++] = 0;
|
|
|
2116 data[datacounter++] = settingsGetPointerStandard()->selected_language;
|
|
|
2117 data[datacounter++] = 1;
|
|
|
2118 break;
|
|
|
2119
|
|
|
2120 case 0x33:
|
|
|
2121 data[datacounter++] = PARAM_ENUM;
|
|
|
2122 data[datacounter++] = 0;
|
|
|
2123 data[datacounter++] = settingsGetPointerStandard()->date_format;
|
|
|
2124 data[datacounter++] = 2;
|
|
|
2125 break;
|
|
|
2126
|
|
|
2127 case 0x34:
|
|
|
2128 data[datacounter++] = PARAM_UNKNOWN ;
|
|
|
2129 data[datacounter++] = 0;
|
|
|
2130 data[datacounter++] = 0; // compass gain, is unknown,, settingsGetPointerStandard()->;
|
|
|
2131 data[datacounter++] = 0;
|
|
|
2132 break;
|
|
|
2133
|
|
|
2134 case 0x35:
|
|
|
2135 data[datacounter++] = PARAM_SINT;
|
|
|
2136 data[datacounter++] = (uint8_t)(256 - 20); // == -20
|
|
|
2137 if(settingsGetPointerStandard()->offsetPressure_mbar < 0)
|
|
|
2138 data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetPressure_mbar);
|
|
|
2139 else
|
|
|
2140 data[datacounter++] = settingsGetPointerStandard()->offsetPressure_mbar;
|
|
|
2141 data[datacounter++] = 20;
|
|
|
2142 break;
|
|
|
2143
|
|
|
2144 case 0x36:
|
|
|
2145 data[datacounter++] = PARAM_BOOL;
|
|
|
2146 data[datacounter++] = 0;
|
|
|
2147 if(settingsGetPointerStandard()->safetystopDuration)
|
|
|
2148 data[datacounter++] = 1;
|
|
|
2149 else
|
|
|
2150 data[datacounter++] = 0;
|
|
|
2151 data[datacounter++] = 1;
|
|
|
2152 break;
|
|
|
2153
|
|
|
2154 case 0x37:
|
|
|
2155 data[datacounter++] = PARAM_UNKNOWN ;
|
|
|
2156 data[datacounter++] = 0;
|
|
|
2157 data[datacounter++] = 0; // Set calibration gas, not possible with optical
|
|
|
2158 data[datacounter++] = 0;
|
|
|
2159 break;
|
|
|
2160
|
|
|
2161 case 0x38:
|
|
|
2162 data[datacounter++] = PARAM_BOOL;
|
|
|
2163 data[datacounter++] = 0;
|
|
|
2164 data[datacounter++] = settingsGetPointerStandard()->fallbackToFixedSetpoint;
|
|
|
2165 data[datacounter++] = 1;
|
|
|
2166 break;
|
|
|
2167
|
|
|
2168 case 0x39:
|
|
|
2169 data[datacounter++] = PARAM_BOOL;
|
|
|
2170 data[datacounter++] = 0;
|
|
|
2171 data[datacounter++] = 0; // flipscreen, not yet :-) settingsGetPointerStandard()->;
|
|
|
2172 data[datacounter++] = 0;
|
|
|
2173 break;
|
|
|
2174
|
|
|
2175 case 0x3A:
|
|
|
2176 data[datacounter++] = PARAM_PERCENT;
|
|
|
2177 data[datacounter++] = 70;
|
|
|
2178 data[datacounter++] = settingsGetPointerStandard()->ButtonResponsiveness[3];
|
|
|
2179 data[datacounter++] = 110;
|
|
|
2180 break;
|
|
|
2181
|
|
|
2182 case 0x3B:
|
|
|
2183 data[datacounter++] = PARAM_UNKNOWN;
|
|
|
2184 data[datacounter++] = 0;
|
|
|
2185 data[datacounter++] = buttonBalanceTranslateArrayOutHex(settingsGetPointerStandard()->buttonBalance);
|
|
|
2186 data[datacounter++] = 128;
|
|
|
2187 break;
|
|
|
2188
|
|
|
2189 case 0x3C:
|
|
|
2190 data[datacounter++] = PARAM_INT8;
|
|
|
2191 data[datacounter++] = 5;
|
|
|
2192 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_bottom_l_min;
|
|
|
2193 data[datacounter++] = 50;
|
|
|
2194 break;
|
|
|
2195
|
|
|
2196 case 0x3D:
|
|
|
2197 data[datacounter++] = PARAM_INT8;
|
|
|
2198 data[datacounter++] = 5;
|
|
|
2199 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_deco_l_min;
|
|
|
2200 data[datacounter++] = 50;
|
|
|
2201 break;
|
|
|
2202
|
|
|
2203 case 0x3E:
|
|
|
2204 data[datacounter++] = PARAM_INT8;
|
|
|
2205 data[datacounter++] = 5;
|
|
|
2206 data[datacounter++] = settingsGetPointerStandard()->gasConsumption_travel_l_min;
|
|
|
2207 data[datacounter++] = 50;
|
|
|
2208 break;
|
|
|
2209
|
|
|
2210 case 0x3F:
|
|
|
2211 data[datacounter++] = PARAM_UNKNOWN;
|
|
|
2212 data[datacounter++] = 0;
|
|
|
2213 data[datacounter++] = 0; // Dynamic ascend rate, not yet :-) settingsGetPointerStandard()->;
|
|
|
2214 data[datacounter++] = 0;
|
|
|
2215 break;
|
|
|
2216
|
|
|
2217 case 0x40:
|
|
|
2218 data[datacounter++] = PARAM_BOOL;
|
|
|
2219 data[datacounter++] = 1;
|
|
|
2220 data[datacounter++] = 1; // Graphical speed indicator;
|
|
|
2221 data[datacounter++] = 1;
|
|
|
2222 break;
|
|
|
2223
|
|
|
2224 case 0x41:
|
|
|
2225 data[datacounter++] = PARAM_BOOL;
|
|
|
2226 data[datacounter++] = 0;
|
|
|
2227 data[datacounter++] = settingsGetPointerStandard()->alwaysShowPPO2;
|
|
|
2228 data[datacounter++] = 1;
|
|
|
2229 break;
|
|
|
2230
|
|
|
2231 case 0x42:
|
|
|
2232 data[datacounter++] = PARAM_SIGNED|PARAM_CENTI;
|
|
|
2233 data[datacounter++] = (uint8_t)(256 - 20); // == -20
|
|
|
2234 if(settingsGetPointerStandard()->offsetTemperature_centigrad < 0)
|
|
|
2235 data[datacounter++] = (uint8_t)(127 - settingsGetPointerStandard()->offsetTemperature_centigrad);
|
|
|
2236 else
|
|
|
2237 data[datacounter++] = settingsGetPointerStandard()->offsetTemperature_centigrad;
|
|
|
2238 data[datacounter++] = 20;
|
|
|
2239 break;
|
|
|
2240
|
|
|
2241 case 0x43:
|
|
|
2242 newDuration = settingsGetPointerStandard()->safetystopDuration;
|
|
|
2243 newDuration *= 60;
|
|
|
2244 if(newDuration > 255)
|
|
|
2245 newDuration = 255;
|
|
|
2246 data[datacounter++] = PARAM_INT8;
|
|
|
2247 data[datacounter++] = 60; // coud be 1 minute instead
|
|
|
2248 data[datacounter++] = (uint8_t)newDuration;
|
|
|
2249 data[datacounter++] = 255; // could be 5 minutes instead
|
|
|
2250 break;
|
|
|
2251
|
|
|
2252 case 0x44:
|
|
|
2253 data[datacounter++] = PARAM_INT8;
|
|
|
2254 data[datacounter++] = 30; // coud be 3 meter instead
|
|
|
2255 data[datacounter++] = settingsGetPointerStandard()->safetystopDepth * 10;
|
|
|
2256 data[datacounter++] = 60; // could be 6 meter instead
|
|
|
2257 break;
|
|
|
2258
|
|
|
2259 case 0x45:
|
|
|
2260 case 0x46:
|
|
|
2261 data[datacounter++] = PARAM_UNKNOWN;
|
|
|
2262 data[datacounter++] = 0;
|
|
|
2263 data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth
|
|
|
2264 data[datacounter++] = 0;
|
|
|
2265 break;
|
|
|
2266
|
|
|
2267 case 0x47:
|
|
|
2268 data[datacounter++] = PARAM_INT15;
|
|
|
2269 data[datacounter++] = 0;
|
|
|
2270 data[datacounter++] = 0;
|
|
|
2271 data[datacounter++] = settingsGetPointerStandard()->logbookOffset & 0xFF;
|
|
|
2272 data[datacounter++] = settingsGetPointerStandard()->logbookOffset / 0xFF;
|
|
|
2273 data[datacounter++] = 9000 & 0xFF;
|
|
|
2274 data[datacounter++] = 9000 / 0xFF;
|
|
|
2275 break;
|
|
|
2276
|
|
|
2277 case 0x70:
|
|
|
2278 data[datacounter++] = PARAM_BOOL;
|
|
|
2279 data[datacounter++] = 0;
|
|
|
2280 data[datacounter++] = settingsGetPointerStandard()->showDebugInfo;
|
|
|
2281 data[datacounter++] = 1;
|
|
|
2282 break;
|
|
|
2283
|
|
|
2284 case 0x71:
|
|
|
2285 data[datacounter++] = PARAM_ENUM;
|
|
|
2286 data[datacounter++] = 0;
|
|
|
2287 data[datacounter++] = settingsGetPointerStandard()->extraDisplay;
|
|
|
2288 data[datacounter++] = (EXTRADISPLAY_END - 1);
|
|
|
2289 break;
|
|
|
2290
|
|
|
2291 case 0x72:
|
|
|
2292 data[datacounter++] = PARAM_ENUM;
|
|
|
2293 data[datacounter++] = 0;
|
|
|
2294 data[datacounter++] = settingsGetPointerStandard()->tX_customViewPrimary;
|
|
|
2295 data[datacounter++] = 8;
|
|
|
2296 break;
|
|
|
2297
|
|
|
2298 case 0x73:
|
|
|
2299 data[datacounter++] = PARAM_INT8;
|
|
|
2300 data[datacounter++] = 0;
|
|
|
2301 data[datacounter++] = settingsGetPointerStandard()->tX_customViewTimeout;
|
|
|
2302 data[datacounter++] = 60;
|
|
|
2303 break;
|
|
|
2304
|
|
|
2305 case 0x74:
|
|
|
2306 data[datacounter++] = PARAM_ENUM;
|
|
|
2307 data[datacounter++] = 1;
|
|
|
2308 data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerPrimary;
|
|
|
2309 data[datacounter++] = 7;
|
|
|
2310 break;
|
|
|
2311
|
|
|
2312 case 0x75:
|
|
|
2313 data[datacounter++] = PARAM_INT8;
|
|
|
2314 data[datacounter++] = 0;
|
|
|
2315 data[datacounter++] = settingsGetPointerStandard()->tX_userselectedLeftLowerCornerTimeout;
|
|
|
2316 data[datacounter++] = 60;
|
|
|
2317 break;
|
|
|
2318 }
|
|
|
2319
|
|
|
2320 if(datacounter == 0)
|
|
|
2321 {
|
|
|
2322 data[datacounter++] = PARAM_UNKNOWN;
|
|
|
2323 data[datacounter++] = 0;
|
|
|
2324 data[datacounter++] = 0; // SafetyStop End Depth and SafetyStop Reset Depth
|
|
|
2325 data[datacounter++] = 0;
|
|
|
2326 }
|
|
|
2327
|
|
|
2328 return datacounter;
|
|
|
2329 }
|
|
|
2330
|
|
|
2331
|
|
|
2332 uint8_t readData(uint8_t what, uint8_t * data)
|
|
|
2333 {
|
|
|
2334 data[0] = 0;
|
|
|
2335 data[1] = 0;
|
|
|
2336 data[2] = 0;
|
|
|
2337 data[3] = 0;
|
|
|
2338 switch(what)
|
|
|
2339 {
|
|
|
2340 case 0x10:
|
|
|
2341 return getGas(1,data);
|
|
|
2342 case 0x11:
|
|
|
2343 return getGas(2,data);
|
|
|
2344 case 0x12:
|
|
|
2345 return getGas(3,data);
|
|
|
2346 case 0x13:
|
|
|
2347 return getGas(4,data);
|
|
|
2348 case 0x14:
|
|
|
2349 return getGas(5,data);
|
|
|
2350 case 0x15:
|
|
|
2351 return getDiluent(1,data);
|
|
|
2352 case 0x16:
|
|
|
2353 return getDiluent(2,data);
|
|
|
2354 case 0x17:
|
|
|
2355 return getDiluent(3,data);
|
|
|
2356 case 0x18:
|
|
|
2357 return getDiluent(4,data);
|
|
|
2358 case 0x19:
|
|
|
2359 return getDiluent(5,data);
|
|
|
2360 case 0x1A:
|
|
|
2361 return getSetpoint(1,data);
|
|
|
2362 case 0x1B:
|
|
|
2363 return getSetpoint(2,data);
|
|
|
2364 case 0x1C:
|
|
|
2365 return getSetpoint(3,data);
|
|
|
2366 case 0x1D:
|
|
|
2367 return getSetpoint(4,data);
|
|
|
2368 case 0x1E:
|
|
|
2369 return getSetpoint(5,data);
|
|
|
2370 case 0x1F:
|
|
|
2371 data[0] = Settings.CCR_Mode;
|
|
|
2372 break;
|
|
|
2373 case 0x20:
|
|
|
2374 data[0] = Settings.dive_mode;
|
|
|
2375 break;
|
|
|
2376 case 0x21:
|
|
|
2377 data[0] = Settings.deco_type.ub.standard;
|
|
|
2378 break;
|
|
|
2379 case 0x22:
|
|
|
2380 data[0] = Settings.ppO2_max_std;
|
|
|
2381 break;
|
|
|
2382 case 0x23:
|
|
|
2383 data[0] = Settings.ppO2_min;
|
|
|
2384 break;
|
|
|
2385 case 0x24:
|
|
|
2386 data[0] = Settings.future_TTS;
|
|
|
2387 break;
|
|
|
2388 case 0x25:
|
|
|
2389 data[0] = Settings.GF_low;
|
|
|
2390 break;
|
|
|
2391 case 0x26:
|
|
|
2392 data[0] = Settings.GF_high;
|
|
|
2393 break;
|
|
|
2394 case 0x27:
|
|
|
2395 data[0] = Settings.aGF_low;
|
|
|
2396 break;
|
|
|
2397 case 0x28:
|
|
|
2398 data[0] = Settings.aGF_high;
|
|
|
2399 break;
|
|
|
2400 case 0x29:
|
|
|
2401 data[0] = Settings.VPM_conservatism.ub.standard;
|
|
|
2402 break;
|
|
|
2403 case 0x2A:
|
|
|
2404 case 0x2B:
|
|
|
2405 data[0] = 100;
|
|
|
2406 break;
|
|
|
2407 case 0x2C:
|
|
|
2408 data[0] = Settings.last_stop_depth_meter;
|
|
|
2409 break;
|
|
|
2410 case 0x2D:
|
|
|
2411 data[0] = Settings.brightness;
|
|
|
2412 break;
|
|
|
2413 case 0x2E:
|
|
|
2414 data[0] = Settings.nonMetricalSystem;
|
|
|
2415 break;
|
|
|
2416 case 0x2F:
|
|
|
2417 data[0] = 0; // 0 == 2 sec sampling rate
|
|
|
2418 break;
|
|
|
2419 case 0x30:
|
|
|
2420 data[0] = Settings.salinity;
|
|
|
2421 break;
|
|
|
2422 case 0x31:
|
|
|
2423 data[0] = Settings.tX_colorscheme;
|
|
|
2424 break;
|
|
|
2425 case 0x32:
|
|
|
2426 data[0] = Settings.selected_language;
|
|
|
2427 break;
|
|
|
2428 case 0x33:
|
|
|
2429 data[0] = Settings.date_format;
|
|
|
2430 break;
|
|
|
2431 case 0x34:
|
|
|
2432 data[0] = 7; // gain should be always 7 as far as I understand the code in RTE
|
|
|
2433 break;
|
|
|
2434 case 0x35:
|
|
|
2435 data[0] = Settings.offsetPressure_mbar;
|
|
|
2436 break;
|
|
|
2437 case 0x36:
|
|
|
2438 if(Settings.safetystopDepth)
|
|
|
2439 data[0] = 1;
|
|
|
2440 else
|
|
|
2441 data[0] = 0;
|
|
|
2442 break;
|
|
|
2443 case 0x37:
|
|
|
2444 data[0] = 0; // calibration gas %O2 -> 0 no gas :-)
|
|
|
2445 break;
|
|
|
2446 case 0x38:
|
|
|
2447 data[0] = Settings.fallbackToFixedSetpoint;
|
|
|
2448 break;
|
|
|
2449 case 0x39:
|
|
|
2450 data[0] = 0; // flip screen
|
|
|
2451 break;
|
|
|
2452 case 0x3A:
|
|
|
2453 data[0] = Settings.ButtonResponsiveness[3];
|
|
|
2454 break;
|
|
|
2455 case 0x3B:
|
|
|
2456 data[0] = buttonBalanceTranslateArrayOutHex(settingsGetPointer()->buttonBalance);
|
|
|
2457 break;
|
|
|
2458 case 0x3C:
|
|
|
2459 data[0] = Settings.gasConsumption_bottom_l_min;
|
|
|
2460 break;
|
|
|
2461 case 0x3D:
|
|
|
2462 data[0] = Settings.gasConsumption_deco_l_min;
|
|
|
2463 break;
|
|
|
2464 case 0x3E:
|
|
|
2465 data[0] = Settings.gasConsumption_travel_l_min;
|
|
|
2466 break;
|
|
|
2467 case 0x3F:
|
|
|
2468 data[0] = 0; // fixed ascend rate 10 m/min
|
|
|
2469 break;
|
|
|
2470 case 0x40:
|
|
|
2471 data[0] = 1; // graphical speed indicator
|
|
|
2472 break;
|
|
|
2473 case 0x41:
|
|
|
2474 data[0] = Settings.alwaysShowPPO2;
|
|
|
2475 break;
|
|
|
2476 case 0x42:
|
|
|
2477 data[0] = Settings.offsetTemperature_centigrad;
|
|
|
2478 break;
|
|
|
2479 case 0x43:
|
|
|
2480 if(Settings.safetystopDuration > 4)
|
|
|
2481 data[0] = 255; // seconds
|
|
|
2482 else
|
|
|
2483 data[0] = 60 * Settings.safetystopDuration;
|
|
|
2484 break;
|
|
|
2485 case 0x44:
|
|
|
2486 data[0] = Settings.safetystopDepth * 10; // cbar instead of meter
|
|
|
2487 break;
|
|
|
2488 case 0x45:
|
|
|
2489 if(Settings.safetystopDepth == 3)
|
|
|
2490 data[0] = 20; // cbar
|
|
|
2491 else
|
|
|
2492 data[0] = 30; // cbar
|
|
|
2493 break;
|
|
|
2494 case 0x46:
|
|
|
2495 data[0] = 10; // reset at 10 meter as far as I understood
|
|
|
2496 break;
|
|
|
2497 case 0x47:
|
|
|
2498 data[0] = Settings.logbookOffset & 0xFF;
|
|
|
2499 data[1] = Settings.logbookOffset / 0xFF;
|
|
|
2500 break;
|
|
|
2501 case 0x70:
|
|
|
2502 data[0] = Settings.showDebugInfo;
|
|
|
2503 break;
|
|
|
2504 case 0x71:
|
|
|
2505 data[0] = Settings.extraDisplay;
|
|
|
2506 break;
|
|
|
2507 case 0x72:
|
|
|
2508 data[0] = Settings.tX_customViewPrimary;
|
|
|
2509 break;
|
|
|
2510 case 0x73:
|
|
|
2511 data[0] = Settings.tX_customViewTimeout;
|
|
|
2512 break;
|
|
|
2513 case 0x74:
|
|
|
2514 data[0] = Settings.tX_userselectedLeftLowerCornerPrimary;
|
|
|
2515 break;
|
|
|
2516 case 0x75:
|
|
|
2517 data[0] = Settings.tX_userselectedLeftLowerCornerTimeout;
|
|
|
2518 break;
|
|
|
2519 }
|
|
|
2520 return 0x4D;
|
|
|
2521 }
|
|
|
2522
|
|
|
2523
|
|
|
2524 uint8_t RTEminimum_required_high(void)
|
|
|
2525 {
|
|
|
2526 return RTErequiredHigh;
|
|
|
2527 }
|
|
|
2528 uint8_t RTEminimum_required_low(void)
|
|
|
2529 {
|
|
|
2530 return RTErequiredLow;
|
|
|
2531 }
|
|
|
2532
|
|
|
2533 uint8_t FONTminimum_required_high(void)
|
|
|
2534 {
|
|
|
2535 return FONTrequiredHigh;
|
|
|
2536 }
|
|
|
2537 uint8_t FONTminimum_required_low(void)
|
|
|
2538 {
|
|
|
2539 return FONTrequiredLow;
|
|
|
2540 }
|
|
|
2541
|
|
|
2542
|
|
|
2543 void setActualRTEversion(uint8_t high, uint8_t low)
|
|
|
2544 {
|
|
|
2545 RTEactualHigh = high;
|
|
|
2546 RTEactualLow = low;
|
|
|
2547 }
|
|
|
2548
|
|
|
2549
|
|
|
2550 void getActualRTEandFONTversion(uint8_t *RTEhigh, uint8_t *RTElow, uint8_t *FONThigh, uint8_t *FONTlow)
|
|
|
2551 {
|
|
|
2552 if(RTEhigh && RTElow)
|
|
|
2553 {
|
|
|
2554 *RTEhigh = RTEactualHigh;
|
|
|
2555 *RTElow = RTEactualLow;
|
|
|
2556 }
|
|
|
2557 if(FONThigh && FONTlow)
|
|
|
2558 {
|
|
|
2559 *FONThigh = *(uint8_t *)0x08132000;
|
|
|
2560 *FONTlow = *(uint8_t *)0x08132001;
|
|
|
2561 }
|
|
|
2562 }
|
|
|
2563
|
|
|
2564
|
|
|
2565 uint8_t getLicence(void)
|
|
|
2566 {
|
|
|
2567 //return 0xFF;
|
|
|
2568 //return LICENCEBONEX;
|
|
|
2569 return hardwareDataGetPointer()->primaryLicence;
|
|
|
2570 }
|
|
|
2571
|
|
|
2572
|
|
|
2573 void firmwareGetDate(RTC_DateTypeDef *SdateOutput)
|
|
|
2574 {
|
|
|
2575 SdateOutput->Year = firmwareDataGetPointer()->release_year;
|
|
|
2576 SdateOutput->Month = firmwareDataGetPointer()->release_month;
|
|
|
2577 SdateOutput->Date = firmwareDataGetPointer()->release_day;
|
|
|
2578 }
|
|
|
2579
|
|
|
2580
|
|
|
2581 // this should use device specific values stored in OTPROG ROM soon
|
|
|
2582 void getButtonFactorDefaults(uint8_t* basePercentage, uint8_t* buttonBalanceArray)
|
|
|
2583 {
|
|
|
2584 *basePercentage = settingsGetPointerStandard()->ButtonResponsiveness[3];
|
|
|
2585
|
|
|
2586 for(int i=0;i<3;i++)
|
|
|
2587 {
|
|
|
2588 buttonBalanceArray[i] = settingsGetPointerStandard()->buttonBalance[i];
|
|
|
2589 }
|
|
|
2590 }
|
|
|
2591
|
|
|
2592
|
|
|
2593 uint8_t buttonBalanceTranslatorHexToArray(uint8_t hexValue, uint8_t* outputArray)
|
|
|
2594 {
|
|
|
2595 if(hexValue > 127)
|
|
|
2596 return 0;
|
|
|
2597 // internal order: 0 = right, 1 = center, 2 = left
|
|
|
2598 // external order: Factory,left,center,right
|
|
|
2599 outputArray[0] = 2 + (hexValue & 0x03);
|
|
|
2600 hexValue /= 4;
|
|
|
2601 outputArray[1] = 2 + (hexValue & 0x03);
|
|
|
2602 hexValue /= 4;
|
|
|
2603 outputArray[2] = 2 + (hexValue & 0x03);
|
|
|
2604
|
|
|
2605 return 1;
|
|
|
2606 }
|
|
|
2607
|
|
|
2608
|
|
|
2609 uint8_t buttonBalanceTranslateArrayOutHex(const uint8_t* inputArray)
|
|
|
2610 {
|
|
|
2611 uint8_t hexValue = 0;
|
|
|
2612
|
|
|
2613 if(inputArray[2] > 2)
|
|
|
2614 {
|
|
|
2615 hexValue += inputArray[2] - 2;
|
|
|
2616 }
|
|
|
2617 hexValue *= 4;
|
|
|
2618
|
|
|
2619 if(inputArray[1] > 2)
|
|
|
2620 {
|
|
|
2621 hexValue += inputArray[1] - 2;
|
|
|
2622 }
|
|
|
2623 hexValue *= 4;
|
|
|
2624 if(inputArray[0] > 2)
|
|
|
2625 {
|
|
|
2626 hexValue += inputArray[0] - 2;
|
|
|
2627 }
|
|
|
2628 return hexValue;
|
|
|
2629 }
|
|
|
2630
|
|
|
2631 void settingsWriteFactoryDefaults(uint8_t inputValueRaw, uint8_t *inputBalanceArray)
|
|
|
2632 {
|
|
|
2633 if((inputValueRaw >= 70) && (inputValueRaw <= 110))
|
|
|
2634 {
|
|
|
2635 Settings.FactoryButtonBase = inputValueRaw;
|
|
|
2636 }
|
|
|
2637 for(int i=0;i<3;i++)
|
|
|
2638 {
|
|
|
2639 if((inputBalanceArray[i] >= 2) && (inputBalanceArray[i] <= 5))
|
|
|
2640 {
|
|
|
2641 Settings.FactoryButtonBalance[i] = inputBalanceArray[i];
|
|
|
2642 }
|
|
|
2643 }
|
|
|
2644 }
|
|
|
2645
|
|
|
2646
|
|
|
2647 /**
|
|
|
2648 ******************************************************************************
|
|
|
2649 * @brief settingsHelperButtonSens. / make 32 bit input to three buttons + storage value in [3]
|
|
|
2650 * @author heinrichs weikamp gmbh
|
|
|
2651 * @version V 01
|
|
|
2652 * @date 19-Sept-2016
|
|
|
2653 ******************************************************************************
|
|
|
2654 *
|
|
|
2655 * @param inputValueRaw:
|
|
|
2656 * @param outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance
|
|
|
2657 * @retval None
|
|
|
2658 */
|
|
|
2659 void settingsHelperButtonSens_keepPercentageValues(uint32_t inputValueRaw, uint8_t *outArray4Values)
|
|
|
2660 {
|
|
|
2661 uint32_t newSensitivity;
|
|
|
2662
|
|
|
2663 if(inputValueRaw > 110)
|
|
|
2664 {
|
|
|
2665 inputValueRaw = 110;
|
|
|
2666 }
|
|
|
2667 else
|
|
|
2668 if(inputValueRaw < 70)
|
|
|
2669 {
|
|
|
2670 inputValueRaw = 70;
|
|
|
2671 }
|
|
|
2672
|
|
|
2673 // the unbalanced value
|
|
|
2674 outArray4Values[3] = inputValueRaw;
|
|
|
2675
|
|
|
2676 // the balanced values
|
|
|
2677 for(int i=0;i<3;i++)
|
|
|
2678 {
|
|
|
2679 newSensitivity = inputValueRaw;
|
|
|
2680 switch(settingsGetPointer()->buttonBalance[i])
|
|
|
2681 {
|
|
|
2682 case 1: // should not be an option hw 170508
|
|
|
2683 newSensitivity -= 20;
|
|
|
2684 break;
|
|
|
2685 case 2:
|
|
|
2686 newSensitivity -= 10;
|
|
|
2687 break;
|
|
|
2688 default:
|
|
|
2689 break;
|
|
|
2690 case 4:
|
|
|
2691 newSensitivity += 10;
|
|
|
2692 break;
|
|
|
2693 case 5:
|
|
|
2694 newSensitivity += 20;
|
|
|
2695 break;
|
|
|
2696 }
|
|
|
2697
|
|
|
2698 if(newSensitivity > 110)
|
|
|
2699 {
|
|
|
2700 newSensitivity = 110;
|
|
|
2701 }
|
|
|
2702 outArray4Values[i] = newSensitivity;
|
|
|
2703 }
|
|
|
2704 }
|
|
|
2705
|
|
|
2706
|
|
|
2707 /**
|
|
|
2708 ******************************************************************************
|
|
|
2709 * @brief settingsHelperButtonSens_translate_to_hwOS_values. / make 32 bit input to three buttons + storage value in [3]
|
|
|
2710 * @author heinrichs weikamp gmbh
|
|
|
2711 * @version V 01
|
|
|
2712 * @date 19-Sept-2016
|
|
|
2713 ******************************************************************************
|
|
|
2714 *
|
|
|
2715 * @param inputValueRaw:
|
|
|
2716 * @param outArray4Values: [0] is right, [1] is center, [2] is left, [3] is original value with zero balance
|
|
|
2717 * @retval None
|
|
|
2718 */
|
|
|
2719 void settingsHelperButtonSens_original_translate_to_hwOS_values(const uint32_t inputValueRaw, uint8_t *outArray4Values)
|
|
|
2720 {
|
|
|
2721 uint32_t newSensitivity;
|
|
|
2722
|
|
|
2723 for(int i=0;i<3;i++)
|
|
|
2724 {
|
|
|
2725 newSensitivity = inputValueRaw;
|
|
|
2726 switch(settingsGetPointer()->buttonBalance[i])
|
|
|
2727 {
|
|
|
2728 case 1:
|
|
|
2729 newSensitivity -= 20;
|
|
|
2730 break;
|
|
|
2731 case 2:
|
|
|
2732 newSensitivity -= 10;
|
|
|
2733 break;
|
|
|
2734 default:
|
|
|
2735 break;
|
|
|
2736 case 4:
|
|
|
2737 newSensitivity += 10;
|
|
|
2738 break;
|
|
|
2739 case 5:
|
|
|
2740 newSensitivity += 20;
|
|
|
2741 break;
|
|
|
2742 }
|
|
|
2743
|
|
|
2744 if(newSensitivity > 100)
|
|
|
2745 {
|
|
|
2746 if(newSensitivity <= 105)
|
|
|
2747 newSensitivity = 10;
|
|
|
2748 else
|
|
|
2749 newSensitivity = 7;
|
|
|
2750 }
|
|
|
2751 else
|
|
|
2752 {
|
|
|
2753 newSensitivity *= 24;
|
|
|
2754 newSensitivity = 2400 - newSensitivity;
|
|
|
2755 newSensitivity /= 10;
|
|
|
2756
|
|
|
2757 newSensitivity += 15;
|
|
|
2758 if(newSensitivity > 255)
|
|
|
2759 newSensitivity = 255;
|
|
|
2760 }
|
|
|
2761 outArray4Values[i] = newSensitivity;
|
|
|
2762 }
|
|
|
2763
|
|
|
2764 // the unbalanced value
|
|
|
2765 newSensitivity = inputValueRaw;
|
|
|
2766 if(newSensitivity > 100)
|
|
|
2767 {
|
|
|
2768 if(newSensitivity <= 105)
|
|
|
2769 newSensitivity = 10;
|
|
|
2770 else
|
|
|
2771 newSensitivity = 7;
|
|
|
2772 }
|
|
|
2773 else
|
|
|
2774 {
|
|
|
2775 newSensitivity *= 24;
|
|
|
2776 newSensitivity = 2400 - newSensitivity;
|
|
|
2777 newSensitivity /= 10;
|
|
|
2778
|
|
|
2779 newSensitivity += 15;
|
|
|
2780 if(newSensitivity > 255)
|
|
|
2781 newSensitivity = 255;
|
|
|
2782 }
|
|
|
2783 outArray4Values[3] = newSensitivity;
|
|
|
2784 }
|
|
|
2785
|
|
|
2786
|
|
|
2787 /**
|
|
|
2788 ******************************************************************************
|
|
|
2789 * @brief settingsHelperButtonSens_translate_percentage_to_hwOS_values.
|
|
|
2790 * @author heinrichs weikamp gmbh
|
|
|
2791 * @version V 01
|
|
|
2792 * @date 6-March-2017
|
|
|
2793 ******************************************************************************
|
|
|
2794 *
|
|
|
2795 * @param inputValuePercentage with buttonBalance included
|
|
|
2796 * @retval PIC compatible value
|
|
|
2797 */
|
|
|
2798 uint8_t settingsHelperButtonSens_translate_percentage_to_hwOS_values(uint8_t inputValuePercentage)
|
|
|
2799 {
|
|
|
2800 uint32_t newSensitivity = inputValuePercentage;
|
|
|
2801
|
|
|
2802 if(newSensitivity > 100)
|
|
|
2803 {
|
|
|
2804 if(newSensitivity <= 105)
|
|
|
2805 newSensitivity = 10;
|
|
|
2806 else
|
|
|
2807 newSensitivity = 7;
|
|
|
2808 }
|
|
|
2809 else
|
|
|
2810 {
|
|
|
2811 newSensitivity *= 24;
|
|
|
2812 newSensitivity = 2400 - newSensitivity;
|
|
|
2813 newSensitivity /= 10;
|
|
|
2814
|
|
|
2815 newSensitivity += 15;
|
|
|
2816 if(newSensitivity > 255)
|
|
|
2817 newSensitivity = 255;
|
|
|
2818 }
|
|
|
2819 return (uint8_t)newSensitivity;
|
|
|
2820 }
|
|
|
2821
|
|
|
2822
|
|
|
2823 /**
|
|
|
2824 ******************************************************************************
|
|
|
2825 * @brief settingsHelperButtonSens_translate_hwOS_values_to_percentage.
|
|
|
2826 * @author heinrichs weikamp gmbh
|
|
|
2827 * @version V 01
|
|
|
2828 * @date 6-March-2017
|
|
|
2829 ******************************************************************************
|
|
|
2830 *
|
|
|
2831 * @param PIC compatible value
|
|
|
2832 * @retval Percentage
|
|
|
2833 */
|
|
|
2834 uint8_t settingsHelperButtonSens_translate_hwOS_values_to_percentage(uint8_t inputValuePIC)
|
|
|
2835 {
|
|
|
2836 if(inputValuePIC >= 15)
|
|
|
2837 {
|
|
|
2838 return(uint8_t)((25500 - (inputValuePIC)*100) / 240);
|
|
|
2839 }
|
|
|
2840 else
|
|
|
2841 {
|
|
|
2842 if(inputValuePIC >= 10)
|
|
|
2843 {
|
|
|
2844 return 105;
|
|
|
2845 }
|
|
|
2846 else
|
|
|
2847 {
|
|
|
2848 return 110;
|
|
|
2849 }
|
|
|
2850 }
|
|
|
2851 }
|
