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