Mercurial > public > ostc4
annotate Small_CPU/Src/externalInterface.c @ 1081:1b38d7b8da35 Icon_Integration
Send sensor data cyclic:
In the previous version the sensor data which had been updated at last was send to the main CPU. With the introduction of the hud a second device is sending sensor data information => in case of fast sensor data updated it could happen that a sensor data record was never transmitted. To avoid this the sensor data of all sensor slots is now transmitted on a cyclic basis.
| author | Ideenmodellierer |
|---|---|
| date | Sun, 15 Mar 2026 21:28:53 +0100 |
| parents | b02311fbb1e1 |
| 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 { |
| 1081 | 550 static uint8_t cyclingSensorId = 0; |
| 794 | 551 uint8_t index = 0; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
552 uint8_t localId = sensorId; |
| 786 | 553 if(localId == 0xFF) |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
554 { |
| 1081 | 555 if(lastSensorDataId != 0xFF) |
| 556 { | |
| 557 localId = lastSensorDataId; | |
| 558 lastSensorDataId = 0xFF; | |
| 559 } | |
| 560 else | |
| 561 { | |
| 562 localId = cyclingSensorId; | |
| 563 cyclingSensorId++; | |
| 564 if(cyclingSensorId == EXT_INTERFACE_SENSOR_CNT) | |
| 565 { | |
| 566 cyclingSensorId = 0; | |
| 567 } | |
| 568 } | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
569 } |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
570 |
| 794 | 571 if((pDataStruct != NULL) && (localId <= EXT_INTERFACE_SENSOR_CNT)) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
572 { |
| 1077 | 573 externalInterface_CopySensorData(localId, pDataStruct, &sensorData[localId][0]); |
| 786 | 574 } |
| 575 else | |
| 576 { | |
| 577 localId = 0xFF; | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
578 } |
| 794 | 579 if(localId > MAX_ADC_CHANNEL) /* at the moment sensor visualization is focused on the three ADC channels => map Mux sensors */ |
| 580 { | |
| 581 for(index = 0; index < MAX_ADC_CHANNEL; index++) | |
| 582 { | |
| 583 if(Mux2ADCMap[index] == localId) | |
| 584 { | |
| 585 localId = index; | |
| 586 } | |
| 587 } | |
| 588 } | |
| 589 | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
590 return localId; |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
591 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
592 |
| 1081 | 593 void externalInterface_ResetSensorData(uint8_t sensorId) |
| 594 { | |
| 595 if(sensorId < EXT_INTERFACE_SENSOR_CNT) | |
| 596 { | |
| 597 memset(&sensorData[sensorId],0,EXTIF_SENSOR_INFO_SIZE); | |
| 598 } | |
| 599 } | |
| 786 | 600 void externalInterface_SetSensorData(uint8_t sensorId, uint8_t* pDataStruct) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
601 { |
| 794 | 602 uint8_t index = 0; |
| 603 | |
| 1081 | 604 if((pDataStruct != NULL) && (sensorId < EXT_INTERFACE_SENSOR_CNT)) |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
605 { |
| 1081 | 606 externalInterface_CopySensorData(sensorId, &sensorData[sensorId][0], pDataStruct); |
| 607 lastSensorDataId = sensorId; | |
| 608 if(sensorId >= MAX_ADC_CHANNEL) | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
609 { |
| 1081 | 610 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
| 794 | 611 { |
| 1081 | 612 if(Mux2ADCMap[index] == sensorId) |
| 794 | 613 { |
| 1081 | 614 externalInterface_CopySensorData(index, &sensorData[index][0], pDataStruct); |
| 615 lastSensorDataId = index; | |
| 616 break; | |
| 794 | 617 } |
| 618 } | |
|
714
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
619 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
620 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
621 } |
|
045ff7800501
Added customizable data area for specific sensor data:
Ideenmodellierer
parents:
704
diff
changeset
|
622 |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
623 void externalInface_SetSensorMap(uint8_t* pMap) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
624 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
625 if(pMap != NULL) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
626 { |
| 794 | 627 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
|
628 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
629 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
630 } |
| 804 | 631 |
| 632 void externalInface_MapUartToLegacyADC(uint8_t* pMap) | |
| 633 { | |
| 634 uint8_t index, index2; | |
| 635 | |
| 636 memset(Mux2ADCMap,0xFF, sizeof(Mux2ADCMap)); | |
| 637 | |
| 638 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) /* Unmap old mirror instances */ | |
| 639 { | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
640 if((pMap[index2] == SENSOR_DIGO2M) || (pMap[index2] == SENSOR_CO2M) || (pMap[index2] == SENSOR_GNSSM)) |
| 804 | 641 { |
| 642 pMap[index2] = SENSOR_NONE; | |
| 643 } | |
| 644 } | |
| 645 | |
| 646 /* 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
|
647 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++) |
| 804 | 648 { |
| 649 if(pMap[index] == SENSOR_DIGO2) | |
| 650 { | |
| 651 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) | |
| 652 { | |
| 653 if(pMap[index2] == SENSOR_NONE) | |
| 654 { | |
| 655 pMap[index2] = SENSOR_DIGO2M; /* store a mirror instance needed for visualization */ | |
| 656 Mux2ADCMap[index2] = index; | |
| 657 break; | |
| 658 } | |
| 659 } | |
| 660 } | |
| 661 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
662 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++) |
| 804 | 663 { |
| 664 if(pMap[index] == SENSOR_CO2) | |
| 665 { | |
| 666 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) | |
| 667 { | |
| 668 if(pMap[index2] == SENSOR_NONE) | |
| 669 { | |
| 670 pMap[index2] = SENSOR_CO2M; /* store a mirror instance needed for visualization */ | |
| 671 Mux2ADCMap[index2] = index; | |
| 672 break; | |
| 673 } | |
| 674 } | |
| 675 } | |
| 676 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
677 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
|
678 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
679 if(pMap[index] == SENSOR_GNSS) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
680 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
681 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
682 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
683 if(pMap[index2] == SENSOR_NONE) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
684 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
685 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
|
686 Mux2ADCMap[index2] = index; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
687 break; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
688 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
689 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
690 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
691 } |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
692 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
693 if(pMap[EXT_INTERFACE_MUX_OFFSET] == SENSOR_SENTINEL) |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
694 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
695 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
696 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
697 pMap[index2] = SENSOR_SENTINELM; /* store a mirror instance needed for visualization */ |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
698 Mux2ADCMap[index2] = index2 + EXT_INTERFACE_MUX_OFFSET; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
699 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
700 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
701 #endif |
| 804 | 702 } |
| 703 | |
| 731 | 704 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
|
705 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
706 uint8_t* pret; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
707 |
| 731 | 708 if((externalAutoDetect != DETECTION_OFF) && (!finalMap)) |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
709 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
710 pret = tmpSensorMap; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
711 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
712 else |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
713 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
714 pret = SensorMap; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
715 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
716 return pret; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
717 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
718 |
| 1080 | 719 static externalInterfaceAutoDetect_t externalInterface_NextUartTypeDetection(externalInterfaceSensorType* pCurrenttype) |
| 720 { | |
| 721 uint8_t index = 0; | |
| 722 externalInterfaceAutoDetect_t nextDetectionStep = DETECTION_DONE; | |
| 723 | |
| 724 while(uartTypeDetection[index] != SENSOR_END) | |
| 725 { | |
| 726 if(uartTypeDetection[index] == *pCurrenttype) | |
| 727 { | |
| 728 break; | |
| 729 } | |
| 730 index++; | |
| 731 } | |
| 732 | |
| 733 if(uartTypeDetection[index] != SENSOR_END) | |
| 734 { | |
| 735 index++; | |
| 736 if(uartTypeDetection[index] != SENSOR_END) | |
| 737 { | |
| 738 externalAutoDetect = DETECTION_UART0; | |
| 739 *pCurrenttype = uartTypeDetection[index]; | |
| 740 switch(*pCurrenttype) /* sensor type specific initialization */ | |
| 741 { | |
| 742 case SENSOR_DIGO2: uartO2_SetChannel(0); | |
| 743 break; | |
| 744 case SENSOR_GNSS: /* TODO: implement faster call cycles for external GNSS */ | |
| 745 /* externalInterfaceMuxReqIntervall = 500; */ | |
| 746 /* iterations needed for module config */ | |
| 747 /* detectionDelayCnt = 6; */ | |
| 748 break; | |
| 749 default: | |
| 750 break; | |
| 751 } | |
| 752 | |
| 753 activeUartChannel = 0; | |
| 754 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = *pCurrenttype; | |
| 755 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; | |
| 756 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) | |
| 757 { | |
| 758 externalInterface_CheckBaudrate(SENSOR_MUX); | |
| 759 UART_MUX_SelectAddress(0); | |
| 760 } | |
| 761 nextDetectionStep = DETECTION_UART0; | |
| 762 } | |
| 763 } | |
| 764 return nextDetectionStep; | |
| 765 } | |
| 766 | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
767 void externalInterface_AutodetectSensor() |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
768 { |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
769 static uint8_t sensorIndex = 0; |
|
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
770 static uint8_t uartMuxChannel = 0; |
| 1080 | 771 static externalInterfaceSensorType currentUartType = SENSOR_MUX; |
| 988 | 772 #ifdef ENABLE_GNSS_EXTERN |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
773 static uint8_t detectionDelayCnt = 0; |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
774 #endif |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
775 uint8_t index = 0; |
| 1080 | 776 uint8_t sensorFound = 0; |
| 794 | 777 uint8_t cntSensor = 0; |
| 778 uint8_t cntUARTSensor = 0; | |
| 1080 | 779 uint8_t nextType = 0; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
780 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
781 if(externalAutoDetect != DETECTION_OFF) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
782 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
783 switch(externalAutoDetect) |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
784 { |
| 975 | 785 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0xffff; |
| 1080 | 786 currentUartType = SENSOR_MUX; |
| 794 | 787 sensorIndex = 0; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
788 uartMuxChannel = 0; |
| 731 | 789 tmpSensorMap[0] = SENSOR_OPTIC; |
| 790 tmpSensorMap[1] = SENSOR_OPTIC; | |
| 791 tmpSensorMap[2] = SENSOR_OPTIC; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
792 tmpSensorMap[3] = SENSOR_NONE; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
793 tmpSensorMap[4] = SENSOR_NONE; |
| 804 | 794 tmpSensorMap[5] = SENSOR_NONE; |
| 795 tmpSensorMap[6] = SENSOR_NONE; | |
| 796 tmpSensorMap[7] = SENSOR_NONE; | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
797 |
| 794 | 798 memset(foundSensorMap, SENSOR_NONE, sizeof(foundSensorMap)); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
799 memset(externalInterface_SensorState,UART_COMMON_INIT,sizeof(externalInterface_SensorState)); |
| 794 | 800 memset(Mux2ADCMap,0, sizeof(Mux2ADCMap)); |
| 781 | 801 |
| 731 | 802 if(externalInterfacePresent) |
| 803 { | |
| 804 externalInterface_SwitchPower33(0); | |
| 839 | 805 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF); |
| 731 | 806 for(index = 0; index < MAX_ADC_CHANNEL; index++) |
| 807 { | |
| 808 externalChannel_mV[index] = 0; | |
| 809 } | |
| 810 externalAutoDetect = DETECTION_START; | |
| 811 } | |
| 812 else | |
| 813 { | |
| 814 externalAutoDetect = DETECTION_DONE; /* without external interface O2 values may only be received via optical port => return default sensor map */ | |
| 815 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
816 break; |
| 731 | 817 case DETECTION_START: tmpSensorMap[0] = SENSOR_ANALOG; |
| 818 tmpSensorMap[1] = SENSOR_ANALOG; | |
| 819 tmpSensorMap[2] = SENSOR_ANALOG; | |
| 820 externalInterface_SwitchPower33(1); | |
| 821 externalInterface_SwitchADC(1); | |
| 822 externalAutoDetect = DETECTION_ANALOG1; | |
| 823 break; | |
| 824 case DETECTION_ANALOG1: externalAutoDetect = DETECTION_ANALOG2; /* do a second loop to make sure all adc channels could be processed */ | |
| 825 break; | |
| 826 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
|
827 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
828 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
|
829 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
830 tmpSensorMap[sensorIndex++] = SENSOR_ANALOG; |
| 794 | 831 foundSensorMap[index] = SENSOR_ANALOG; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
832 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
833 else |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
834 { |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
835 tmpSensorMap[sensorIndex++] = SENSOR_NONE; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
836 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
837 } |
| 804 | 838 externalInterfaceMuxReqIntervall = 1100; |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
839 externalAutoDetect = DETECTION_UARTMUX; |
| 839 | 840 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
841 externalInterface_CheckBaudrate(SENSOR_DIGO2); |
| 794 | 842 UART_MUX_SelectAddress(MAX_MUX_CHANNEL); |
| 843 uartO2_SetChannel(MAX_MUX_CHANNEL); | |
| 844 activeUartChannel = MAX_MUX_CHANNEL; | |
| 845 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
|
846 break; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
847 case DETECTION_UARTMUX: if(uartO2_isSensorConnected()) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
848 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
849 uartMuxChannel = 1; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
850 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
851 foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
852 } |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
853 else |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
854 { |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
855 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
856 } |
| 1080 | 857 externalAutoDetect = externalInterface_NextUartTypeDetection(¤tUartType); |
| 858 externalInterface_CheckBaudrate(currentUartType); | |
|
779
0b5f45448eb6
Added UART multiplexer support for DiveO2:
Ideenmodellierer
parents:
753
diff
changeset
|
859 break; |
| 1080 | 860 case DETECTION_UART0: |
| 861 case DETECTION_UART1: | |
| 862 case DETECTION_UART2: | |
| 863 case DETECTION_UART3: switch(currentUartType) | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
864 { |
| 1080 | 865 case SENSOR_DIGO2: if(uartO2_isSensorConnected()) { sensorFound = 1; } |
| 866 break; | |
| 867 case SENSOR_CO2: if(uartCo2_isSensorConnected()) { sensorFound = 1; nextType = 1;} | |
| 868 break; | |
| 869 #ifdef ENABLE_HUD_SUPPORT | |
| 870 case SENSOR_HUD: if(uartHUD_isSensorConnected()) { sensorFound = 1; nextType = 1;} | |
| 871 break; | |
| 872 #endif | |
| 873 default: | |
| 874 break; | |
| 781 | 875 } |
| 1080 | 876 if(sensorFound) |
| 877 { | |
| 878 foundSensorMap[externalAutoDetect - DETECTION_UART0 + EXT_INTERFACE_MUX_OFFSET] = currentUartType; | |
| 879 } | |
| 880 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
|
881 { |
| 1080 | 882 uartMuxChannel = 1; |
| 883 } | |
| 884 tmpSensorMap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; /* reset detection slot */ | |
| 885 if((uartMuxChannel) && (externalAutoDetect != DETECTION_UART3) && (nextType == 0)) | |
| 886 { | |
| 887 externalInterface_CheckBaudrate(SENSOR_MUX); | |
| 794 | 888 UART_MUX_SelectAddress(uartMuxChannel); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
889 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; |
| 1080 | 890 externalInterface_CheckBaudrate(currentUartType); |
| 891 switch(currentUartType) | |
| 784 | 892 { |
| 1080 | 893 case SENSOR_DIGO2: uartO2_SetChannel(uartMuxChannel); |
| 894 break; | |
| 895 default: | |
| 896 break; | |
| 809 | 897 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
898 activeUartChannel = uartMuxChannel; |
| 1080 | 899 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = currentUartType; |
| 900 | |
| 901 uartMuxChannel++; | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
902 externalAutoDetect++; |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
903 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
904 else |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
905 { |
| 1080 | 906 externalAutoDetect = externalInterface_NextUartTypeDetection(¤tUartType); |
| 907 externalInterface_CheckBaudrate(currentUartType); | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
908 } |
| 1080 | 909 break; |
| 742 | 910 |
| 794 | 911 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF; |
| 839 | 912 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF); |
| 794 | 913 activeUartChannel = 0xFF; |
| 914 cntSensor = 0; | |
| 915 cntUARTSensor = 0; | |
| 916 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++) | |
| 731 | 917 { |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
918 if((foundSensorMap[index] >= SENSOR_ANALOG) && (foundSensorMap[index] < SENSOR_MUX)) |
| 794 | 919 { |
| 920 cntSensor++; | |
| 921 } | |
| 784 | 922 |
| 1077 | 923 if((foundSensorMap[index] == SENSOR_DIGO2) || (foundSensorMap[index] == SENSOR_CO2) || (foundSensorMap[index] == SENSOR_GNSS) || (foundSensorMap[index] == SENSOR_HUD)) |
| 794 | 924 { |
| 925 cntUARTSensor++; | |
| 926 } | |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
927 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
928 if(foundSensorMap[index] == SENSOR_SENTINEL) /* The Sentinel has a fixed setup */ |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
929 { |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
930 cntSensor = 3; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
931 cntUARTSensor = 1; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
932 break; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
933 } |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
934 #endif |
| 786 | 935 } |
| 804 | 936 externalInface_MapUartToLegacyADC(foundSensorMap); |
| 794 | 937 externalInterfaceMuxReqIntervall = 0xFFFF; |
| 1077 | 938 if((cntSensor == 0) /* return default sensor map if no sensor at all has been detected */ |
| 939 || ((foundSensorMap[0] == SENSOR_NONE) && (foundSensorMap[1] == SENSOR_NONE) && (foundSensorMap[2] == SENSOR_NONE))) | |
| 784 | 940 { |
| 794 | 941 foundSensorMap[0] = SENSOR_OPTIC; |
| 942 foundSensorMap[1] = SENSOR_OPTIC; | |
| 943 foundSensorMap[2] = SENSOR_OPTIC; | |
| 944 } | |
| 1077 | 945 if(cntUARTSensor != 0) |
| 794 | 946 { |
| 1077 | 947 externalInterfaceMuxReqIntervall = REQUEST_INT_SENSOR_MS / cntUARTSensor; |
| 948 if(foundSensorMap[0] == SENSOR_SENTINELM) /* special case: Sentinel sends combined data */ | |
| 784 | 949 { |
| 1077 | 950 externalInterfaceMuxReqIntervall = 4000; |
| 784 | 951 } |
| 952 } | |
| 1077 | 953 |
| 794 | 954 memcpy(SensorMap, foundSensorMap, sizeof(foundSensorMap)); |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
955 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
|
956 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
957 default: |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
958 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
959 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
960 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
961 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
962 |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
963 |
| 662 | 964 void externalInterface_ExecuteCmd(uint16_t Cmd) |
| 965 { | |
| 966 char cmdString[10]; | |
| 967 uint8_t cmdLength = 0; | |
| 804 | 968 uint8_t index; |
| 794 | 969 uint8_t cntUARTSensor = 0; |
| 662 | 970 |
| 971 switch(Cmd & 0x00FF) /* lower byte is reserved for commands */ | |
| 972 { | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
973 case EXT_INTERFACE_AUTODETECT: externalAutoDetect = DETECTION_INIT; |
| 742 | 974 for(index = 0; index < 3; index++) |
| 975 { | |
| 976 SensorMap[index] = SENSOR_SEARCH; | |
| 977 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
978 break; |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
979 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
|
980 { |
| 794 | 981 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap)); |
| 982 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
|
983 { |
| 1080 | 984 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2) || (SensorMap[index] == SENSOR_GNSS) |
| 985 || (SensorMap[index] == SENSOR_SENTINEL) || (SensorMap[index] == SENSOR_HUD)) | |
| 794 | 986 { |
| 987 cntUARTSensor++; | |
| 988 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
989 } |
| 804 | 990 externalInface_MapUartToLegacyADC(SensorMap); |
| 794 | 991 if(cntUARTSensor > 0) |
| 992 { | |
| 993 externalInterfaceMuxReqIntervall = REQUEST_INT_SENSOR_MS / cntUARTSensor; | |
| 994 activeUartChannel = 0xFF; | |
| 1062 | 995 |
| 996 if(SensorMap[0] == SENSOR_SENTINELM) /* special case: Sentinel sends compined data */ | |
| 997 { | |
| 998 externalInterfaceMuxReqIntervall = 4000; | |
| 999 } | |
| 794 | 1000 } |
| 1001 else | |
| 1002 { | |
| 1003 externalInterfaceMuxReqIntervall = 0xFFFF; | |
| 1004 } | |
|
729
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1005 } |
|
d646a0f724a7
Added auto detection functionality for sensors connected to the external interface:
Ideenmodellierer
parents:
714
diff
changeset
|
1006 break; |
|
957
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1007 case EXT_INTERFACE_CO2_CALIB: index = (Cmd >> 8) & 0x000F; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1008 if(SensorMap[index] == SENSOR_CO2M) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1009 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1010 index = Mux2ADCMap[index]; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1011 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1012 if(SensorMap[index] == SENSOR_CO2) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1013 { |
| 1072 | 1014 externalInterface_SensorState[index] = UART_CO2_CALIBRATE_H; |
|
957
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1015 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1016 break; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1017 case EXT_INTERFACE_O2_INDICATE: index = (Cmd >> 8) & 0x000F; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1018 if(SensorMap[index] == SENSOR_DIGO2M) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1019 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1020 index = Mux2ADCMap[index]; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1021 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1022 if(SensorMap[index] == SENSOR_DIGO2) |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1023 { |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1024 externalInterface_SensorState[index] = UART_O2_CHECK; |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1025 } |
|
3420e3ba698d
External sensor commands: Add sensor ID to command:
Ideenmodellierer
parents:
956
diff
changeset
|
1026 break; |
| 1077 | 1027 #ifdef ENABLE_HUD_SUPPORT |
| 1028 case EXT_INTERFACE_HUD_UPDATE: index = (Cmd >> 8) & 0x000F; | |
| 1029 if(SensorMap[index] == SENSOR_HUD) | |
| 1030 { | |
| 1031 externalInterface_SensorState[index] = UART_HUD_UPDATE; | |
| 1032 } | |
| 1033 break; | |
| 1034 case EXT_INTERFACE_HUD_ABORT: index = (Cmd >> 8) & 0x000F; | |
| 1035 if(SensorMap[index] == SENSOR_HUD) | |
| 1036 { | |
| 1037 externalInterface_SensorState[index] = UART_HUD_ABORT; | |
| 1038 } | |
| 1039 break; | |
| 1040 #endif | |
| 662 | 1041 default: |
| 1042 break; | |
| 1043 } | |
| 1044 if(cmdLength != 0) | |
| 1045 { | |
| 1046 HAL_UART_Transmit(&huart1,(uint8_t*)cmdString,cmdLength,10); | |
| 1047 } | |
| 1048 return; | |
| 1049 } | |
| 1050 | |
| 794 | 1051 uint8_t ExternalInterface_SelectUsedMuxChannel(uint8_t currentChannel) |
| 1052 { | |
| 1053 uint8_t index = currentChannel; | |
| 1054 uint8_t newChannel = index; | |
| 1055 uint8_t *pmap = externalInterface_GetSensorMapPointer(0); | |
| 1056 | |
| 1057 do | |
| 1058 { | |
| 1059 index++; | |
| 1060 if(index == MAX_MUX_CHANNEL) | |
| 1061 { | |
| 1062 index = 0; | |
| 1063 } | |
|
918
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
1064 if(((pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_DIGO2) |
|
f72613a152dd
Switch external interface tx communication to DMA:
Ideenmodellierer
parents:
916
diff
changeset
|
1065 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_CO2) |
| 1077 | 1066 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_GNSS) |
| 1067 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_HUD)) | |
| 794 | 1068 && (index != activeUartChannel)) |
| 1069 { | |
| 1070 newChannel = index; | |
| 1071 break; | |
| 1072 } | |
| 1073 } while(index != currentChannel); | |
| 1074 | |
| 1075 return newChannel; | |
| 1076 } | |
| 1077 | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1078 void externalInterface_CheckBaudrate(uint8_t sensorType) |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1079 { |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1080 uint32_t newBaudrate = 0; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1081 |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1082 switch(sensorType) |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1083 { |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1084 case SENSOR_GNSS: |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1085 case SENSOR_SENTINEL: |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1086 case SENSOR_CO2: newBaudrate = 9600; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1087 break; |
| 1080 | 1088 case SENSOR_MUX: |
| 1077 | 1089 case SENSOR_HUD: |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1090 case SENSOR_DIGO2: |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1091 default: newBaudrate = 19200; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1092 break; |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1093 } |
| 809 | 1094 if(huart1.Init.BaudRate != newBaudrate) |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1095 { |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1096 UART_ChangeBaudrate(newBaudrate); |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1097 } |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1098 } |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1099 |
| 794 | 1100 void externalInterface_HandleUART() |
| 1101 { | |
| 1102 static uint8_t retryRequest = 0; | |
| 1103 static uint32_t lastRequestTick = 0; | |
| 1104 static uint32_t TriggerTick = 0; | |
| 1105 uint8_t index = 0; | |
| 1106 static uint8_t timeToTrigger = 0; | |
| 1107 uint32_t tick = HAL_GetTick(); | |
| 1108 uint8_t *pmap = externalInterface_GetSensorMapPointer(0); | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1109 uint8_t forceMuxChannel = 0; |
| 1065 | 1110 static uint8_t flushUART = 0; |
| 794 | 1111 |
| 1112 | |
| 1113 if(externalInterfaceMuxReqIntervall != 0xFFFF) | |
| 1114 { | |
| 804 | 1115 if(activeUartChannel == 0xFF) |
| 1116 { | |
| 809 | 1117 MX_USART1_UART_Init(); |
| 804 | 1118 activeUartChannel = ExternalInterface_SelectUsedMuxChannel(0); |
| 1119 uartO2_SetChannel(activeUartChannel); | |
| 1120 | |
| 1121 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]) | |
| 1122 { | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1123 case SENSOR_DIGO2: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1124 case SENSOR_GNSS: |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1125 case SENSOR_CO2: |
| 1080 | 1126 case SENSOR_HUD: |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1127 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
|
1128 break; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1129 default: externalInterface_CheckBaudrate(SENSOR_DIGO2); |
| 804 | 1130 break; |
| 1131 } | |
| 1132 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) | |
| 1133 { | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1134 HAL_Delay(10); /* make sure MUX is available for reception after wakeup */ |
| 804 | 1135 UART_MUX_SelectAddress(activeUartChannel); |
| 1136 } | |
| 1137 } | |
| 1138 | |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1139 if(externalInterface_SensorState[activeSensorId] != UART_COMMON_INIT) |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1140 { |
| 1065 | 1141 UART_ReadData(pmap[activeSensorId], flushUART); |
| 932 | 1142 UART_WriteData(&Uart1Ctrl); |
| 1065 | 1143 flushUART = 0; |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1144 } |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1145 if(externalInterface_SensorState[activeSensorId] == UART_COMMON_INIT) |
| 794 | 1146 { |
| 1147 lastRequestTick = tick; | |
| 1148 TriggerTick = tick - 10; /* just to make sure control is triggered */ | |
| 1149 timeToTrigger = 1; | |
| 1150 retryRequest = 0; | |
| 1151 } | |
| 1065 | 1152 else if(((retryRequest == 0) && (pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET] != SENSOR_SENTINEL)) /* timeout or error */ |
| 1153 && (((time_elapsed_ms(lastRequestTick,tick) > (TIMEOUT_SENSOR_ANSWER)) && (externalInterface_SensorState[activeSensorId] != UART_COMMON_IDLE)) /* retry if no answer after half request interval */ | |
| 1154 || (externalInterface_SensorState[activeSensorId] == UART_COMMON_ERROR))) | |
| 794 | 1155 { |
| 1156 /* The channel switch will cause the sensor to respond with an error message. */ | |
| 1157 /* The sensor needs ~30ms to recover before he is ready to receive the next command => transmission delay needed */ | |
| 1158 | |
| 1159 TriggerTick = tick; | |
| 1160 timeToTrigger = COMMAND_TX_DELAY; | |
| 1161 retryRequest = 1; | |
| 1162 } | |
| 1163 else if(time_elapsed_ms(lastRequestTick,tick) > externalInterfaceMuxReqIntervall) /* switch sensor and / or trigger next request */ | |
| 1164 { | |
| 975 | 1165 if(timeToTrigger == 0) /* no pending action */ |
| 1166 { | |
| 1167 TriggerTick = tick; | |
| 1168 retryRequest = 0; | |
| 1169 timeToTrigger = 1; | |
| 794 | 1170 |
| 975 | 1171 if((externalInterface_SensorState[activeSensorId] == UART_O2_REQ_O2) /* timeout */ |
| 1172 || (externalInterface_SensorState[activeSensorId] == UART_O2_REQ_RAW) | |
| 1173 || (externalInterface_SensorState[activeSensorId] == UART_CO2_OPERATING) | |
| 1174 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_PVT) | |
| 1062 | 1175 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_SAT) |
| 1176 || (externalInterface_SensorState[activeSensorId] == UART_SENTINEL_OPERATING)) | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1177 { |
| 975 | 1178 forceMuxChannel = 1; |
| 1179 externalInterface_SensorState[activeSensorId] = UART_O2_IDLE; | |
| 1180 switch(pmap[activeSensorId]) | |
| 1181 { | |
| 1182 case SENSOR_DIGO2: setExternalInterfaceChannel(activeSensorId,0.0); | |
| 1183 break; | |
| 1184 case SENSOR_CO2: externalInterface_SetCO2Value(0.0); | |
| 1065 | 1185 externalInterface_SetCO2SignalStrength(0); |
| 975 | 1186 break; |
| 1062 | 1187 case SENSOR_SENTINEL: setExternalInterfaceChannel(0,0.0); |
| 1188 setExternalInterfaceChannel(1,0.0); | |
| 1189 setExternalInterfaceChannel(2,0.0); | |
| 1190 externalInterface_SetBottlePressure(0,0); | |
| 1191 externalInterface_SetBottlePressure(1,0); | |
| 1192 break; | |
| 975 | 1193 default: |
| 1194 break; | |
| 1195 } | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1196 } |
| 975 | 1197 if((externalInterface_SensorState[activeSensorId] == UART_CO2_SETUP) /* timeout while setting up sensors */ |
| 1198 || (externalInterface_SensorState[activeSensorId] == UART_O2_CHECK)) | |
| 1199 { | |
| 1200 forceMuxChannel = 1; | |
| 1201 } | |
|
956
083afabc6578
Bugfix UART sensor MUX channel selection after sleep:
Ideenmodellierer
parents:
932
diff
changeset
|
1202 |
| 794 | 1203 |
| 975 | 1204 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) /* select next sensor if mux is connected */ |
| 794 | 1205 { |
| 1065 | 1206 |
| 975 | 1207 if(activeUartChannel < MAX_MUX_CHANNEL) |
| 794 | 1208 { |
| 975 | 1209 index = ExternalInterface_SelectUsedMuxChannel(activeUartChannel); |
| 1210 if((index != activeUartChannel) || (forceMuxChannel)) | |
| 794 | 1211 { |
| 975 | 1212 forceMuxChannel = 0; |
| 1213 timeToTrigger = 100; | |
| 1065 | 1214 lastRequestTick = tick; |
| 975 | 1215 activeUartChannel = index; |
| 1065 | 1216 flushUART = 1; /* discard data which might be received while switching to new channel */ |
| 975 | 1217 switch(pmap[index + EXT_INTERFACE_MUX_OFFSET]) |
| 1218 { | |
| 1219 case SENSOR_DIGO2: uartO2_SetChannel(activeUartChannel); | |
| 1220 /* no break */ | |
| 1221 case SENSOR_CO2: | |
| 1080 | 1222 case SENSOR_HUD: |
| 975 | 1223 case SENSOR_GNSS: externalInterface_CheckBaudrate(SENSOR_MUX); |
| 1224 UART_MUX_SelectAddress(activeUartChannel); | |
| 1225 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); | |
| 1226 break; | |
| 1227 default: | |
| 1228 break; | |
| 1229 } | |
| 794 | 1230 } |
| 1231 } | |
| 1232 } | |
| 1233 } | |
| 1234 } | |
| 1235 if((timeToTrigger != 0) && (time_elapsed_ms(TriggerTick,tick) > timeToTrigger)) | |
| 1236 { | |
| 975 | 1237 lastRequestTick = tick; |
| 794 | 1238 timeToTrigger = 0; |
| 1239 switch (pmap[activeSensorId]) | |
| 1240 { | |
| 1241 case SENSOR_MUX: | |
| 1242 case SENSOR_DIGO2: uartO2_Control(); | |
| 1243 break; | |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1244 #ifdef ENABLE_CO2_SUPPORT |
|
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1245 case SENSOR_CO2: uartCo2_Control(); |
| 794 | 1246 break; |
|
798
e9eba334b942
Migrated CO2 protocol implementation to new format:
Ideenmodellierer
parents:
794
diff
changeset
|
1247 #endif |
| 988 | 1248 #ifdef ENABLE_GNSS_EXTERN |
|
916
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1249 case SENSOR_GNSS: uartGnss_Control(); |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1250 break; |
|
4832981f9af8
External sensor UART: Switch to DMA TX transfers:
Ideenmodellierer
parents:
861
diff
changeset
|
1251 #endif |
|
842
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1252 #ifdef ENABLE_SENTINEL_MODE |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1253 case SENSOR_SENTINEL: uartSentinel_Control(); |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1254 break; |
|
c3dd461ca3f9
Migrated Sentinel protocol to new UART structure:
Ideenmodellierer
parents:
839
diff
changeset
|
1255 #endif |
| 1077 | 1256 #ifdef ENABLE_HUD_SUPPORT |
| 1257 case SENSOR_HUD: uartHUD_Control(); | |
| 1258 break; | |
| 1259 #endif | |
| 794 | 1260 default: |
| 1261 break; | |
| 1262 } | |
| 1263 } | |
| 1264 } | |
| 1265 } |