38
+ − 1 /**
+ − 2 ******************************************************************************
+ − 3 * @file scheduler.c
+ − 4 * @author heinrichs weikamp gmbh
+ − 5 * @date 27-March-2014
+ − 6 * @version V0.0.6
+ − 7 * @since 18-June-2015
+ − 8 * @brief the main part except for base.c
+ − 9 *
+ − 10 @verbatim
+ − 11 ==============================================================================
+ − 12 ##### How to use #####
+ − 13 ==============================================================================
+ − 14 @endverbatim
+ − 15 ******************************************************************************
+ − 16 * @attention
+ − 17 *
+ − 18 * <h2><center>© COPYRIGHT(c) 2015 heinrichs weikamp</center></h2>
+ − 19 *
+ − 20 ******************************************************************************
+ − 21 */
+ − 22
+ − 23
+ − 24 //#define DEBUGMODE
+ − 25
+ − 26 /* Includes ------------------------------------------------------------------*/
+ − 27 #include <string.h>
+ − 28 #include "baseCPU2.h"
+ − 29 #include "stm32f4xx_hal.h"
+ − 30 #include "i2c.h"
+ − 31 #include "scheduler.h"
+ − 32 #include "pressure.h"
+ − 33 #include "compass.h"
+ − 34 #include "batteryGasGauge.h"
+ − 35 #include "batteryCharger.h"
+ − 36 #include "spi.h"
+ − 37 #include "rtc.h"
+ − 38 #include "dma.h"
+ − 39 #include "adc.h"
+ − 40 #include "calc_crush.h"
+ − 41 #include "stm32f4xx_hal_rtc_ex.h"
+ − 42 #include "decom.h"
+ − 43 #include "tm_stm32f4_otp.h"
+ − 44
+ − 45
135
+ − 46 #define INVALID_PREASURE_VALUE (100.0F)
+ − 47
38
+ − 48 /* Private types -------------------------------------------------------------*/
+ − 49 const SGas Air = {79,0,0,0,0};
+ − 50
+ − 51 /* Exported variables --------------------------------------------------------*/
+ − 52 SGlobal global;
+ − 53 SDevice DeviceDataFlash;
+ − 54 uint8_t deviceDataFlashValid = 0;
+ − 55 uint8_t deviceDataSubSeconds = 0;
+ − 56
+ − 57 /* Private variables ---------------------------------------------------------*/
+ − 58 /* can be lost while in sleep */
+ − 59 uint8_t clearDecoNow = 0;
+ − 60 uint8_t setButtonsNow = 0;
+ − 61
+ − 62 /* has to be in SRAM2 */
+ − 63 uint8_t secondsCount = 0;
142
+ − 64
207
+ − 65 static uint8_t dospisync = SPI_SYNC_METHOD_NONE;
+ − 66
142
+ − 67 SScheduleCtrl Scheduler;
38
+ − 68
+ − 69 /* Private function prototypes -----------------------------------------------*/
+ − 70
+ − 71 _Bool vpm_crush2(void);
+ − 72 void scheduleUpdateDeviceData(void);
+ − 73 long get_nofly_time_minutes(void);
+ − 74 void copyActualGas(SGas gas);
+ − 75 void copyPressureData(void);
+ − 76 void copyCnsAndOtuData(void);
+ − 77 void copyTimeData(void);
+ − 78 void copyCompassData(void);
+ − 79 void copyCompassDataDuringCalibration(int16_t dx, int16_t dy, int16_t dz);
+ − 80 void copyAmbientLightData(void);
+ − 81 void copyTissueData(void);
+ − 82 void copyVpmCrushingData(void);
+ − 83 void copyDeviceData(void);
+ − 84 void copyPICdata(void);
230
+ − 85 static void schedule_update_timer_helper(int8_t thisSeconds);
38
+ − 86 uint32_t time_elapsed_ms(uint32_t ticksstart,uint32_t ticksnow);
+ − 87
+ − 88 void scheduleSetDate(SDeviceLine *line);
+ − 89
+ − 90 /* Exported functions --------------------------------------------------------*/
+ − 91
+ − 92 void initGlobals(void)
+ − 93 {
231
+ − 94 bzero(&global, sizeof(SGlobal));
38
+ − 95
+ − 96 global.dataSendToSlavePending = 0;
+ − 97 global.dataSendToSlaveIsValid = 1;
+ − 98 global.dataSendToSlaveIsNotValidCount = 0;
+ − 99
+ − 100 global.mode = MODE_POWERUP;
+ − 101 global.repetitive_dive = 0;
+ − 102 global.conservatism = 0;
+ − 103 global.whichGas = 0;
+ − 104 global.aktualGas[0] = Air;
+ − 105 global.lifeData.actualGas = global.aktualGas[0];
+ − 106
172
+ − 107 const uint8_t button_standard_sensitivity = 85;
38
+ − 108 global.ButtonResponsiveness[0] = button_standard_sensitivity;
+ − 109 global.ButtonResponsiveness[1] = button_standard_sensitivity;
+ − 110 global.ButtonResponsiveness[2] = button_standard_sensitivity;
+ − 111 global.ButtonResponsiveness[3] = button_standard_sensitivity;
+ − 112
+ − 113 global.ButtonPICdata[0] = 0xFF;
+ − 114 global.ButtonPICdata[1] = 0xFF;
+ − 115 global.ButtonPICdata[2] = 0xFF;
+ − 116 global.ButtonPICdata[3] = 0xFF;
+ − 117
240
+ − 118 global.I2C_SystemStatus = HAL_ERROR; // 0x00 would be everything working
38
+ − 119
135
+ − 120 global.lifeData.pressure_ambient_bar = INVALID_PREASURE_VALUE;
+ − 121 global.lifeData.pressure_surface_bar = INVALID_PREASURE_VALUE;
38
+ − 122 decom_reset_with_1000mbar(&global.lifeData);
+ − 123
+ − 124 global.demo_mode = 0;
+ − 125
+ − 126 for(int i = 0; i < MAX_SENSORS; i++)
+ − 127 {
+ − 128 global.sensorError[i] = HAL_OK; // HAL_OK = 0;
+ − 129 }
+ − 130
+ − 131 global.dataSendToMaster.RTE_VERSION_high = firmwareVersionHigh();//RTE_VERSION_HIGH;;
+ − 132 global.dataSendToMaster.RTE_VERSION_low = firmwareVersionLow();//RTE_VERSION_LOW;;
+ − 133 global.dataSendToMaster.chargeStatus = 0;
+ − 134
+ − 135 global.dataSendToMaster.power_on_reset = 1;
+ − 136 global.dataSendToMaster.header.checkCode[0] = 0xA1;
264
+ − 137 global.dataSendToMaster.header.checkCode[1] = SPI_RX_STATE_OFFLINE;
38
+ − 138 global.dataSendToMaster.header.checkCode[2] = 0xA3;
+ − 139 global.dataSendToMaster.header.checkCode[3] = 0xA4;
+ − 140 global.dataSendToMaster.footer.checkCode[3] = 0xE4;
+ − 141 global.dataSendToMaster.footer.checkCode[2] = 0xE3;
+ − 142 global.dataSendToMaster.footer.checkCode[1] = 0xE2;
+ − 143 global.dataSendToMaster.footer.checkCode[0] = 0xE1;
+ − 144 global.dataSendToMaster.sensorErrors = 0;
+ − 145
+ − 146 global.sync_error_count = 0;
+ − 147 global.check_sync_not_running = 0;
+ − 148
+ − 149 global.deviceDataSendToMaster.RTE_VERSION_high = firmwareVersionHigh();//RTE_VERSION_HIGH;
+ − 150 global.deviceDataSendToMaster.RTE_VERSION_low = firmwareVersionLow();//RTE_VERSION_LOW;
+ − 151 global.deviceDataSendToMaster.chargeStatus = 0;
+ − 152
+ − 153 global.deviceDataSendToMaster.power_on_reset = 1;
+ − 154 global.deviceDataSendToMaster.header.checkCode[0] = 0xDF;
+ − 155 global.deviceDataSendToMaster.header.checkCode[1] = 0xDE;
+ − 156 global.deviceDataSendToMaster.header.checkCode[2] = 0xDD;
+ − 157 global.deviceDataSendToMaster.header.checkCode[3] = 0xDC;
+ − 158 global.deviceDataSendToMaster.footer.checkCode[3] = 0xE4;
+ − 159 global.deviceDataSendToMaster.footer.checkCode[2] = 0xE3;
+ − 160 global.deviceDataSendToMaster.footer.checkCode[1] = 0xE2;
+ − 161 global.deviceDataSendToMaster.footer.checkCode[0] = 0xE1;
+ − 162
+ − 163 global.dataSendToSlave.getDeviceDataNow = 0;
+ − 164
+ − 165 global.deviceData.batteryChargeCompleteCycles.value_int32 = 0;
+ − 166 global.deviceData.batteryChargeCycles.value_int32 = 0;
+ − 167 global.deviceData.depthMaximum.value_int32 = 0;
+ − 168 global.deviceData.diveCycles.value_int32 = 0;
+ − 169 global.deviceData.hoursOfOperation.value_int32 = 0;
+ − 170 global.deviceData.temperatureMaximum.value_int32 = INT32_MIN;
+ − 171 global.deviceData.temperatureMinimum.value_int32 = INT32_MAX;
+ − 172 global.deviceData.voltageMinimum.value_int32 = INT32_MAX;
148
+ − 173
265
+ − 174 Scheduler.communicationTimeout = SPI_COM_TIMEOUT_START;
207
+ − 175 Scheduler_Request_sync_with_SPI(SPI_SYNC_METHOD_HARD);
38
+ − 176 }
+ − 177
264
+ − 178 void reinitGlobals(void)
+ − 179 {
+ − 180 global.dataSendToSlavePending = 0;
+ − 181 global.dataSendToSlaveIsValid = 0;
+ − 182 global.dataSendToSlaveIsNotValidCount = 0;
+ − 183 global.sync_error_count = 0;
+ − 184 global.check_sync_not_running = 0;
265
+ − 185 Scheduler.communicationTimeout = SPI_COM_TIMEOUT_START;
264
+ − 186 }
38
+ − 187
+ − 188 void scheduleSpecial_Evaluate_DataSendToSlave(void)
+ − 189 {
104
+ − 190 //TEMPORARY fix for compass calibration.
+ − 191 //TODO: Fix I2C timeout for complete solving problem.
+ − 192 if(global.mode==MODE_CALIB){
+ − 193 return;
+ − 194 }
90
+ − 195
88
+ − 196 global.dataSendToSlavePending = 0;
+ − 197 if(!global.dataSendToSlaveIsValid) return;
38
+ − 198
+ − 199 global.dataSendToMaster.confirmRequest.uw = 0;
+ − 200
+ − 201 if(TM_OTP_Read(0,0) == 0xFF)
+ − 202 {
+ − 203 if(global.dataSendToSlave.revisionHardware == (global.dataSendToSlave.revisionCRCx0x7A ^ 0x7A))
+ − 204 TM_OTP_Write(0,0,global.dataSendToSlave.revisionHardware);
+ − 205 }
+ − 206
+ − 207 if(global.dataSendToSlave.setAccidentFlag)
+ − 208 {
+ − 209 global.dataSendToMaster.confirmRequest.ub.accident = 1;
+ − 210 global.deviceData.diveAccident.value_int32 = global.dataSendToSlave.setAccidentFlag;
+ − 211 scheduleSetDate(&global.deviceData.diveAccident);
+ − 212 global.accidentFlag |= global.dataSendToSlave.setAccidentFlag;
+ − 213 if(global.accidentFlag == ACCIDENT_CNS) // LVL1
+ − 214 global.accidentRemainingSeconds = 2*60*60;
+ − 215 else
+ − 216 global.accidentRemainingSeconds = 24*60*60;
+ − 217 }
+ − 218
+ − 219 if(global.dataSendToSlave.setTimeNow)
+ − 220 {
+ − 221 global.dataSendToMaster.confirmRequest.ub.time = 1;
+ − 222 RTC_SetTime(global.dataSendToSlave.data.newTime);
+ − 223 schedule_update_timer_helper(0);
+ − 224 }
+ − 225
+ − 226 if(global.dataSendToSlave.setDateNow)
+ − 227 {
+ − 228 global.dataSendToMaster.confirmRequest.ub.date = 1;
+ − 229 RTC_SetDate(global.dataSendToSlave.data.newDate);
+ − 230 schedule_update_timer_helper(0);
+ − 231 }
+ − 232
+ − 233 if(global.dataSendToSlave.calibrateCompassNow)
+ − 234 {
+ − 235 global.dataSendToMaster.confirmRequest.ub.compass = 1;
+ − 236 global.mode = MODE_CALIB;
+ − 237 }
+ − 238
+ − 239 if(global.dataSendToSlave.clearDecoNow)
+ − 240 {
+ − 241 global.dataSendToMaster.confirmRequest.ub.clearDeco = 1;
+ − 242 clearDecoNow = 1;
+ − 243 }
+ − 244
+ − 245 if(global.dataSendToSlave.setButtonSensitivityNow)
+ − 246 {
+ − 247 global.dataSendToMaster.confirmRequest.ub.button = 1;
+ − 248 global.ButtonResponsiveness[0] = global.dataSendToSlave.data.buttonResponsiveness[0];
+ − 249 global.ButtonResponsiveness[1] = global.dataSendToSlave.data.buttonResponsiveness[1];
+ − 250 global.ButtonResponsiveness[2] = global.dataSendToSlave.data.buttonResponsiveness[2];
+ − 251 global.ButtonResponsiveness[3] = global.dataSendToSlave.data.buttonResponsiveness[3];
+ − 252 setButtonsNow = 1;
+ − 253 }
+ − 254
+ − 255 if(global.dataSendToSlave.setBatteryGaugeNow)
+ − 256 {
104
+ − 257 if(global.mode!=MODE_CALIB){
38
+ − 258 global.dataSendToMaster.confirmRequest.ub.batterygauge = 1;
+ − 259 battery_gas_gauge_set(global.dataSendToSlave.data.newBatteryGaugePercentageFloat);
104
+ − 260 }
38
+ − 261 }
+ − 262
+ − 263 if((global.mode == MODE_SURFACE) && (global.dataSendToSlave.mode == MODE_SHUTDOWN))
+ − 264 {
+ − 265 global.mode = MODE_SHUTDOWN;
+ − 266 }
+ − 267
+ − 268 if(global.mode == MODE_DIVE)
+ − 269 {
+ − 270 copyActualGas(global.dataSendToSlave.data.actualGas);
+ − 271 }
+ − 272 else
+ − 273 {
+ − 274 copyActualGas(Air);
+ − 275 global.settings.divetimeToCreateLogbook = global.dataSendToSlave.data.divetimeToCreateLogbook;
+ − 276 global.settings.timeoutDiveReachedZeroDepth = global.dataSendToSlave.data.timeoutDiveReachedZeroDepth;
+ − 277 }
+ − 278
+ − 279 /* for simulation / testing */
+ − 280 global.ceiling_from_main_CPU_mbar = global.dataSendToSlave.data.ambient_pressure_mbar_ceiling;
+ − 281
88
+ − 282 /* for device data updates */
+ − 283 deviceDataFlashValid = 0;
+ − 284 memcpy(&DeviceDataFlash, &global.dataSendToSlave.data.DeviceData, sizeof(SDevice));
+ − 285 deviceDataFlashValid = 1;
89
+ − 286
264
+ − 287 #if 0
104
+ − 288 //TODO: Temporary placed here. Duration ~210 ms.
+ − 289 if (global.I2C_SystemStatus != HAL_OK) {
+ − 290 MX_I2C1_TestAndClear();
+ − 291 MX_I2C1_Init();
+ − 292 // init_pressure();
+ − 293 // compass_init(0, 7);
+ − 294 // accelerator_init();
+ − 295 }
264
+ − 296 #endif /* already called once a second */
38
+ − 297 }
+ − 298
+ − 299
+ − 300 /**
+ − 301 ******************************************************************************
+ − 302 * @brief schedule_time_compare_helper.
+ − 303 * @author heinrichs weikamp gmbh
+ − 304 * @version V0.0.1
+ − 305 * @date 20-Oct-2016
+ − 306 ******************************************************************************
+ − 307 */
+ − 308
+ − 309 uint8_t RtcBugFixChsw(uint8_t inStupidTime)
+ − 310 {
+ − 311 uint8_t multiplesOf16 = 0;
+ − 312
+ − 313 multiplesOf16 = inStupidTime / 16;
+ − 314
+ − 315 inStupidTime -= multiplesOf16 * 16;
+ − 316
+ − 317 return (10 * multiplesOf16) + inStupidTime;
+ − 318 }
+ − 319
+ − 320 uint32_t schedule_time_compare_helper(RTC_TimeTypeDef timeNow, RTC_DateTypeDef dateNow, RTC_TimeTypeDef timeLast, RTC_DateTypeDef dateLast)
+ − 321 {
+ − 322 uint32_t nowInSeconds;
+ − 323 uint32_t lastInSeconds;
+ − 324 uint32_t resultDiff;
+ − 325
+ − 326 nowInSeconds = (uint32_t)RtcBugFixChsw(timeNow.Hours) * 3600;
+ − 327 nowInSeconds += (uint32_t)RtcBugFixChsw(timeNow.Minutes) * 60;
+ − 328 nowInSeconds += (uint32_t)RtcBugFixChsw(timeNow.Seconds);
+ − 329
+ − 330 lastInSeconds = (uint32_t)RtcBugFixChsw(timeLast.Hours) * 3600;
+ − 331 lastInSeconds += (uint32_t)RtcBugFixChsw(timeLast.Minutes) * 60;
+ − 332 lastInSeconds += (uint32_t)RtcBugFixChsw(timeLast.Seconds);
+ − 333
+ − 334 if(dateNow.Date != dateLast.Date)
+ − 335 {
+ − 336 resultDiff = 86400 + nowInSeconds - lastInSeconds;
+ − 337 }
+ − 338 else
+ − 339 {
+ − 340 resultDiff = nowInSeconds - lastInSeconds;
+ − 341 }
+ − 342 return resultDiff;
+ − 343 }
+ − 344
+ − 345
+ − 346
+ − 347 /**
+ − 348 ******************************************************************************
+ − 349 * @brief schedule_update_timer_helper.
+ − 350 * @author heinrichs weikamp gmbh
+ − 351 * @version V0.0.1
+ − 352 * @date 20-Oct-2016
+ − 353 * @brief use 0 for init
+ − 354 use -1 for RTC controlled
+ − 355 use >= 1 for manual control
+ − 356 ******************************************************************************
+ − 357 */
+ − 358 extern RTC_HandleTypeDef RTCHandle;
+ − 359
230
+ − 360 static void schedule_update_timer_helper(int8_t thisSeconds)
38
+ − 361 {
+ − 362 static RTC_TimeTypeDef sTimeLast;
+ − 363 static RTC_DateTypeDef sDateLast;
+ − 364 RTC_TimeTypeDef sTimeNow;
+ − 365 RTC_DateTypeDef sDateNow;
+ − 366 uint32_t secondsPast;
+ − 367
+ − 368 HAL_RTC_GetTime(&RTCHandle, &sTimeNow, RTC_FORMAT_BCD);
+ − 369 HAL_RTC_GetDate(&RTCHandle, &sDateNow, RTC_FORMAT_BCD);
+ − 370
230
+ − 371 if(thisSeconds != 0) // otherwise just store sTimeLast, sDateLast
38
+ − 372 {
+ − 373 if(thisSeconds > 0) // use this value instead, good for pre-loading sTimeLast and sDateLast
+ − 374 {
+ − 375 secondsPast = thisSeconds;
230
+ − 376 } else {
+ − 377 // thisSeconds < 0 and not <= !
+ − 378 secondsPast = schedule_time_compare_helper(sTimeNow, sDateNow, sTimeLast, sDateLast);
38
+ − 379 }
+ − 380
+ − 381 if(global.seconds_since_last_dive)
+ − 382 {
+ − 383 if(secondsPast >= 777900)
+ − 384 {
+ − 385 global.seconds_since_last_dive = 0;
+ − 386 }
+ − 387 else
+ − 388 {
230
+ − 389 uint32_t tempNewValue = ((uint32_t)global.seconds_since_last_dive) + secondsPast;
38
+ − 390 if(tempNewValue > 777900) // a bit more than nine days [seconds]
+ − 391 global.seconds_since_last_dive = 0;
+ − 392 else
+ − 393 global.seconds_since_last_dive = (long)tempNewValue;
+ − 394 }
+ − 395 }
+ − 396 }
+ − 397
+ − 398 sTimeLast = sTimeNow;
+ − 399 sDateLast = sDateNow;
+ − 400 }
+ − 401
+ − 402 /**
+ − 403 ******************************************************************************
+ − 404 * @brief schedule_check_resync.
+ − 405 * @author heinrichs weikamp gmbh
+ − 406 * @version V0.0.2
+ − 407 * @date 18-June-2015
+ − 408 ******************************************************************************
+ − 409 */
135
+ − 410
38
+ − 411 void schedule_check_resync(void)
+ − 412 {
155
+ − 413 /* counter is incremented in cyclic 100ms loop and reset to 0 if the transmission complete callback is called */
265
+ − 414 if((global.check_sync_not_running >= Scheduler.communicationTimeout))
38
+ − 415 {
89
+ − 416 // global.dataSendToSlaveIsNotValidCount = 0;
135
+ − 417 global.check_sync_not_running = 0;
+ − 418 global.sync_error_count++;
+ − 419
+ − 420 /* Try to start communication again. If exchange is stuck during execution for some reason the TX will be aborted by the
+ − 421 * function error handler
+ − 422 */
277
+ − 423 HAL_SPI_TransmitReceive_DMA(&hspi1,(uint8_t*) &(global.dataSendToMaster),(uint8_t*) &(global.dataSendToSlave), EXCHANGE_BUFFERSIZE);
265
+ − 424 Scheduler.communicationTimeout = SPI_COM_TIMEOUT_COMMON; /* Reduce error detection time */
264
+ − 425 Scheduler_Request_sync_with_SPI(SPI_SYNC_METHOD_HARD);
155
+ − 426 }
38
+ − 427 }
+ − 428
+ − 429
+ − 430 /**
+ − 431 ******************************************************************************
+ − 432 * @brief scheduleDiveMode. / Dive Mode: Main Loop
+ − 433 * @author Peter Ryser
+ − 434 * @version V0.0.1
+ − 435 * @date 22-April-2014
+ − 436 ******************************************************************************
+ − 437 */
+ − 438 void scheduleDiveMode(void)
+ − 439 {
+ − 440 uint32_t ticksdiff = 0;
+ − 441 uint32_t lasttick = 0;
+ − 442 uint8_t counterAscentRate = 0;
+ − 443 float lastPressure_bar = 0.0f;
+ − 444 global.dataSendToMaster.mode = MODE_DIVE;
+ − 445 global.deviceDataSendToMaster.mode = MODE_DIVE;
+ − 446 uint8_t counter_exit = 0;
264
+ − 447
142
+ − 448 Scheduler.counterSPIdata100msec = 0;
+ − 449 Scheduler.counterCompass100msec = 0;
+ − 450 Scheduler.counterPressure100msec = 0;
+ − 451 Scheduler.counterAmbientLight100msec = 0;
220
+ − 452 Scheduler.tick_execute1second = SCHEDULER_TICK_EXE1SEC;
38
+ − 453
+ − 454 global.deviceData.diveCycles.value_int32++;
+ − 455 scheduleSetDate(&global.deviceData.diveCycles);
+ − 456 global.lifeData.counterSecondsShallowDepth = 0;
+ − 457
240
+ − 458 Scheduler.tickstart = HAL_GetTick();
38
+ − 459 while(global.mode == MODE_DIVE)
+ − 460 {
+ − 461 lasttick = HAL_GetTick();
142
+ − 462 ticksdiff = time_elapsed_ms(Scheduler.tickstart,lasttick);
38
+ − 463
142
+ − 464 if(ticksdiff >= Scheduler.counterSPIdata100msec * 100 + 10)
+ − 465 {
277
+ − 466 if(SPI_Evaluate_RX_Data()!=0) /* did we receive something ? */
+ − 467 {
+ − 468 Scheduler.counterSPIdata100msec++;
+ − 469 }
+ − 470 schedule_check_resync();
142
+ − 471 }
+ − 472
38
+ − 473 //Evaluate pressure at 20 ms, 120 ms, 220 ms,....
142
+ − 474 if(ticksdiff >= Scheduler.counterPressure100msec * 100 + 20)
38
+ − 475 {
+ − 476 global.check_sync_not_running++;
277
+ − 477 pressure_update_alternating();
135
+ − 478 scheduleUpdateDeviceData();
186
+ − 479 #ifdef DEMOMODE
38
+ − 480 if(global.demo_mode)
+ − 481 {
186
+ − 482 int turbo_seconds = demo_modify_temperature_and_pressure(global.lifeData.dive_time_seconds, Scheduler.counterPressure100msec, global.ceiling_from_main_CPU_mbar);
38
+ − 483 if(turbo_seconds)
+ − 484 {
+ − 485 global.lifeData.dive_time_seconds += turbo_seconds;
+ − 486 decom_tissues_exposure((int)(turbo_seconds), &global.lifeData);
+ − 487 copyTissueData();
+ − 488 }
+ − 489 if((global.lifeData.counterSecondsShallowDepth > 1) && (global.lifeData.counterSecondsShallowDepth < (global.settings.timeoutDiveReachedZeroDepth - 10)))
+ − 490 global.lifeData.counterSecondsShallowDepth = (global.settings.timeoutDiveReachedZeroDepth - 10);
+ − 491 }
186
+ − 492 #endif
38
+ − 493
+ − 494 //Calc ascentrate every two second (20 * 100 ms)
+ − 495 counterAscentRate++;
+ − 496 if(counterAscentRate == 20)
+ − 497 {
+ − 498 global.lifeData.pressure_ambient_bar = get_pressure_mbar() / 1000.0f;
+ − 499 if(lastPressure_bar >= 0)
+ − 500 {
+ − 501 //2 seconds * 30 == 1 minute, bar * 10 = meter
+ − 502 global.lifeData.ascent_rate_meter_per_min = (lastPressure_bar - global.lifeData.pressure_ambient_bar) * 30 * 10;
+ − 503 }
+ − 504 lastPressure_bar = global.lifeData.pressure_ambient_bar;
+ − 505 counterAscentRate = 0;
+ − 506 }
135
+ − 507 copyPressureData();
142
+ − 508 Scheduler.counterPressure100msec++;
38
+ − 509 }
+ − 510 //evaluate compass data at 50 ms, 150 ms, 250 ms,....
142
+ − 511 if(ticksdiff >= Scheduler.counterCompass100msec * 100 + 50)
135
+ − 512 {
+ − 513 compass_read();
+ − 514 acceleration_read();
+ − 515 compass_calc();
+ − 516 copyCompassData();
142
+ − 517 Scheduler.counterCompass100msec++;
135
+ − 518 }
38
+ − 519
142
+ − 520 if(ticksdiff >= Scheduler.counterAmbientLight100msec * 100 + 70)
38
+ − 521 {
+ − 522 adc_ambient_light_sensor_get_data();
+ − 523 copyAmbientLightData();
142
+ − 524 Scheduler.counterAmbientLight100msec++;
38
+ − 525 }
+ − 526
220
+ − 527 //Evaluate tissues, toxic data, vpm, etc. once a second
+ − 528 if(ticksdiff >= Scheduler.tick_execute1second)
38
+ − 529 {
220
+ − 530 Scheduler.tick_execute1second = 0xFFFFFFFF; /* execute once only in the second cycle */
38
+ − 531 if(global.dataSendToSlave.diveModeInfo != DIVEMODE_Apnea)
+ − 532 {
+ − 533 scheduleUpdateLifeData(0); // includes tissues
+ − 534 global.lifeData.dive_time_seconds++; // there is dive_time_seconds_without_surface_time too
+ − 535 global.lifeData.ppO2 = decom_calc_ppO2(global.lifeData.pressure_ambient_bar, &global.lifeData.actualGas);
+ − 536 decom_oxygen_calculate_cns(&global.lifeData.cns,global.lifeData.ppO2);
+ − 537 decom_oxygen_calculate_otu(&global.lifeData.otu,global.lifeData.ppO2);
88
+ − 538 battery_gas_gauge_get_data();
38
+ − 539
+ − 540
+ − 541 /** counter_exit allows safe exit via button for testing
+ − 542 * and demo_mode is exited too if aplicable.
+ − 543 */
+ − 544 if(global.dataSendToMaster.mode == MODE_ENDDIVE)
+ − 545 {
+ − 546 counter_exit++;
+ − 547 if(counter_exit >= 2)
+ − 548 {
+ − 549 global.mode = MODE_SURFACE;
+ − 550 global.demo_mode = 0;
+ − 551 }
+ − 552 }
+ − 553
+ − 554 if(is_ambient_pressure_close_to_surface(&global.lifeData))
+ − 555 {
+ − 556 global.lifeData.counterSecondsShallowDepth++;
+ − 557 if((global.lifeData.counterSecondsShallowDepth >= global.settings.timeoutDiveReachedZeroDepth) || ((global.lifeData.dive_time_seconds < 60) && (global.demo_mode == 0)) || (global.dataSendToSlave.setEndDive))
+ − 558 {
+ − 559 global.seconds_since_last_dive = 1; // start counter
+ − 560 schedule_update_timer_helper(0); // zum starten :-)
+ − 561 global.dataSendToMaster.mode = MODE_ENDDIVE;
+ − 562 global.deviceDataSendToMaster.mode = MODE_ENDDIVE;
+ − 563 }
+ − 564 }
+ − 565 else
+ − 566 {
+ − 567 global.lifeData.counterSecondsShallowDepth = 0;
+ − 568 global.lifeData.dive_time_seconds_without_surface_time++;
+ − 569 }
+ − 570 vpm_crush2();
+ − 571 }
+ − 572 else // DIVEMODE_Apnea
+ − 573 {
+ − 574 global.lifeData.dive_time_seconds++;
+ − 575
+ − 576 // exit dive mode
+ − 577 if(global.dataSendToMaster.mode == MODE_ENDDIVE)
+ − 578 {
+ − 579 counter_exit++;
+ − 580 if(counter_exit >= 2)
+ − 581 {
+ − 582 scheduleUpdateLifeData(-1); // 'restart' tissue calculations without calculating time during apnea mode
+ − 583 global.lifeData.dive_time_seconds = 0; // use backup noflytime and desaturation time
+ − 584 global.mode = MODE_SURFACE;
+ − 585 global.demo_mode = 0;
+ − 586 }
+ − 587 }
+ − 588
+ − 589 // surface break
+ − 590 if(is_ambient_pressure_close_to_surface(&global.lifeData))
+ − 591 {
+ − 592 global.lifeData.counterSecondsShallowDepth++;
+ − 593 if(global.lifeData.counterSecondsShallowDepth > 3) // time for main cpu to copy to apnea_last_dive_time_seconds
+ − 594 {
+ − 595 global.lifeData.dive_time_seconds = 0; // this apnea dive ends here
+ − 596 }
+ − 597 if((global.lifeData.counterSecondsShallowDepth >= global.settings.timeoutDiveReachedZeroDepth) || (global.dataSendToSlave.setEndDive))
+ − 598 {
+ − 599 global.dataSendToMaster.mode = MODE_ENDDIVE;
+ − 600 global.deviceDataSendToMaster.mode = MODE_ENDDIVE;
+ − 601 }
+ − 602 }
+ − 603 else
+ − 604 {
+ − 605 global.lifeData.counterSecondsShallowDepth = 0;
+ − 606 global.lifeData.dive_time_seconds_without_surface_time++;
+ − 607 }
+ − 608 } // standard dive or DIVEMODE_Apnea
+ − 609
88
+ − 610 copyVpmCrushingData();
+ − 611 copyTimeData();
+ − 612 copyCnsAndOtuData();
+ − 613 copyBatteryData();
38
+ − 614
88
+ − 615 // new hw 170523
+ − 616 if(global.I2C_SystemStatus != HAL_OK)
+ − 617 {
+ − 618 MX_I2C1_TestAndClear();
+ − 619 MX_I2C1_Init();
+ − 620 if(!is_init_pressure_done())
+ − 621 {
+ − 622 init_pressure();
+ − 623 }
+ − 624 }
220
+ − 625 }
+ − 626 if(ticksdiff >= 1000)
+ − 627 {
+ − 628 /* reset counter */
+ − 629 Scheduler.tickstart = HAL_GetTick();
142
+ − 630 Scheduler.counterSPIdata100msec = 0;
+ − 631 Scheduler.counterCompass100msec = 0;
+ − 632 Scheduler.counterPressure100msec = 0;
+ − 633 Scheduler.counterAmbientLight100msec = 0;
220
+ − 634 Scheduler.tick_execute1second = SCHEDULER_TICK_EXE1SEC;
38
+ − 635 }
+ − 636 }
+ − 637 }
+ − 638
+ − 639
+ − 640 /**
+ − 641 ******************************************************************************
+ − 642 * @brief scheduleSurfaceMode / surface mode: Main Loop
+ − 643 * @author Peter Ryser
+ − 644 * @version V0.0.1
+ − 645 * @date 22-April-2014
+ − 646 ******************************************************************************
+ − 647 */
+ − 648
+ − 649
+ − 650 // ===============================================================================
+ − 651 // scheduleTestMode
+ − 652 /// @brief included for sealed hardware with permanent RTE update message
+ − 653 // ===============================================================================
+ − 654 void scheduleTestMode(void)
+ − 655 {
+ − 656 uint32_t ticksdiff = 0;
+ − 657 uint32_t lasttick = 0;
142
+ − 658 Scheduler.tickstart = HAL_GetTick();
38
+ − 659
142
+ − 660 Scheduler.counterPressure100msec = 0;
38
+ − 661
+ − 662 float temperature_carousel = 0.0f;
+ − 663 float temperature_changer = 0.1f;
+ − 664
+ − 665 while(global.mode == MODE_TEST)
+ − 666 {
+ − 667 lasttick = HAL_GetTick();
142
+ − 668 ticksdiff = time_elapsed_ms(Scheduler.tickstart,lasttick);
+ − 669
+ − 670 //Evaluate received data at 10 ms, 110 ms, 210 ms,...
+ − 671 if(ticksdiff >= Scheduler.counterSPIdata100msec * 100 + 10)
+ − 672 {
277
+ − 673 if(SPI_Evaluate_RX_Data()!=0) /* did we receive something ? */
+ − 674 {
+ − 675 Scheduler.counterSPIdata100msec++;
+ − 676 }
+ − 677 schedule_check_resync();
142
+ − 678 }
38
+ − 679
+ − 680 //Evaluate pressure at 20 ms, 120 ms, 220 ms,...
142
+ − 681 if(ticksdiff >= Scheduler.counterPressure100msec * 100 + 20)
38
+ − 682 {
+ − 683 global.check_sync_not_running++;
+ − 684
277
+ − 685 pressure_update_alternating();
142
+ − 686 scheduleUpdateDeviceData();
+ − 687 global.lifeData.ascent_rate_meter_per_min = 0;
+ − 688 copyPressureData();
38
+ − 689
+ − 690 if(temperature_carousel > 20.0f)
+ − 691 {
+ − 692 temperature_carousel = 20.0f;
+ − 693 temperature_changer = -0.1f;
+ − 694 }
+ − 695 else
+ − 696 if(temperature_carousel < 0)
+ − 697 {
+ − 698 temperature_carousel = 0;
+ − 699 temperature_changer = +0.1f;
+ − 700 }
+ − 701
+ − 702 temperature_carousel += temperature_changer;
+ − 703
+ − 704 uint8_t boolPressureData = !global.dataSendToMaster.boolPressureData;
+ − 705
142
+ − 706 global.dataSendToMaster.data[boolPressureData].pressure_mbar = get_pressure_mbar();
38
+ − 707
+ − 708 global.dataSendToMaster.data[boolPressureData].temperature = temperature_carousel;
+ − 709 global.dataSendToMaster.data[boolPressureData].pressure_uTick = HAL_GetTick();
+ − 710 global.dataSendToMaster.boolPressureData = boolPressureData;
142
+ − 711 Scheduler.counterPressure100msec++;
38
+ − 712 }
+ − 713
+ − 714 if(ticksdiff >= 1000)
+ − 715 {
+ − 716 //Set back tick counter
142
+ − 717 Scheduler.tickstart = HAL_GetTick();
+ − 718 Scheduler.counterPressure100msec = 0;
+ − 719 Scheduler.counterSPIdata100msec = 0;
38
+ − 720 }
+ − 721 };
+ − 722 }
+ − 723
+ − 724
142
+ − 725
38
+ − 726 void scheduleSurfaceMode(void)
+ − 727 {
142
+ − 728
38
+ − 729 uint32_t ticksdiff = 0;
+ − 730 uint32_t lasttick = 0;
142
+ − 731 Scheduler.tickstart = HAL_GetTick();
+ − 732 Scheduler.counterSPIdata100msec = 0;
+ − 733 Scheduler.counterCompass100msec = 0;
+ − 734 Scheduler.counterPressure100msec = 0;
+ − 735 Scheduler.counterAmbientLight100msec = 0;
220
+ − 736 Scheduler.tick_execute1second = SCHEDULER_TICK_EXE1SEC;
142
+ − 737
38
+ − 738 global.dataSendToMaster.mode = MODE_SURFACE;
+ − 739 global.deviceDataSendToMaster.mode = MODE_SURFACE;
+ − 740
+ − 741 while(global.mode == MODE_SURFACE)
+ − 742 {
277
+ − 743
38
+ − 744 lasttick = HAL_GetTick();
142
+ − 745 ticksdiff = time_elapsed_ms(Scheduler.tickstart,lasttick);
38
+ − 746
+ − 747 if(setButtonsNow == 1)
+ − 748 {
+ − 749 if(scheduleSetButtonResponsiveness())
+ − 750 setButtonsNow = 0;
+ − 751 }
+ − 752
220
+ − 753 /* Evaluate received data at 10 ms, 110 ms, 210 ms,... duration ~<1ms */
142
+ − 754 if(ticksdiff >= Scheduler.counterSPIdata100msec * 100 + 10)
+ − 755 {
264
+ − 756 if(SPI_Evaluate_RX_Data()!=0) /* did we receive something ? */
+ − 757 {
+ − 758 Scheduler.counterSPIdata100msec++;
+ − 759 }
277
+ − 760 schedule_check_resync();
142
+ − 761 }
+ − 762
220
+ − 763 /* Evaluate pressure at 20 ms, 120 ms, 220 ms,... duration ~22ms] */
142
+ − 764 if(ticksdiff >= Scheduler.counterPressure100msec * 100 + 20)
38
+ − 765 {
+ − 766 global.check_sync_not_running++;
277
+ − 767 pressure_update_alternating();
135
+ − 768 scheduleUpdateDeviceData();
38
+ − 769 global.lifeData.ascent_rate_meter_per_min = 0;
135
+ − 770 copyPressureData();
142
+ − 771 Scheduler.counterPressure100msec++;
135
+ − 772
301
a09b1855d656
cleanup, RTE: factor out scheduleCheck_pressure_reached_dive_mode_level
Jan Mulder <jlmulder@xs4all.nl>
diff
changeset
+ − 773 if (!is_ambient_pressure_close_to_surface(&global.lifeData))
38
+ − 774 global.mode = MODE_DIVE;
+ − 775 }
+ − 776
220
+ − 777 /* Evaluate compass data at 50 ms, 150 ms, 250 ms,... duration ~5ms */
142
+ − 778 if(ticksdiff >= Scheduler.counterCompass100msec * 100 + 50)
135
+ − 779 {
+ − 780 compass_read();
+ − 781 acceleration_read();
+ − 782 compass_calc();
+ − 783 copyCompassData();
142
+ − 784 Scheduler.counterCompass100msec++;
135
+ − 785 }
38
+ − 786
220
+ − 787 /* evaluate compass data at 70 ms, 170 ms, 270 ms,... duration <1ms */
142
+ − 788 if(ticksdiff >= Scheduler.counterAmbientLight100msec * 100 + 70)
38
+ − 789 {
+ − 790 adc_ambient_light_sensor_get_data();
+ − 791 copyAmbientLightData();
142
+ − 792 Scheduler.counterAmbientLight100msec++;
38
+ − 793 }
220
+ − 794
+ − 795
+ − 796
+ − 797 /* Evaluate tissues, toxic data, etc. once a second... duration ~1ms */
+ − 798 if(ticksdiff >= Scheduler.tick_execute1second)
38
+ − 799 {
220
+ − 800 Scheduler.tick_execute1second = 0xFFFFFFFF;
38
+ − 801 if(clearDecoNow)
+ − 802 {
+ − 803 decom_reset_with_1000mbar(&global.lifeData); ///< this should almost reset desaturation time
+ − 804 // new 160215 hw
+ − 805 global.repetitive_dive = 0;
+ − 806 global.seconds_since_last_dive = 0; ///< this will reset OTU and CNS as well
+ − 807 global.no_fly_time_minutes = 0;
+ − 808 global.accidentFlag = 0;
+ − 809 global.accidentRemainingSeconds = 0;
+ − 810 vpm_init(&global.vpm, global.conservatism, global.repetitive_dive, global.seconds_since_last_dive);
+ − 811 clearDecoNow = 0;
+ − 812 }
89
+ − 813
38
+ − 814 if(global.seconds_since_last_dive)
+ − 815 {
+ − 816 schedule_update_timer_helper(-1);
+ − 817 }
89
+ − 818
38
+ − 819 if(global.accidentRemainingSeconds)
+ − 820 {
+ − 821 global.accidentRemainingSeconds--;
+ − 822 if(!global.accidentRemainingSeconds)
+ − 823 global.accidentFlag = 0;
+ − 824 }
+ − 825 global.dataSendToMaster.accidentFlags = global.accidentFlag;
89
+ − 826
38
+ − 827 update_surface_pressure(1);
+ − 828 scheduleUpdateLifeData(0);
+ − 829 decom_oxygen_calculate_otu_degrade(&global.lifeData.otu, global.seconds_since_last_dive);
+ − 830 decom_oxygen_calculate_cns_degrade(&global.lifeData.cns, global.seconds_since_last_dive);
135
+ − 831
+ − 832 /* start desaturation calculation after first valid measurement has been done */
+ − 833 if(global.lifeData.pressure_surface_bar != INVALID_PREASURE_VALUE)
+ − 834 {
+ − 835 global.lifeData.desaturation_time_minutes = decom_calc_desaturation_time(global.lifeData.tissue_nitrogen_bar,global.lifeData.tissue_helium_bar,global.lifeData.pressure_surface_bar);
+ − 836 }
+ − 837 else
+ − 838 {
+ − 839 global.lifeData.desaturation_time_minutes = 0;
+ − 840 }
38
+ − 841 battery_charger_get_status_and_contral_battery_gas_gauge(0);
88
+ − 842 battery_gas_gauge_get_data();
89
+ − 843
88
+ − 844 copyCnsAndOtuData();
+ − 845 copyTimeData();
+ − 846 copyBatteryData();
+ − 847 copyDeviceData();
38
+ − 848
88
+ − 849 // new hw 170523
+ − 850 if(global.I2C_SystemStatus != HAL_OK)
+ − 851 {
+ − 852 MX_I2C1_TestAndClear();
+ − 853 MX_I2C1_Init();
+ − 854 if(!is_init_pressure_done())
+ − 855 {
+ − 856 init_pressure();
+ − 857 }
+ − 858 }
220
+ − 859 }
+ − 860
+ − 861 if(ticksdiff >= 1000)
+ − 862 {
+ − 863 //Set back tick counter
+ − 864 Scheduler.tickstart = HAL_GetTick();
142
+ − 865 Scheduler.counterSPIdata100msec = 0;
+ − 866 Scheduler.counterCompass100msec = 0;
+ − 867 Scheduler.counterPressure100msec = 0;
+ − 868 Scheduler.counterAmbientLight100msec = 0;
220
+ − 869 Scheduler.tick_execute1second = SCHEDULER_TICK_EXE1SEC;
38
+ − 870 }
+ − 871 }
+ − 872 }
+ − 873
207
+ − 874 inline void Scheduler_Request_sync_with_SPI(uint8_t SyncMethod)
142
+ − 875 {
207
+ − 876 if( SyncMethod < SPI_SYNC_METHOD_INVALID)
+ − 877 {
+ − 878 dospisync = SyncMethod;
+ − 879 }
+ − 880 }
+ − 881
264
+ − 882 void Scheduler_SyncToSPI(uint8_t TXtick)
207
+ − 883 {
+ − 884 uint32_t deltatick = 0;
264
+ − 885 int8_t TXcompensation;
207
+ − 886
+ − 887 switch(dospisync)
142
+ − 888 {
207
+ − 889 case SPI_SYNC_METHOD_HARD:
+ − 890 //Set back tick counter
264
+ − 891 Scheduler.tickstart = HAL_GetTick() - 4; /* consider 4ms offset for transfer */
207
+ − 892 Scheduler.counterSPIdata100msec = 0;
+ − 893 Scheduler.counterCompass100msec = 0;
+ − 894 Scheduler.counterPressure100msec = 0;
+ − 895 Scheduler.counterAmbientLight100msec = 0;
+ − 896 dospisync = SPI_SYNC_METHOD_NONE;
+ − 897 break;
+ − 898 case SPI_SYNC_METHOD_SOFT:
+ − 899 deltatick = time_elapsed_ms(Scheduler.tickstart,HAL_GetTick());
+ − 900 deltatick %= 100; /* clip to 100ms window */
+ − 901 if(Scheduler.tickstart - deltatick >= 0) /* adjust start time to the next 100ms window */
+ − 902 {
+ − 903 Scheduler.tickstart -= deltatick;
+ − 904 }
+ − 905 else
+ − 906 {
+ − 907 Scheduler.tickstart = 0xFFFFFFFF- (deltatick - Scheduler.tickstart);
+ − 908 }
+ − 909 dospisync = SPI_SYNC_METHOD_NONE;
+ − 910 break;
264
+ − 911 default: /* continous sync activity */
+ − 912 if(TXtick < 100) /* do not handle unexpected jump length > 100ms */
+ − 913 {
+ − 914 TXtick += 4; /* add 4ms TX time to offset of 100ms time stamp */
+ − 915 deltatick = time_elapsed_ms(Scheduler.tickstart,HAL_GetTick());
+ − 916 deltatick %= 100;
+ − 917 if(deltatick > 50)
+ − 918 {
+ − 919 TXcompensation = deltatick - 100; /* neg drift */
+ − 920 }
+ − 921 else
+ − 922 {
+ − 923 TXcompensation = deltatick; /* pos drift */
+ − 924 }
+ − 925 TXcompensation = TXtick - TXcompensation;
+ − 926 Scheduler.tickstart -= TXcompensation;
+ − 927 }
+ − 928 else
+ − 929 {
+ − 930 Scheduler_Request_sync_with_SPI(SPI_SYNC_METHOD_SOFT); /* A large shift in 100ms cycle occured => clip to 100ms in next sync call */
+ − 931 }
207
+ − 932 break;
142
+ − 933 }
+ − 934 }
38
+ − 935
+ − 936 /**
+ − 937 ******************************************************************************
+ − 938 * @brief scheduleCompassCalibrationMode
+ − 939 * @author heinrichs weikamp gmbh
+ − 940 * @version V0.0.1
+ − 941 * @since 31-March-2015
+ − 942 * @date 31-March-2015
+ − 943 ******************************************************************************
+ − 944 */
+ − 945 void scheduleCompassCalibrationMode(void)
+ − 946 {
+ − 947 compass_init(1,7); // fast mode, max gain
+ − 948 compass_calib(); // duration : 1 minute!
+ − 949 compass_init(0,7); // back to normal mode
+ − 950
+ − 951 if(global.seconds_since_last_dive)
+ − 952 {
+ − 953 schedule_update_timer_helper(-1);
+ − 954 }
+ − 955
+ − 956 scheduleUpdateLifeData(0);
+ − 957 global.mode = MODE_SURFACE;
+ − 958 }
+ − 959
+ − 960
+ − 961 /**
+ − 962 ******************************************************************************
+ − 963 * @brief scheduleSleepMode / sleep mode: Main Loop
+ − 964 * @author heinrichs weikamp gmbh
+ − 965 * @version V0.0.2
+ − 966 * @since 31-March-2015
+ − 967 * @date 22-April-2014
+ − 968 ******************************************************************************
+ − 969 */
+ − 970
+ − 971 void scheduleSleepMode(void)
+ − 972 {
+ − 973 global.dataSendToMaster.mode = 0;
+ − 974 global.deviceDataSendToMaster.mode = 0;
+ − 975
+ − 976 /* prevent button wake up problem while in sleep_prepare
+ − 977 * sleep prepare does I2C_DeInit()
+ − 978 */
+ − 979 if(global.mode != MODE_SLEEP)
+ − 980 MX_I2C1_Init();
+ − 981 else
+ − 982 do
+ − 983 {
+ − 984 I2C_DeInit();
+ − 985
+ − 986 #ifdef DEBUGMODE
+ − 987 HAL_Delay(2000);
+ − 988 #else
+ − 989 RTC_StopMode_2seconds();
+ − 990 #endif
+ − 991
+ − 992
+ − 993
+ − 994 if(global.mode == MODE_SLEEP)
+ − 995 secondsCount += 2;
+ − 996
+ − 997 MX_I2C1_Init();
+ − 998 pressure_sensor_get_pressure_raw();
+ − 999
+ − 1000 if(secondsCount >= 30)
+ − 1001 {
+ − 1002 pressure_sensor_get_temperature_raw();
+ − 1003 battery_gas_gauge_get_data();
+ − 1004 // ReInit_battery_charger_status_pins();
+ − 1005 battery_charger_get_status_and_contral_battery_gas_gauge(1);
+ − 1006 // DeInit_battery_charger_status_pins();
+ − 1007 secondsCount = 0;
+ − 1008 }
+ − 1009
+ − 1010 pressure_calculation();
+ − 1011
+ − 1012 scheduleUpdateDeviceData();
+ − 1013 update_surface_pressure(2);
+ − 1014
+ − 1015 if(global.seconds_since_last_dive)
+ − 1016 {
+ − 1017 schedule_update_timer_helper(-1);
+ − 1018 }
+ − 1019
+ − 1020 if(global.accidentRemainingSeconds)
+ − 1021 {
+ − 1022 if(global.accidentRemainingSeconds > 2)
+ − 1023 global.accidentRemainingSeconds -= 2;
+ − 1024 else
+ − 1025 {
+ − 1026 global.accidentRemainingSeconds = 0;
+ − 1027 global.accidentFlag = 0;
+ − 1028 }
+ − 1029 }
+ − 1030
301
a09b1855d656
cleanup, RTE: factor out scheduleCheck_pressure_reached_dive_mode_level
Jan Mulder <jlmulder@xs4all.nl>
diff
changeset
+ − 1031 if (!is_ambient_pressure_close_to_surface(&global.lifeData))
38
+ − 1032 global.mode = MODE_BOOT;
+ − 1033
+ − 1034 scheduleUpdateLifeData(2000);
+ − 1035 }
+ − 1036 while(global.mode == MODE_SLEEP);
+ − 1037 /* new section for system after Standby */
+ − 1038 scheduleUpdateLifeData(-1);
+ − 1039 clearDecoNow = 0;
+ − 1040 setButtonsNow = 0;
264
+ − 1041 reinitGlobals();
38
+ − 1042 }
+ − 1043
+ − 1044
+ − 1045
+ − 1046 /* Private functions ---------------------------------------------------------*/
+ − 1047
+ − 1048 /**
+ − 1049 ******************************************************************************
+ − 1050 * @brief scheduleUpdateLifeData / calculates tissues
+ − 1051 * @author Peter Ryser
+ − 1052 * @version V0.0.1
+ − 1053 * @date 22-April-2014
+ − 1054 ******************************************************************************
+ − 1055 */
+ − 1056
+ − 1057
+ − 1058 void scheduleUpdateLifeData(int32_t asynchron_milliseconds_since_last)
+ − 1059 {
+ − 1060 static _Bool first = 1;
+ − 1061 static uint32_t tickstart = 0;
+ − 1062 static uint32_t ticksrest = 0;
+ − 1063
+ − 1064 uint32_t ticksdiff = 0;
+ − 1065 uint32_t ticksnow = 0;
+ − 1066 uint32_t time_seconds = 0;
+ − 1067 uint8_t whichGasTmp = 0;
+ − 1068
135
+ − 1069 uint8_t updateTissueData = 0;
+ − 1070
+ − 1071
+ − 1072 if(global.lifeData.pressure_surface_bar == INVALID_PREASURE_VALUE)
+ − 1073 {
+ − 1074 updateTissueData = 1;
+ − 1075 }
+ − 1076
38
+ − 1077 if(asynchron_milliseconds_since_last < 0)
+ − 1078 {
+ − 1079 first = 1;
+ − 1080 tickstart = 0;
+ − 1081 ticksrest = 0;
+ − 1082 return;
+ − 1083 }
+ − 1084
+ − 1085 if(!asynchron_milliseconds_since_last && first)
+ − 1086 {
+ − 1087 tickstart = HAL_GetTick();
+ − 1088 first = 0;
+ − 1089 return;
+ − 1090 }
+ − 1091
+ − 1092 whichGasTmp = global.whichGas;
+ − 1093 global.lifeData.actualGas = global.aktualGas[whichGasTmp];
+ − 1094 global.lifeData.pressure_ambient_bar = get_pressure_mbar() / 1000.0f;
+ − 1095 global.lifeData.pressure_surface_bar = get_surface_mbar() / 1000.0f;
+ − 1096
135
+ − 1097 if(updateTissueData)
+ − 1098 {
+ − 1099 decom_reset_with_ambientmbar(global.lifeData.pressure_surface_bar,&global.lifeData);
+ − 1100 }
+ − 1101
38
+ − 1102 if(!asynchron_milliseconds_since_last)
+ − 1103 {
+ − 1104 ticksnow = HAL_GetTick();
+ − 1105 ticksdiff = time_elapsed_ms(tickstart,ticksnow);
+ − 1106 }
+ − 1107 else
+ − 1108 {
+ − 1109 first = 1;
+ − 1110 ticksdiff = asynchron_milliseconds_since_last;
+ − 1111 }
+ − 1112
+ − 1113 if(ticksrest > 1000) // whatever happens after standby with STM32L476
+ − 1114 ticksrest = 0; // maybe move static to SRAM2
+ − 1115
+ − 1116 ticksdiff += ticksrest;
+ − 1117 time_seconds = ticksdiff/ 1000;
+ − 1118 ticksrest = ticksdiff - time_seconds * 1000;
+ − 1119 tickstart = ticksnow;
+ − 1120
+ − 1121 decom_tissues_exposure((int)time_seconds, &global.lifeData);
+ − 1122 if(global.demo_mode)
+ − 1123 decom_tissues_exposure((int)(3*time_seconds), &global.lifeData);
+ − 1124 copyTissueData();
+ − 1125 }
+ − 1126
+ − 1127
+ − 1128 /**
+ − 1129 ******************************************************************************
+ − 1130 * @brief scheduleUpdateDeviceData
+ − 1131 * @author heinrichs weikamp gmbh
+ − 1132 * @version V0.0.1
+ − 1133 * @date 16-March-2015
+ − 1134 *
+ − 1135 * two step process
+ − 1136 * first compare with data from main CPU == externalLogbookFlash
+ − 1137 * second update with new sensor data
+ − 1138 ******************************************************************************
+ − 1139 */
+ − 1140 void scheduleSetDate(SDeviceLine *line)
+ − 1141 {
+ − 1142 extern RTC_HandleTypeDef RTCHandle;
+ − 1143
+ − 1144 line->date_rtc_dr = (uint32_t)(RTCHandle.Instance->DR & RTC_DR_RESERVED_MASK);
+ − 1145 line->time_rtc_tr = (uint32_t)(RTCHandle.Instance->TR & RTC_TR_RESERVED_MASK);
+ − 1146 }
+ − 1147
+ − 1148
+ − 1149 void scheduleCopyDeviceData(SDeviceLine *lineWrite, const SDeviceLine *lineRead)
+ − 1150 {
+ − 1151 lineWrite->date_rtc_dr = lineRead->date_rtc_dr;
+ − 1152 lineWrite->time_rtc_tr = lineRead->time_rtc_tr;
+ − 1153 lineWrite->value_int32 = lineRead->value_int32;
+ − 1154 }
+ − 1155
+ − 1156
+ − 1157 void scheduleUpdateDeviceData(void)
+ − 1158 {
+ − 1159 /* first step, main CPU */
+ − 1160
+ − 1161 if(deviceDataFlashValid)
+ − 1162 {
+ − 1163 /* max values */
+ − 1164 if(global.deviceData.batteryChargeCompleteCycles.value_int32 < DeviceDataFlash.batteryChargeCompleteCycles.value_int32)
+ − 1165 {
+ − 1166 scheduleCopyDeviceData(&global.deviceData.batteryChargeCompleteCycles, &DeviceDataFlash.batteryChargeCompleteCycles);
+ − 1167 }
+ − 1168 if(global.deviceData.batteryChargeCycles.value_int32 < DeviceDataFlash.batteryChargeCycles.value_int32)
+ − 1169 {
+ − 1170 scheduleCopyDeviceData(&global.deviceData.batteryChargeCycles, &DeviceDataFlash.batteryChargeCycles);
+ − 1171 }
+ − 1172 if(global.deviceData.temperatureMaximum.value_int32 < DeviceDataFlash.temperatureMaximum.value_int32)
+ − 1173 {
+ − 1174 scheduleCopyDeviceData(&global.deviceData.temperatureMaximum, &DeviceDataFlash.temperatureMaximum);
+ − 1175 }
+ − 1176 if(global.deviceData.depthMaximum.value_int32 < DeviceDataFlash.depthMaximum.value_int32)
+ − 1177 {
+ − 1178 scheduleCopyDeviceData(&global.deviceData.depthMaximum, &DeviceDataFlash.depthMaximum);
+ − 1179 }
+ − 1180 if(global.deviceData.diveCycles.value_int32 < DeviceDataFlash.diveCycles.value_int32)
+ − 1181 {
+ − 1182 scheduleCopyDeviceData(&global.deviceData.diveCycles, &DeviceDataFlash.diveCycles);
+ − 1183 }
+ − 1184 if(global.deviceData.hoursOfOperation.value_int32 < DeviceDataFlash.hoursOfOperation.value_int32)
+ − 1185 {
+ − 1186 scheduleCopyDeviceData(&global.deviceData.hoursOfOperation, &DeviceDataFlash.hoursOfOperation);
+ − 1187 }
+ − 1188
+ − 1189 /* min values */
+ − 1190 if(global.deviceData.temperatureMinimum.value_int32 > DeviceDataFlash.temperatureMinimum.value_int32)
+ − 1191 {
+ − 1192 scheduleCopyDeviceData(&global.deviceData.temperatureMinimum, &DeviceDataFlash.temperatureMinimum);
+ − 1193 }
+ − 1194 if(global.deviceData.voltageMinimum.value_int32 > DeviceDataFlash.voltageMinimum.value_int32)
+ − 1195 {
+ − 1196 scheduleCopyDeviceData(&global.deviceData.voltageMinimum, &DeviceDataFlash.voltageMinimum);
+ − 1197 }
+ − 1198 }
+ − 1199
+ − 1200 /* second step, sensor data */
+ − 1201 int32_t temperature_centigrad_int32;
+ − 1202 int32_t pressure_mbar_int32;
+ − 1203 int32_t voltage_mvolt_int32;
+ − 1204
+ − 1205 temperature_centigrad_int32 = (int32_t)(get_temperature() * 100);
+ − 1206 if(temperature_centigrad_int32 < global.deviceData.temperatureMinimum.value_int32)
+ − 1207 {
+ − 1208 global.deviceData.temperatureMinimum.value_int32 = temperature_centigrad_int32;
88
+ − 1209 scheduleSetDate(&global.deviceData.temperatureMinimum);
38
+ − 1210 }
+ − 1211
+ − 1212 if(temperature_centigrad_int32 > global.deviceData.temperatureMaximum.value_int32)
+ − 1213 {
+ − 1214 global.deviceData.temperatureMaximum.value_int32 = temperature_centigrad_int32;
88
+ − 1215 scheduleSetDate(&global.deviceData.temperatureMaximum);
38
+ − 1216 }
+ − 1217
+ − 1218 pressure_mbar_int32 = (int32_t)get_pressure_mbar();
+ − 1219 if(pressure_mbar_int32 > global.deviceData.depthMaximum.value_int32)
+ − 1220 {
+ − 1221 global.deviceData.depthMaximum.value_int32 = pressure_mbar_int32;
88
+ − 1222 scheduleSetDate(&global.deviceData.depthMaximum);
38
+ − 1223 }
+ − 1224
+ − 1225 voltage_mvolt_int32 = (int32_t)(get_voltage() * 1000);
+ − 1226 if(voltage_mvolt_int32 < global.deviceData.voltageMinimum.value_int32)
+ − 1227 {
+ − 1228 global.deviceData.voltageMinimum.value_int32 = voltage_mvolt_int32;
88
+ − 1229 scheduleSetDate(&global.deviceData.voltageMinimum);
38
+ − 1230 }
+ − 1231
+ − 1232 /* third step, counter */
+ − 1233 switch (global.mode)
+ − 1234 {
+ − 1235 case MODE_SURFACE:
+ − 1236 case MODE_DIVE:
+ − 1237 default:
+ − 1238 deviceDataSubSeconds++;
+ − 1239 if(deviceDataSubSeconds > 10)
+ − 1240 {
+ − 1241 deviceDataSubSeconds = 0;
+ − 1242 global.deviceData.hoursOfOperation.value_int32++;
+ − 1243 }
+ − 1244 break;
+ − 1245
+ − 1246 case MODE_SLEEP:
+ − 1247 case MODE_SHUTDOWN:
+ − 1248 break;
+ − 1249 }
+ − 1250 }
+ − 1251
+ − 1252
+ − 1253 void scheduleUpdateDeviceDataChargerFull(void)
+ − 1254 {
+ − 1255 global.deviceData.batteryChargeCompleteCycles.value_int32++;
88
+ − 1256 scheduleSetDate(&global.deviceData.batteryChargeCompleteCycles);
38
+ − 1257 }
+ − 1258
+ − 1259
+ − 1260 void scheduleUpdateDeviceDataChargerCharging(void)
+ − 1261 {
+ − 1262 global.deviceData.batteryChargeCycles.value_int32++;
88
+ − 1263 scheduleSetDate(&global.deviceData.batteryChargeCycles);
38
+ − 1264 }
+ − 1265
+ − 1266
+ − 1267 /**
+ − 1268 ******************************************************************************
+ − 1269 * @brief vpm_crush / calls vpm calc_crushing_pressure every four seconds during descend
+ − 1270 * @author Peter Ryser
+ − 1271 * @version V0.0.1
+ − 1272 * @date 22-April-2014
+ − 1273 ******************************************************************************
+ − 1274 */
+ − 1275 _Bool vpm_crush2(void)
+ − 1276 {
+ − 1277 int i = 0;
+ − 1278 static float starting_ambient_pressure = 0;
+ − 1279 static float ending_ambient_pressure = 0;
+ − 1280 static float time_calc_begin = -1;
+ − 1281 static float initial_helium_pressure[16];
+ − 1282 static float initial_nitrogen_pressure[16];
+ − 1283 ending_ambient_pressure = global.lifeData.pressure_ambient_bar * 10;
+ − 1284
+ − 1285 if((global.lifeData.dive_time_seconds <= 4) || (starting_ambient_pressure >= ending_ambient_pressure))
+ − 1286 {
+ − 1287 time_calc_begin = global.lifeData.dive_time_seconds;
+ − 1288 starting_ambient_pressure = global.lifeData.pressure_ambient_bar * 10;
+ − 1289 for( i = 0; i < 16; i++)
+ − 1290 {
+ − 1291 initial_helium_pressure[i] = global.lifeData.tissue_helium_bar[i] * 10;
+ − 1292 initial_nitrogen_pressure[i] = global.lifeData.tissue_nitrogen_bar[i] * 10;
+ − 1293 }
+ − 1294 return 0;
+ − 1295 }
+ − 1296 if(global.lifeData.dive_time_seconds - time_calc_begin >= 4)
+ − 1297 {
+ − 1298 if(ending_ambient_pressure > starting_ambient_pressure + 0.5f)
+ − 1299 {
+ − 1300 float rate = (ending_ambient_pressure - starting_ambient_pressure) * 60 / 4;
+ − 1301 calc_crushing_pressure(&global.lifeData, &global.vpm, initial_helium_pressure, initial_nitrogen_pressure, starting_ambient_pressure, rate);
+ − 1302
+ − 1303 time_calc_begin = global.lifeData.dive_time_seconds;
+ − 1304 starting_ambient_pressure = global.lifeData.pressure_ambient_bar * 10;
+ − 1305 for( i = 0; i < 16; i++)
+ − 1306 {
+ − 1307 initial_helium_pressure[i] = global.lifeData.tissue_helium_bar[i] * 10;
+ − 1308 initial_nitrogen_pressure[i] = global.lifeData.tissue_nitrogen_bar[i] * 10;
+ − 1309 }
+ − 1310
+ − 1311 return 1;
+ − 1312 }
+ − 1313
+ − 1314 }
+ − 1315 return 0;
+ − 1316 }
+ − 1317
+ − 1318
+ − 1319 long get_nofly_time_minutes(void)
+ − 1320 {
+ − 1321
+ − 1322 if(global.no_fly_time_minutes <= 0)
+ − 1323 return 0;
+ − 1324
+ − 1325 long minutes_since_last_dive = global.seconds_since_last_dive/60;
+ − 1326
+ − 1327 if((global.seconds_since_last_dive > 0) && (global.no_fly_time_minutes > minutes_since_last_dive))
+ − 1328 {
+ − 1329 return (global.no_fly_time_minutes - minutes_since_last_dive);
+ − 1330 }
+ − 1331 else
+ − 1332 {
+ − 1333 global.no_fly_time_minutes = 0;
+ − 1334 return 0;
+ − 1335 }
+ − 1336 }
+ − 1337
+ − 1338
+ − 1339 //Supports threadsave copying!!!
+ − 1340 void copyActualGas(SGas gas)
+ − 1341 {
+ − 1342 uint8_t whichGas = !global.whichGas;
+ − 1343 global.aktualGas[whichGas] = gas;
+ − 1344 global.whichGas = whichGas;
+ − 1345 }
+ − 1346
+ − 1347
+ − 1348 //Supports threadsave copying!!!
+ − 1349 void copyPressureData(void)
+ − 1350 {
240
+ − 1351 global.dataSendToMaster.sensorErrors = global.I2C_SystemStatus;
38
+ − 1352 uint8_t boolPressureData = !global.dataSendToMaster.boolPressureData;
+ − 1353 global.dataSendToMaster.data[boolPressureData].temperature = get_temperature();
+ − 1354 global.dataSendToMaster.data[boolPressureData].pressure_mbar = get_pressure_mbar();
+ − 1355 global.dataSendToMaster.data[boolPressureData].surface_mbar = get_surface_mbar();
+ − 1356 global.dataSendToMaster.data[boolPressureData].ascent_rate_meter_per_min = global.lifeData.ascent_rate_meter_per_min;
+ − 1357 global.dataSendToMaster.data[boolPressureData].pressure_uTick = HAL_GetTick();
+ − 1358 global.dataSendToMaster.boolPressureData = boolPressureData;
+ − 1359 }
+ − 1360
+ − 1361
+ − 1362 //Supports threadsave copying!!!
+ − 1363 void copyCnsAndOtuData(void)
+ − 1364 {
+ − 1365 //uint8_t dataSendToMaster.
+ − 1366 uint8_t boolToxicData = !global.dataSendToMaster.boolToxicData;
+ − 1367 global.dataSendToMaster.data[boolToxicData].cns = global.lifeData.cns;
+ − 1368 global.dataSendToMaster.data[boolToxicData].otu = global.lifeData.otu;
+ − 1369 global.dataSendToMaster.data[boolToxicData].desaturation_time_minutes = global.lifeData.desaturation_time_minutes;
+ − 1370 global.dataSendToMaster.data[boolToxicData].no_fly_time_minutes = get_nofly_time_minutes();
+ − 1371 global.dataSendToMaster.boolToxicData = boolToxicData;
+ − 1372 }
+ − 1373
+ − 1374
+ − 1375 //Supports threadsave copying!!!
+ − 1376 void copyTimeData(void)
+ − 1377 {
+ − 1378 extern RTC_HandleTypeDef RTCHandle;
+ − 1379
+ − 1380 uint8_t boolTimeData = !global.dataSendToMaster.boolTimeData;
+ − 1381 global.dataSendToMaster.data[boolTimeData].localtime_rtc_tr = (uint32_t)(RTCHandle.Instance->TR & RTC_TR_RESERVED_MASK);
+ − 1382 global.dataSendToMaster.data[boolTimeData].localtime_rtc_dr = (uint32_t)(RTCHandle.Instance->DR & RTC_DR_RESERVED_MASK);
+ − 1383 global.dataSendToMaster.data[boolTimeData].divetime_seconds = (uint32_t)global.lifeData.dive_time_seconds;
+ − 1384 global.dataSendToMaster.data[boolTimeData].dive_time_seconds_without_surface_time = (uint32_t)global.lifeData.dive_time_seconds_without_surface_time;
+ − 1385 global.dataSendToMaster.data[boolTimeData].surfacetime_seconds = (uint32_t)global.seconds_since_last_dive;
+ − 1386 global.dataSendToMaster.data[boolTimeData].counterSecondsShallowDepth = (uint32_t)global.lifeData.counterSecondsShallowDepth;
+ − 1387 global.dataSendToMaster.boolTimeData = boolTimeData;
+ − 1388 }
+ − 1389
+ − 1390
+ − 1391 //Supports threadsave copying!!!
+ − 1392 void copyCompassData(void)
+ − 1393 {
+ − 1394 extern float compass_heading;
+ − 1395 extern float compass_roll;
+ − 1396 extern float compass_pitch;
+ − 1397 //uint8_t dataSendToMaster.
+ − 1398 uint8_t boolCompassData = !global.dataSendToMaster.boolCompassData;
+ − 1399 global.dataSendToMaster.data[boolCompassData].compass_heading = compass_heading;
+ − 1400 global.dataSendToMaster.data[boolCompassData].compass_roll = compass_roll;
+ − 1401 global.dataSendToMaster.data[boolCompassData].compass_pitch = compass_pitch;
+ − 1402 global.dataSendToMaster.data[boolCompassData].compass_DX_f = 0;
+ − 1403 global.dataSendToMaster.data[boolCompassData].compass_DY_f = 0;
+ − 1404 global.dataSendToMaster.data[boolCompassData].compass_DZ_f = 0;
+ − 1405 global.dataSendToMaster.data[boolCompassData].compass_uTick = HAL_GetTick();
+ − 1406 global.dataSendToMaster.boolCompassData = boolCompassData;
+ − 1407 }
+ − 1408
+ − 1409
+ − 1410 void copyCompassDataDuringCalibration(int16_t dx, int16_t dy, int16_t dz)
+ − 1411 {
+ − 1412 extern float compass_heading;
+ − 1413 extern float compass_roll;
+ − 1414 extern float compass_pitch;
+ − 1415 //uint8_t dataSendToMaster.
+ − 1416 uint8_t boolCompassData = !global.dataSendToMaster.boolCompassData;
+ − 1417 global.dataSendToMaster.data[boolCompassData].compass_heading = compass_heading;
+ − 1418 global.dataSendToMaster.data[boolCompassData].compass_roll = compass_roll;
+ − 1419 global.dataSendToMaster.data[boolCompassData].compass_pitch = compass_pitch;
+ − 1420 global.dataSendToMaster.data[boolCompassData].compass_DX_f = dx;
+ − 1421 global.dataSendToMaster.data[boolCompassData].compass_DY_f = dy;
+ − 1422 global.dataSendToMaster.data[boolCompassData].compass_DZ_f = dz;
+ − 1423 global.dataSendToMaster.boolCompassData = boolCompassData;
+ − 1424 }
+ − 1425
+ − 1426
+ − 1427 //Supports threadsave copying!!!
+ − 1428 void copyBatteryData(void)
+ − 1429 {
+ − 1430 uint8_t boolBatteryData = !global.dataSendToMaster.boolBatteryData;
+ − 1431 global.dataSendToMaster.data[boolBatteryData].battery_voltage = get_voltage();
+ − 1432 global.dataSendToMaster.data[boolBatteryData].battery_charge= get_charge();
+ − 1433 global.dataSendToMaster.boolBatteryData = boolBatteryData;
+ − 1434 }
+ − 1435
+ − 1436
+ − 1437 //Supports threadsave copying!!!
+ − 1438 void copyAmbientLightData(void)
+ − 1439 {
+ − 1440 uint8_t boolAmbientLightData = !global.dataSendToMaster.boolAmbientLightData;
+ − 1441 global.dataSendToMaster.data[boolAmbientLightData].ambient_light_level = get_ambient_light_level();
+ − 1442 global.dataSendToMaster.boolAmbientLightData = boolAmbientLightData;
+ − 1443 }
+ − 1444
+ − 1445
+ − 1446 //Supports threadsave copying!!!
+ − 1447 void copyTissueData(void)
+ − 1448 {
+ − 1449 //uint8_t dataSendToMaster.
+ − 1450 uint8_t boolTisssueData = !global.dataSendToMaster.boolTisssueData;
+ − 1451 for(int i = 0; i < 16; i++)
+ − 1452 {
+ − 1453 global.dataSendToMaster.data[boolTisssueData].tissue_nitrogen_bar[i] = global.lifeData.tissue_nitrogen_bar[i];
+ − 1454 global.dataSendToMaster.data[boolTisssueData].tissue_helium_bar[i] = global.lifeData.tissue_helium_bar[i];
+ − 1455 }
+ − 1456 global.dataSendToMaster.boolTisssueData = boolTisssueData;
+ − 1457 }
+ − 1458
+ − 1459
+ − 1460 //Supports threadsave copying!!!
+ − 1461 void copyVpmCrushingData(void)
+ − 1462 {
+ − 1463 //uint8_t dataSendToMaster.
+ − 1464 uint8_t boolCrushingData = !global.dataSendToMaster.boolCrushingData;
+ − 1465 for(int i = 0; i < 16; i++)
+ − 1466 {
+ − 1467 global.dataSendToMaster.data[boolCrushingData].max_crushing_pressure_n2[i] = global.vpm.max_crushing_pressure_n2[i];
+ − 1468 global.dataSendToMaster.data[boolCrushingData].max_crushing_pressure_he[i] = global.vpm.max_crushing_pressure_he[i];
+ − 1469 global.dataSendToMaster.data[boolCrushingData].adjusted_critical_radius_he[i] = global.vpm.adjusted_critical_radius_he[i];
+ − 1470 global.dataSendToMaster.data[boolCrushingData].adjusted_critical_radius_n2[i] = global.vpm.adjusted_critical_radius_n2[i];
+ − 1471 }
+ − 1472 global.dataSendToMaster.boolCrushingData = boolCrushingData;
+ − 1473 }
+ − 1474
+ − 1475
+ − 1476 void copyDeviceData(void)
+ − 1477 {
+ − 1478 uint8_t boolDeviceData = !global.deviceDataSendToMaster.boolDeviceData;
+ − 1479 memcpy(&global.deviceDataSendToMaster.DeviceData[boolDeviceData], &global.deviceData,sizeof(SDevice));
+ − 1480 global.deviceDataSendToMaster.boolDeviceData = boolDeviceData;
+ − 1481
+ − 1482 global.deviceDataSendToMaster.boolVpmRepetitiveDataValid = 0;
+ − 1483 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.adjusted_critical_radius_he, &global.vpm.adjusted_critical_radius_he, sizeof(16*4));
+ − 1484 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.adjusted_critical_radius_n2, &global.vpm.adjusted_critical_radius_n2, sizeof(16*4));
+ − 1485 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.adjusted_crushing_pressure_he, &global.vpm.adjusted_crushing_pressure_he, sizeof(16*4));
+ − 1486 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.adjusted_crushing_pressure_n2, &global.vpm.adjusted_crushing_pressure_n2, sizeof(16*4));
+ − 1487 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.initial_allowable_gradient_he, &global.vpm.initial_allowable_gradient_he, sizeof(16*4));
+ − 1488 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.initial_allowable_gradient_n2, &global.vpm.initial_allowable_gradient_n2, sizeof(16*4));
+ − 1489 memcpy(&global.deviceDataSendToMaster.VpmRepetitiveData.max_actual_gradient, &global.vpm.max_actual_gradient, sizeof(16*4));
+ − 1490 global.deviceDataSendToMaster.VpmRepetitiveData.repetitive_variables_not_valid = global.vpm.repetitive_variables_not_valid;
+ − 1491 global.deviceDataSendToMaster.boolVpmRepetitiveDataValid = 1;
+ − 1492 }
+ − 1493
+ − 1494 /* copyPICdata(); is used in spi.c */
+ − 1495 void copyPICdata(void)
+ − 1496 {
+ − 1497 uint8_t boolPICdata = !global.dataSendToMaster.boolPICdata;
+ − 1498 for(int i = 0; i < 3; i++)
+ − 1499 {
+ − 1500 global.dataSendToMaster.data[boolPICdata].button_setting[i] = global.ButtonPICdata[i];
+ − 1501 }
+ − 1502 global.dataSendToMaster.boolPICdata = boolPICdata;
+ − 1503 }
+ − 1504
+ − 1505
+ − 1506 typedef enum
+ − 1507 {
+ − 1508 SPI3_OK = 0x00,
+ − 1509 SPI3_DEINIT = 0x01,
+ − 1510 } SPI3_StatusTypeDef;
+ − 1511 /* if spi3 is running and the SPI3_ButtonAdjust call returns OK, all is fine
+ − 1512 if the SPI3_ButtonAdjust call returns error, the spi3 is DeInit
+ − 1513 and will be init the next call of scheduleSetButtonResponsiveness()
+ − 1514 and data will be send again on the third call
+ − 1515 therefore on return 0 of scheduleSetButtonResponsiveness() the caller flag should kept active
+ − 1516 */
+ − 1517 uint8_t scheduleSetButtonResponsiveness(void)
+ − 1518 {
+ − 1519 static uint8_t SPI3status = SPI3_OK;
+ − 1520
+ − 1521 if((SPI3status == SPI3_OK) && (SPI3_ButtonAdjust(global.ButtonResponsiveness, global.ButtonPICdata)))
+ − 1522 {
+ − 1523 copyPICdata();
+ − 1524 return 1;
+ − 1525 }
+ − 1526 else
+ − 1527 {
+ − 1528 for(int i=0;i<3;i++)
+ − 1529 {
+ − 1530 global.ButtonPICdata[i] = 0xFF;
+ − 1531 }
+ − 1532 copyPICdata();
+ − 1533
+ − 1534 if(SPI3status == SPI3_OK)
+ − 1535 {
+ − 1536 MX_SPI3_DeInit();
+ − 1537 SPI3status = SPI3_DEINIT;
+ − 1538 }
+ − 1539 else
+ − 1540 {
+ − 1541 MX_SPI3_Init();
+ − 1542 SPI3status = SPI3_OK;
+ − 1543 }
+ − 1544 return 0;
+ − 1545 }
+ − 1546 }
+ − 1547
+ − 1548
186
+ − 1549 //save time difference
38
+ − 1550 uint32_t time_elapsed_ms(uint32_t ticksstart,uint32_t ticksnow)
+ − 1551 {
+ − 1552 if(ticksstart <= ticksnow)
+ − 1553 {
+ − 1554 return ticksnow - ticksstart;
+ − 1555 }
+ − 1556 else
+ − 1557 {
+ − 1558 return 0xFFFFFFFF - ticksstart + ticksnow;
+ − 1559 }
+ − 1560 }
+ − 1561
+ − 1562 /* same as in data_central.c */
+ − 1563 _Bool is_ambient_pressure_close_to_surface(SLifeData *lifeDataCall)
+ − 1564 {
+ − 1565 if(lifeDataCall->pressure_ambient_bar < (lifeDataCall->pressure_surface_bar + 0.1f)) // hw 161121 now 1 mter, before 0.04f
+ − 1566 return true;
+ − 1567 else
+ − 1568 return false;
+ − 1569 }
+ − 1570
+ − 1571
+ − 1572 /************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/
+ − 1573
