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