Mercurial > public > ostc4
annotate Small_CPU/Src/pressure.c @ 824:2a9a47547b05 Evo_2_23
Bugfix Flipscreen visualization:
In Timer and CCR overview the free custom fram coordinates were not initialized. Depending on which view was activ before the coordinates of the former view were used and sometimes resulting in a bad visualization. To fix the problem the coordinates are now initialized by the views.
The top menu bar text in the flip view did not consider spacings in the text position calculation causing an offset between color bar and text. The offset has been corrected.
| author | Ideenmodellierer |
|---|---|
| date | Mon, 09 Oct 2023 16:50:11 +0200 |
| parents | 8c92f7743e14 |
| children | 2ace67231c49 |
| 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 | |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
52 |
| 535 | 53 #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
|
54 |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
55 #define PRESSURE_MINIMUM (0.0f) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
56 #define TEMPERATURE_MINIMUM (-100.0f) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
57 |
| 352 | 58 #define PRESSURE_SURFACE_QUE (30u) /* history buffer [minutes] for past pressure measurements */ |
| 59 #define PRESSURE_SURFACE_EVA_WINDOW (15u) /* Number of entries evaluated during instability test. Used to avoid detection while dive enters water */ | |
| 60 #define PRESSURE_SURFACE_STABLE_LIMIT (10u) /* Define pressure as stable if delta (mBar) is below this value */ | |
| 61 #define PRESSURE_SURFACE_DETECT_STABLE_CNT (5u) /* Event count to detect stable condition */ | |
| 62 #define PRESSURE_SURFACE_UNSTABLE_LIMIT (50u) /* Define pressure as not stable if delta (mBar) is larger than this value */ | |
| 63 #define PRESSURE_SURFACE_DETECT_UNSTABLE_CNT (3u) /* Event count to detect unstable condition */ | |
| 64 | |
|
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
|
65 |
| 356 | 66 static uint8_t PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5803; /* Default Address */ |
| 67 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
68 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
|
69 //void pressure_calculation_new(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
70 //void pressure_calculation_old(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
71 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void); |
| 356 | 72 //static uint8_t crc4(uint16_t n_prom[]); |
| 38 | 73 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
74 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
|
75 static uint32_t get_adc(void); |
| 38 | 76 uint8_t pressureSensorInitSuccess = 0; |
| 77 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
78 static uint16_t C[8] = { 1 }; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
79 static uint32_t D1 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
80 static uint32_t D2 = 1; |
| 356 | 81 //static uint8_t n_crc; |
| 38 | 82 |
| 83 /* | |
| 84 short C2plus10000 = -1; | |
| 85 short C3plus200 = -1; | |
| 86 short C4minus250 = -1; | |
| 87 short UT1 = -1; | |
| 88 short C6plus100 = -1; | |
| 89 */ | |
|
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
|
90 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
|
91 static float temperature_offset = 0.0; /* Offset value which may be specified by the user via PC Software */ |
| 38 | 92 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
93 static float ambient_temperature = 0; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
94 static float ambient_pressure_mbar = 1000.0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
95 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
|
96 static float surface_ring_mbar[PRESSURE_SURFACE_QUE] = { 0 }; |
| 38 | 97 |
| 352 | 98 static uint8_t surface_pressure_writeIndex = 0; |
| 99 static float surface_pressure_stable_value = 0; | |
| 100 static uint8_t surface_pressure_stable = 0; | |
| 101 | |
|
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
|
102 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
|
103 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
|
104 static float runningAvg = 0; |
| 38 | 105 |
| 106 float get_temperature(void) | |
| 107 { | |
| 108 return ambient_temperature; | |
| 109 } | |
| 110 | |
| 111 float get_pressure_mbar(void) | |
| 112 { | |
| 113 return ambient_pressure_mbar; | |
| 114 } | |
| 115 | |
| 116 float get_surface_mbar(void) | |
| 117 { | |
| 118 return surface_pressure_mbar; | |
| 119 } | |
| 120 | |
| 121 | |
|
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
|
122 void init_surface_ring(uint8_t force) |
| 38 | 123 { |
|
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
|
124 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
|
125 { |
|
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
|
126 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
|
127 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
|
128 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
|
129 |
|
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
|
130 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
|
131 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
|
132 surface_pressure_mbar = ambient_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 */ |
|
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
|
239 } |
| 352 | 240 evaluate_surface_pressure(); |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
241 } |
| 38 | 242 } |
| 243 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
244 #ifdef DEMOMODE |
| 38 | 245 float demo_modify_temperature_helper(float bottom_mbar_diff_to_surface) |
| 246 { | |
| 247 const float temperature_surface = 31.0; | |
| 248 const float temperature_bottom = 14.0; | |
| 249 | |
| 250 const float temperature_difference = temperature_bottom - temperature_surface; | |
| 251 | |
| 252 // range 0.0 - 1.0 | |
| 253 float position_now = (ambient_pressure_mbar - surface_pressure_mbar) / bottom_mbar_diff_to_surface; | |
| 254 | |
| 255 if(position_now <= 0) | |
| 256 return temperature_surface; | |
| 257 | |
| 258 if(position_now >= 1) | |
| 259 return temperature_bottom; | |
| 260 | |
| 261 return temperature_surface + (temperature_difference * position_now); | |
| 262 } | |
| 263 | |
| 264 | |
| 265 uint32_t demo_modify_temperature_and_pressure(int32_t divetime_in_seconds, uint8_t subseconds, float ceiling_mbar) | |
| 266 { | |
| 267 | |
| 268 const float descent_rate = 4000/60; | |
| 269 const float ascent_rate = 1000/60; | |
| 270 const uint32_t seconds_descend = (1 * 60) + 30; | |
| 271 const uint32_t turbo_seconds_at_bottom_start = (0 * 60) + 0; | |
| 272 const uint32_t seconds_descend_and_bottomtime = seconds_descend + turbo_seconds_at_bottom_start + (2 * 60) + 0; | |
| 273 uint32_t time_elapsed_in_seconds; | |
| 274 static float ambient_pressure_mbar_memory = 0; | |
| 275 static uint32_t time_last_call = 0; | |
| 276 | |
| 277 if(divetime_in_seconds <= seconds_descend) | |
| 278 { | |
| 279 ambient_pressure_mbar = (divetime_in_seconds * descent_rate) + ((float)(subseconds) * descent_rate) + surface_pressure_mbar; | |
| 280 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 281 | |
| 282 time_last_call = divetime_in_seconds; | |
| 283 return 0; | |
| 284 } | |
| 285 else | |
| 286 if(divetime_in_seconds <= seconds_descend + turbo_seconds_at_bottom_start) | |
| 287 { | |
| 288 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 289 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 290 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 291 time_last_call = divetime_in_seconds; | |
| 292 return turbo_seconds_at_bottom_start; | |
| 293 } | |
| 294 else | |
| 295 if(divetime_in_seconds <= seconds_descend_and_bottomtime) | |
| 296 { | |
| 297 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 298 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 299 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 300 time_last_call = divetime_in_seconds; | |
| 301 return 0; | |
| 302 } | |
| 303 else | |
| 304 { | |
| 305 time_elapsed_in_seconds = divetime_in_seconds - time_last_call; | |
| 306 ambient_pressure_mbar = ambient_pressure_mbar_memory - time_elapsed_in_seconds * ascent_rate; | |
| 307 | |
| 308 if(ambient_pressure_mbar < surface_pressure_mbar) | |
| 309 ambient_pressure_mbar = surface_pressure_mbar; | |
| 310 else if(ambient_pressure_mbar < ceiling_mbar) | |
| 311 ambient_pressure_mbar = ceiling_mbar; | |
| 312 | |
| 313 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 314 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 315 time_last_call = divetime_in_seconds; | |
| 316 return 0; | |
| 317 } | |
| 318 } | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
319 #endif |
| 38 | 320 |
| 321 uint8_t is_init_pressure_done(void) | |
| 322 { | |
| 323 return pressureSensorInitSuccess; | |
| 324 } | |
| 325 | |
| 326 uint8_t init_pressure(void) | |
| 327 { | |
| 328 uint8_t buffer[1]; | |
| 356 | 329 buffer[0] = 0x1E; // Reset Command |
| 38 | 330 uint8_t retValue = 0xFF; |
| 331 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
332 pressureSensorInitSuccess = false; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
333 |
| 356 | 334 /* Probe new sensor first */ |
| 335 retValue = I2C_Master_Transmit( DEVICE_PRESSURE_MS5837, buffer, 1); | |
| 336 if(retValue != HAL_OK) | |
| 337 { | |
| 338 PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5803; // use old sensor | |
| 339 HAL_Delay(100); | |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
340 I2C_DeInit(); |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
341 HAL_Delay(100); |
| 356 | 342 MX_I2C1_Init(); |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
343 HAL_Delay(100); |
| 356 | 344 } |
| 345 else | |
| 346 { | |
| 347 PRESSURE_ADDRESS = DEVICE_PRESSURE_MS5837; // Success, use new sensor | |
| 348 } | |
| 349 HAL_Delay(3); //2.8ms according to datasheet | |
| 350 | |
| 351 buffer[0] = 0x1E; // Reset Command | |
| 352 retValue = 0xFF; | |
| 353 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
354 /* Send reset request to pressure sensor */ |
| 356 | 355 retValue = I2C_Master_Transmit( PRESSURE_ADDRESS, buffer, 1); |
| 38 | 356 if(retValue != HAL_OK) |
| 357 { | |
| 358 return (HAL_StatusTypeDef)retValue; | |
| 359 } | |
| 356 | 360 HAL_Delay(3); //2.8ms according to datasheet |
| 38 | 361 |
| 356 | 362 for(uint8_t i=0;i<7;i++) |
| 38 | 363 { |
| 364 C[i] = get_ci_by_coef_num(i); | |
| 365 } | |
| 356 | 366 // n_crc = crc4(C); // no evaluation at the moment hw 151026 |
| 38 | 367 |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
368 if(global.I2C_SystemStatus == HAL_OK) |
| 38 | 369 { |
| 370 pressureSensorInitSuccess = 1; | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
371 retValue = pressure_update(); |
| 38 | 372 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
373 return retValue; |
| 38 | 374 } |
| 375 | |
| 376 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
377 static uint32_t get_adc(void) |
| 38 | 378 { |
| 379 uint8_t buffer[1]; | |
| 380 uint8_t resivebuf[4]; | |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
381 uint32_t answer = 0xFFFFFFFF; |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
382 |
| 38 | 383 buffer[0] = 0x00; // Get ADC |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
384 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
|
385 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
386 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
|
387 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
388 resivebuf[3] = 0; |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
389 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
|
390 } |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
391 } |
| 38 | 392 return answer; |
| 393 } | |
| 394 | |
| 395 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
396 static uint16_t get_ci_by_coef_num(uint8_t coef_num) |
| 38 | 397 { |
| 398 uint8_t resivebuf[2]; | |
| 399 | |
| 400 uint8_t cmd = CMD_PROM_RD+coef_num*2; | |
| 356 | 401 I2C_Master_Transmit( PRESSURE_ADDRESS, &cmd, 1); |
| 402 I2C_Master_Receive( PRESSURE_ADDRESS, resivebuf, 2); | |
| 38 | 403 return (256*(uint16_t)resivebuf[0]) + (uint16_t)resivebuf[1]; |
| 404 } | |
| 405 | |
| 406 | |
| 407 | |
| 408 uint8_t pressure_update(void) | |
| 409 { | |
| 410 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; | |
| 411 | |
| 412 statusReturn = pressure_sensor_get_data(); | |
| 413 pressure_calculation(); | |
| 414 return (uint8_t)statusReturn; | |
| 415 } | |
| 416 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
417 /* Switch between pressure and temperature measurement with every successful read operation */ |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
418 void pressure_update_alternating(void) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
419 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
420 static uint8_t getTemperature= 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
421 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
422 if(getTemperature) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
423 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
424 if(pressure_sensor_get_temperature_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
425 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
426 getTemperature = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
427 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
428 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
429 else |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
430 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
431 if(pressure_sensor_get_pressure_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
432 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
433 getTemperature = 1; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
434 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
435 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
436 pressure_calculation(); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
437 return; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
438 } |
| 38 | 439 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
440 static uint32_t pressure_sensor_get_one_value(uint8_t cmd, HAL_StatusTypeDef *statusReturn) |
| 38 | 441 { |
| 442 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
|
443 uint32_t adcValue = 0; |
| 38 | 444 HAL_StatusTypeDef statusReturnTemp = HAL_TIMEOUT; |
| 445 | |
| 356 | 446 statusReturnTemp = I2C_Master_Transmit( PRESSURE_ADDRESS, &command, 1); |
| 38 | 447 |
| 448 if(statusReturn) | |
| 449 { | |
| 450 *statusReturn = statusReturnTemp; | |
| 451 } | |
| 479 | 452 |
| 453 switch (cmd & 0x0f) // wait necessary conversion time | |
| 38 | 454 { |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
455 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
|
456 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
|
457 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
|
458 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
|
459 case CMD_ADC_4096: HAL_Delay(11); break; |
| 479 | 460 default: |
| 461 break; | |
| 462 } | |
| 463 adcValue = get_adc(); | |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
464 /* if(adcValue == 0xFFFFFFFF) |
| 479 | 465 { |
| 466 if(statusReturn) | |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
467 { |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
468 *statusReturn = HAL_ERROR; |
|
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
469 } |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
470 }*/ |
|
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
471 |
|
474
4be72d55b09a
Added error detection for reading of ADC values in sleep mode:
ideenmodellierer
parents:
403
diff
changeset
|
472 return adcValue; |
| 38 | 473 } |
| 474 | |
| 475 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
476 static HAL_StatusTypeDef pressure_sensor_get_data(void) |
| 38 | 477 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
478 uint32_t requestedValue = 0; |
| 38 | 479 HAL_StatusTypeDef statusReturn1 = HAL_TIMEOUT; |
| 480 HAL_StatusTypeDef statusReturn2 = HAL_TIMEOUT; | |
| 481 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
482 |
| 38 | 483 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
484 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
|
485 if (statusReturn2 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
486 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
487 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
488 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
489 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
490 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
|
491 if (statusReturn1 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
492 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
493 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
494 } |
| 38 | 495 if(statusReturn2 > statusReturn1) // if anything is not HAL_OK (0x00) or worse |
| 496 return statusReturn2; | |
| 497 else | |
| 498 return statusReturn1; | |
| 499 } | |
| 500 | |
| 501 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
502 HAL_StatusTypeDef pressure_sensor_get_pressure_raw(void) |
| 38 | 503 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
504 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
505 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
506 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
507 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
|
508 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
509 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
510 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
511 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
512 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
513 return statusReturn; |
| 38 | 514 } |
| 515 | |
| 516 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
517 HAL_StatusTypeDef pressure_sensor_get_temperature_raw(void) |
| 38 | 518 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
519 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
520 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
521 |
|
488
9eeab3fead8f
Added "I2C_DeInit();" in hardware detection routines. It's the recommended way
heinrichsweikamp
parents:
480
diff
changeset
|
522 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
|
523 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
524 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
525 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
526 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
527 return statusReturn; |
| 38 | 528 } |
| 529 | |
| 530 | |
| 352 | 531 #ifdef SIMULATE_PRESSURE |
| 532 void pressure_simulation() | |
| 533 { | |
| 534 static uint32_t tickstart = 0; | |
| 535 static float pressure_sim_mbar = 0; | |
| 536 static uint32_t passedSecond = 0; | |
| 537 static uint32_t secondtick = 0; | |
| 538 | |
| 539 uint32_t lasttick = 0; | |
| 540 | |
| 541 | |
| 542 | |
| 543 if( tickstart == 0) | |
| 544 { | |
| 545 tickstart = HAL_GetTick(); /* init time stamp */ | |
| 546 secondtick = tickstart; | |
| 547 pressure_sim_mbar = 1000; | |
| 548 } | |
| 549 | |
| 550 lasttick = HAL_GetTick(); | |
| 551 if(time_elapsed_ms(secondtick,lasttick) > 1000) /* one second passed since last tick */ | |
| 552 { | |
| 553 secondtick = lasttick; | |
| 554 passedSecond++; | |
| 555 | |
| 556 #ifdef DIVE_AFTER_LANDING | |
| 557 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ | |
| 558 else if(passedSecond < 300) pressure_sim_mbar -= 1.0; /* decrease pressure in 5 minutes target 770mbar => delta 330 */ | |
| 559 else if(passedSecond < 900) pressure_sim_mbar += 0.0; /*stay stable 10 minutes*/ | |
| 560 else if(passedSecond < 1500) pressure_sim_mbar += 0.5; /* return to 1 bar in 10 Minutes*/ | |
| 561 else if(passedSecond < 1800) pressure_sim_mbar += 0.0; /* 5 minutes break */ | |
| 562 else if(passedSecond < 2000) pressure_sim_mbar += 10.0; /* start dive */ | |
| 563 else if(passedSecond < 2300) pressure_sim_mbar += 0.0; /* stay on depth */ | |
| 564 else if(passedSecond < 2500) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 565 else pressure_sim_mbar = 1000.0; /* final state */ | |
| 566 #else /* short dive */ | |
| 567 if(passedSecond < 10) pressure_sim_mbar = 1000.0; /* stay stable for 10 seconds */ | |
| 568 else if(passedSecond < 180) pressure_sim_mbar += 10.0; /* Start dive */ | |
| 569 else if(passedSecond < 300) pressure_sim_mbar += 0.0; /*stay on depth*/ | |
| 570 else if(passedSecond < 460) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 571 else if(passedSecond < 600) pressure_sim_mbar += 0.0; /* stay */ | |
| 572 else if(passedSecond < 610) pressure_sim_mbar = 1000.0; /* get ready for second dive */ | |
| 573 else if(passedSecond < 780) pressure_sim_mbar += 10.0; /* Start dive */ | |
| 574 else if(passedSecond < 900) pressure_sim_mbar += 0.0; /*stay on depth*/ | |
| 575 else if(passedSecond < 1060) pressure_sim_mbar -= 10.0; /* return to surface */ | |
| 576 else if(passedSecond < 1200) pressure_sim_mbar += 0.0; /* stay */ | |
| 577 else pressure_sim_mbar = 1000.0; /* final state */ | |
| 578 #endif | |
| 579 } | |
| 580 | |
| 581 | |
| 582 ambient_pressure_mbar = pressure_sim_mbar; | |
| 583 ambient_temperature = 25.0; | |
| 584 return; | |
| 585 } | |
| 586 | |
| 587 #endif | |
| 588 | |
| 38 | 589 void pressure_calculation(void) |
| 590 { | |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
591 if(global.I2C_SystemStatus != HAL_OK) |
| 38 | 592 return; |
| 352 | 593 |
| 594 #ifdef SIMULATE_PRESSURE | |
| 595 pressure_simulation(); | |
| 596 #else | |
| 38 | 597 pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(); |
| 352 | 598 #endif |
| 38 | 599 } |
| 600 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
601 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void) |
| 38 | 602 { |
|
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
|
603 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
|
604 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
|
605 |
| 38 | 606 uint32_t local_D1; // ADC value of the pressure conversion |
| 607 uint32_t local_D2; // ADC value of the temperature conversion | |
| 608 int32_t local_Px10; // compensated pressure value | |
| 609 int32_t local_Tx100; // compensated temperature value | |
| 610 int64_t local_dT; // int32_t, difference between actual and measured temperature | |
| 611 int64_t local_OFF; // offset at actual temperature | |
| 612 int64_t local_SENS; // sensitivity at actual temperature | |
| 613 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
614 float calc_pressure; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
615 |
| 38 | 616 int64_t T2; |
| 617 int64_t OFF2; | |
| 618 int64_t SENS2; | |
| 619 | |
| 620 local_D1 = D1; | |
| 621 local_D2 = D2; | |
| 622 | |
| 623 local_dT = ((int64_t)local_D2) - ((int64_t)C[5]) * 256; //pow(2,8); | |
| 624 local_OFF = ((int64_t)C[2]) * 65536 + local_dT * ((int64_t)C[4]) / 128; // pow(2,16), pow(2,7) | |
| 625 local_SENS = ((int64_t)C[1]) * 32768 + local_dT * ((int64_t)C[3]) / 256; // pow(2,15), pow(2,8) | |
| 626 | |
| 627 local_Tx100 = (int32_t)(2000 + (local_dT * ((int64_t)C[6])) / 8388608);// pow(2,23) | |
| 628 | |
| 629 | |
| 630 if(local_Tx100 < 2000) // low temperature | |
| 631 { | |
| 632 T2 = 3 * local_dT; | |
| 633 T2 *= local_dT; | |
| 634 T2 /= 8589934592; | |
| 635 | |
| 636 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 637 OFF2 *= OFF2; | |
| 638 OFF2 *= 3; | |
| 639 OFF2 /= 2; | |
| 640 | |
| 641 SENS2 = ((int64_t)local_Tx100) - 2000; | |
| 642 SENS2 *= SENS2; | |
| 643 SENS2 *= 5; | |
| 644 SENS2 /= 8; | |
| 645 | |
| 646 local_Tx100 -= (int32_t)T2; | |
| 647 local_OFF -= OFF2; | |
| 648 local_SENS -= SENS2; | |
| 649 } | |
| 650 else | |
| 651 { | |
| 652 T2 = 7 * local_dT; | |
| 653 T2 *= local_dT; | |
| 654 T2 /= 137438953472; | |
| 655 | |
| 656 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 657 OFF2 *= OFF2; | |
| 658 OFF2 /= 16; | |
| 659 | |
| 660 local_Tx100 -= (int32_t)T2; | |
| 661 local_OFF -= OFF2; | |
| 662 } | |
| 663 | |
| 664 local_Px10 = (int32_t)( | |
| 665 (((int64_t)((local_D1 * local_SENS) / 2097152)) - local_OFF) | |
| 666 / 8192 );// )) / 10; // pow(2,21), pow(2,13) | |
| 667 | |
|
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
|
668 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
|
669 ambient_temperature += temperature_offset; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
670 |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
671 if(ambient_temperature < TEMPERATURE_MINIMUM) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
672 { |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
673 ambient_temperature = 20.0; |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
674 } |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
675 |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
676 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
|
677 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
|
678 |
| 480 | 679 runningAvg = (avgCnt * runningAvg + calc_pressure) / (avgCnt + 1); |
| 680 if (avgCnt < 10) /* build an average considering the last measurements to have a weight "1 of 10" */ | |
| 681 { /* Main reason for this is the jitter of up to +-10 HPa in surface mode which is caused */ | |
| 682 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
|
683 } |
| 480 | 684 ambient_pressure_mbar = runningAvg; |
|
688
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
685 |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
686 if(ambient_pressure_mbar < PRESSURE_MINIMUM) |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
687 { |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
688 ambient_pressure_mbar = 1000.0; |
|
8c92f7743e14
Added sanity check for temperature and pressure values:
Ideenmodellierer
parents:
579
diff
changeset
|
689 } |
| 38 | 690 } |
| 691 | |
| 692 | |
| 693 /* taken from AN520 by meas-spec.com dated 9. Aug. 2011 | |
| 694 * short and int are both 16bit according to AVR/GCC google results | |
| 695 */ | |
| 356 | 696 /*static uint8_t crc4(uint16_t n_prom[]) |
| 38 | 697 { |
| 698 uint16_t cnt; // simple counter | |
| 699 uint16_t n_rem; // crc reminder | |
| 700 uint16_t crc_read; // original value of the crc | |
| 701 uint8_t n_bit; | |
| 702 n_rem = 0x00; | |
| 703 crc_read=n_prom[7]; //save read CRC | |
| 704 n_prom[7]=(0xFF00 & (n_prom[7])); //CRC byte is replaced by 0 | |
| 705 for (cnt = 0; cnt < 16; cnt++) // operation is performed on bytes | |
| 706 { // choose LSB or MSB | |
| 707 if (cnt%2==1) n_rem ^= (uint16_t) ((n_prom[cnt>>1]) & 0x00FF); | |
| 708 else n_rem ^= (uint16_t) (n_prom[cnt>>1]>>8); | |
| 709 for (n_bit = 8; n_bit > 0; n_bit--) | |
| 710 { | |
| 711 if (n_rem & (0x8000)) | |
| 712 { | |
| 713 n_rem = (n_rem << 1) ^ 0x3000; | |
| 714 } | |
| 715 else | |
| 716 { | |
| 717 n_rem = (n_rem << 1); | |
| 718 } | |
| 719 } | |
| 720 } | |
| 721 n_rem= (0x000F & (n_rem >> 12)); // // final 4-bit reminder is CRC code | |
| 722 n_prom[7]=crc_read; // restore the crc_read to its original place | |
| 723 return (n_rem ^ 0x00); | |
| 724 } | |
| 356 | 725 |
| 38 | 726 void test_calculation(void) |
| 727 { | |
| 728 C1 = 29112; | |
| 729 C2 = 26814; | |
| 730 C3 = 19125; | |
| 731 C4 = 17865; | |
| 732 C5 = 32057; | |
| 733 C6 = 31305; | |
| 734 | |
| 735 C2_x_2p16 = C2 * 65536; | |
| 736 C1_x_2p15 = C1 * 32768; | |
| 737 | |
| 738 D1 = 4944364; | |
| 739 D2 = 8198974; | |
| 740 pressure_calculation() ; | |
| 741 }; | |
| 742 */ | |
|
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
|
743 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
|
744 { |
|
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
|
745 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
|
746 { |
|
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
|
747 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
|
748 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
|
749 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
|
750 } |
| 38 | 751 |
|
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
|
752 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
|
753 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
|
754 } |
|
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
|
755 |
|
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
|
756 |