Mercurial > public > ostc4
annotate Small_CPU/Src/pressure.c @ 946:80ae8ea7f0a0 Evo_2_23
GNSS set to full power at startup:
In case of an reset the module would continue in sleep mode if it was in this state. To avoid this the module will now always set to full power at startup of the RTE.
| author | Ideenmodellierer |
|---|---|
| date | Sun, 22 Dec 2024 20:52:08 +0100 |
| parents | 06aaccaf2e02 |
| children |
| rev | line source |
|---|---|
| 38 | 1 /** |
| 2 ****************************************************************************** | |
| 3 * @file pressure.c | |
| 4 * @author heinrichs weikamp gmbh | |
| 5 * @date 2014 | |
| 6 * @version V0.0.2 | |
| 7 * @since 20-Oct-2016 | |
| 8 * @brief | |
| 9 * | |
| 10 @verbatim | |
| 11 ============================================================================== | |
| 12 ##### How to use ##### | |
| 13 ============================================================================== | |
| 14 V0.0.2 18-Oct-2016 pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015 | |
| 15 | |
| 16 @endverbatim | |
| 17 ****************************************************************************** | |
| 18 * @attention | |
| 19 * | |
| 20 * <h2><center>© COPYRIGHT(c) 2016 heinrichs weikamp</center></h2> | |
| 21 * | |
| 22 ****************************************************************************** | |
| 23 */ | |
| 24 | |
| 25 | |
| 26 | |
| 27 /* surface time | |
| 28 the last 30 minutes will be saved once per minute in a endless loop | |
| 29 at the beginning of a dive the oldest value will be used | |
| 30 */ | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
31 #include "math.h" |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
32 #include "scheduler.h" |
| 38 | 33 #include "pressure.h" |
| 34 #include "i2c.h" | |
| 35 #include "rtc.h" | |
| 36 | |
| 37 #define CMD_RESET 0x1E // ADC reset command | |
| 38 #define CMD_ADC_READ 0x00 // ADC read command | |
| 39 #define CMD_ADC_CONV 0x40 // ADC conversion command | |
| 40 #define CMD_ADC_D1 0x00 // ADC D1 conversion | |
| 41 #define CMD_ADC_D2 0x10 // ADC D2 conversion | |
| 42 #define CMD_ADC_256 0x00 // ADC OSR=256 | |
| 43 #define CMD_ADC_512 0x02 // ADC OSR=512 | |
| 44 #define CMD_ADC_1024 0x04 // ADC OSR=1024 | |
| 45 #define CMD_ADC_2048 0x06 // ADC OSR=2056 | |
| 46 #define CMD_ADC_4096 0x08 // ADC OSR=4096 | |
| 47 #define CMD_PROM_RD 0xA0 // Prom read command | |
| 48 | |
| 352 | 49 /* remove comment to use a predefined profile for pressure changes instead of real world data */ |
| 50 /* #define SIMULATE_PRESSURE */ | |
| 51 | |
| 535 | 52 #define PRESSURE_SURFACE_MAX_MBAR (1060.0f) /* It is unlikely that pressure at surface is greater than this value => clip to it */ |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
53 |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
54 #define PRESSURE_MINIMUM (0.0f) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
55 #define TEMPERATURE_MINIMUM (-100.0f) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
56 |
| 352 | 57 #define PRESSURE_SURFACE_QUE (30u) /* history buffer [minutes] for past pressure measurements */ |
| 58 #define PRESSURE_SURFACE_EVA_WINDOW (15u) /* Number of entries evaluated during instability test. Used to avoid detection while dive enters water */ | |
| 59 #define PRESSURE_SURFACE_STABLE_LIMIT (10u) /* Define pressure as stable if delta (mBar) is below this value */ | |
| 60 #define PRESSURE_SURFACE_DETECT_STABLE_CNT (5u) /* Event count to detect stable condition */ | |
| 61 #define PRESSURE_SURFACE_UNSTABLE_LIMIT (50u) /* Define pressure as not stable if delta (mBar) is larger than this value */ | |
| 62 #define PRESSURE_SURFACE_DETECT_UNSTABLE_CNT (3u) /* Event count to detect unstable condition */ | |
| 63 | |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
64 |
| 356 | 65 static uint8_t PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5803; /* Default Address */ |
| 66 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
67 static uint16_t get_ci_by_coef_num(uint8_t coef_num); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
68 //void pressure_calculation_new(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
69 //void pressure_calculation_old(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
70 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void); |
| 356 | 71 //static uint8_t crc4(uint16_t n_prom[]); |
| 38 | 72 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
73 static HAL_StatusTypeDef pressure_sensor_get_data(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
74 static uint32_t get_adc(void); |
| 38 | 75 uint8_t pressureSensorInitSuccess = 0; |
| 76 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
77 static uint16_t C[8] = { 1 }; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
78 static uint32_t D1 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
79 static uint32_t D2 = 1; |
| 356 | 80 //static uint8_t n_crc; |
| 38 | 81 |
| 82 /* | |
| 83 short C2plus10000 = -1; | |
| 84 short C3plus200 = -1; | |
| 85 short C4minus250 = -1; | |
| 86 short UT1 = -1; | |
| 87 short C6plus100 = -1; | |
| 88 */ | |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
89 static float pressure_offset = 0.0; /* Offset value which may be specified by the user via PC Software */ |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
90 static float temperature_offset = 0.0; /* Offset value which may be specified by the user via PC Software */ |
| 38 | 91 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
92 static float ambient_temperature = 0; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
93 static float ambient_pressure_mbar = 1000.0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
94 static float surface_pressure_mbar = 1000.0; |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
95 static float surface_ring_mbar[PRESSURE_SURFACE_QUE] = { 0 }; |
| 38 | 96 |
| 352 | 97 static uint8_t surface_pressure_writeIndex = 0; |
| 98 static float surface_pressure_stable_value = 0; | |
| 99 static uint8_t surface_pressure_stable = 0; | |
| 100 | |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
101 static uint8_t secondCounterSurfaceRing = 0; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
102 static uint8_t avgCount = 0; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
103 static float runningAvg = 0; |
| 38 | 104 |
| 105 float get_temperature(void) | |
| 106 { | |
| 107 return ambient_temperature; | |
| 108 } | |
| 109 | |
| 110 float get_pressure_mbar(void) | |
| 111 { | |
| 112 return ambient_pressure_mbar; | |
| 113 } | |
| 114 | |
| 115 float get_surface_mbar(void) | |
| 116 { | |
| 117 return surface_pressure_mbar; | |
| 118 } | |
| 119 | |
| 120 | |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
121 void init_surface_ring(uint8_t force) |
| 38 | 122 { |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
123 if((surface_ring_mbar[0] == 0) || (force)) /* only initialize once. Keep value in place in case of an i2c recovery */ |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
124 { |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
125 secondCounterSurfaceRing = 0; /* restart calculation */ |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
126 avgCount = 0; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
127 runningAvg = 0; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
128 |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
129 for(int i=0; i<PRESSURE_SURFACE_QUE; i++) |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
130 surface_ring_mbar[i] = ambient_pressure_mbar; |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
131 surface_pressure_mbar = ambient_pressure_mbar; |
|
858
08ea8e9d6cfe
Bugfix initialisation of surface pressure:
Ideenmodellierer
parents:
846
diff
changeset
|
132 surface_pressure_stable_value = surface_pressure_mbar; |
| 352 | 133 surface_pressure_writeIndex = 0; /* index of the oldest value in the ring buffer */ |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
134 } |
| 38 | 135 } |
| 136 | |
| 352 | 137 uint8_t is_surface_pressure_stable(void) |
| 138 { | |
| 139 return surface_pressure_stable; | |
| 140 } | |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
141 |
| 352 | 142 float set_last_surface_pressure_stable(void) |
| 143 { | |
| 144 surface_pressure_mbar = surface_pressure_stable_value; | |
| 145 return surface_pressure_stable_value; | |
| 146 } | |
| 147 | |
| 148 /* iterate backward through the history memory and evaluate the changes pressure changes during the last 30 minutes */ | |
| 149 void evaluate_surface_pressure() | |
| 150 { | |
| 151 uint8_t index; | |
| 152 float lastvalue; | |
| 153 uint8_t stablecnt = 0; | |
| 154 uint8_t unstablecnt = 0; | |
| 155 uint8_t EvaluationWindow = PRESSURE_SURFACE_QUE - PRESSURE_SURFACE_EVA_WINDOW; /* do not use the latest 15 values to avoid unstable condition due to something like fin handling */ | |
| 156 uint8_t EvaluatedValues = 0; | |
| 157 | |
| 158 lastvalue = surface_ring_mbar[surface_pressure_writeIndex]; | |
| 159 surface_pressure_stable_value = surface_ring_mbar[surface_pressure_writeIndex]; /* default: if no stable value is found return the oldest value */ | |
| 160 index = surface_pressure_writeIndex; | |
| 161 surface_pressure_stable = 1; | |
| 162 | |
| 163 if(index == 0) | |
| 164 { | |
| 165 index = PRESSURE_SURFACE_QUE - 1; | |
| 166 } | |
| 167 else | |
| 168 { | |
| 169 index = index - 1; | |
| 170 } | |
| 171 do | |
| 172 { | |
| 173 if((EvaluatedValues < EvaluationWindow) && | |
| 174 (fabs(surface_pressure_stable_value - surface_ring_mbar[index]) > PRESSURE_SURFACE_UNSTABLE_LIMIT)) /* unusual change during last 30 minutes */ | |
| 175 { | |
| 176 unstablecnt++; | |
| 177 if(unstablecnt > PRESSURE_SURFACE_DETECT_UNSTABLE_CNT) | |
| 178 { | |
| 179 surface_pressure_stable = 0; | |
| 180 } | |
| 181 } | |
| 182 /* search for a value which does not change for several iterations */ | |
| 183 if (fabs(lastvalue - surface_ring_mbar[index]) < PRESSURE_SURFACE_STABLE_LIMIT) | |
| 184 { | |
| 185 stablecnt++; | |
| 186 } | |
| 187 else | |
| 188 { | |
| 189 stablecnt = 0; | |
| 190 } | |
| 191 if ((stablecnt >= PRESSURE_SURFACE_DETECT_STABLE_CNT) && (surface_pressure_stable == 0)&&(surface_pressure_stable_value == surface_ring_mbar[surface_pressure_writeIndex])) /* pressure is unstable => search for new stable value */ | |
| 192 { | |
| 193 surface_pressure_stable_value = surface_ring_mbar[index]; | |
| 194 unstablecnt = 0; | |
| 195 } | |
| 196 | |
| 197 lastvalue = surface_ring_mbar[index]; | |
| 198 | |
| 199 if(index == 0) | |
| 200 { | |
| 201 index = PRESSURE_SURFACE_QUE - 1; | |
| 202 } | |
| 203 else | |
| 204 { | |
| 205 index = index - 1; | |
| 206 } | |
| 207 EvaluatedValues++; | |
| 208 } while (index != surface_pressure_writeIndex); | |
| 209 } | |
| 38 | 210 void update_surface_pressure(uint8_t call_rhythm_seconds) |
| 211 { | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
212 if(is_init_pressure_done()) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
213 { |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
214 runningAvg = (runningAvg * avgCount + ambient_pressure_mbar) / (avgCount +1); |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
215 avgCount++; |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
216 secondCounterSurfaceRing += call_rhythm_seconds; |
| 38 | 217 |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
218 if(secondCounterSurfaceRing >= 60) |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
219 { |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
220 if(runningAvg < PRESSURE_SURFACE_MAX_MBAR) |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
221 { |
| 352 | 222 surface_ring_mbar[surface_pressure_writeIndex] = runningAvg; |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
223 } |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
224 else |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
225 { |
| 352 | 226 surface_ring_mbar[surface_pressure_writeIndex] = PRESSURE_SURFACE_MAX_MBAR; |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
227 } |
| 352 | 228 surface_pressure_writeIndex++; /* the write index is now pointing to the oldest value in the buffer which will be overwritten next time */ |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
229 |
| 352 | 230 if(surface_pressure_writeIndex == PRESSURE_SURFACE_QUE) |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
231 { |
| 352 | 232 surface_pressure_writeIndex = 0; |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
233 } |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
234 |
| 352 | 235 surface_pressure_mbar = surface_ring_mbar[surface_pressure_writeIndex]; /* 30 minutes old measurement */ |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
236 |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
237 secondCounterSurfaceRing = 0; |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
238 avgCount = 1; /* use the current value as starting point but restart the weight decrement of the measurements */ |
|
858
08ea8e9d6cfe
Bugfix initialisation of surface pressure:
Ideenmodellierer
parents:
846
diff
changeset
|
239 |
|
08ea8e9d6cfe
Bugfix initialisation of surface pressure:
Ideenmodellierer
parents:
846
diff
changeset
|
240 evaluate_surface_pressure(); |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
241 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
242 } |
| 38 | 243 } |
| 244 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
245 #ifdef DEMOMODE |
| 38 | 246 float demo_modify_temperature_helper(float bottom_mbar_diff_to_surface) |
| 247 { | |
| 248 const float temperature_surface = 31.0; | |
| 249 const float temperature_bottom = 14.0; | |
| 250 | |
| 251 const float temperature_difference = temperature_bottom - temperature_surface; | |
| 252 | |
| 253 // range 0.0 - 1.0 | |
| 254 float position_now = (ambient_pressure_mbar - surface_pressure_mbar) / bottom_mbar_diff_to_surface; | |
| 255 | |
| 256 if(position_now <= 0) | |
| 257 return temperature_surface; | |
| 258 | |
| 259 if(position_now >= 1) | |
| 260 return temperature_bottom; | |
| 261 | |
| 262 return temperature_surface + (temperature_difference * position_now); | |
| 263 } | |
| 264 | |
| 265 | |
| 266 uint32_t demo_modify_temperature_and_pressure(int32_t divetime_in_seconds, uint8_t subseconds, float ceiling_mbar) | |
| 267 { | |
| 268 | |
| 269 const float descent_rate = 4000/60; | |
| 270 const float ascent_rate = 1000/60; | |
| 271 const uint32_t seconds_descend = (1 * 60) + 30; | |
| 272 const uint32_t turbo_seconds_at_bottom_start = (0 * 60) + 0; | |
| 273 const uint32_t seconds_descend_and_bottomtime = seconds_descend + turbo_seconds_at_bottom_start + (2 * 60) + 0; | |
| 274 uint32_t time_elapsed_in_seconds; | |
| 275 static float ambient_pressure_mbar_memory = 0; | |
| 276 static uint32_t time_last_call = 0; | |
| 277 | |
| 278 if(divetime_in_seconds <= seconds_descend) | |
| 279 { | |
| 280 ambient_pressure_mbar = (divetime_in_seconds * descent_rate) + ((float)(subseconds) * descent_rate) + surface_pressure_mbar; | |
| 281 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 282 | |
| 283 time_last_call = divetime_in_seconds; | |
| 284 return 0; | |
| 285 } | |
| 286 else | |
| 287 if(divetime_in_seconds <= seconds_descend + turbo_seconds_at_bottom_start) | |
| 288 { | |
| 289 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 290 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 291 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 292 time_last_call = divetime_in_seconds; | |
| 293 return turbo_seconds_at_bottom_start; | |
| 294 } | |
| 295 else | |
| 296 if(divetime_in_seconds <= seconds_descend_and_bottomtime) | |
| 297 { | |
| 298 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 299 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 300 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 301 time_last_call = divetime_in_seconds; | |
| 302 return 0; | |
| 303 } | |
| 304 else | |
| 305 { | |
| 306 time_elapsed_in_seconds = divetime_in_seconds - time_last_call; | |
| 307 ambient_pressure_mbar = ambient_pressure_mbar_memory - time_elapsed_in_seconds * ascent_rate; | |
| 308 | |
| 309 if(ambient_pressure_mbar < surface_pressure_mbar) | |
| 310 ambient_pressure_mbar = surface_pressure_mbar; | |
| 311 else if(ambient_pressure_mbar < ceiling_mbar) | |
| 312 ambient_pressure_mbar = ceiling_mbar; | |
| 313 | |
| 314 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 315 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 316 time_last_call = divetime_in_seconds; | |
| 317 return 0; | |
| 318 } | |
| 319 } | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
320 #endif |
| 38 | 321 |
| 322 uint8_t is_init_pressure_done(void) | |
| 323 { | |
| 324 return pressureSensorInitSuccess; | |
| 325 } | |
| 326 | |
| 327 uint8_t init_pressure(void) | |
| 328 { | |
| 329 uint8_t buffer[1]; | |
| 356 | 330 buffer[0] = 0x1E; // Reset Command |
| 38 | 331 uint8_t retValue = 0xFF; |
| 332 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
333 pressureSensorInitSuccess = false; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
334 |
| 356 | 335 /* Probe new sensor first */ |
| 336 retValue = I2C_Master_Transmit( DEVICE_PRESSURE_MS5837, buffer, 1); | |
| 337 if(retValue != HAL_OK) | |
| 338 { | |
| 339 PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5803; // use old sensor | |
| 340 HAL_Delay(100); | |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
341 I2C_DeInit(); |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
342 HAL_Delay(100); |
| 356 | 343 MX_I2C1_Init(); |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
344 HAL_Delay(100); |
| 356 | 345 } |
| 346 else | |
| 347 { | |
| 348 PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5837; // Success, use new sensor | |
| 349 } | |
| 350 HAL_Delay(3); //2.8ms according to datasheet | |
| 351 | |
| 352 buffer[0] = 0x1E; // Reset Command | |
| 353 retValue = 0xFF; | |
| 354 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
355 /* Send reset request to pressure sensor */ |
| 356 | 356 retValue = I2C_Master_Transmit( PRESSURE_ADDRESS, buffer, 1); |
| 38 | 357 if(retValue != HAL_OK) |
| 358 { | |
| 359 return (HAL_StatusTypeDef)retValue; | |
| 360 } | |
| 356 | 361 HAL_Delay(3); //2.8ms according to datasheet |
| 38 | 362 |
| 356 | 363 for(uint8_t i=0;i<7;i++) |
| 38 | 364 { |
| 365 C[i] = get_ci_by_coef_num(i); | |
| 366 } | |
| 356 | 367 // n_crc = crc4(C); // no evaluation at the moment hw 151026 |
| 38 | 368 |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
369 if(global.I2C_SystemStatus == HAL_OK) |
| 38 | 370 { |
| 371 pressureSensorInitSuccess = 1; | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
372 retValue = pressure_update(); |
| 38 | 373 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
374 return retValue; |
| 38 | 375 } |
| 376 | |
| 377 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
378 static uint32_t get_adc(void) |
| 38 | 379 { |
| 380 uint8_t buffer[1]; | |
| 381 uint8_t resivebuf[4]; | |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
382 uint32_t answer = 0xFFFFFFFF; |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
383 |
| 38 | 384 buffer[0] = 0x00; // Get ADC |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
385 if(I2C_Master_Transmit( PRESSURE_ADDRESS, buffer, 1) == HAL_OK) |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
386 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
387 if(I2C_Master_Receive( PRESSURE_ADDRESS, resivebuf, 4) == HAL_OK) |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
388 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
389 resivebuf[3] = 0; |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
390 answer = 256*256 *(uint32_t)resivebuf[0] + 256 * (uint32_t)resivebuf[1] + (uint32_t)resivebuf[2]; |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
391 } |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
392 } |
| 38 | 393 return answer; |
| 394 } | |
| 395 | |
| 396 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
397 static uint16_t get_ci_by_coef_num(uint8_t coef_num) |
| 38 | 398 { |
| 399 uint8_t resivebuf[2]; | |
| 400 | |
| 401 uint8_t cmd = CMD_PROM_RD+coef_num*2; | |
| 356 | 402 I2C_Master_Transmit( PRESSURE_ADDRESS, &cmd, 1); |
| 403 I2C_Master_Receive( PRESSURE_ADDRESS, resivebuf, 2); | |
| 38 | 404 return (256*(uint16_t)resivebuf[0]) + (uint16_t)resivebuf[1]; |
| 405 } | |
| 406 | |
| 407 | |
| 408 | |
| 409 uint8_t pressure_update(void) | |
| 410 { | |
| 411 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; | |
| 412 | |
| 413 statusReturn = pressure_sensor_get_data(); | |
| 414 pressure_calculation(); | |
| 415 return (uint8_t)statusReturn; | |
| 416 } | |
| 417 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
418 /* Switch between pressure and temperature measurement with every successful read operation */ |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
419 void pressure_update_alternating(void) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
420 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
421 static uint8_t getTemperature= 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
422 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
423 if(getTemperature) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
424 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
425 if(pressure_sensor_get_temperature_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
426 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
427 getTemperature = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
428 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
429 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
430 else |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
431 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
432 if(pressure_sensor_get_pressure_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
433 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
434 getTemperature = 1; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
435 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
436 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
437 pressure_calculation(); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
438 return; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
439 } |
| 38 | 440 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
441 static uint32_t pressure_sensor_get_one_value(uint8_t cmd, HAL_StatusTypeDef *statusReturn) |
| 38 | 442 { |
| 443 uint8_t command = CMD_ADC_CONV + cmd; | |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
444 uint32_t adcValue = 0; |
| 38 | 445 HAL_StatusTypeDef statusReturnTemp = HAL_TIMEOUT; |
| 446 | |
| 356 | 447 statusReturnTemp = I2C_Master_Transmit( PRESSURE_ADDRESS, &command, 1); |
| 38 | 448 |
| 449 if(statusReturn) | |
| 450 { | |
| 451 *statusReturn = statusReturnTemp; | |
| 452 } | |
| 479 | 453 |
| 454 switch (cmd & 0x0f) // wait necessary conversion time | |
| 38 | 455 { |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
456 case CMD_ADC_256 : HAL_Delay(2); break; |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
457 case CMD_ADC_512 : HAL_Delay(4); break; |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
458 case CMD_ADC_1024: HAL_Delay(5); break; |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
459 case CMD_ADC_2048: HAL_Delay(7); break; |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
460 case CMD_ADC_4096: HAL_Delay(11); break; |
| 479 | 461 default: |
| 462 break; | |
| 463 } | |
| 464 adcValue = get_adc(); | |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
465 /* if(adcValue == 0xFFFFFFFF) |
| 479 | 466 { |
| 467 if(statusReturn) | |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
468 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
469 *statusReturn = HAL_ERROR; |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
470 } |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
471 }*/ |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
472 |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
473 return adcValue; |
| 38 | 474 } |
| 475 | |
| 476 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
477 static HAL_StatusTypeDef pressure_sensor_get_data(void) |
| 38 | 478 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
479 uint32_t requestedValue = 0; |
| 38 | 480 HAL_StatusTypeDef statusReturn1 = HAL_TIMEOUT; |
| 481 HAL_StatusTypeDef statusReturn2 = HAL_TIMEOUT; | |
| 482 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
483 |
| 38 | 484 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
485 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D2 + CMD_ADC_4096, &statusReturn2); |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
486 if (statusReturn2 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
487 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
488 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
489 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
490 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
491 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D1 + CMD_ADC_4096, &statusReturn1); |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
492 if (statusReturn1 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
493 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
494 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
495 } |
| 38 | 496 if(statusReturn2 > statusReturn1) // if anything is not HAL_OK (0x00) or worse |
| 497 return statusReturn2; | |
| 498 else | |
| 499 return statusReturn1; | |
| 500 } | |
| 501 | |
| 502 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
503 HAL_StatusTypeDef pressure_sensor_get_pressure_raw(void) |
| 38 | 504 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
505 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
506 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
507 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
508 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D1 + CMD_ADC_4096, &statusReturn); |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
509 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
510 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
511 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
512 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
513 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
514 return statusReturn; |
| 38 | 515 } |
| 516 | |
| 517 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
518 HAL_StatusTypeDef pressure_sensor_get_temperature_raw(void) |
| 38 | 519 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
520 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
521 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
522 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
523 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D2 + CMD_ADC_4096, &statusReturn); |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
524 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
525 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
526 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
527 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
528 return statusReturn; |
| 38 | 529 } |
| 530 | |
| 531 | |
| 352 | 532 #ifdef SIMULATE_PRESSURE |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
533 |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
534 #define SECDIV 10 /* update every 100ms */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
535 |
| 352 | 536 void pressure_simulation() |
| 537 { | |
| 538 static uint32_t tickstart = 0; | |
| 539 static float pressure_sim_mbar = 0; | |
| 540 static uint32_t passedSecond = 0; | |
| 541 static uint32_t secondtick = 0; | |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
542 static uint32_t lastsecondtick = 0; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
543 static float delta_mbar = 0.0; |
| 352 | 544 |
| 545 uint32_t lasttick = 0; | |
| 546 | |
| 547 | |
| 548 | |
| 549 if( tickstart == 0) | |
| 550 { | |
| 551 tickstart = HAL_GetTick(); /* init time stamp */ | |
| 552 secondtick = tickstart; | |
| 553 pressure_sim_mbar = 1000; | |
| 554 } | |
| 555 | |
| 556 lasttick = HAL_GetTick(); | |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
557 if(time_elapsed_ms(secondtick,lasttick) >= (1000 / SECDIV)) /* one second passed since last tick */ |
| 352 | 558 { |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
559 if(time_elapsed_ms(lastsecondtick,lasttick) > 1000) |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
560 { |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
561 passedSecond++; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
562 lastsecondtick = lasttick; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
563 } |
| 352 | 564 secondtick = lasttick; |
| 565 | |
| 942 | 566 #define DIVE_EASY 1 |
| 352 | 567 #ifdef DIVE_AFTER_LANDING |
| 568 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ | |
| 569 else if(passedSecond < 300) pressure_sim_mbar -= 1.0; /* decrease pressure in 5 minutes target 770mbar => delta 330 */ | |
| 570 else if(passedSecond < 900) pressure_sim_mbar += 0.0; /*stay stable 10 minutes*/ | |
| 571 else if(passedSecond < 1500) pressure_sim_mbar += 0.5; /* return to 1 bar in 10 Minutes*/ | |
| 572 else if(passedSecond < 1800) pressure_sim_mbar += 0.0; /* 5 minutes break */ | |
| 573 else if(passedSecond < 2000) pressure_sim_mbar += 10.0; /* start dive */ | |
| 574 else if(passedSecond < 2300) pressure_sim_mbar += 0.0; /* stay on depth */ | |
| 575 else if(passedSecond < 2500) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 576 else pressure_sim_mbar = 1000.0; /* final state */ | |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
577 #endif |
| 942 | 578 #ifdef DIVE_EASY |
| 579 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ | |
| 580 else if(passedSecond < 120) pressure_sim_mbar += 1.0; /* decrease pressure in 2 minutes */ | |
| 581 else if(passedSecond < 240) pressure_sim_mbar += 0.0; /*stay stable 2 minutes*/ | |
| 582 else if(passedSecond < 360) pressure_sim_mbar -= 1.0; /* return to 1 bar in 2 Minutes*/ | |
| 583 else pressure_sim_mbar = 1000.0; /* final state */ | |
| 584 #endif | |
| 585 #if DIVE_AT_SPEED | |
|
867
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
586 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
587 else if(passedSecond < 20) delta_mbar = 200.0 / SECDIV; /* Start dive */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
588 else if(passedSecond < 30) delta_mbar = 0.0; /*stay on depth*/ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
589 else if(passedSecond < 45) delta_mbar -= 0.2 / SECDIV; /* return to surface */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
590 else if(passedSecond < 40) delta_mbar -= 0.4 / SECDIV; /* stay */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
591 else if(passedSecond < 50) delta_mbar += 0.3 / SECDIV; /* get ready for second dive */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
592 else if(passedSecond < 60) delta_mbar -= 0.4; /*stay on depth*/ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
593 else if(passedSecond < 70) delta_mbar = 0.2; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
594 else if(passedSecond < 1060) pressure_sim_mbar -= 10.0/ SECDIV; /* return to surface */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
595 else if(passedSecond < 1200) pressure_sim_mbar += 0.0; /* stay */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
596 else { pressure_sim_mbar = 1000.0; delta_mbar = 0.0;} /* final state */ |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
597 |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
598 pressure_sim_mbar += delta_mbar; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
599 if(pressure_sim_mbar < surface_pressure_mbar) |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
600 { |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
601 pressure_sim_mbar = surface_pressure_mbar; |
|
3311b720a072
Decrease calculation interval for ascend speed:
Ideenmodellierer
parents:
858
diff
changeset
|
602 } |
| 942 | 603 #endif |
| 604 #ifdef SHORTDIVE /* short dive */ | |
| 352 | 605 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ |
| 606 else if(passedSecond < 180) pressure_sim_mbar += 10.0; /* Start dive */ | |
| 607 else if(passedSecond < 300) pressure_sim_mbar += 0.0; /*stay on depth*/ | |
| 608 else if(passedSecond < 460) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 609 else if(passedSecond < 600) pressure_sim_mbar += 0.0; /* stay */ | |
| 610 else if(passedSecond < 610) pressure_sim_mbar = 1000.0; /* get ready for second dive */ | |
| 611 else if(passedSecond < 780) pressure_sim_mbar += 10.0; /* Start dive */ | |
| 612 else if(passedSecond < 900) pressure_sim_mbar += 0.0; /*stay on depth*/ | |
| 613 else if(passedSecond < 1060) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 614 else if(passedSecond < 1200) pressure_sim_mbar += 0.0; /* stay */ | |
| 615 else pressure_sim_mbar = 1000.0; /* final state */ | |
| 616 #endif | |
| 617 } | |
| 618 | |
| 619 | |
| 620 ambient_pressure_mbar = pressure_sim_mbar; | |
| 621 ambient_temperature = 25.0; | |
| 622 return; | |
| 623 } | |
| 624 | |
| 625 #endif | |
| 626 | |
| 38 | 627 void pressure_calculation(void) |
| 628 { | |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
629 if(global.I2C_SystemStatus != HAL_OK) |
| 38 | 630 return; |
| 352 | 631 |
| 632 #ifdef SIMULATE_PRESSURE | |
| 633 pressure_simulation(); | |
| 634 #else | |
| 38 | 635 pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(); |
| 352 | 636 #endif |
| 38 | 637 } |
| 638 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
639 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void) |
| 38 | 640 { |
|
335
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
641 static float runningAvg = 0; |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
642 static uint8_t avgCnt = 0; |
|
c11ce8c885d3
Use average calculation for pressure: precondition was that pressure values jittered +- 10 HPa from one capture (once a second) to the other. Basically pressure is measured several times a second => using these values in an additional history calculation reduces the jitter down to +-1 per second
ideenmodellierer
parents:
331
diff
changeset
|
643 |
| 38 | 644 uint32_t local_D1; // ADC value of the pressure conversion |
| 645 uint32_t local_D2; // ADC value of the temperature conversion | |
| 646 int32_t local_Px10; // compensated pressure value | |
| 647 int32_t local_Tx100; // compensated temperature value | |
| 648 int64_t local_dT; // int32_t, difference between actual and measured temperature | |
| 649 int64_t local_OFF; // offset at actual temperature | |
| 650 int64_t local_SENS; // sensitivity at actual temperature | |
| 651 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
652 float calc_pressure; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
653 |
| 38 | 654 int64_t T2; |
| 655 int64_t OFF2; | |
| 656 int64_t SENS2; | |
| 657 | |
| 658 local_D1 = D1; | |
| 659 local_D2 = D2; | |
| 660 | |
| 661 local_dT = ((int64_t)local_D2) - ((int64_t)C[5]) * 256; //pow(2,8); | |
| 662 local_OFF = ((int64_t)C[2]) * 65536 + local_dT * ((int64_t)C[4]) / 128; // pow(2,16), pow(2,7) | |
| 663 local_SENS = ((int64_t)C[1]) * 32768 + local_dT * ((int64_t)C[3]) / 256; // pow(2,15), pow(2,8) | |
| 664 | |
| 665 local_Tx100 = (int32_t)(2000 + (local_dT * ((int64_t)C[6])) / 8388608);// pow(2,23) | |
| 666 | |
| 667 | |
| 668 if(local_Tx100 < 2000) // low temperature | |
| 669 { | |
| 670 T2 = 3 * local_dT; | |
| 671 T2 *= local_dT; | |
| 672 T2 /= 8589934592; | |
| 673 | |
| 674 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 675 OFF2 *= OFF2; | |
| 676 OFF2 *= 3; | |
| 677 OFF2 /= 2; | |
| 678 | |
| 679 SENS2 = ((int64_t)local_Tx100) - 2000; | |
| 680 SENS2 *= SENS2; | |
| 681 SENS2 *= 5; | |
| 682 SENS2 /= 8; | |
| 683 | |
| 684 local_Tx100 -= (int32_t)T2; | |
| 685 local_OFF -= OFF2; | |
| 686 local_SENS -= SENS2; | |
| 687 } | |
| 688 else | |
| 689 { | |
| 690 T2 = 7 * local_dT; | |
| 691 T2 *= local_dT; | |
| 692 T2 /= 137438953472; | |
| 693 | |
| 694 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 695 OFF2 *= OFF2; | |
| 696 OFF2 /= 16; | |
| 697 | |
| 698 local_Tx100 -= (int32_t)T2; | |
| 699 local_OFF -= OFF2; | |
| 700 } | |
| 701 | |
| 702 local_Px10 = (int32_t)( | |
| 703 (((int64_t)((local_D1 * local_SENS) / 2097152)) - local_OFF) | |
| 704 / 8192 );// )) / 10; // pow(2,21), pow(2,13) | |
| 705 | |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
706 ambient_temperature = ((float)local_Tx100) / 100; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
707 ambient_temperature += temperature_offset; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
708 |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
709 if(ambient_temperature < TEMPERATURE_MINIMUM) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
710 { |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
711 ambient_temperature = 20.0; |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
712 } |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
713 |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
714 calc_pressure = ((float)local_Px10) / 10; |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
715 calc_pressure += pressure_offset; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
716 |
| 480 | 717 runningAvg = (avgCnt * runningAvg + calc_pressure) / (avgCnt + 1); |
| 718 if (avgCnt < 10) /* build an average considering the last measurements to have a weight "1 of 10" */ | |
| 719 { /* Main reason for this is the jitter of up to +-10 HPa in surface mode which is caused */ | |
| 720 avgCnt++; /* by the measurement range of the sensor which is focused on under water pressure measurement */ | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
721 } |
| 480 | 722 ambient_pressure_mbar = runningAvg; |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
723 |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
724 if(ambient_pressure_mbar < PRESSURE_MINIMUM) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
725 { |
|
846
2ace67231c49
Consider pressure offset compensation in case of setting a default value:
Ideenmodellierer
parents:
688
diff
changeset
|
726 ambient_pressure_mbar = 1000.0 + pressure_offset; |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
727 } |
| 38 | 728 } |
| 729 | |
| 730 | |
| 731 /* taken from AN520 by meas-spec.com dated 9. Aug. 2011 | |
| 732 * short and int are both 16bit according to AVR/GCC google results | |
| 733 */ | |
| 356 | 734 /*static uint8_t crc4(uint16_t n_prom[]) |
| 38 | 735 { |
| 736 uint16_t cnt; // simple counter | |
| 737 uint16_t n_rem; // crc reminder | |
| 738 uint16_t crc_read; // original value of the crc | |
| 739 uint8_t n_bit; | |
| 740 n_rem = 0x00; | |
| 741 crc_read=n_prom[7]; //save read CRC | |
| 742 n_prom[7]=(0xFF00 & (n_prom[7])); //CRC byte is replaced by 0 | |
| 743 for (cnt = 0; cnt < 16; cnt++) // operation is performed on bytes | |
| 744 { // choose LSB or MSB | |
| 745 if (cnt%2==1) n_rem ^= (uint16_t) ((n_prom[cnt>>1]) & 0x00FF); | |
| 746 else n_rem ^= (uint16_t) (n_prom[cnt>>1]>>8); | |
| 747 for (n_bit = 8; n_bit > 0; n_bit--) | |
| 748 { | |
| 749 if (n_rem & (0x8000)) | |
| 750 { | |
| 751 n_rem = (n_rem << 1) ^ 0x3000; | |
| 752 } | |
| 753 else | |
| 754 { | |
| 755 n_rem = (n_rem << 1); | |
| 756 } | |
| 757 } | |
| 758 } | |
| 759 n_rem= (0x000F & (n_rem >> 12)); // // final 4-bit reminder is CRC code | |
| 760 n_prom[7]=crc_read; // restore the crc_read to its original place | |
| 761 return (n_rem ^ 0x00); | |
| 762 } | |
| 356 | 763 |
| 38 | 764 void test_calculation(void) |
| 765 { | |
| 766 C1 = 29112; | |
| 767 C2 = 26814; | |
| 768 C3 = 19125; | |
| 769 C4 = 17865; | |
| 770 C5 = 32057; | |
| 771 C6 = 31305; | |
| 772 | |
| 773 C2_x_2p16 = C2 * 65536; | |
| 774 C1_x_2p15 = C1 * 32768; | |
| 775 | |
| 776 D1 = 4944364; | |
| 777 D2 = 8198974; | |
| 778 pressure_calculation() ; | |
| 779 }; | |
| 780 */ | |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
781 void pressure_set_offset (float pressureOffset, float temperatureOffset) |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
782 { |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
783 if(pressure_offset != pressureOffset) /* we received a new value => reinit surface que */ |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
784 { |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
785 ambient_pressure_mbar -= pressure_offset; /* revert old value */ |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
786 ambient_pressure_mbar += pressureOffset; /* apply new offset */ |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
787 init_surface_ring(1); |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
788 } |
| 38 | 789 |
|
339
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
790 pressure_offset = pressureOffset; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
791 temperature_offset = temperatureOffset; |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
792 } |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
793 |
|
37f45300bc2e
Apply averaging to pressure measurement: In pre versions calculated pressure value jittered +/-10hPa. Since we measure the pressure several time a second but only use one value a second, calc average including not used values
ideenmodellierer
parents:
335
diff
changeset
|
794 |