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