Mercurial > public > ostc4
annotate Small_CPU/Src/externalInterface.c @ 1062:785772303f9c Icon_Integration
Added pressure sensors in Sentnel mode:
The Red Head/Provide pressure and tempstick information on a uart channel together with the O2 data. The support for receiving pressure data has been added to the Sentinel protocol function.
| author | Ideenmodellierer |
|---|---|
| date | Tue, 10 Feb 2026 19:36:05 +0100 |
| parents | d9290c76b840 |
| children | a3f42192da0f |
| rev | line source |
|---|---|
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
1 /** |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
2 ****************************************************************************** |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
3 * @file externalInterface.c |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
4 * @author heinrichs weikamp gmbh |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
5 * @version V0.0.1 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
6 * @date 07-Nov-2020 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
7 * @brief Interface functionality to proceed external analog signal via i2c connection |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
8 * |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
9 @verbatim |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
10 ============================================================================== |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
11 ##### stm32f4xx_hal_i2c.c modification ##### |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
12 ============================================================================== |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
13 The LTC2942 requires an repeated start condition without stop condition |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
14 for data reception. |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
15 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
16 @endverbatim |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
17 ****************************************************************************** |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
18 * @attention |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
19 * |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
20 * <h2><center>© COPYRIGHT(c) 2014 heinrichs weikamp</center></h2> |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
21 * |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
22 ****************************************************************************** |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
23 */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
24 /* Includes ------------------------------------------------------------------*/ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
25 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
26 #include <math.h> |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
27 #include <string.h> |
| 794 | 28 #include "data_central.h" |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
29 #include "i2c.h" |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
30 #include "externalInterface.h" |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
31 #include "scheduler.h" |
| 662 | 32 #include "uart.h" |
| 33 #include "data_exchange.h" | |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
34 #include "pressure.h" |
| 794 | 35 #include "uartProtocol_O2.h" |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
36 #include "uartProtocol_Co2.h" |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
37 #include "uartProtocol_Sentinel.h" |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
38 #include "uartProtocol_GNSS.h" |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
39 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
40 extern SGlobal global; |
| 662 | 41 extern UART_HandleTypeDef huart1; |
| 932 | 42 extern sUartComCtrl Uart1Ctrl; |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
43 |
| 921 | 44 #define ADC_ANSWER_LENGTH (5u) /* 3424 will provide addr + 4 data bytes */ |
| 45 #define ADC_TIMEOUT (10u) /* conversion stuck for unknown reason => restart */ | |
| 46 #define ADC_REF_VOLTAGE_MV (2048.0f) /* reference voltage of MPC3424*/ | |
| 47 #define ADC_CYCLE_INTERVAL_MS (1000u) /* start adc read out once per second*/ | |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
48 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
49 #define ADC_START_CONVERSION (0x80) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
50 #define ADC_GAIN_4 (0x02) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
51 #define ADC_GAIN_4_VALUE (4.0f) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
52 #define ADC_GAIN_8 (0x03) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
53 #define ADC_GAIN_8_VALUE (8.0f) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
54 #define ADC_RESOLUTION_16BIT (0x08) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
55 #define ADC_RESOLUTION_16BIT_VALUE (16u) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
56 #define ADC_RESOLUTION_18BIT (0x0C) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
57 #define ADC_RESOLUTION_18BIT_VALUE (18u) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
58 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
59 #define ANSWER_CONFBYTE_INDEX (4u) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
60 |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
61 #define LOOKUP_CO2_CORR_TABLE_SCALE (1000u) |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
62 #define LOOKUP_CO2_CORR_TABLE_MAX (30000u) |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
63 |
| 794 | 64 #define REQUEST_INT_SENSOR_MS (1500) /* Minimum time interval for cyclic sensor data requests per sensor (UART mux) */ |
| 65 #define COMMAND_TX_DELAY (30u) /* The time the sensor needs to recover from a invalid command request */ | |
| 66 #define TIMEOUT_SENSOR_ANSWER (300) /* Time till a request is repeated if no answer was received */ | |
| 67 | |
| 68 #define activeSensorId (activeUartChannel + EXT_INTERFACE_MUX_OFFSET) /* Used if UART channels are applied to Sensor map */ | |
| 69 | |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
70 static uint8_t activeChannel = 0; /* channel which is in request */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
71 static uint8_t recBuf[ADC_ANSWER_LENGTH]; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
72 static uint8_t timeoutCnt = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
73 static uint8_t externalInterfacePresent = 0; |
| 861 | 74 static uint8_t delayAdcConversion = 0; |
| 921 | 75 static uint32_t startTickADC = 0; |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
76 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
77 float externalChannel_mV[MAX_ADC_CHANNEL]; |
| 662 | 78 static uint8_t externalV33_On = 0; |
| 691 | 79 static uint8_t externalADC_On = 0; |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
80 static uint8_t externalUART_Protocol = 0; |
| 662 | 81 static uint16_t externalCO2Value; |
| 82 static uint16_t externalCO2SignalStrength; | |
| 794 | 83 static uint16_t externalCO2Status = 0; |
| 84 static float externalCO2Scale = 0.0; | |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
85 |
| 1062 | 86 static uint8_t externalBottleBar[PRESSURE_BOTTLE_CNT] = {0,0}; |
| 87 | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
88 static uint8_t lastSensorDataId = 0; |
| 794 | 89 static SSensorDataDiveO2 sensorDataDiveO2[EXT_INTERFACE_SENSOR_CNT]; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
90 static externalInterfaceAutoDetect_t externalAutoDetect = DETECTION_OFF; |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
91 static externalInterfaceSensorType SensorMap[EXT_INTERFACE_SENSOR_CNT] ={ SENSOR_OPTIC, SENSOR_OPTIC, SENSOR_OPTIC, SENSOR_NONE, SENSOR_NONE}; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
92 static externalInterfaceSensorType tmpSensorMap[EXT_INTERFACE_SENSOR_CNT]; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
93 static externalInterfaceSensorType MasterSensorMap[EXT_INTERFACE_SENSOR_CNT]; |
| 794 | 94 static externalInterfaceSensorType foundSensorMap[EXT_INTERFACE_SENSOR_CNT]; |
| 95 static uint8_t Mux2ADCMap[MAX_ADC_CHANNEL]; | |
| 96 static uint8_t externalInterface_SensorState[EXT_INTERFACE_SENSOR_CNT]; | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
97 |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
98 static float LookupCO2PressureCorrection[LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE]; /* lookup table for pressure compensation values */ |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
99 |
| 804 | 100 static uint16_t externalInterfaceMuxReqIntervall = 0xffff; /* delay between switching from one MUX channel to the next */ |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
101 static uint8_t activeUartChannel = 0xff; |
| 804 | 102 |
| 103 | |
| 104 static void externalInface_MapUartToLegacyADC(uint8_t* pMap); | |
| 809 | 105 static void externalInterface_CheckBaudrate(uint8_t sensorType); |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
106 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
107 void externalInterface_Init(void) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
108 { |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
109 uint16_t index; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
110 uint16_t coeff; |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
111 activeChannel = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
112 timeoutCnt = 0; |
| 861 | 113 delayAdcConversion = 0; |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
114 if(externalInterface_StartConversion(activeChannel) == HAL_OK) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
115 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
116 externalInterfacePresent = 1; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
117 global.deviceDataSendToMaster.hw_Info.extADC = 1; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
118 } |
| 559 | 119 global.deviceDataSendToMaster.hw_Info.checkADC = 1; |
| 662 | 120 |
| 804 | 121 |
| 794 | 122 |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
123 /* Create a lookup table based on GSS application note AN001: PRESSURE COMPENSATION OF A CO2 SENSOR */ |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
124 /* The main purpose of the sensor in the dive application is to be a warning indicator */ |
| 753 | 125 /* => no exact values necessary => a lookup table with 1000ppm scaling should be sufficient */ |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
126 LookupCO2PressureCorrection [0] = -0.0014; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
127 for(index = 1; index < (LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE); index++) |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
128 { |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
129 coeff = index * LOOKUP_CO2_CORR_TABLE_SCALE; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
130 LookupCO2PressureCorrection[index] = 2.811*pow(10,-38)*pow(coeff,6)- 9.817*pow(10,-32)*pow(coeff,5)+1.304*pow(10,-25)*pow(coeff,4)-8.216*pow(10,-20)*pow(coeff,3)+2.311*pow(10,-14)*pow(coeff,2) - 2.195*pow(10,-9)*coeff - 1.471*pow(10,-3); |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
131 } |
|
738
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
132 externalInterface_InitDatastruct(); |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
133 } |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
134 |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
135 void externalInterface_InitDatastruct(void) |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
136 { |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
137 uint8_t index = 0; |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
138 /* init data values */ |
| 804 | 139 externalUART_Protocol = 0; |
| 662 | 140 externalCO2Value = 0; |
| 141 externalCO2SignalStrength = 0; | |
| 142 externalCO2Status = 0; | |
| 804 | 143 externalCO2Scale = 0.0; |
| 1062 | 144 externalBottleBar[0] = 0; |
| 145 externalBottleBar[1] = 0; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
146 externalAutoDetect = DETECTION_OFF; |
|
738
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
147 |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
148 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
149 { |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
150 externalChannel_mV[index] = 0.0; |
|
30717de00f3a
Added data init function for external interface:
Ideenmodellierer
parents:
731
diff
changeset
|
151 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
152 memset(externalInterface_SensorState,UART_COMMON_INIT,sizeof(externalInterface_SensorState)); |
| 804 | 153 externalInface_MapUartToLegacyADC(SensorMap); |
| 154 activeUartChannel = 0xFF; | |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
155 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
156 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
157 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
158 uint8_t externalInterface_StartConversion(uint8_t channel) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
159 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
160 uint8_t retval = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
161 uint8_t confByte = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
162 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
163 if(channel < MAX_ADC_CHANNEL) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
164 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
165 confByte = ADC_START_CONVERSION | ADC_RESOLUTION_16BIT | ADC_GAIN_8; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
166 confByte |= channel << 5; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
167 retval = I2C_Master_Transmit(DEVICE_EXTERNAL_ADC, &confByte, 1); |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
168 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
169 return retval; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
170 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
171 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
172 /* Check if conversion is done and trigger measurement of next channel */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
173 uint8_t externalInterface_ReadAndSwitch() |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
174 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
175 uint8_t retval = EXTERNAL_ADC_NO_DATA; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
176 uint8_t nextChannel; |
| 731 | 177 uint8_t* psensorMap = externalInterface_GetSensorMapPointer(0); |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
178 |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
179 if(externalADC_On) |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
180 { |
| 921 | 181 if(time_elapsed_ms(startTickADC, HAL_GetTick()) > ADC_CYCLE_INTERVAL_MS) |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
182 { |
| 921 | 183 if(delayAdcConversion) |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
184 { |
| 921 | 185 if(UART_isComActive(activeUartChannel) == 0) |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
186 { |
| 921 | 187 externalInterface_StartConversion(activeChannel); |
| 188 delayAdcConversion = 0; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
189 } |
| 921 | 190 } |
| 191 else if(I2C_Master_Receive(DEVICE_EXTERNAL_ADC, recBuf, ADC_ANSWER_LENGTH) == HAL_OK) | |
| 192 { | |
| 193 if((recBuf[ANSWER_CONFBYTE_INDEX] & ADC_START_CONVERSION) == 0) /* !ready set => received data contains new value */ | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
194 { |
| 921 | 195 retval = activeChannel; /* return channel number providing new data */ |
| 196 nextChannel = activeChannel + 1; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
197 if(nextChannel == MAX_ADC_CHANNEL) |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
198 { |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
199 nextChannel = 0; |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
200 } |
| 921 | 201 |
| 202 while((psensorMap[nextChannel] != SENSOR_ANALOG) && (nextChannel != activeChannel)) | |
| 203 { | |
| 204 if(nextChannel == MAX_ADC_CHANNEL) | |
| 205 { | |
| 206 nextChannel = 0; | |
| 207 startTickADC = HAL_GetTick(); | |
| 208 } | |
| 209 else | |
| 210 { | |
| 211 nextChannel++; | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 activeChannel = nextChannel; | |
| 216 if(activeChannel == 0) | |
| 217 { | |
| 218 delayAdcConversion = 1; /* wait for next cycle interval */ | |
| 219 } | |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
220 else |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
221 { |
| 921 | 222 if(UART_isComActive(activeUartChannel) == 0) |
| 223 { | |
| 224 externalInterface_StartConversion(activeChannel); | |
| 225 } | |
| 226 else | |
| 227 { | |
| 228 delayAdcConversion = 1; | |
| 229 } | |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
230 } |
| 921 | 231 timeoutCnt = 0; |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
232 } |
| 921 | 233 } |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
234 |
| 861 | 235 if(timeoutCnt++ >= ADC_TIMEOUT) |
| 236 { | |
| 237 externalInterface_StartConversion(activeChannel); | |
| 238 delayAdcConversion = 0; | |
| 239 timeoutCnt = 0; | |
|
581
011d8f9f5ddb
Added ex Interface measurement restart in case of i2c disturbance:
Ideenmodellierer
parents:
559
diff
changeset
|
240 } |
| 921 | 241 } |
|
554
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
242 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
243 return retval; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
244 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
245 float externalInterface_CalculateADCValue(uint8_t channel) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
246 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
247 int32_t rawvalue = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
248 float retValue = 0.0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
249 if(channel < MAX_ADC_CHANNEL) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
250 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
251 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
252 rawvalue = ((recBuf[0] << 16) | (recBuf[1] << 8) | (recBuf[2])); |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
253 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
254 switch(recBuf[3] & 0x0C) /* confbyte => Resolution bits*/ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
255 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
256 case ADC_RESOLUTION_16BIT: rawvalue = rawvalue >> 8; /* only 2 databytes received shift out confbyte*/ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
257 if(rawvalue & (0x1 << (ADC_RESOLUTION_16BIT_VALUE-1))) /* MSB set => negative number */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
258 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
259 rawvalue |= 0xFFFF0000; /* set MSB for int32 */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
260 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
261 else |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
262 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
263 rawvalue &= 0x0000FFFF; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
264 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
265 externalChannel_mV[channel] = ADC_REF_VOLTAGE_MV * 2.0 / (float) pow(2,ADC_RESOLUTION_16BIT_VALUE); /* calculate bit resolution */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
266 break; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
267 case ADC_RESOLUTION_18BIT: if(rawvalue & (0x1 << (ADC_RESOLUTION_18BIT_VALUE-1))) /* MSB set => negative number */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
268 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
269 rawvalue |= 0xFFFE0000; /* set MSB for int32 */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
270 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
271 externalChannel_mV[channel] = ADC_REF_VOLTAGE_MV * 2.0 / (float) pow(2,ADC_RESOLUTION_18BIT_VALUE); /* calculate bit resolution */ |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
272 break; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
273 default: rawvalue = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
274 break; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
275 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
276 externalChannel_mV[channel] = externalChannel_mV[channel] * rawvalue / ADC_GAIN_8_VALUE; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
277 retValue = externalChannel_mV[channel]; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
278 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
279 return retValue; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
280 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
281 float getExternalInterfaceChannel(uint8_t channel) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
282 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
283 float retval = 0; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
284 |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
285 if(channel < MAX_ADC_CHANNEL) |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
286 { |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
287 retval = externalChannel_mV[channel]; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
288 } |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
289 return retval; |
|
3328189786e7
Added external ADC interface functionality (MCP3424):
Ideenmodellierer
parents:
diff
changeset
|
290 } |
| 662 | 291 |
| 691 | 292 uint8_t setExternalInterfaceChannel(uint8_t channel, float value) |
| 293 { | |
| 294 uint8_t retval = 0; | |
| 794 | 295 uint8_t localId = channel; |
| 296 uint8_t index = 0; | |
| 691 | 297 |
| 794 | 298 if(localId >= MAX_ADC_CHANNEL) /* at the moment sensor visualization is focused on the three ADC channels => map Mux sensors */ |
| 691 | 299 { |
| 794 | 300 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
| 301 { | |
| 302 if(Mux2ADCMap[index] == localId) | |
| 303 { | |
| 304 localId = index; | |
| 305 break; | |
| 306 } | |
| 307 } | |
| 308 } | |
| 309 | |
| 310 if(localId < MAX_ADC_CHANNEL) | |
| 311 { | |
| 312 externalChannel_mV[localId] = value; | |
| 691 | 313 retval = 1; |
| 314 } | |
| 315 return retval; | |
| 316 } | |
| 317 | |
| 662 | 318 void externalInterface_InitPower33(void) |
| 319 { | |
| 320 GPIO_InitTypeDef GPIO_InitStructure; | |
| 321 | |
| 322 GPIO_InitStructure.Pin = GPIO_PIN_7; | |
| 323 GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; | |
| 324 GPIO_InitStructure.Pull = GPIO_PULLUP; | |
| 325 GPIO_InitStructure.Speed = GPIO_SPEED_LOW; | |
| 326 HAL_GPIO_Init(GPIOC, &GPIO_InitStructure); | |
| 327 HAL_GPIO_WritePin(GPIOC,GPIO_PIN_7,GPIO_PIN_SET); | |
| 328 } | |
| 329 | |
| 330 | |
| 331 uint8_t externalInterface_isEnabledPower33() | |
| 332 { | |
| 333 return externalV33_On; | |
| 334 } | |
| 691 | 335 |
| 336 uint8_t externalInterface_isEnabledADC() | |
| 337 { | |
| 338 return externalADC_On; | |
| 339 } | |
| 340 | |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
341 uint8_t externalInterface_GetUARTProtocol() |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
342 { |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
343 return externalUART_Protocol; |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
344 } |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
345 |
| 662 | 346 void externalInterface_SwitchPower33(uint8_t state) |
| 347 { | |
| 348 if(state != externalV33_On) | |
| 349 { | |
| 350 if(state) | |
| 351 { | |
| 352 HAL_GPIO_WritePin(GPIOC,GPIO_PIN_7,GPIO_PIN_RESET); | |
| 353 externalV33_On = 1; | |
| 354 } | |
| 355 else | |
| 356 { | |
| 731 | 357 if(externalAutoDetect == DETECTION_OFF) |
| 358 { | |
| 359 HAL_GPIO_WritePin(GPIOC,GPIO_PIN_7,GPIO_PIN_SET); | |
| 360 externalV33_On = 0; | |
| 361 externalInterface_SetCO2Value(0); | |
| 362 externalInterface_SetCO2SignalStrength(0); | |
| 363 } | |
| 662 | 364 } |
| 365 } | |
| 366 } | |
| 691 | 367 void externalInterface_SwitchADC(uint8_t state) |
| 368 { | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
369 uint8_t loop = 0; |
| 691 | 370 if((state) && (externalInterfacePresent)) |
| 371 { | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
372 if(externalADC_On == 0) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
373 { |
| 921 | 374 startTickADC = HAL_GetTick(); |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
375 activeChannel = 0; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
376 externalInterface_StartConversion(activeChannel); |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
377 externalADC_On = 1; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
378 } |
| 691 | 379 } |
| 380 else | |
| 381 { | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
382 if(externalAutoDetect == DETECTION_OFF) /* block deactivation requests if auto detection is active */ |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
383 { |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
384 externalADC_On = 0; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
385 for(loop = 0; loop < MAX_ADC_CHANNEL; loop++) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
386 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
387 externalChannel_mV[loop] = 0; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
388 } |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
389 } |
| 691 | 390 } |
| 391 } | |
| 662 | 392 |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
393 void externalInterface_SwitchUART(uint8_t protocol) |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
394 { |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
395 switch(protocol) |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
396 { |
| 839 | 397 case EXT_INTERFACE_UART_OFF: |
| 398 case EXT_INTERFACE_UART_CO2: | |
| 399 case EXT_INTERFACE_UART_O2: | |
| 400 case EXT_INTERFACE_UART_SENTINEL: | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
401 case EXT_INTERFACE_UART_GNSS: |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
402 if((externalAutoDetect <= DETECTION_START) |
| 839 | 403 || ((protocol == EXT_INTERFACE_UART_O2) && (externalAutoDetect >= DETECTION_UARTMUX) && (externalAutoDetect <= DETECTION_DIGO2_3)) |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
404 |
| 746 | 405 #ifdef ENABLE_CO2_SUPPORT |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
406 || ((externalAutoDetect >= DETECTION_CO2_0) && (externalAutoDetect <= DETECTION_CO2_3)) |
| 746 | 407 #endif |
| 988 | 408 #ifdef ENABLE_GNSS_EXTERN |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
409 || ((externalAutoDetect >= DETECTION_GNSS_0) && (externalAutoDetect <= DETECTION_GNSS_3)) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
410 #endif |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
411 |
| 746 | 412 #ifdef ENABLE_SENTINEL_MODE |
| 839 | 413 || ((protocol == EXT_INTERFACE_UART_SENTINEL) && (externalAutoDetect == DETECTION_SENTINEL)) |
| 746 | 414 #endif |
| 415 ) | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
416 { |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
417 lastSensorDataId = 0; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
418 externalUART_Protocol = protocol; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
419 MX_USART1_UART_DeInit(); |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
420 if( protocol != 0) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
421 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
422 MX_USART1_UART_Init(); |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
423 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
424 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
425 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
426 default: |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
427 break; |
|
704
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
428 } |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
429 } |
|
f1b40364b0af
Added protocol functions for UART DiveO2 sensor:
Ideenmodellierer
parents:
691
diff
changeset
|
430 |
| 794 | 431 uint8_t externalInterface_GetActiveUartSensor() |
| 432 { | |
| 433 return activeUartChannel; | |
| 434 } | |
| 435 | |
| 436 void externalInterface_SetSensorState(uint8_t sensorIdx, uint8_t state) | |
| 437 { | |
| 438 if(sensorIdx < EXT_INTERFACE_SENSOR_CNT) | |
| 439 { | |
| 440 externalInterface_SensorState[sensorIdx] = state; | |
| 441 } | |
| 442 } | |
| 443 | |
| 444 uint8_t externalInterface_GetSensorState(uint8_t sensorIdx) | |
| 445 { | |
| 446 uint8_t ret = COMMON_SENSOR_STATE_INVALID; | |
| 447 if(sensorIdx < EXT_INTERFACE_SENSOR_CNT) | |
| 448 { | |
| 449 ret = externalInterface_SensorState[sensorIdx]; | |
| 450 } | |
| 451 return ret; | |
| 452 } | |
| 453 | |
| 454 /* The supported sensors from GSS have different scaling factors depending on their accuracy. The factor may be read out of the sensor */ | |
| 455 void externalInterface_SetCO2Scale(float CO2Scale) | |
| 456 { | |
| 457 if((CO2Scale == 10) || (CO2Scale == 100)) | |
| 458 { | |
| 459 externalCO2Scale = CO2Scale; | |
| 460 } | |
| 461 } | |
| 462 float externalInterface_GetCO2Scale() | |
| 463 { | |
| 464 return externalCO2Scale; | |
| 465 } | |
| 466 | |
| 662 | 467 void externalInterface_SetCO2Value(uint16_t CO2_ppm) |
| 468 { | |
| 794 | 469 float local_ppm = CO2_ppm * externalCO2Scale; |
|
747
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
470 |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
471 #ifndef ENABLE_EXTERNAL_PRESSURE |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
472 float local_corr = 0.0; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
473 |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
474 if (local_ppm >= LOOKUP_CO2_CORR_TABLE_MAX) |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
475 { |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
476 local_corr = -0.0014; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
477 } |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
478 else |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
479 { |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
480 local_corr = LookupCO2PressureCorrection[((uint16_t) (local_ppm / LOOKUP_CO2_CORR_TABLE_SCALE))]; |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
481 } |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
482 local_ppm = local_ppm / (1.0 + (local_corr * (get_surface_mbar() - get_pressure_mbar()))); |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
483 #else |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
484 /* The external pressure value is passed via ADC channel2 and calibration is done at firmware => just forward sensor data */ |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
485 /* compensation is done at firmware side. This is for testing only. Take care the the same algorithm is taken as used for the lookup table */ |
|
df0d43da1614
Added pressure compensation to CO2 detection:
Ideenmodellierer
parents:
746
diff
changeset
|
486 #endif |
| 794 | 487 externalCO2Value = local_ppm / externalCO2Scale; |
| 662 | 488 } |
| 489 | |
| 490 void externalInterface_SetCO2SignalStrength(uint16_t LED_qa) | |
| 491 { | |
| 492 externalCO2SignalStrength = LED_qa; | |
| 493 } | |
| 494 | |
| 495 uint16_t externalInterface_GetCO2Value(void) | |
| 496 { | |
| 497 return externalCO2Value; | |
| 498 } | |
| 499 | |
| 500 uint16_t externalInterface_GetCO2SignalStrength(void) | |
| 501 { | |
| 502 return externalCO2SignalStrength; | |
| 503 } | |
| 504 | |
| 505 | |
| 506 void externalInterface_SetCO2State(uint16_t state) | |
| 507 { | |
| 508 externalCO2Status = state; | |
| 509 } | |
| 510 | |
| 511 uint16_t externalInterface_GetCO2State(void) | |
| 512 { | |
| 513 return externalCO2Status; | |
| 514 } | |
| 515 | |
| 1062 | 516 void externalInterface_SetBottlePressure(uint8_t bottle, uint8_t bar) |
| 517 { | |
| 518 if(bottle < PRESSURE_BOTTLE_CNT) | |
| 519 { | |
| 520 externalBottleBar[bottle] = bar; | |
| 521 } | |
| 522 } | |
| 523 | |
| 524 uint8_t externalInterface_GetBottlePressure(uint8_t bottle) | |
| 525 { | |
| 526 uint8_t ret = 0; | |
| 527 | |
| 528 if(bottle < PRESSURE_BOTTLE_CNT) | |
| 529 { | |
| 530 ret = externalBottleBar[bottle]; | |
| 531 } | |
| 532 return ret; | |
| 533 } | |
| 534 | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
535 |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
536 uint8_t externalInterface_GetSensorData(uint8_t sensorId, uint8_t* pDataStruct) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
537 { |
| 794 | 538 uint8_t index = 0; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
539 uint8_t localId = sensorId; |
| 786 | 540 if(localId == 0xFF) |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
541 { |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
542 localId = lastSensorDataId; |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
543 } |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
544 |
| 794 | 545 if((pDataStruct != NULL) && (localId <= EXT_INTERFACE_SENSOR_CNT)) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
546 { |
| 786 | 547 memcpy(pDataStruct, &sensorDataDiveO2[localId], sizeof(SSensorDataDiveO2)); |
| 548 } | |
| 549 else | |
| 550 { | |
| 551 localId = 0xFF; | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
552 } |
| 794 | 553 if(localId > MAX_ADC_CHANNEL) /* at the moment sensor visualization is focused on the three ADC channels => map Mux sensors */ |
| 554 { | |
| 555 for(index = 0; index < MAX_ADC_CHANNEL; index++) | |
| 556 { | |
| 557 if(Mux2ADCMap[index] == localId) | |
| 558 { | |
| 559 localId = index; | |
| 560 } | |
| 561 } | |
| 562 } | |
| 563 | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
564 return localId; |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
565 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
566 |
| 786 | 567 void externalInterface_SetSensorData(uint8_t sensorId, uint8_t* pDataStruct) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
568 { |
| 794 | 569 uint8_t index = 0; |
| 570 | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
571 if(pDataStruct != NULL) |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
572 { |
| 794 | 573 if((sensorId != 0xFF) && (sensorId < EXT_INTERFACE_SENSOR_CNT)) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
574 { |
| 786 | 575 memcpy(&sensorDataDiveO2[sensorId], pDataStruct, sizeof(SSensorDataDiveO2)); |
| 576 lastSensorDataId = sensorId; | |
| 804 | 577 if(sensorId >= MAX_ADC_CHANNEL) |
| 794 | 578 { |
| 804 | 579 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
| 794 | 580 { |
| 804 | 581 if(Mux2ADCMap[index] == sensorId) |
| 582 { | |
| 583 memcpy(&sensorDataDiveO2[index], pDataStruct, sizeof(SSensorDataDiveO2)); | |
| 584 lastSensorDataId = index; | |
| 585 break; | |
| 586 } | |
| 794 | 587 } |
| 588 } | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
589 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
590 else |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
591 { |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
592 memset(&sensorDataDiveO2,0,sizeof(sensorDataDiveO2)); |
| 786 | 593 lastSensorDataId = 0xFF; |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
594 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
595 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
596 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
597 |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
598 void externalInface_SetSensorMap(uint8_t* pMap) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
599 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
600 if(pMap != NULL) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
601 { |
| 794 | 602 memcpy(MasterSensorMap, pMap, EXT_INTERFACE_SENSOR_CNT); /* the map is not directly copied. Copy is done via cmd request */ |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
603 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
604 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
605 } |
| 804 | 606 |
| 607 void externalInface_MapUartToLegacyADC(uint8_t* pMap) | |
| 608 { | |
| 609 uint8_t index, index2; | |
| 610 | |
| 611 memset(Mux2ADCMap,0xFF, sizeof(Mux2ADCMap)); | |
| 612 | |
| 613 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) /* Unmap old mirror instances */ | |
| 614 { | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
615 if((pMap[index2] == SENSOR_DIGO2M) || (pMap[index2] == SENSOR_CO2M) || (pMap[index2] == SENSOR_GNSSM)) |
| 804 | 616 { |
| 617 pMap[index2] = SENSOR_NONE; | |
| 618 } | |
| 619 } | |
| 620 | |
| 621 /* Map Mux O2 sensors to ADC Slot if ADC slot is not in use */ | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
622 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++) |
| 804 | 623 { |
| 624 if(pMap[index] == SENSOR_DIGO2) | |
| 625 { | |
| 626 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) | |
| 627 { | |
| 628 if(pMap[index2] == SENSOR_NONE) | |
| 629 { | |
| 630 pMap[index2] = SENSOR_DIGO2M; /* store a mirror instance needed for visualization */ | |
| 631 Mux2ADCMap[index2] = index; | |
| 632 break; | |
| 633 } | |
| 634 } | |
| 635 } | |
| 636 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
637 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++) |
| 804 | 638 { |
| 639 if(pMap[index] == SENSOR_CO2) | |
| 640 { | |
| 641 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) | |
| 642 { | |
| 643 if(pMap[index2] == SENSOR_NONE) | |
| 644 { | |
| 645 pMap[index2] = SENSOR_CO2M; /* store a mirror instance needed for visualization */ | |
| 646 Mux2ADCMap[index2] = index; | |
| 647 break; | |
| 648 } | |
| 649 } | |
| 650 } | |
| 651 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
652 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++) |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
653 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
654 if(pMap[index] == SENSOR_GNSS) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
655 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
656 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
657 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
658 if(pMap[index2] == SENSOR_NONE) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
659 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
660 pMap[index2] = SENSOR_GNSSM; /* store a mirror instance needed for visualization */ |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
661 Mux2ADCMap[index2] = index; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
662 break; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
663 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
664 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
665 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
666 } |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
667 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
668 if(pMap[EXT_INTERFACE_MUX_OFFSET] == SENSOR_SENTINEL) |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
669 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
670 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
671 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
672 pMap[index2] = SENSOR_SENTINELM; /* store a mirror instance needed for visualization */ |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
673 Mux2ADCMap[index2] = index2 + EXT_INTERFACE_MUX_OFFSET; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
674 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
675 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
676 #endif |
| 804 | 677 } |
| 678 | |
| 731 | 679 uint8_t* externalInterface_GetSensorMapPointer(uint8_t finalMap) |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
680 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
681 uint8_t* pret; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
682 |
| 731 | 683 if((externalAutoDetect != DETECTION_OFF) && (!finalMap)) |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
684 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
685 pret = tmpSensorMap; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
686 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
687 else |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
688 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
689 pret = SensorMap; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
690 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
691 return pret; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
692 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
693 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
694 void externalInterface_AutodetectSensor() |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
695 { |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
696 static uint8_t sensorIndex = 0; |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
697 static uint8_t uartMuxChannel = 0; |
| 988 | 698 #ifdef ENABLE_GNSS_EXTERN |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
699 static uint8_t detectionDelayCnt = 0; |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
700 #endif |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
701 uint8_t index = 0; |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
702 |
| 794 | 703 uint8_t cntSensor = 0; |
| 704 uint8_t cntUARTSensor = 0; | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
705 #ifdef ENABLE_CO2_SUPPORT |
| 794 | 706 uint8_t cmdString[10]; |
| 707 uint8_t cmdLength = 0; | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
708 #endif |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
709 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
710 if(externalAutoDetect != DETECTION_OFF) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
711 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
712 switch(externalAutoDetect) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
713 { |
| 975 | 714 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0xffff; |
| 794 | 715 sensorIndex = 0; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
716 uartMuxChannel = 0; |
| 731 | 717 tmpSensorMap[0] = SENSOR_OPTIC; |
| 718 tmpSensorMap[1] = SENSOR_OPTIC; | |
| 719 tmpSensorMap[2] = SENSOR_OPTIC; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
720 tmpSensorMap[3] = SENSOR_NONE; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
721 tmpSensorMap[4] = SENSOR_NONE; |
| 804 | 722 tmpSensorMap[5] = SENSOR_NONE; |
| 723 tmpSensorMap[6] = SENSOR_NONE; | |
| 724 tmpSensorMap[7] = SENSOR_NONE; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
725 |
| 794 | 726 memset(foundSensorMap, SENSOR_NONE, sizeof(foundSensorMap)); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
727 memset(externalInterface_SensorState,UART_COMMON_INIT,sizeof(externalInterface_SensorState)); |
| 794 | 728 memset(Mux2ADCMap,0, sizeof(Mux2ADCMap)); |
| 781 | 729 |
| 731 | 730 if(externalInterfacePresent) |
| 731 { | |
| 732 externalInterface_SwitchPower33(0); | |
| 839 | 733 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF); |
| 731 | 734 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
| 735 { | |
| 736 externalChannel_mV[index] = 0; | |
| 737 } | |
| 738 externalAutoDetect = DETECTION_START; | |
| 739 } | |
| 740 else | |
| 741 { | |
| 742 externalAutoDetect = DETECTION_DONE; /* without external interface O2 values may only be received via optical port => return default sensor map */ | |
| 743 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
744 break; |
| 731 | 745 case DETECTION_START: tmpSensorMap[0] = SENSOR_ANALOG; |
| 746 tmpSensorMap[1] = SENSOR_ANALOG; | |
| 747 tmpSensorMap[2] = SENSOR_ANALOG; | |
| 748 externalInterface_SwitchPower33(1); | |
| 749 externalInterface_SwitchADC(1); | |
| 750 externalAutoDetect = DETECTION_ANALOG1; | |
| 751 break; | |
| 752 case DETECTION_ANALOG1: externalAutoDetect = DETECTION_ANALOG2; /* do a second loop to make sure all adc channels could be processed */ | |
| 753 break; | |
| 754 case DETECTION_ANALOG2: for(index = 0; index < MAX_ADC_CHANNEL; index++) | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
755 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
756 if(externalChannel_mV[index] > MIN_ADC_VOLTAGE_MV) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
757 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
758 tmpSensorMap[sensorIndex++] = SENSOR_ANALOG; |
| 794 | 759 foundSensorMap[index] = SENSOR_ANALOG; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
760 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
761 else |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
762 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
763 tmpSensorMap[sensorIndex++] = SENSOR_NONE; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
764 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
765 } |
| 804 | 766 externalInterfaceMuxReqIntervall = 1100; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
767 externalAutoDetect = DETECTION_UARTMUX; |
| 839 | 768 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
769 externalInterface_CheckBaudrate(SENSOR_DIGO2); |
| 794 | 770 UART_MUX_SelectAddress(MAX_MUX_CHANNEL); |
| 771 uartO2_SetChannel(MAX_MUX_CHANNEL); | |
| 772 activeUartChannel = MAX_MUX_CHANNEL; | |
| 773 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
774 break; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
775 case DETECTION_UARTMUX: if(uartO2_isSensorConnected()) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
776 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
777 uartMuxChannel = 1; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
778 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
779 foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
780 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
781 else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
782 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
783 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
784 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
785 externalAutoDetect = DETECTION_DIGO2_0; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
786 uartO2_SetChannel(0); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
787 activeUartChannel = 0; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
788 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
789 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
790 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
791 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
792 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
793 UART_MUX_SelectAddress(0); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
794 } |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
795 break; |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
796 case DETECTION_DIGO2_0: |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
797 case DETECTION_DIGO2_1: |
| 781 | 798 case DETECTION_DIGO2_2: |
| 799 case DETECTION_DIGO2_3: | |
| 794 | 800 if(uartO2_isSensorConnected()) |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
801 { |
| 794 | 802 foundSensorMap[externalAutoDetect - DETECTION_DIGO2_0 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; |
| 781 | 803 } |
| 804 | 804 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
805 if(uartMuxChannel) |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
806 { |
| 839 | 807 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); |
| 794 | 808 UART_MUX_SelectAddress(uartMuxChannel); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
809 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
| 794 | 810 uartO2_SetChannel(uartMuxChannel); |
| 811 activeUartChannel = uartMuxChannel; | |
| 812 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; | |
| 813 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; | |
| 814 | |
| 815 if(uartMuxChannel < MAX_MUX_CHANNEL - 1) | |
| 784 | 816 { |
| 817 uartMuxChannel++; | |
| 818 } | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
819 } |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
820 else |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
821 { |
| 781 | 822 externalAutoDetect = DETECTION_DIGO2_3; /* skip detection of other serial sensors */ |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
823 } |
| 742 | 824 externalAutoDetect++; |
| 825 #ifdef ENABLE_CO2_SUPPORT | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
826 if(externalAutoDetect == DETECTION_CO2_0) |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
827 { |
| 809 | 828 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
| 829 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) | |
| 830 { | |
| 831 UART_MUX_SelectAddress(0); | |
| 832 } | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
833 activeUartChannel = 0; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
834 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
835 uartMuxChannel = 1; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
836 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_CO2; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
837 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
| 809 | 838 externalInterface_CheckBaudrate(SENSOR_CO2); |
| 839 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) /* switch sensor operation mode depending on HW config */ | |
| 794 | 840 { |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
841 uartCo2_SendCmd(CO2CMD_MODE_POLL, cmdString, &cmdLength); |
| 794 | 842 } |
| 843 else | |
| 844 { | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
845 uartCo2_SendCmd(CO2CMD_MODE_STREAM, cmdString, &cmdLength); |
| 794 | 846 } |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
847 } |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
848 break; |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
849 case DETECTION_CO2_0: |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
850 case DETECTION_CO2_1: |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
851 case DETECTION_CO2_2: |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
852 case DETECTION_CO2_3: if(uartCo2_isSensorConnected()) |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
853 { |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
854 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_CO2; |
| 988 | 855 #ifdef ENABLE_GNSS_EXTERN |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
856 externalAutoDetect = DETECTION_GNSS_0; /* only one CO2 sensor supported */ |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
857 #else |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
858 externalAutoDetect = DETECTION_DONE; /* only one CO2 sensor supported */ |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
859 #endif |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
860 } |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
861 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
862 { |
| 809 | 863 externalInterface_CheckBaudrate(SENSOR_DIGO2); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
864 UART_MUX_SelectAddress(uartMuxChannel); |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
865 activeUartChannel = uartMuxChannel; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
866 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
867 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
868 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT; |
| 809 | 869 externalInterface_CheckBaudrate(SENSOR_CO2); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
870 uartCo2_SendCmd(CO2CMD_MODE_POLL, cmdString, &cmdLength); |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
871 externalAutoDetect++; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
872 uartMuxChannel++; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
873 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
874 else |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
875 { |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
876 |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
877 |
| 988 | 878 #if defined ENABLE_SENTINEL_MODE || defined ENABLE_GNSS_EXTERN |
| 879 #ifdef ENABLE_GNSS_EXTERN | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
880 externalAutoDetect = DETECTION_GNSS_0; |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
881 externalInterface_SwitchUART(EXT_INTERFACE_UART_GNSS); |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
882 #else |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
883 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
884 externalAutoDetect = DETECTION_SENTINEL; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
885 #endif |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
886 #endif |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
887 #else |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
888 externalAutoDetect = DETECTION_DONE; |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
889 #endif |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
890 } |
| 742 | 891 #endif |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
892 |
| 988 | 893 #ifdef ENABLE_GNSS_EXTERN |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
894 if(externalAutoDetect == DETECTION_GNSS_0) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
895 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
896 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
897 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
898 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
899 externalInterface_CheckBaudrate(SENSOR_DIGO2); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
900 UART_MUX_SelectAddress(0); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
901 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
902 activeUartChannel = 0; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
903 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
904 uartMuxChannel = 1; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
905 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_GNSS; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
906 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
907 externalInterface_CheckBaudrate(SENSOR_GNSS); |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
908 externalInterfaceMuxReqIntervall = 500; /* iterations needed for module config */ |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
909 detectionDelayCnt = 6; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
910 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
911 break; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
912 case DETECTION_GNSS_0: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
913 case DETECTION_GNSS_1: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
914 case DETECTION_GNSS_2: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
915 case DETECTION_GNSS_3: if(detectionDelayCnt == 0) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
916 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
917 if(uartGnss_isSensorConnected()) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
918 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
919 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_GNSS; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
920 #ifdef ENABLE_SENTINEL_MODE |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
921 externalAutoDetect = DETECTION_SENTINEL; /* only one GNSS sensor supported */ |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
922 #else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
923 externalAutoDetect = DETECTION_DONE; /* only one GNSS sensor supported */ |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
924 #endif |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
925 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
926 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
927 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
928 externalInterface_CheckBaudrate(SENSOR_DIGO2); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
929 UART_MUX_SelectAddress(uartMuxChannel); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
930 activeUartChannel = uartMuxChannel; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
931 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
932 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
933 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
934 externalInterface_CheckBaudrate(SENSOR_CO2); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
935 // uartGnss_SendCmd(GNSSCMD_MODE_POLL, cmdString, &cmdLength); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
936 externalAutoDetect++; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
937 detectionDelayCnt = 3; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
938 uartMuxChannel++; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
939 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
940 else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
941 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
942 #ifdef ENABLE_SENTINEL_MODE |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
943 externalAutoDetect = DETECTION_SENTINEL; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
944 #else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
945 externalAutoDetect = DETECTION_DONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
946 #endif |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
947 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
948 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
949 else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
950 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
951 detectionDelayCnt--; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
952 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
953 #endif |
| 742 | 954 #ifdef ENABLE_SENTINEL_MODE |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
955 if(externalAutoDetect == DETECTION_SENTINEL) |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
956 { |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
957 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
958 uartO2_SetChannel(0); |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
959 activeUartChannel = 0; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
960 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_SENTINEL; |
| 839 | 961 externalInterface_SwitchUART(EXT_INTERFACE_UART_SENTINEL); |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
962 externalInterface_CheckBaudrate(SENSOR_SENTINEL); |
| 932 | 963 UART_StartDMA_Receiption(&Uart1Ctrl); |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
964 } |
| 742 | 965 break; |
| 966 | |
| 967 case DETECTION_SENTINEL: | |
| 968 case DETECTION_SENTINEL2: | |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
969 if(uartSentinel_isSensorConnected()) |
| 742 | 970 { |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
971 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_MUX_OFFSET+3; index++) |
| 742 | 972 { |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
973 foundSensorMap[index] = SENSOR_SENTINEL; |
| 742 | 974 } |
| 975 } | |
| 976 externalAutoDetect++; | |
| 977 #endif | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
978 break; |
| 794 | 979 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF; |
| 839 | 980 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF); |
| 794 | 981 activeUartChannel = 0xFF; |
| 982 cntSensor = 0; | |
| 983 cntUARTSensor = 0; | |
| 984 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++) | |
| 731 | 985 { |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
986 if((foundSensorMap[index] >= SENSOR_ANALOG) && (foundSensorMap[index] < SENSOR_MUX)) |
| 794 | 987 { |
| 988 cntSensor++; | |
| 989 } | |
| 784 | 990 |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
991 if((foundSensorMap[index] == SENSOR_DIGO2) || (foundSensorMap[index] == SENSOR_CO2) || (foundSensorMap[index] == SENSOR_GNSS)) |
| 794 | 992 { |
| 993 cntUARTSensor++; | |
| 994 } | |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
995 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
996 if(foundSensorMap[index] == SENSOR_SENTINEL) /* The Sentinel has a fixed setup */ |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
997 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
998 cntSensor = 3; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
999 cntUARTSensor = 1; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1000 break; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1001 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1002 #endif |
| 786 | 1003 } |
| 804 | 1004 externalInface_MapUartToLegacyADC(foundSensorMap); |
| 794 | 1005 externalInterfaceMuxReqIntervall = 0xFFFF; |
| 1006 if(cntSensor == 0) /* return default sensor map if no sensor at all has been detected */ | |
| 784 | 1007 { |
| 794 | 1008 foundSensorMap[0] = SENSOR_OPTIC; |
| 1009 foundSensorMap[1] = SENSOR_OPTIC; | |
| 1010 foundSensorMap[2] = SENSOR_OPTIC; | |
| 1011 } | |
| 1012 else | |
| 1013 { | |
| 1014 if(cntUARTSensor != 0) | |
| 784 | 1015 { |
| 794 | 1016 externalInterfaceMuxReqIntervall = REQUEST_INT_SENSOR_MS / cntUARTSensor; |
| 1062 | 1017 if(foundSensorMap[0] == SENSOR_SENTINELM) /* special case: Sentinel sends combined data */ |
| 1018 { | |
| 1019 externalInterfaceMuxReqIntervall = 4000; | |
| 1020 } | |
| 784 | 1021 } |
| 1022 } | |
| 794 | 1023 memcpy(SensorMap, foundSensorMap, sizeof(foundSensorMap)); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1024 memset(externalInterface_SensorState, UART_COMMON_INIT, sizeof(externalInterface_SensorState)); |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1025 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1026 default: |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1027 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1028 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1029 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1030 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1031 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1032 |
| 662 | 1033 void externalInterface_ExecuteCmd(uint16_t Cmd) |
| 1034 { | |
| 1035 char cmdString[10]; | |
| 1036 uint8_t cmdLength = 0; | |
| 804 | 1037 uint8_t index; |
| 794 | 1038 uint8_t cntUARTSensor = 0; |
| 662 | 1039 |
| 1040 switch(Cmd & 0x00FF) /* lower byte is reserved for commands */ | |
| 1041 { | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1042 case EXT_INTERFACE_AUTODETECT: externalAutoDetect = DETECTION_INIT; |
| 742 | 1043 for(index = 0; index < 3; index++) |
| 1044 { | |
| 1045 SensorMap[index] = SENSOR_SEARCH; | |
| 1046 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1047 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1048 case EXT_INTERFACE_COPY_SENSORMAP: if(externalAutoDetect == DETECTION_OFF) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1049 { |
| 794 | 1050 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap)); |
| 1051 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++) | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1052 { |
| 1062 | 1053 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2) || (SensorMap[index] == SENSOR_GNSS) || (SensorMap[index] == SENSOR_SENTINEL)) |
| 794 | 1054 { |
| 1055 cntUARTSensor++; | |
| 1056 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1057 } |
| 804 | 1058 externalInface_MapUartToLegacyADC(SensorMap); |
| 794 | 1059 if(cntUARTSensor > 0) |
| 1060 { | |
| 1061 externalInterfaceMuxReqIntervall = REQUEST_INT_SENSOR_MS / cntUARTSensor; | |
| 1062 activeUartChannel = 0xFF; | |
| 1062 | 1063 |
| 1064 if(SensorMap[0] == SENSOR_SENTINELM) /* special case: Sentinel sends compined data */ | |
| 1065 { | |
| 1066 externalInterfaceMuxReqIntervall = 4000; | |
| 1067 } | |
| 794 | 1068 } |
| 1069 else | |
| 1070 { | |
| 1071 externalInterfaceMuxReqIntervall = 0xFFFF; | |
| 1072 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1073 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1074 break; |
|
957
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1075 case EXT_INTERFACE_CO2_CALIB: index = (Cmd >> 8) & 0x000F; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1076 if(SensorMap[index] == SENSOR_CO2M) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1077 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1078 index = Mux2ADCMap[index]; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1079 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1080 if(SensorMap[index] == SENSOR_CO2) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1081 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1082 externalInterface_SensorState[index] = UART_CO2_CALIBRATE; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1083 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1084 break; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1085 case EXT_INTERFACE_O2_INDICATE: index = (Cmd >> 8) & 0x000F; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1086 if(SensorMap[index] == SENSOR_DIGO2M) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1087 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1088 index = Mux2ADCMap[index]; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1089 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1090 if(SensorMap[index] == SENSOR_DIGO2) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1091 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1092 externalInterface_SensorState[index] = UART_O2_CHECK; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1093 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1094 break; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1095 |
| 662 | 1096 default: |
| 1097 break; | |
| 1098 } | |
| 1099 if(cmdLength != 0) | |
| 1100 { | |
| 1101 HAL_UART_Transmit(&huart1,(uint8_t*)cmdString,cmdLength,10); | |
| 1102 } | |
| 1103 return; | |
| 1104 } | |
| 1105 | |
| 794 | 1106 uint8_t ExternalInterface_SelectUsedMuxChannel(uint8_t currentChannel) |
| 1107 { | |
| 1108 uint8_t index = currentChannel; | |
| 1109 uint8_t newChannel = index; | |
| 1110 uint8_t *pmap = externalInterface_GetSensorMapPointer(0); | |
| 1111 | |
| 1112 do | |
| 1113 { | |
| 1114 index++; | |
| 1115 if(index == MAX_MUX_CHANNEL) | |
| 1116 { | |
| 1117 index = 0; | |
| 1118 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
1119 if(((pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_DIGO2) |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
1120 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_CO2) |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
1121 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_GNSS)) |
| 794 | 1122 && (index != activeUartChannel)) |
| 1123 { | |
| 1124 newChannel = index; | |
| 1125 break; | |
| 1126 } | |
| 1127 } while(index != currentChannel); | |
| 1128 | |
| 1129 return newChannel; | |
| 1130 } | |
| 1131 | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1132 void externalInterface_CheckBaudrate(uint8_t sensorType) |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1133 { |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1134 uint32_t newBaudrate = 0; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1135 |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1136 switch(sensorType) |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1137 { |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1138 case SENSOR_GNSS: |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1139 case SENSOR_SENTINEL: |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1140 case SENSOR_CO2: newBaudrate = 9600; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1141 break; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1142 case SENSOR_DIGO2: |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1143 default: newBaudrate = 19200; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1144 break; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1145 } |
| 809 | 1146 if(huart1.Init.BaudRate != newBaudrate) |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1147 { |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1148 UART_ChangeBaudrate(newBaudrate); |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1149 } |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1150 } |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1151 |
| 794 | 1152 void externalInterface_HandleUART() |
| 1153 { | |
| 1154 static uint8_t retryRequest = 0; | |
| 1155 static uint32_t lastRequestTick = 0; | |
| 1156 static uint32_t TriggerTick = 0; | |
| 1157 uint8_t index = 0; | |
| 1158 static uint8_t timeToTrigger = 0; | |
| 1159 uint32_t tick = HAL_GetTick(); | |
| 1160 uint8_t *pmap = externalInterface_GetSensorMapPointer(0); | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1161 uint8_t forceMuxChannel = 0; |
| 794 | 1162 |
| 1163 | |
| 1164 if(externalInterfaceMuxReqIntervall != 0xFFFF) | |
| 1165 { | |
| 804 | 1166 if(activeUartChannel == 0xFF) |
| 1167 { | |
| 809 | 1168 MX_USART1_UART_Init(); |
| 804 | 1169 activeUartChannel = ExternalInterface_SelectUsedMuxChannel(0); |
| 1170 uartO2_SetChannel(activeUartChannel); | |
| 1171 | |
| 1172 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]) | |
| 1173 { | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1174 case SENSOR_DIGO2: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1175 case SENSOR_GNSS: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1176 case SENSOR_CO2: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1177 case SENSOR_SENTINEL: externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1178 break; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1179 default: externalInterface_CheckBaudrate(SENSOR_DIGO2); |
| 804 | 1180 break; |
| 1181 } | |
| 1182 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) | |
| 1183 { | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1184 HAL_Delay(10); /* make sure MUX is available for reception after wakeup */ |
| 804 | 1185 UART_MUX_SelectAddress(activeUartChannel); |
| 1186 } | |
| 1187 } | |
| 1188 | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1189 if(externalInterface_SensorState[activeSensorId] != UART_COMMON_INIT) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1190 { |
| 976 | 1191 UART_ReadData(pmap[activeSensorId], 0); |
| 932 | 1192 UART_WriteData(&Uart1Ctrl); |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1193 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1194 if(externalInterface_SensorState[activeSensorId] == UART_COMMON_INIT) |
| 794 | 1195 { |
| 1196 lastRequestTick = tick; | |
| 1197 TriggerTick = tick - 10; /* just to make sure control is triggered */ | |
| 1198 timeToTrigger = 1; | |
| 1199 retryRequest = 0; | |
| 1200 } | |
| 1062 | 1201 else if(((retryRequest == 0) && (pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET] != SENSOR_SENTINEL) /* timeout or error */ |
| 794 | 1202 && (((time_elapsed_ms(lastRequestTick,tick) > (TIMEOUT_SENSOR_ANSWER)) && (externalInterface_SensorState[activeSensorId] != UART_O2_IDLE)) /* retry if no answer after half request interval */ |
| 1203 || (externalInterface_SensorState[activeSensorId] == UART_O2_ERROR)))) | |
| 1204 { | |
| 1205 /* The channel switch will cause the sensor to respond with an error message. */ | |
| 1206 /* The sensor needs ~30ms to recover before he is ready to receive the next command => transmission delay needed */ | |
| 1207 | |
| 1208 TriggerTick = tick; | |
| 1209 timeToTrigger = COMMAND_TX_DELAY; | |
| 1210 retryRequest = 1; | |
| 1211 } | |
| 1212 else if(time_elapsed_ms(lastRequestTick,tick) > externalInterfaceMuxReqIntervall) /* switch sensor and / or trigger next request */ | |
| 1213 { | |
| 975 | 1214 if(timeToTrigger == 0) /* no pending action */ |
| 1215 { | |
| 1216 TriggerTick = tick; | |
| 1217 retryRequest = 0; | |
| 1218 timeToTrigger = 1; | |
| 794 | 1219 |
| 975 | 1220 if((externalInterface_SensorState[activeSensorId] == UART_O2_REQ_O2) /* timeout */ |
| 1221 || (externalInterface_SensorState[activeSensorId] == UART_O2_REQ_RAW) | |
| 1222 || (externalInterface_SensorState[activeSensorId] == UART_CO2_OPERATING) | |
| 1223 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_PVT) | |
| 1062 | 1224 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_SAT) |
| 1225 || (externalInterface_SensorState[activeSensorId] == UART_SENTINEL_OPERATING)) | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1226 { |
| 975 | 1227 forceMuxChannel = 1; |
| 1228 externalInterface_SensorState[activeSensorId] = UART_O2_IDLE; | |
| 1229 switch(pmap[activeSensorId]) | |
| 1230 { | |
| 1231 case SENSOR_DIGO2: setExternalInterfaceChannel(activeSensorId,0.0); | |
| 1232 break; | |
| 1233 case SENSOR_CO2: externalInterface_SetCO2Value(0.0); | |
| 1234 externalInterface_SetCO2State(0); | |
| 1235 break; | |
| 1062 | 1236 case SENSOR_SENTINEL: setExternalInterfaceChannel(0,0.0); |
| 1237 setExternalInterfaceChannel(1,0.0); | |
| 1238 setExternalInterfaceChannel(2,0.0); | |
| 1239 externalInterface_SetBottlePressure(0,0); | |
| 1240 externalInterface_SetBottlePressure(1,0); | |
| 1241 break; | |
| 975 | 1242 default: |
| 1243 break; | |
| 1244 } | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1245 } |
| 975 | 1246 if((externalInterface_SensorState[activeSensorId] == UART_CO2_SETUP) /* timeout while setting up sensors */ |
| 1247 || (externalInterface_SensorState[activeSensorId] == UART_O2_CHECK)) | |
| 1248 { | |
| 1249 forceMuxChannel = 1; | |
| 1250 } | |
|
956
083afabc6578
Bugfix UART sensor MUX channel selection after sleep:
Ideenmodellierer
parents:
932
diff
changeset
|
1251 |
| 794 | 1252 |
| 975 | 1253 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) /* select next sensor if mux is connected */ |
| 794 | 1254 { |
| 975 | 1255 if(activeUartChannel < MAX_MUX_CHANNEL) |
| 794 | 1256 { |
| 975 | 1257 index = ExternalInterface_SelectUsedMuxChannel(activeUartChannel); |
| 1258 if((index != activeUartChannel) || (forceMuxChannel)) | |
| 794 | 1259 { |
| 975 | 1260 forceMuxChannel = 0; |
| 1261 timeToTrigger = 100; | |
| 1262 activeUartChannel = index; | |
| 1263 switch(pmap[index + EXT_INTERFACE_MUX_OFFSET]) | |
| 1264 { | |
| 1265 case SENSOR_DIGO2: uartO2_SetChannel(activeUartChannel); | |
| 1266 /* no break */ | |
| 1267 case SENSOR_CO2: | |
| 1268 case SENSOR_GNSS: externalInterface_CheckBaudrate(SENSOR_MUX); | |
| 1269 UART_MUX_SelectAddress(activeUartChannel); | |
| 1270 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); | |
| 1271 break; | |
| 1272 default: | |
| 1273 break; | |
| 1274 } | |
| 794 | 1275 } |
| 1276 } | |
| 1277 } | |
| 1278 } | |
| 1279 } | |
| 1280 if((timeToTrigger != 0) && (time_elapsed_ms(TriggerTick,tick) > timeToTrigger)) | |
| 1281 { | |
| 975 | 1282 lastRequestTick = tick; |
| 794 | 1283 timeToTrigger = 0; |
| 1284 switch (pmap[activeSensorId]) | |
| 1285 { | |
| 1286 case SENSOR_MUX: | |
| 1287 case SENSOR_DIGO2: uartO2_Control(); | |
| 1288 break; | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1289 #ifdef ENABLE_CO2_SUPPORT |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1290 case SENSOR_CO2: uartCo2_Control(); |
| 794 | 1291 break; |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1292 #endif |
| 988 | 1293 #ifdef ENABLE_GNSS_EXTERN |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1294 case SENSOR_GNSS: uartGnss_Control(); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1295 break; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1296 #endif |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1297 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1298 case SENSOR_SENTINEL: uartSentinel_Control(); |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1299 break; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1300 #endif |
| 794 | 1301 default: |
| 1302 break; | |
| 1303 } | |
| 1304 } | |
| 1305 } | |
| 1306 } |