Mercurial > public > ostc4
annotate Small_CPU/Src/pressure.c @ 343:c9d217b110cc FlightMode_Improvment
Added compile switch to enable debug view option in system menu
Code lines for the option had to be uncommented one by one to get function activated. The compile switch makes life easier
| author | ideenmodellierer |
|---|---|
| date | Tue, 01 Oct 2019 19:43:30 +0200 |
| parents | 37f45300bc2e |
| children | 591c03a1e68d 4093ac18b25c |
| 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 | |
|
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
|
49 #define PRESSURE_SURFACE_MAX_MBAR (1070.0f) /* It is very 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
|
50 #define PRESSURE_HISTORY_SIZE (8u) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
51 #define PRESSURE_JUMP_VALID_MBAR (500.0f) /* values are measure several times a second => jumps > 5m very unlikely */ |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
52 |
|
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
|
53 #define PRESSURE_SURFACE_QUE (30u) /* history buffer [minutes] for past pressure 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
|
54 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
55 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
|
56 //void pressure_calculation_new(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
57 //void pressure_calculation_old(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
58 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void); |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
59 static uint8_t crc4(uint16_t n_prom[]); |
| 38 | 60 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
61 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
|
62 static uint32_t get_adc(void); |
| 38 | 63 uint8_t pressureSensorInitSuccess = 0; |
| 64 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
65 static uint16_t C[8] = { 1 }; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
66 static uint32_t D1 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
67 static uint32_t D2 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
68 static uint8_t n_crc; |
| 38 | 69 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
70 static int64_t C5_x_2p8 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
71 static int64_t C2_x_2p16 = 1; |
|
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
72 static int64_t C1_x_2p15 = 1; |
| 38 | 73 |
| 74 /* | |
| 75 short C2plus10000 = -1; | |
| 76 short C3plus200 = -1; | |
| 77 short C4minus250 = -1; | |
| 78 short UT1 = -1; | |
| 79 short C6plus100 = -1; | |
| 80 */ | |
|
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
|
81 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
|
82 static float temperature_offset = 0.0; /* Offset value which may be specified by the user via PC Software */ |
| 38 | 83 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
84 static float ambient_temperature = 0; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
85 static float ambient_pressure_mbar = 1000.0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
86 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
|
87 static float surface_ring_mbar[PRESSURE_SURFACE_QUE] = { 0 }; |
| 38 | 88 |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
89 static float pressure_history_mbar[PRESSURE_HISTORY_SIZE]; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
90 |
|
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
|
91 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
|
92 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
|
93 static float runningAvg = 0; |
| 38 | 94 |
| 95 float get_temperature(void) | |
| 96 { | |
| 97 return ambient_temperature; | |
| 98 } | |
| 99 | |
| 100 float get_pressure_mbar(void) | |
| 101 { | |
| 102 return ambient_pressure_mbar; | |
| 103 } | |
| 104 | |
| 105 float get_surface_mbar(void) | |
| 106 { | |
| 107 return surface_pressure_mbar; | |
| 108 } | |
| 109 | |
| 110 | |
|
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
|
111 void init_surface_ring(uint8_t force) |
| 38 | 112 { |
|
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
|
113 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
|
114 { |
|
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
|
115 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
|
116 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
|
117 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
|
118 |
|
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
|
119 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
|
120 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
|
121 surface_pressure_mbar = 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
|
122 } |
| 38 | 123 } |
| 124 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
125 void init_pressure_history(void) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
126 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
127 for(int i=0; i<PRESSURE_HISTORY_SIZE; i++) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
128 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
129 pressure_history_mbar[i] = 1000.0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
130 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
131 } |
| 38 | 132 |
|
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
|
133 |
| 38 | 134 void update_surface_pressure(uint8_t call_rhythm_seconds) |
| 135 { | |
|
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
|
136 static uint8_t writeIndex = 0; /* Reinitialization will reset all entries to the same value => no need to reinit write index */ |
|
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
|
137 |
|
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
|
138 |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
139 if(is_init_pressure_done()) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
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 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
|
142 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
|
143 secondCounterSurfaceRing += call_rhythm_seconds; |
| 38 | 144 |
|
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
|
145 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
|
146 { |
|
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
|
147 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
|
148 { |
|
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
|
149 surface_ring_mbar[writeIndex] = runningAvg; |
|
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
|
150 } |
|
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
|
151 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
|
152 { |
|
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
|
153 surface_ring_mbar[writeIndex] = 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
|
154 } |
|
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
|
155 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
|
156 |
|
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
|
157 if(writeIndex == PRESSURE_SURFACE_QUE) |
|
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
|
158 { |
|
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
|
159 writeIndex = 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
|
160 } |
|
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
|
161 |
|
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
|
162 surface_pressure_mbar = surface_ring_mbar[writeIndex]; /* 30 minutes old measurement */ |
|
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
|
163 |
|
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
|
164 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
|
165 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
|
166 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
167 } |
| 38 | 168 } |
| 169 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
170 #ifdef DEMOMODE |
| 38 | 171 float demo_modify_temperature_helper(float bottom_mbar_diff_to_surface) |
| 172 { | |
| 173 const float temperature_surface = 31.0; | |
| 174 const float temperature_bottom = 14.0; | |
| 175 | |
| 176 const float temperature_difference = temperature_bottom - temperature_surface; | |
| 177 | |
| 178 // range 0.0 - 1.0 | |
| 179 float position_now = (ambient_pressure_mbar - surface_pressure_mbar) / bottom_mbar_diff_to_surface; | |
| 180 | |
| 181 if(position_now <= 0) | |
| 182 return temperature_surface; | |
| 183 | |
| 184 if(position_now >= 1) | |
| 185 return temperature_bottom; | |
| 186 | |
| 187 return temperature_surface + (temperature_difference * position_now); | |
| 188 } | |
| 189 | |
| 190 | |
| 191 uint32_t demo_modify_temperature_and_pressure(int32_t divetime_in_seconds, uint8_t subseconds, float ceiling_mbar) | |
| 192 { | |
| 193 | |
| 194 const float descent_rate = 4000/60; | |
| 195 const float ascent_rate = 1000/60; | |
| 196 const uint32_t seconds_descend = (1 * 60) + 30; | |
| 197 const uint32_t turbo_seconds_at_bottom_start = (0 * 60) + 0; | |
| 198 const uint32_t seconds_descend_and_bottomtime = seconds_descend + turbo_seconds_at_bottom_start + (2 * 60) + 0; | |
| 199 uint32_t time_elapsed_in_seconds; | |
| 200 static float ambient_pressure_mbar_memory = 0; | |
| 201 static uint32_t time_last_call = 0; | |
| 202 | |
| 203 if(divetime_in_seconds <= seconds_descend) | |
| 204 { | |
| 205 ambient_pressure_mbar = (divetime_in_seconds * descent_rate) + ((float)(subseconds) * descent_rate) + surface_pressure_mbar; | |
| 206 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 207 | |
| 208 time_last_call = divetime_in_seconds; | |
| 209 return 0; | |
| 210 } | |
| 211 else | |
| 212 if(divetime_in_seconds <= seconds_descend + turbo_seconds_at_bottom_start) | |
| 213 { | |
| 214 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 215 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 216 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 217 time_last_call = divetime_in_seconds; | |
| 218 return turbo_seconds_at_bottom_start; | |
| 219 } | |
| 220 else | |
| 221 if(divetime_in_seconds <= seconds_descend_and_bottomtime) | |
| 222 { | |
| 223 ambient_pressure_mbar = (seconds_descend * descent_rate) + surface_pressure_mbar; | |
| 224 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 225 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 226 time_last_call = divetime_in_seconds; | |
| 227 return 0; | |
| 228 } | |
| 229 else | |
| 230 { | |
| 231 time_elapsed_in_seconds = divetime_in_seconds - time_last_call; | |
| 232 ambient_pressure_mbar = ambient_pressure_mbar_memory - time_elapsed_in_seconds * ascent_rate; | |
| 233 | |
| 234 if(ambient_pressure_mbar < surface_pressure_mbar) | |
| 235 ambient_pressure_mbar = surface_pressure_mbar; | |
| 236 else if(ambient_pressure_mbar < ceiling_mbar) | |
| 237 ambient_pressure_mbar = ceiling_mbar; | |
| 238 | |
| 239 ambient_temperature = demo_modify_temperature_helper(descent_rate * seconds_descend); | |
| 240 ambient_pressure_mbar_memory = ambient_pressure_mbar; | |
| 241 time_last_call = divetime_in_seconds; | |
| 242 return 0; | |
| 243 } | |
| 244 } | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
245 #endif |
| 38 | 246 |
| 247 uint8_t is_init_pressure_done(void) | |
| 248 { | |
| 249 return pressureSensorInitSuccess; | |
| 250 } | |
| 251 | |
| 252 uint8_t init_pressure(void) | |
| 253 { | |
| 254 uint8_t buffer[1]; | |
| 255 buffer[0] = 0x1e; | |
| 256 uint8_t retValue = 0xFF; | |
| 257 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
258 pressureSensorInitSuccess = false; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
259 init_pressure_history(); |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
260 |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
261 /* Send reset request to pressure sensor */ |
| 38 | 262 retValue = I2C_Master_Transmit( DEVICE_PRESSURE, buffer, 1); |
| 263 if(retValue != HAL_OK) | |
| 264 { | |
| 265 return (HAL_StatusTypeDef)retValue; | |
| 266 } | |
| 267 HAL_Delay(3); | |
| 268 | |
| 269 for(uint8_t i=0;i<8;i++) | |
| 270 { | |
| 271 C[i] = get_ci_by_coef_num(i); | |
| 272 } | |
| 273 n_crc = crc4(C); // no evaluation at the moment hw 151026 | |
| 274 | |
| 275 C5_x_2p8 = C[5] * 256; | |
| 276 C2_x_2p16 = C[2] * 65536; | |
| 277 C1_x_2p15 = C[1] * 32768; | |
| 278 | |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
279 if(global.I2C_SystemStatus == HAL_OK) |
| 38 | 280 { |
| 281 pressureSensorInitSuccess = 1; | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
282 retValue = pressure_update(); |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
283 |
| 38 | 284 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
285 return retValue; |
| 38 | 286 } |
| 287 | |
| 288 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
289 static uint32_t get_adc(void) |
| 38 | 290 { |
| 291 uint8_t buffer[1]; | |
| 292 uint8_t resivebuf[4]; | |
| 293 uint32_t answer = 0; | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
294 |
| 38 | 295 buffer[0] = 0x00; // Get ADC |
| 296 I2C_Master_Transmit( DEVICE_PRESSURE, buffer, 1); | |
| 297 I2C_Master_Receive( DEVICE_PRESSURE, resivebuf, 4); | |
| 298 resivebuf[3] = 0; | |
| 299 answer = 256*256 *(uint32_t)resivebuf[0] + 256 * (uint32_t)resivebuf[1] + (uint32_t)resivebuf[2]; | |
| 300 | |
| 301 return answer; | |
| 302 } | |
| 303 | |
| 304 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
305 static uint16_t get_ci_by_coef_num(uint8_t coef_num) |
| 38 | 306 { |
| 307 uint8_t resivebuf[2]; | |
| 308 | |
| 309 uint8_t cmd = CMD_PROM_RD+coef_num*2; | |
| 310 I2C_Master_Transmit( DEVICE_PRESSURE, &cmd, 1); | |
| 311 I2C_Master_Receive( DEVICE_PRESSURE, resivebuf, 2); | |
| 312 return (256*(uint16_t)resivebuf[0]) + (uint16_t)resivebuf[1]; | |
| 313 } | |
| 314 | |
| 315 | |
| 316 | |
| 317 uint8_t pressure_update(void) | |
| 318 { | |
| 319 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; | |
| 320 | |
| 321 statusReturn = pressure_sensor_get_data(); | |
| 322 pressure_calculation(); | |
| 323 return (uint8_t)statusReturn; | |
| 324 } | |
| 325 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
326 /* Switch between pressure and temperature measurement with every successful read operation */ |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
327 void pressure_update_alternating(void) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
328 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
329 static uint8_t getTemperature= 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
330 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
331 if(getTemperature) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
332 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
333 if(pressure_sensor_get_temperature_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
334 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
335 getTemperature = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
336 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
337 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
338 else |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
339 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
340 if(pressure_sensor_get_pressure_raw() == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
341 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
342 getTemperature = 1; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
343 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
344 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
345 pressure_calculation(); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
346 return; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
347 } |
| 38 | 348 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
349 static uint32_t pressure_sensor_get_one_value(uint8_t cmd, HAL_StatusTypeDef *statusReturn) |
| 38 | 350 { |
| 351 uint8_t command = CMD_ADC_CONV + cmd; | |
| 352 HAL_StatusTypeDef statusReturnTemp = HAL_TIMEOUT; | |
| 353 | |
| 354 statusReturnTemp = I2C_Master_Transmit( DEVICE_PRESSURE, &command, 1); | |
| 355 | |
| 356 if(statusReturn) | |
| 357 { | |
| 358 *statusReturn = statusReturnTemp; | |
| 359 } | |
| 360 | |
| 361 switch (cmd & 0x0f) // wait necessary conversion time | |
| 362 { | |
| 363 case CMD_ADC_256 : HAL_Delay(1); break; | |
| 364 case CMD_ADC_512 : HAL_Delay(3); break; | |
| 365 case CMD_ADC_1024: HAL_Delay(4); break; | |
| 366 case CMD_ADC_2048: HAL_Delay(6); break; | |
| 367 case CMD_ADC_4096: HAL_Delay(10); break; | |
| 368 } | |
| 369 return get_adc(); | |
| 370 } | |
| 371 | |
| 372 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
373 static HAL_StatusTypeDef pressure_sensor_get_data(void) |
| 38 | 374 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
375 uint32_t requestedValue = 0; |
| 38 | 376 HAL_StatusTypeDef statusReturn1 = HAL_TIMEOUT; |
| 377 HAL_StatusTypeDef statusReturn2 = HAL_TIMEOUT; | |
| 378 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
379 |
| 38 | 380 |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
381 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D2 + CMD_ADC_1024, &statusReturn2); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
382 if (statusReturn2 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
383 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
384 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
385 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
386 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
387 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D1 + CMD_ADC_1024, &statusReturn1); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
388 if (statusReturn1 == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
389 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
390 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
391 } |
| 38 | 392 if(statusReturn2 > statusReturn1) // if anything is not HAL_OK (0x00) or worse |
| 393 return statusReturn2; | |
| 394 else | |
| 395 return statusReturn1; | |
| 396 } | |
| 397 | |
| 398 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
399 HAL_StatusTypeDef pressure_sensor_get_pressure_raw(void) |
| 38 | 400 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
401 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
402 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
403 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
404 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D1 + CMD_ADC_1024, &statusReturn); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
405 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
406 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
407 D1 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
408 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
409 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
410 return statusReturn; |
| 38 | 411 } |
| 412 | |
| 413 | |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
414 HAL_StatusTypeDef pressure_sensor_get_temperature_raw(void) |
| 38 | 415 { |
|
276
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
416 uint32_t requestedValue = 0; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
417 HAL_StatusTypeDef statusReturn = HAL_TIMEOUT; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
418 |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
419 requestedValue = pressure_sensor_get_one_value(CMD_ADC_D2 + CMD_ADC_1024, &statusReturn); |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
420 if (statusReturn == HAL_OK) |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
421 { |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
422 D2 = requestedValue; |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
423 } |
|
8e9c502c0b06
Rework pressure/ temperature data aquisition
ideenmodellierer
parents:
241
diff
changeset
|
424 return statusReturn; |
| 38 | 425 } |
| 426 | |
| 427 | |
| 428 void pressure_calculation(void) | |
| 429 { | |
|
241
2b9775f71e30
cleanup: factor out I2C1_Status() and cleanup type
Jan Mulder <jlmulder@xs4all.nl>
parents:
186
diff
changeset
|
430 if(global.I2C_SystemStatus != HAL_OK) |
| 38 | 431 return; |
| 432 | |
| 433 pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(); | |
| 434 } | |
| 435 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
436 static uint8_t pressure_plausible(float pressurevalue) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
437 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
438 static uint8_t pressurewriteindex = 0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
439 uint8_t retval = 0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
440 uint8_t index; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
441 float pressure_average = 0; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
442 |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
443 for(index = 0; index < PRESSURE_HISTORY_SIZE; index++) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
444 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
445 pressure_average += pressure_history_mbar[index]; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
446 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
447 pressure_average /= PRESSURE_HISTORY_SIZE; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
448 if(pressure_average == 1000.0) /* first pressure calculation */ |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
449 { |
|
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
|
450 if(fabs(pressurevalue - pressure_average) < 11000.0) /* just in case a reset occur during dive assume value equal < 100m as valid */ |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
451 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
452 for(index = 0; index < PRESSURE_HISTORY_SIZE; index++) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
453 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
454 pressure_history_mbar[index] = pressurevalue; /* set history to current value */ |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
455 retval = 1; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
456 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
457 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
458 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
459 else |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
460 { |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
461 if(fabs(pressurevalue - pressure_average) < PRESSURE_JUMP_VALID_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
|
462 { |
|
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
|
463 pressure_history_mbar[pressurewriteindex++] = pressurevalue; |
|
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
|
464 pressurewriteindex &= 0x7; /* wrap around if necessary */ |
|
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
|
465 retval = 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
|
466 } |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
467 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
468 |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
469 return retval; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
470 } |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
471 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
472 static void pressure_calculation_AN520_004_mod_MS5803_30BA__09_2015(void) |
| 38 | 473 { |
|
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
|
474 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
|
475 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
|
476 |
| 38 | 477 uint32_t local_D1; // ADC value of the pressure conversion |
| 478 uint32_t local_D2; // ADC value of the temperature conversion | |
| 479 int32_t local_Px10; // compensated pressure value | |
| 480 int32_t local_Tx100; // compensated temperature value | |
| 481 int64_t local_dT; // int32_t, difference between actual and measured temperature | |
| 482 int64_t local_OFF; // offset at actual temperature | |
| 483 int64_t local_SENS; // sensitivity at actual temperature | |
| 484 | |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
485 float calc_pressure; |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
486 |
| 38 | 487 int64_t T2; |
| 488 int64_t OFF2; | |
| 489 int64_t SENS2; | |
| 490 | |
| 491 local_D1 = D1; | |
| 492 local_D2 = D2; | |
| 493 | |
| 494 local_dT = ((int64_t)local_D2) - ((int64_t)C[5]) * 256; //pow(2,8); | |
| 495 local_OFF = ((int64_t)C[2]) * 65536 + local_dT * ((int64_t)C[4]) / 128; // pow(2,16), pow(2,7) | |
| 496 local_SENS = ((int64_t)C[1]) * 32768 + local_dT * ((int64_t)C[3]) / 256; // pow(2,15), pow(2,8) | |
| 497 | |
| 498 local_Tx100 = (int32_t)(2000 + (local_dT * ((int64_t)C[6])) / 8388608);// pow(2,23) | |
| 499 | |
| 500 | |
| 501 if(local_Tx100 < 2000) // low temperature | |
| 502 { | |
| 503 T2 = 3 * local_dT; | |
| 504 T2 *= local_dT; | |
| 505 T2 /= 8589934592; | |
| 506 | |
| 507 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 508 OFF2 *= OFF2; | |
| 509 OFF2 *= 3; | |
| 510 OFF2 /= 2; | |
| 511 | |
| 512 SENS2 = ((int64_t)local_Tx100) - 2000; | |
| 513 SENS2 *= SENS2; | |
| 514 SENS2 *= 5; | |
| 515 SENS2 /= 8; | |
| 516 | |
| 517 local_Tx100 -= (int32_t)T2; | |
| 518 local_OFF -= OFF2; | |
| 519 local_SENS -= SENS2; | |
| 520 } | |
| 521 else | |
| 522 { | |
| 523 T2 = 7 * local_dT; | |
| 524 T2 *= local_dT; | |
| 525 T2 /= 137438953472; | |
| 526 | |
| 527 OFF2 = ((int64_t)local_Tx100) - 2000; | |
| 528 OFF2 *= OFF2; | |
| 529 OFF2 /= 16; | |
| 530 | |
| 531 local_Tx100 -= (int32_t)T2; | |
| 532 local_OFF -= OFF2; | |
| 533 } | |
| 534 | |
| 535 local_Px10 = (int32_t)( | |
| 536 (((int64_t)((local_D1 * local_SENS) / 2097152)) - local_OFF) | |
| 537 / 8192 );// )) / 10; // pow(2,21), pow(2,13) | |
| 538 | |
|
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
|
539 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
|
540 ambient_temperature += temperature_offset; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
541 |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
542 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
|
543 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
|
544 |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
545 if(pressure_plausible(calc_pressure)) |
|
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
546 { |
|
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
|
547 runningAvg = (avgCnt * runningAvg + calc_pressure) / (avgCnt + 1); |
|
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
|
548 if (avgCnt < 10) /* build an average considering the last measurements to have a weight "1 of 10" */ |
|
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
|
549 { /* Main reason for this is the jitter of up to +-10 HPa in surface mode which is caused */ |
|
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
|
550 avgCnt++; /* by the measurement range of the sensor which is focused on under water pressure measurement */ |
|
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
|
551 } |
|
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
|
552 ambient_pressure_mbar = runningAvg; |
|
331
b4c578caaafb
Added plausibility check for pressure values
ideenmodellierer
parents:
276
diff
changeset
|
553 } |
| 38 | 554 } |
| 555 | |
| 556 | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
557 /* |
| 38 | 558 void pressure_calculation_new(void) |
| 559 { | |
| 560 #define POW2_8 (256) | |
| 561 #define POW2_17 (131072) | |
| 562 #define POW2_6 (64) | |
| 563 #define POW2_16 (65536) | |
| 564 #define POW2_7 (128) | |
| 565 #define POW2_23 (8388608) | |
| 566 #define POW2_21 (2097152) | |
| 567 #define POW2_15 (32768) | |
| 568 #define POW2_13 (8192) | |
| 569 #define POW2_37 (137438953472) | |
| 570 #define POW2_4 (16) | |
| 571 #define POW2_33 (8589934592) | |
| 572 #define POW2_3 (8) | |
| 573 | |
| 574 int32_t P; // compensated pressure value | |
| 575 int32_t T; // compensated temperature value | |
| 576 int32_t dT; // difference between actual and measured temperature | |
| 577 int64_t OFF; // offset at actual temperature | |
| 578 int64_t SENS; | |
| 579 | |
| 580 int32_t T2; | |
| 581 int64_t OFF2; | |
| 582 int64_t SENS2; | |
| 583 | |
| 584 dT = ((int32_t)D2) - ((int32_t)C[5]) * POW2_8; | |
| 585 OFF = ((int64_t)C[2]) * POW2_16 + ((int64_t)dT) * ((int64_t)C[4]) / POW2_7; | |
| 586 SENS = ((int64_t)C[1]) * POW2_15 + ((int64_t)dT) * ((int64_t)C[3]) / POW2_8; | |
| 587 | |
| 588 T = 2000 + (dT * ((int32_t)C[6])) / POW2_23; | |
| 589 | |
| 590 | |
| 591 if(T < 2000) // low temperature | |
| 592 { | |
| 593 T2 = 3 * dT * dT; | |
| 594 T2 /= POW2_33; | |
| 595 OFF2 = ((int64_t)T) - 2000; | |
| 596 OFF2 *= OFF2; | |
| 597 OFF2 *= 3; | |
| 598 OFF2 /= 2; | |
| 599 SENS2 = ((int64_t)T) - 2000; | |
| 600 SENS2 *= SENS2; | |
| 601 SENS2 *= 5; | |
| 602 SENS2 /= POW2_3; | |
| 603 } | |
| 604 else // high temperature | |
| 605 { | |
| 606 T2 = 7 * dT * dT; | |
| 607 T2 /= POW2_37; | |
| 608 OFF2 = ((int64_t)T) - 2000; | |
| 609 OFF2 *= OFF2; | |
| 610 OFF2 /= POW2_4; | |
| 611 SENS2 = 0; | |
| 612 } | |
| 613 | |
| 614 T = T - T2; | |
| 615 OFF = OFF - OFF2; | |
| 616 SENS = SENS - SENS2; | |
| 617 | |
| 618 P = (int32_t)(((((int64_t)D1) * SENS) / POW2_21 - OFF) / POW2_13); | |
| 619 | |
| 620 ambient_temperature = ((float)T) / 100; | |
| 621 ambient_pressure_mbar = ((float)P) / 10; | |
| 622 } | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
623 */ |
| 38 | 624 |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
625 /* |
| 38 | 626 void pressure_calculation_old(void) { |
| 627 // | |
| 628 double ambient_temperature_centigrad = 0; | |
| 629 double ambient_pressure_decimbar = 0; | |
| 630 | |
| 631 // static for debug | |
| 632 static int64_t dt = 0; | |
| 633 static int64_t temp = 0; | |
| 634 static int64_t ms_off = 0; | |
| 635 static int64_t sens = 0; | |
| 636 // | |
| 637 static int64_t ms_off2 = 0; | |
| 638 static int64_t sens2 = 0; | |
| 639 static int64_t t2 = 0; | |
| 640 | |
| 641 if((D2 == 0) || (D1 == 0)) | |
| 642 return; | |
| 643 // | |
| 644 | |
| 645 // dT = D2 - C[5] * POW2_8; | |
| 646 // T = 2000 + (dT * C[6]) / POW2_23; | |
| 647 dt = (int64_t)D2 - C5_x_2p8; | |
| 648 //temp ; // in 10 milliGrad Celcius | |
| 649 ambient_temperature_centigrad = 2000 + dt * C[6] / 8388608; | |
| 650 | |
| 651 | |
| 652 if(ambient_temperature_centigrad < 2000) // low temperature | |
| 653 { | |
| 654 t2 = 3 * dt; | |
| 655 t2 *= dt; | |
| 656 t2 /= 8589934592; | |
| 657 ms_off2 = ambient_temperature_centigrad - 2000; | |
| 658 ms_off2 *= ms_off2; | |
| 659 sens2 = ms_off2; | |
| 660 ms_off2 *= 3; | |
| 661 ms_off2 /= 2; | |
| 662 sens2 *= 5; | |
| 663 sens2 /= 8; | |
| 664 } | |
| 665 else // high temperature | |
| 666 { | |
| 667 t2 = 7 * dt; | |
| 668 t2 *= dt; | |
| 669 t2 /= 137438953472; | |
| 670 ms_off2 = ambient_temperature_centigrad - 2000; | |
| 671 ms_off2 *= ms_off2; | |
| 672 ms_off2 /= 16; | |
| 673 sens2 = 0; | |
| 674 } | |
| 675 | |
| 676 | |
| 677 // | |
| 678 | |
| 679 // pressure | |
| 680 // OFF = C[2] * POW2_16 + dT * C[4] / POW2_7; | |
| 681 // SENS = C[1] * POW2_15 + dT * C[3] / POW2_8; | |
| 682 ms_off = C[4] * dt; | |
| 683 ms_off /= 128; | |
| 684 ms_off += C2_x_2p16; | |
| 685 // | |
| 686 sens = C[3] * dt; | |
| 687 sens /= 256; | |
| 688 sens += C1_x_2p15; | |
| 689 | |
| 690 // 2nd order correction | |
| 691 ambient_temperature_centigrad -= t2; | |
| 692 ms_off -= ms_off2; | |
| 693 sens -= sens2; | |
| 694 | |
| 695 ambient_temperature = ambient_temperature_centigrad / 100; | |
| 696 // P = (D1 * SENS / POW2_21 - OFF) / POW2_13; | |
| 697 temp = D1 * sens; | |
| 698 temp /= 2097152; | |
| 699 temp -= ms_off; | |
| 700 temp /= 8192; | |
| 701 ambient_pressure_decimbar = temp; // to float/double | |
| 702 ambient_pressure_mbar = ambient_pressure_decimbar / 10; | |
| 703 } | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
704 */ |
| 38 | 705 |
| 706 | |
| 707 /* taken from AN520 by meas-spec.com dated 9. Aug. 2011 | |
| 708 * short and int are both 16bit according to AVR/GCC google results | |
| 709 */ | |
|
186
f11f0bf6ef2d
cleanup: remove obsolete code, make static, etc.
Jan Mulder <jlmulder@xs4all.nl>
parents:
38
diff
changeset
|
710 static uint8_t crc4(uint16_t n_prom[]) |
| 38 | 711 { |
| 712 uint16_t cnt; // simple counter | |
| 713 uint16_t n_rem; // crc reminder | |
| 714 uint16_t crc_read; // original value of the crc | |
| 715 uint8_t n_bit; | |
| 716 n_rem = 0x00; | |
| 717 crc_read=n_prom[7]; //save read CRC | |
| 718 n_prom[7]=(0xFF00 & (n_prom[7])); //CRC byte is replaced by 0 | |
| 719 for (cnt = 0; cnt < 16; cnt++) // operation is performed on bytes | |
| 720 { // choose LSB or MSB | |
| 721 if (cnt%2==1) n_rem ^= (uint16_t) ((n_prom[cnt>>1]) & 0x00FF); | |
| 722 else n_rem ^= (uint16_t) (n_prom[cnt>>1]>>8); | |
| 723 for (n_bit = 8; n_bit > 0; n_bit--) | |
| 724 { | |
| 725 if (n_rem & (0x8000)) | |
| 726 { | |
| 727 n_rem = (n_rem << 1) ^ 0x3000; | |
| 728 } | |
| 729 else | |
| 730 { | |
| 731 n_rem = (n_rem << 1); | |
| 732 } | |
| 733 } | |
| 734 } | |
| 735 n_rem= (0x000F & (n_rem >> 12)); // // final 4-bit reminder is CRC code | |
| 736 n_prom[7]=crc_read; // restore the crc_read to its original place | |
| 737 return (n_rem ^ 0x00); | |
| 738 } | |
| 739 /* | |
| 740 void test_calculation(void) | |
| 741 { | |
| 742 C1 = 29112; | |
| 743 C2 = 26814; | |
| 744 C3 = 19125; | |
| 745 C4 = 17865; | |
| 746 C5 = 32057; | |
| 747 C6 = 31305; | |
| 748 | |
| 749 C2_x_2p16 = C2 * 65536; | |
| 750 C1_x_2p15 = C1 * 32768; | |
| 751 | |
| 752 D1 = 4944364; | |
| 753 D2 = 8198974; | |
| 754 pressure_calculation() ; | |
| 755 }; | |
| 756 */ | |
|
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
|
757 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
|
758 { |
|
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
|
759 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
|
760 { |
|
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
|
761 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
|
762 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
|
763 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
|
764 } |
| 38 | 765 |
|
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
|
766 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
|
767 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
|
768 } |
|
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
|
769 |
|
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
|
770 |