Mercurial > public > ostc4

comparison Small_CPU/Src/externalInterface.c @ 981:c6c781a2e85b default

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge into default
author heinrichsweikamp
date Tue, 11 Feb 2025 18:12:00 +0100
parents 0b81ac558e89
children d9290c76b840
comparison
equal deleted inserted replaced
871:f7318457df4d 981:c6c781a2e85b
32 #include "uart.h" 32 #include "uart.h"
33 #include "data_exchange.h" 33 #include "data_exchange.h"
34 #include "pressure.h" 34 #include "pressure.h"
35 #include "uartProtocol_O2.h" 35 #include "uartProtocol_O2.h"
36 #include "uartProtocol_Co2.h" 36 #include "uartProtocol_Co2.h"
37 #include "uartProtocol_Sentinel.h"
38 #include "uartProtocol_GNSS.h"
37 39
38 extern SGlobal global; 40 extern SGlobal global;
39 extern UART_HandleTypeDef huart1; 41 extern UART_HandleTypeDef huart1;
40 42 extern sUartComCtrl Uart1Ctrl;
41 #define ADC_ANSWER_LENGTH (5u) /* 3424 will provide addr + 4 data bytes */ 43
42 #define ADC_TIMEOUT (10u) /* conversion stuck for unknown reason => restart */ 44 #define ADC_ANSWER_LENGTH (5u) /* 3424 will provide addr + 4 data bytes */
43 #define ADC_REF_VOLTAGE_MV (2048.0f) /* reference voltage of MPC3424*/ 45 #define ADC_TIMEOUT (10u) /* conversion stuck for unknown reason => restart */
46 #define ADC_REF_VOLTAGE_MV (2048.0f) /* reference voltage of MPC3424*/
47 #define ADC_CYCLE_INTERVAL_MS (1000u) /* start adc read out once per second*/
44 48
45 #define ADC_START_CONVERSION (0x80) 49 #define ADC_START_CONVERSION (0x80)
46 #define ADC_GAIN_4 (0x02) 50 #define ADC_GAIN_4 (0x02)
47 #define ADC_GAIN_4_VALUE (4.0f) 51 #define ADC_GAIN_4_VALUE (4.0f)
48 #define ADC_GAIN_8 (0x03) 52 #define ADC_GAIN_8 (0x03)
65 69
66 static uint8_t activeChannel = 0; /* channel which is in request */ 70 static uint8_t activeChannel = 0; /* channel which is in request */
67 static uint8_t recBuf[ADC_ANSWER_LENGTH]; 71 static uint8_t recBuf[ADC_ANSWER_LENGTH];
68 static uint8_t timeoutCnt = 0; 72 static uint8_t timeoutCnt = 0;
69 static uint8_t externalInterfacePresent = 0; 73 static uint8_t externalInterfacePresent = 0;
74 static uint8_t delayAdcConversion = 0;
75 static uint32_t startTickADC = 0;
70 76
71 float externalChannel_mV[MAX_ADC_CHANNEL]; 77 float externalChannel_mV[MAX_ADC_CHANNEL];
72 static uint8_t externalV33_On = 0; 78 static uint8_t externalV33_On = 0;
73 static uint8_t externalADC_On = 0; 79 static uint8_t externalADC_On = 0;
74 static uint8_t externalUART_Protocol = 0; 80 static uint8_t externalUART_Protocol = 0;
88 static uint8_t externalInterface_SensorState[EXT_INTERFACE_SENSOR_CNT]; 94 static uint8_t externalInterface_SensorState[EXT_INTERFACE_SENSOR_CNT];
89 95
90 static float LookupCO2PressureCorrection[LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE]; /* lookup table for pressure compensation values */ 96 static float LookupCO2PressureCorrection[LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE]; /* lookup table for pressure compensation values */
91 97
92 static uint16_t externalInterfaceMuxReqIntervall = 0xffff; /* delay between switching from one MUX channel to the next */ 98 static uint16_t externalInterfaceMuxReqIntervall = 0xffff; /* delay between switching from one MUX channel to the next */
93 static uint8_t activeUartChannel = 0; /* Index of the sensor port which is selected by the mux or 0 if no mux is connected */ 99 static uint8_t activeUartChannel = 0xff;
94 100
95 101
96 static void externalInface_MapUartToLegacyADC(uint8_t* pMap); 102 static void externalInface_MapUartToLegacyADC(uint8_t* pMap);
97 static void externalInterface_CheckBaudrate(uint8_t sensorType); 103 static void externalInterface_CheckBaudrate(uint8_t sensorType);
98 104
100 { 106 {
101 uint16_t index; 107 uint16_t index;
102 uint16_t coeff; 108 uint16_t coeff;
103 activeChannel = 0; 109 activeChannel = 0;
104 timeoutCnt = 0; 110 timeoutCnt = 0;
105 externalInterfacePresent = 0; 111 delayAdcConversion = 0;
106 if(externalInterface_StartConversion(activeChannel) == HAL_OK) 112 if(externalInterface_StartConversion(activeChannel) == HAL_OK)
107 { 113 {
108 externalInterfacePresent = 1; 114 externalInterfacePresent = 1;
109 global.deviceDataSendToMaster.hw_Info.extADC = 1; 115 global.deviceDataSendToMaster.hw_Info.extADC = 1;
110 } 116 }
126 132
127 void externalInterface_InitDatastruct(void) 133 void externalInterface_InitDatastruct(void)
128 { 134 {
129 uint8_t index = 0; 135 uint8_t index = 0;
130 /* init data values */ 136 /* init data values */
131 externalV33_On = 0;
132 externalADC_On = 0;
133 externalUART_Protocol = 0; 137 externalUART_Protocol = 0;
134 externalCO2Value = 0; 138 externalCO2Value = 0;
135 externalCO2SignalStrength = 0; 139 externalCO2SignalStrength = 0;
136 externalCO2Status = 0; 140 externalCO2Status = 0;
137 externalCO2Scale = 0.0; 141 externalCO2Scale = 0.0;
168 uint8_t nextChannel; 172 uint8_t nextChannel;
169 uint8_t* psensorMap = externalInterface_GetSensorMapPointer(0); 173 uint8_t* psensorMap = externalInterface_GetSensorMapPointer(0);
170 174
171 if(externalADC_On) 175 if(externalADC_On)
172 { 176 {
173 if(I2C_Master_Receive(DEVICE_EXTERNAL_ADC, recBuf, ADC_ANSWER_LENGTH) == HAL_OK) 177 if(time_elapsed_ms(startTickADC, HAL_GetTick()) > ADC_CYCLE_INTERVAL_MS)
174 { 178 {
175 if((recBuf[ANSWER_CONFBYTE_INDEX] & ADC_START_CONVERSION) == 0) /* !ready set => received data contains new value */ 179 if(delayAdcConversion)
176 { 180 {
177 retval = activeChannel; /* return channel number providing new data */ 181 if(UART_isComActive(activeUartChannel) == 0)
178 nextChannel = activeChannel + 1;
179 if(nextChannel == MAX_ADC_CHANNEL)
180 { 182 {
181 nextChannel = 0; 183 externalInterface_StartConversion(activeChannel);
184 delayAdcConversion = 0;
182 } 185 }
183 186 }
184 while((psensorMap[nextChannel] != SENSOR_ANALOG) && (nextChannel != activeChannel)) 187 else if(I2C_Master_Receive(DEVICE_EXTERNAL_ADC, recBuf, ADC_ANSWER_LENGTH) == HAL_OK)
188 {
189 if((recBuf[ANSWER_CONFBYTE_INDEX] & ADC_START_CONVERSION) == 0) /* !ready set => received data contains new value */
185 { 190 {
191 retval = activeChannel; /* return channel number providing new data */
192 nextChannel = activeChannel + 1;
186 if(nextChannel == MAX_ADC_CHANNEL) 193 if(nextChannel == MAX_ADC_CHANNEL)
187 { 194 {
188 nextChannel = 0; 195 nextChannel = 0;
189 } 196 }
197
198 while((psensorMap[nextChannel] != SENSOR_ANALOG) && (nextChannel != activeChannel))
199 {
200 if(nextChannel == MAX_ADC_CHANNEL)
201 {
202 nextChannel = 0;
203 startTickADC = HAL_GetTick();
204 }
205 else
206 {
207 nextChannel++;
208 }
209 }
210
211 activeChannel = nextChannel;
212 if(activeChannel == 0)
213 {
214 delayAdcConversion = 1; /* wait for next cycle interval */
215 }
190 else 216 else
191 { 217 {
192 nextChannel++; 218 if(UART_isComActive(activeUartChannel) == 0)
219 {
220 externalInterface_StartConversion(activeChannel);
221 }
222 else
223 {
224 delayAdcConversion = 1;
225 }
193 } 226 }
194 }
195
196 activeChannel = nextChannel;
197 externalInterface_StartConversion(activeChannel);
198 timeoutCnt = 0;
199 }
200 else
201 {
202 if(timeoutCnt++ >= ADC_TIMEOUT)
203 {
204 externalInterface_StartConversion(activeChannel);
205 timeoutCnt = 0; 227 timeoutCnt = 0;
206 } 228 }
207 } 229 }
208 } 230
209 else /* take also i2c bus disturb into account */ 231 if(timeoutCnt++ >= ADC_TIMEOUT)
210 { 232 {
211 if(timeoutCnt++ >= ADC_TIMEOUT) 233 externalInterface_StartConversion(activeChannel);
212 { 234 delayAdcConversion = 0;
213 externalInterface_StartConversion(activeChannel); 235 timeoutCnt = 0;
214 timeoutCnt = 0; 236 }
215 }
216 } 237 }
217 } 238 }
218 return retval; 239 return retval;
219 } 240 }
220 float externalInterface_CalculateADCValue(uint8_t channel) 241 float externalInterface_CalculateADCValue(uint8_t channel)
344 uint8_t loop = 0; 365 uint8_t loop = 0;
345 if((state) && (externalInterfacePresent)) 366 if((state) && (externalInterfacePresent))
346 { 367 {
347 if(externalADC_On == 0) 368 if(externalADC_On == 0)
348 { 369 {
370 startTickADC = HAL_GetTick();
349 activeChannel = 0; 371 activeChannel = 0;
350 externalInterface_StartConversion(activeChannel); 372 externalInterface_StartConversion(activeChannel);
351 externalADC_On = 1; 373 externalADC_On = 1;
352 } 374 }
353 } 375 }
366 388
367 void externalInterface_SwitchUART(uint8_t protocol) 389 void externalInterface_SwitchUART(uint8_t protocol)
368 { 390 {
369 switch(protocol) 391 switch(protocol)
370 { 392 {
371 case 0: 393 case EXT_INTERFACE_UART_OFF:
372 case (EXT_INTERFACE_UART_CO2 >> 8): 394 case EXT_INTERFACE_UART_CO2:
373 case (EXT_INTERFACE_UART_O2 >> 8): 395 case EXT_INTERFACE_UART_O2:
374 case (EXT_INTERFACE_UART_SENTINEL >> 8): 396 case EXT_INTERFACE_UART_SENTINEL:
397 case EXT_INTERFACE_UART_GNSS:
375 if((externalAutoDetect <= DETECTION_START) 398 if((externalAutoDetect <= DETECTION_START)
376 || ((protocol == EXT_INTERFACE_UART_O2 >> 8) && (externalAutoDetect >= DETECTION_UARTMUX) && (externalAutoDetect <= DETECTION_DIGO2_3)) 399 || ((protocol == EXT_INTERFACE_UART_O2) && (externalAutoDetect >= DETECTION_UARTMUX) && (externalAutoDetect <= DETECTION_DIGO2_3))
377 400
378 #ifdef ENABLE_CO2_SUPPORT 401 #ifdef ENABLE_CO2_SUPPORT
379 || ((externalAutoDetect >= DETECTION_CO2_0) && (externalAutoDetect <= DETECTION_CO2_3)) 402 || ((externalAutoDetect >= DETECTION_CO2_0) && (externalAutoDetect <= DETECTION_CO2_3))
380 #endif 403 #endif
404 #ifdef ENABLE_GNSS_SUPPORT
405 || ((externalAutoDetect >= DETECTION_GNSS_0) && (externalAutoDetect <= DETECTION_GNSS_3))
406 #endif
407
381 #ifdef ENABLE_SENTINEL_MODE 408 #ifdef ENABLE_SENTINEL_MODE
382 || ((protocol == EXT_INTERFACE_UART_SENTINEL >> 8) && (externalAutoDetect == DETECTION_SENTINEL)) 409 || ((protocol == EXT_INTERFACE_UART_SENTINEL) && (externalAutoDetect == DETECTION_SENTINEL))
383 #endif 410 #endif
384 ) 411 )
385 { 412 {
386 lastSensorDataId = 0; 413 lastSensorDataId = 0;
387 externalUART_Protocol = protocol; 414 externalUART_Protocol = protocol;
560 587
561 memset(Mux2ADCMap,0xFF, sizeof(Mux2ADCMap)); 588 memset(Mux2ADCMap,0xFF, sizeof(Mux2ADCMap));
562 589
563 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) /* Unmap old mirror instances */ 590 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) /* Unmap old mirror instances */
564 { 591 {
565 if((pMap[index2] == SENSOR_DIGO2M) || (pMap[index2] == SENSOR_CO2M)) 592 if((pMap[index2] == SENSOR_DIGO2M) || (pMap[index2] == SENSOR_CO2M) || (pMap[index2] == SENSOR_GNSSM))
566 { 593 {
567 pMap[index2] = SENSOR_NONE; 594 pMap[index2] = SENSOR_NONE;
568 } 595 }
569 } 596 }
570 597
571 /* Map Mux O2 sensors to ADC Slot if ADC slot is not in use */ 598 /* Map Mux O2 sensors to ADC Slot if ADC slot is not in use */
572 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++) 599 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++)
573 { 600 {
574 if(pMap[index] == SENSOR_DIGO2) 601 if(pMap[index] == SENSOR_DIGO2)
575 { 602 {
576 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) 603 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++)
577 { 604 {
582 break; 609 break;
583 } 610 }
584 } 611 }
585 } 612 }
586 } 613 }
587 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++) 614 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++)
588 { 615 {
589 if(pMap[index] == SENSOR_CO2) 616 if(pMap[index] == SENSOR_CO2)
590 { 617 {
591 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++) 618 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++)
592 { 619 {
597 break; 624 break;
598 } 625 }
599 } 626 }
600 } 627 }
601 } 628 }
629 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_SENSOR_CNT-1; index++)
630 {
631 if(pMap[index] == SENSOR_GNSS)
632 {
633 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++)
634 {
635 if(pMap[index2] == SENSOR_NONE)
636 {
637 pMap[index2] = SENSOR_GNSSM; /* store a mirror instance needed for visualization */
638 Mux2ADCMap[index2] = index;
639 break;
640 }
641 }
642 }
643 }
644 #ifdef ENABLE_SENTINEL_MODE
645 if(pMap[EXT_INTERFACE_MUX_OFFSET] == SENSOR_SENTINEL)
646 {
647 for(index2 = 0; index2 < MAX_ADC_CHANNEL; index2++)
648 {
649 pMap[index2] = SENSOR_SENTINELM; /* store a mirror instance needed for visualization */
650 Mux2ADCMap[index2] = index2 + EXT_INTERFACE_MUX_OFFSET;
651 }
652 }
653 #endif
602 } 654 }
603 655
604 uint8_t* externalInterface_GetSensorMapPointer(uint8_t finalMap) 656 uint8_t* externalInterface_GetSensorMapPointer(uint8_t finalMap)
605 { 657 {
606 uint8_t* pret; 658 uint8_t* pret;
618 670
619 void externalInterface_AutodetectSensor() 671 void externalInterface_AutodetectSensor()
620 { 672 {
621 static uint8_t sensorIndex = 0; 673 static uint8_t sensorIndex = 0;
622 static uint8_t uartMuxChannel = 0; 674 static uint8_t uartMuxChannel = 0;
675 #ifdef ENABLE_GNSS_SUPPORT
676 static uint8_t detectionDelayCnt = 0;
677 #endif
623 uint8_t index = 0; 678 uint8_t index = 0;
679
624 uint8_t cntSensor = 0; 680 uint8_t cntSensor = 0;
625 uint8_t cntUARTSensor = 0; 681 uint8_t cntUARTSensor = 0;
626 #ifdef ENABLE_CO2_SUPPORT 682 #ifdef ENABLE_CO2_SUPPORT
627 uint8_t cmdString[10]; 683 uint8_t cmdString[10];
628 uint8_t cmdLength = 0; 684 uint8_t cmdLength = 0;
630 686
631 if(externalAutoDetect != DETECTION_OFF) 687 if(externalAutoDetect != DETECTION_OFF)
632 { 688 {
633 switch(externalAutoDetect) 689 switch(externalAutoDetect)
634 { 690 {
635 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0; 691 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0xffff;
636 sensorIndex = 0; 692 sensorIndex = 0;
637 uartMuxChannel = 0; 693 uartMuxChannel = 0;
638 tmpSensorMap[0] = SENSOR_OPTIC; 694 tmpSensorMap[0] = SENSOR_OPTIC;
639 tmpSensorMap[1] = SENSOR_OPTIC; 695 tmpSensorMap[1] = SENSOR_OPTIC;
640 tmpSensorMap[2] = SENSOR_OPTIC; 696 tmpSensorMap[2] = SENSOR_OPTIC;
649 memset(Mux2ADCMap,0, sizeof(Mux2ADCMap)); 705 memset(Mux2ADCMap,0, sizeof(Mux2ADCMap));
650 706
651 if(externalInterfacePresent) 707 if(externalInterfacePresent)
652 { 708 {
653 externalInterface_SwitchPower33(0); 709 externalInterface_SwitchPower33(0);
654 externalInterface_SwitchUART(0); 710 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF);
655 for(index = 0; index < MAX_ADC_CHANNEL; index++) 711 for(index = 0; index < MAX_ADC_CHANNEL; index++)
656 { 712 {
657 externalChannel_mV[index] = 0; 713 externalChannel_mV[index] = 0;
658 } 714 }
659 externalAutoDetect = DETECTION_START; 715 externalAutoDetect = DETECTION_START;
684 tmpSensorMap[sensorIndex++] = SENSOR_NONE; 740 tmpSensorMap[sensorIndex++] = SENSOR_NONE;
685 } 741 }
686 } 742 }
687 externalInterfaceMuxReqIntervall = 1100; 743 externalInterfaceMuxReqIntervall = 1100;
688 externalAutoDetect = DETECTION_UARTMUX; 744 externalAutoDetect = DETECTION_UARTMUX;
689 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2 >> 8); 745 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2);
746 externalInterface_CheckBaudrate(SENSOR_DIGO2);
690 UART_MUX_SelectAddress(MAX_MUX_CHANNEL); 747 UART_MUX_SelectAddress(MAX_MUX_CHANNEL);
691 uartO2_SetChannel(MAX_MUX_CHANNEL); 748 uartO2_SetChannel(MAX_MUX_CHANNEL);
692 activeUartChannel = MAX_MUX_CHANNEL; 749 activeUartChannel = MAX_MUX_CHANNEL;
693 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; 750 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX;
694 break; 751 break;
695 case DETECTION_UARTMUX: if(uartO2_isSensorConnected()) 752 case DETECTION_UARTMUX: if(uartO2_isSensorConnected())
696 { 753 {
697 uartMuxChannel = 1; 754 uartMuxChannel = 1;
698 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; 755 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX;
699 foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX; 756 foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_MUX;
700 } 757 }
701 else 758 else
702 { 759 {
703 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE; 760 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE;
704 } 761 }
705 externalAutoDetect = DETECTION_DIGO2_0; 762 externalAutoDetect = DETECTION_DIGO2_0;
706 uartO2_SetChannel(0); 763 uartO2_SetChannel(0);
707 activeUartChannel = 0; 764 activeUartChannel = 0;
708 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; 765 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2;
709 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; 766 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
710 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2 >> 8); 767 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2);
711 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) 768 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
712 { 769 {
713 UART_MUX_SelectAddress(0); 770 UART_MUX_SelectAddress(0);
714 } 771 }
715 break; 772 break;
716 case DETECTION_DIGO2_0: 773 case DETECTION_DIGO2_0:
717 case DETECTION_DIGO2_1: 774 case DETECTION_DIGO2_1:
718 case DETECTION_DIGO2_2: 775 case DETECTION_DIGO2_2:
719 case DETECTION_DIGO2_3: 776 case DETECTION_DIGO2_3:
722 foundSensorMap[externalAutoDetect - DETECTION_DIGO2_0 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; 779 foundSensorMap[externalAutoDetect - DETECTION_DIGO2_0 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2;
723 } 780 }
724 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; 781 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
725 if(uartMuxChannel) 782 if(uartMuxChannel)
726 { 783 {
727 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2 >> 8); 784 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2);
728 UART_MUX_SelectAddress(uartMuxChannel); 785 UART_MUX_SelectAddress(uartMuxChannel);
729 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; 786 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
730 uartO2_SetChannel(uartMuxChannel); 787 uartO2_SetChannel(uartMuxChannel);
731 activeUartChannel = uartMuxChannel; 788 activeUartChannel = uartMuxChannel;
732 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; 789 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
770 case DETECTION_CO2_1: 827 case DETECTION_CO2_1:
771 case DETECTION_CO2_2: 828 case DETECTION_CO2_2:
772 case DETECTION_CO2_3: if(uartCo2_isSensorConnected()) 829 case DETECTION_CO2_3: if(uartCo2_isSensorConnected())
773 { 830 {
774 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_CO2; 831 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_CO2;
832 #ifdef ENABLE_GNSS_SUPPORT
833 externalAutoDetect = DETECTION_GNSS_0; /* only one CO2 sensor supported */
834 #else
775 externalAutoDetect = DETECTION_DONE; /* only one CO2 sensor supported */ 835 externalAutoDetect = DETECTION_DONE; /* only one CO2 sensor supported */
836 #endif
776 } 837 }
777 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) 838 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
778 { 839 {
779 externalInterface_CheckBaudrate(SENSOR_DIGO2); 840 externalInterface_CheckBaudrate(SENSOR_DIGO2);
780 UART_MUX_SelectAddress(uartMuxChannel); 841 UART_MUX_SelectAddress(uartMuxChannel);
787 externalAutoDetect++; 848 externalAutoDetect++;
788 uartMuxChannel++; 849 uartMuxChannel++;
789 } 850 }
790 else 851 else
791 { 852 {
853
854
855 #if defined ENABLE_SENTINEL_MODE || defined ENABLE_GNSS_SUPPORT
856 #ifdef ENABLE_GNSS_SUPPORT
857 externalAutoDetect = DETECTION_GNSS_0;
858 externalInterface_SwitchUART(EXT_INTERFACE_UART_GNSS);
859 #else
860 #ifdef ENABLE_SENTINEL_MODE
861 externalAutoDetect = DETECTION_SENTINEL;
862 #endif
863 #endif
864 #else
792 externalAutoDetect = DETECTION_DONE; 865 externalAutoDetect = DETECTION_DONE;
793 } 866 #endif
794 #endif 867 }
868 #endif
869
870 #ifdef ENABLE_GNSS_SUPPORT
871 if(externalAutoDetect == DETECTION_GNSS_0)
872 {
873 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
874 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
875 {
876 externalInterface_CheckBaudrate(SENSOR_DIGO2);
877 UART_MUX_SelectAddress(0);
878 }
879 activeUartChannel = 0;
880 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
881 uartMuxChannel = 1;
882 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_GNSS;
883 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
884 externalInterface_CheckBaudrate(SENSOR_GNSS);
885 externalInterfaceMuxReqIntervall = 500; /* iterations needed for module config */
886 detectionDelayCnt = 6;
887 }
888 break;
889 case DETECTION_GNSS_0:
890 case DETECTION_GNSS_1:
891 case DETECTION_GNSS_2:
892 case DETECTION_GNSS_3: if(detectionDelayCnt == 0)
893 {
894 if(uartGnss_isSensorConnected())
895 {
896 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_GNSS;
897 #ifdef ENABLE_SENTINEL_MODE
898 externalAutoDetect = DETECTION_SENTINEL; /* only one GNSS sensor supported */
899 #else
900 externalAutoDetect = DETECTION_DONE; /* only one GNSS sensor supported */
901 #endif
902 }
903 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
904 {
905 externalInterface_CheckBaudrate(SENSOR_DIGO2);
906 UART_MUX_SelectAddress(uartMuxChannel);
907 activeUartChannel = uartMuxChannel;
908 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
909 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2;
910 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT;
911 externalInterface_CheckBaudrate(SENSOR_CO2);
912 // uartGnss_SendCmd(GNSSCMD_MODE_POLL, cmdString, &cmdLength);
913 externalAutoDetect++;
914 detectionDelayCnt = 3;
915 uartMuxChannel++;
916 }
917 else
918 {
919 #ifdef ENABLE_SENTINEL_MODE
920 externalAutoDetect = DETECTION_SENTINEL;
921 #else
922 externalAutoDetect = DETECTION_DONE;
923 #endif
924 }
925 }
926 else
927 {
928 detectionDelayCnt--;
929 }
930 #endif
795 #ifdef ENABLE_SENTINEL_MODE 931 #ifdef ENABLE_SENTINEL_MODE
796 if(externalAutoDetect == DETECTION_SENTINEL) 932 if(externalAutoDetect == DETECTION_SENTINEL)
797 { 933 {
798 externalInterface_SwitchUART(EXT_INTERFACE_UART_SENTINEL >> 8); 934 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
799 UART_StartDMA_Receiption(); 935 uartO2_SetChannel(0);
936 activeUartChannel = 0;
937 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_SENTINEL;
938 externalInterface_SwitchUART(EXT_INTERFACE_UART_SENTINEL);
939 externalInterface_CheckBaudrate(SENSOR_SENTINEL);
940 UART_StartDMA_Receiption(&Uart1Ctrl);
800 } 941 }
801 break; 942 break;
802 943
803 case DETECTION_SENTINEL: 944 case DETECTION_SENTINEL:
804 case DETECTION_SENTINEL2: 945 case DETECTION_SENTINEL2:
805 if(UART_isSentinelConnected()) 946 if(uartSentinel_isSensorConnected())
806 { 947 {
807 for(index = 0; index < 3; index++) /* Sentinel is occupiing all sensor slots */ 948 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_MUX_OFFSET+3; index++)
808 { 949 {
809 tmpSensorMap[index] = SENSOR_SENTINEL; 950 foundSensorMap[index] = SENSOR_SENTINEL;
810 } 951 }
811 sensorIndex = 3;
812 } 952 }
813 externalAutoDetect++; 953 externalAutoDetect++;
814 #endif 954 #endif
815 break; 955 break;
816 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF; 956 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF;
817 externalInterface_SwitchUART(0); 957 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF);
818 activeUartChannel = 0xFF; 958 activeUartChannel = 0xFF;
819 cntSensor = 0; 959 cntSensor = 0;
820 cntUARTSensor = 0; 960 cntUARTSensor = 0;
821 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++) 961 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT-1; index++)
822 { 962 {
823 if((foundSensorMap[index] >= SENSOR_ANALOG) && (foundSensorMap[index] < SENSOR_MUX)) 963 if((foundSensorMap[index] >= SENSOR_ANALOG) && (foundSensorMap[index] < SENSOR_MUX))
824 { 964 {
825 cntSensor++; 965 cntSensor++;
826 } 966 }
827 967
828 if((foundSensorMap[index] == SENSOR_DIGO2) || (foundSensorMap[index] == SENSOR_CO2)) 968 if((foundSensorMap[index] == SENSOR_DIGO2) || (foundSensorMap[index] == SENSOR_CO2) || (foundSensorMap[index] == SENSOR_GNSS))
829 { 969 {
830 cntUARTSensor++; 970 cntUARTSensor++;
831 } 971 }
972 #ifdef ENABLE_SENTINEL_MODE
973 if(foundSensorMap[index] == SENSOR_SENTINEL) /* The Sentinel has a fixed setup */
974 {
975 cntSensor = 3;
976 cntUARTSensor = 1;
977 break;
978 }
979 #endif
832 } 980 }
833 externalInface_MapUartToLegacyADC(foundSensorMap); 981 externalInface_MapUartToLegacyADC(foundSensorMap);
834 externalInterfaceMuxReqIntervall = 0xFFFF; 982 externalInterfaceMuxReqIntervall = 0xFFFF;
835 if(cntSensor == 0) /* return default sensor map if no sensor at all has been detected */ 983 if(cntSensor == 0) /* return default sensor map if no sensor at all has been detected */
836 { 984 {
866 { 1014 {
867 case EXT_INTERFACE_AUTODETECT: externalAutoDetect = DETECTION_INIT; 1015 case EXT_INTERFACE_AUTODETECT: externalAutoDetect = DETECTION_INIT;
868 for(index = 0; index < 3; index++) 1016 for(index = 0; index < 3; index++)
869 { 1017 {
870 SensorMap[index] = SENSOR_SEARCH; 1018 SensorMap[index] = SENSOR_SEARCH;
871 }
872 break;
873 case EXT_INTERFACE_CO2_CALIB: for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++)
874 {
875 if(SensorMap[index] == SENSOR_CO2)
876 {
877 externalInterface_SensorState[index] = UART_CO2_CALIBRATE;
878 break;
879 }
880 } 1019 }
881 break; 1020 break;
882 case EXT_INTERFACE_COPY_SENSORMAP: if(externalAutoDetect == DETECTION_OFF) 1021 case EXT_INTERFACE_COPY_SENSORMAP: if(externalAutoDetect == DETECTION_OFF)
883 { 1022 {
884 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap)); 1023 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap));
885 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++) 1024 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++)
886 { 1025 {
887 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2)) 1026 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2) || (SensorMap[index] == SENSOR_GNSS))
888 { 1027 {
889 cntUARTSensor++; 1028 cntUARTSensor++;
890 } 1029 }
891 } 1030 }
892 externalInface_MapUartToLegacyADC(SensorMap); 1031 externalInface_MapUartToLegacyADC(SensorMap);
899 { 1038 {
900 externalInterfaceMuxReqIntervall = 0xFFFF; 1039 externalInterfaceMuxReqIntervall = 0xFFFF;
901 } 1040 }
902 } 1041 }
903 break; 1042 break;
1043 case EXT_INTERFACE_CO2_CALIB: index = (Cmd >> 8) & 0x000F;
1044 if(SensorMap[index] == SENSOR_CO2M)
1045 {
1046 index = Mux2ADCMap[index];
1047 }
1048 if(SensorMap[index] == SENSOR_CO2)
1049 {
1050 externalInterface_SensorState[index] = UART_CO2_CALIBRATE;
1051 }
1052 break;
1053 case EXT_INTERFACE_O2_INDICATE: index = (Cmd >> 8) & 0x000F;
1054 if(SensorMap[index] == SENSOR_DIGO2M)
1055 {
1056 index = Mux2ADCMap[index];
1057 }
1058 if(SensorMap[index] == SENSOR_DIGO2)
1059 {
1060 externalInterface_SensorState[index] = UART_O2_CHECK;
1061 }
1062 break;
1063
904 default: 1064 default:
905 break; 1065 break;
906 } 1066 }
907 if(cmdLength != 0) 1067 if(cmdLength != 0)
908 { 1068 {
922 index++; 1082 index++;
923 if(index == MAX_MUX_CHANNEL) 1083 if(index == MAX_MUX_CHANNEL)
924 { 1084 {
925 index = 0; 1085 index = 0;
926 } 1086 }
927 if(((pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_DIGO2) || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_CO2)) 1087 if(((pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_DIGO2)
1088 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_CO2)
1089 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_GNSS))
928 && (index != activeUartChannel)) 1090 && (index != activeUartChannel))
929 { 1091 {
930 newChannel = index; 1092 newChannel = index;
931 break; 1093 break;
932 } 1094 }
939 { 1101 {
940 uint32_t newBaudrate = 0; 1102 uint32_t newBaudrate = 0;
941 1103
942 switch(sensorType) 1104 switch(sensorType)
943 { 1105 {
1106 case SENSOR_GNSS:
1107 case SENSOR_SENTINEL:
944 case SENSOR_CO2: newBaudrate = 9600; 1108 case SENSOR_CO2: newBaudrate = 9600;
945 break; 1109 break;
946 case SENSOR_DIGO2: 1110 case SENSOR_DIGO2:
947 default: newBaudrate = 19200; 1111 default: newBaudrate = 19200;
948 break; 1112 break;
960 static uint32_t TriggerTick = 0; 1124 static uint32_t TriggerTick = 0;
961 uint8_t index = 0; 1125 uint8_t index = 0;
962 static uint8_t timeToTrigger = 0; 1126 static uint8_t timeToTrigger = 0;
963 uint32_t tick = HAL_GetTick(); 1127 uint32_t tick = HAL_GetTick();
964 uint8_t *pmap = externalInterface_GetSensorMapPointer(0); 1128 uint8_t *pmap = externalInterface_GetSensorMapPointer(0);
1129 uint8_t forceMuxChannel = 0;
965 1130
966 1131
967 if(externalInterfaceMuxReqIntervall != 0xFFFF) 1132 if(externalInterfaceMuxReqIntervall != 0xFFFF)
968 { 1133 {
969 UART_ReadData(pmap[activeSensorId]);
970
971 if(activeUartChannel == 0xFF) 1134 if(activeUartChannel == 0xFF)
972 { 1135 {
973 MX_USART1_UART_Init(); 1136 MX_USART1_UART_Init();
974 activeUartChannel = ExternalInterface_SelectUsedMuxChannel(0); 1137 activeUartChannel = ExternalInterface_SelectUsedMuxChannel(0);
975 uartO2_SetChannel(activeUartChannel); 1138 uartO2_SetChannel(activeUartChannel);
976 1139
977 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]) 1140 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET])
978 { 1141 {
979 case SENSOR_CO2: externalInterface_CheckBaudrate(SENSOR_CO2); 1142 case SENSOR_DIGO2:
1143 case SENSOR_GNSS:
1144 case SENSOR_CO2:
1145 case SENSOR_SENTINEL: externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]);
980 break; 1146 break;
981 default: 1147 default: externalInterface_CheckBaudrate(SENSOR_DIGO2);
982 case SENSOR_DIGO2: externalInterface_CheckBaudrate(SENSOR_DIGO2);
983 break; 1148 break;
984 } 1149 }
985 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) 1150 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
986 { 1151 {
1152 HAL_Delay(10); /* make sure MUX is available for reception after wakeup */
987 UART_MUX_SelectAddress(activeUartChannel); 1153 UART_MUX_SelectAddress(activeUartChannel);
988 } 1154 }
989 } 1155 }
990 1156
1157 if(externalInterface_SensorState[activeSensorId] != UART_COMMON_INIT)
1158 {
1159 UART_ReadData(pmap[activeSensorId], 0);
1160 UART_WriteData(&Uart1Ctrl);
1161 }
991 if(externalInterface_SensorState[activeSensorId] == UART_COMMON_INIT) 1162 if(externalInterface_SensorState[activeSensorId] == UART_COMMON_INIT)
992 { 1163 {
993 lastRequestTick = tick; 1164 lastRequestTick = tick;
994 TriggerTick = tick - 10; /* just to make sure control is triggered */ 1165 TriggerTick = tick - 10; /* just to make sure control is triggered */
995 timeToTrigger = 1; 1166 timeToTrigger = 1;
1004 1175
1005 TriggerTick = tick; 1176 TriggerTick = tick;
1006 timeToTrigger = COMMAND_TX_DELAY; 1177 timeToTrigger = COMMAND_TX_DELAY;
1007 retryRequest = 1; 1178 retryRequest = 1;
1008 } 1179 }
1009
1010 else if(time_elapsed_ms(lastRequestTick,tick) > externalInterfaceMuxReqIntervall) /* switch sensor and / or trigger next request */ 1180 else if(time_elapsed_ms(lastRequestTick,tick) > externalInterfaceMuxReqIntervall) /* switch sensor and / or trigger next request */
1011 { 1181 {
1012 lastRequestTick = tick; 1182 if(timeToTrigger == 0) /* no pending action */
1013 TriggerTick = tick; 1183 {
1014 retryRequest = 0; 1184 TriggerTick = tick;
1015 timeToTrigger = 1; 1185 retryRequest = 0;
1016 1186 timeToTrigger = 1;
1017 if((externalInterface_SensorState[activeSensorId] == UART_O2_REQ_O2) /* timeout */ 1187
1018 || (externalInterface_SensorState[activeSensorId] == UART_O2_REQ_RAW) 1188 if((externalInterface_SensorState[activeSensorId] == UART_O2_REQ_O2) /* timeout */
1019 || (externalInterface_SensorState[activeSensorId] == UART_CO2_OPERATING)) 1189 || (externalInterface_SensorState[activeSensorId] == UART_O2_REQ_RAW)
1020 { 1190 || (externalInterface_SensorState[activeSensorId] == UART_CO2_OPERATING)
1021 switch(pmap[activeSensorId]) 1191 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_PVT)
1192 || (externalInterface_SensorState[activeSensorId] == UART_GNSS_GET_SAT))
1022 { 1193 {
1023 case SENSOR_DIGO2: setExternalInterfaceChannel(activeSensorId,0.0); 1194 forceMuxChannel = 1;
1024 break; 1195 externalInterface_SensorState[activeSensorId] = UART_O2_IDLE;
1025 case SENSOR_CO2: externalInterface_SetCO2Value(0.0); 1196 switch(pmap[activeSensorId])
1026 externalInterface_SetCO2State(0); 1197 {
1027 break; 1198 case SENSOR_DIGO2: setExternalInterfaceChannel(activeSensorId,0.0);
1028 default: 1199 break;
1029 break; 1200 case SENSOR_CO2: externalInterface_SetCO2Value(0.0);
1201 externalInterface_SetCO2State(0);
1202 break;
1203 default:
1204 break;
1205 }
1030 } 1206 }
1031 } 1207 if((externalInterface_SensorState[activeSensorId] == UART_CO2_SETUP) /* timeout while setting up sensors */
1032 1208 || (externalInterface_SensorState[activeSensorId] == UART_O2_CHECK))
1033 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) /* select next sensor if mux is connected */
1034 {
1035 if(activeUartChannel < MAX_MUX_CHANNEL)
1036 { 1209 {
1037 index = ExternalInterface_SelectUsedMuxChannel(activeUartChannel); 1210 forceMuxChannel = 1;
1038 if(index != activeUartChannel) 1211 }
1212
1213
1214 if(pmap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) /* select next sensor if mux is connected */
1215 {
1216 if(activeUartChannel < MAX_MUX_CHANNEL)
1039 { 1217 {
1040 timeToTrigger = 100; 1218 index = ExternalInterface_SelectUsedMuxChannel(activeUartChannel);
1041 activeUartChannel = index; 1219 if((index != activeUartChannel) || (forceMuxChannel))
1042 if((pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_DIGO2)
1043 || (pmap[index + EXT_INTERFACE_MUX_OFFSET] == SENSOR_CO2))
1044 { 1220 {
1045 uartO2_SetChannel(activeUartChannel); 1221 forceMuxChannel = 0;
1046 externalInterface_CheckBaudrate(SENSOR_MUX); 1222 timeToTrigger = 100;
1047 UART_MUX_SelectAddress(activeUartChannel); 1223 activeUartChannel = index;
1048 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); 1224 switch(pmap[index + EXT_INTERFACE_MUX_OFFSET])
1225 {
1226 case SENSOR_DIGO2: uartO2_SetChannel(activeUartChannel);
1227 /* no break */
1228 case SENSOR_CO2:
1229 case SENSOR_GNSS: externalInterface_CheckBaudrate(SENSOR_MUX);
1230 UART_MUX_SelectAddress(activeUartChannel);
1231 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]);
1232 break;
1233 default:
1234 break;
1235 }
1049 } 1236 }
1050 } 1237 }
1051 } 1238 }
1052 } 1239 }
1053 else
1054 {
1055 timeToTrigger = 1;
1056 }
1057 } 1240 }
1058 if((timeToTrigger != 0) && (time_elapsed_ms(TriggerTick,tick) > timeToTrigger)) 1241 if((timeToTrigger != 0) && (time_elapsed_ms(TriggerTick,tick) > timeToTrigger))
1059 { 1242 {
1243 lastRequestTick = tick;
1060 timeToTrigger = 0; 1244 timeToTrigger = 0;
1061 switch (pmap[activeSensorId]) 1245 switch (pmap[activeSensorId])
1062 { 1246 {
1063 case SENSOR_MUX: 1247 case SENSOR_MUX:
1064 case SENSOR_DIGO2: uartO2_Control(); 1248 case SENSOR_DIGO2: uartO2_Control();
1065 break; 1249 break;
1066 #ifdef ENABLE_CO2_SUPPORT 1250 #ifdef ENABLE_CO2_SUPPORT
1067 case SENSOR_CO2: uartCo2_Control(); 1251 case SENSOR_CO2: uartCo2_Control();
1068 break; 1252 break;
1069 #endif 1253 #endif
1254 #ifdef ENABLE_GNSS_SUPPORT
1255 case SENSOR_GNSS: uartGnss_Control();
1256 break;
1257 #endif
1258 #ifdef ENABLE_SENTINEL_MODE
1259 case SENSOR_SENTINEL: uartSentinel_Control();
1260 break;
1261 #endif
1070 default: 1262 default:
1071 break; 1263 break;
1072 } 1264 }
1073 } 1265 }
1074 } 1266 }
1075 1267
1076
1077
1078 #if 0 1268 #if 0
1079 #ifdef ENABLE_SENTINEL_MODE 1269 #ifdef ENABLE_SENTINEL_MODE
1080 if(externalInterface_GetUARTProtocol() & (EXT_INTERFACE_UART_SENTINEL >> 8)) 1270 if(externalInterface_GetUARTProtocol() & (EXT_INTERFACE_UART_SENTINEL))
1081 { 1271 {
1082 UART_HandleSentinelData(); 1272 UART_HandleSentinelData();
1083 } 1273 }
1084 #endif 1274 #endif
1085 #endif 1275 #endif
1086 1276 }
1087
1088 }