Mercurial > public > ostc4

comparison Small_CPU/Src/externalInterface.c @ 1080:b02311fbb1e1 Icon_Integration tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added MUX operation for HUD: Instead of adding some new detection steps to the autodetection loop (which would be another copy paste implementation) the detection loop has been reworked. Instead of having a several individual steps per sensor type the steps are now related to mux channels. A structure is used to identify the type which shall be handled during the uart channel iteration. This make the code better readable and maintanance easier.
author Ideenmodellierer
date Sun, 08 Mar 2026 21:08:33 +0100
parents bd8ab302ef4a
children
comparison
equal deleted inserted replaced
1079:9e1fdb383d86 1080:b02311fbb1e1
103 static float LookupCO2PressureCorrection[LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE]; /* lookup table for pressure compensation values */ 103 static float LookupCO2PressureCorrection[LOOKUP_CO2_CORR_TABLE_MAX / LOOKUP_CO2_CORR_TABLE_SCALE]; /* lookup table for pressure compensation values */
104 104
105 static uint16_t externalInterfaceMuxReqIntervall = 0xffff; /* delay between switching from one MUX channel to the next */ 105 static uint16_t externalInterfaceMuxReqIntervall = 0xffff; /* delay between switching from one MUX channel to the next */
106 static uint8_t activeUartChannel = 0xff; 106 static uint8_t activeUartChannel = 0xff;
107 107
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 };
108 118
109 static void externalInface_MapUartToLegacyADC(uint8_t* pMap); 119 static void externalInface_MapUartToLegacyADC(uint8_t* pMap);
110 static void externalInterface_CheckBaudrate(uint8_t sensorType); 120 static void externalInterface_CheckBaudrate(uint8_t sensorType);
111 121
112 void externalInterface_Init(void) 122 void externalInterface_Init(void)
691 pret = SensorMap; 701 pret = SensorMap;
692 } 702 }
693 return pret; 703 return pret;
694 } 704 }
695 705
706 static externalInterfaceAutoDetect_t externalInterface_NextUartTypeDetection(externalInterfaceSensorType* pCurrenttype)
707 {
708 uint8_t index = 0;
709 externalInterfaceAutoDetect_t nextDetectionStep = DETECTION_DONE;
710
711 while(uartTypeDetection[index] != SENSOR_END)
712 {
713 if(uartTypeDetection[index] == *pCurrenttype)
714 {
715 break;
716 }
717 index++;
718 }
719
720 if(uartTypeDetection[index] != SENSOR_END)
721 {
722 index++;
723 if(uartTypeDetection[index] != SENSOR_END)
724 {
725 externalAutoDetect = DETECTION_UART0;
726 *pCurrenttype = uartTypeDetection[index];
727 switch(*pCurrenttype) /* sensor type specific initialization */
728 {
729 case SENSOR_DIGO2: uartO2_SetChannel(0);
730 break;
731 case SENSOR_GNSS: /* TODO: implement faster call cycles for external GNSS */
732 /* externalInterfaceMuxReqIntervall = 500; */
733 /* iterations needed for module config */
734 /* detectionDelayCnt = 6; */
735 break;
736 default:
737 break;
738 }
739
740 activeUartChannel = 0;
741 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = *pCurrenttype;
742 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
743 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
744 {
745 externalInterface_CheckBaudrate(SENSOR_MUX);
746 UART_MUX_SelectAddress(0);
747 }
748 nextDetectionStep = DETECTION_UART0;
749 }
750 }
751 return nextDetectionStep;
752 }
753
696 void externalInterface_AutodetectSensor() 754 void externalInterface_AutodetectSensor()
697 { 755 {
698 static uint8_t sensorIndex = 0; 756 static uint8_t sensorIndex = 0;
699 static uint8_t uartMuxChannel = 0; 757 static uint8_t uartMuxChannel = 0;
758 static externalInterfaceSensorType currentUartType = SENSOR_MUX;
700 #ifdef ENABLE_GNSS_EXTERN 759 #ifdef ENABLE_GNSS_EXTERN
701 static uint8_t detectionDelayCnt = 0; 760 static uint8_t detectionDelayCnt = 0;
702 #endif 761 #endif
703 uint8_t index = 0; 762 uint8_t index = 0;
704 763 uint8_t sensorFound = 0;
705 uint8_t cntSensor = 0; 764 uint8_t cntSensor = 0;
706 uint8_t cntUARTSensor = 0; 765 uint8_t cntUARTSensor = 0;
766 uint8_t nextType = 0;
707 767
708 if(externalAutoDetect != DETECTION_OFF) 768 if(externalAutoDetect != DETECTION_OFF)
709 { 769 {
710 switch(externalAutoDetect) 770 switch(externalAutoDetect)
711 { 771 {
712 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0xffff; 772 case DETECTION_INIT: externalInterfaceMuxReqIntervall = 0xffff;
773 currentUartType = SENSOR_MUX;
713 sensorIndex = 0; 774 sensorIndex = 0;
714 uartMuxChannel = 0; 775 uartMuxChannel = 0;
715 tmpSensorMap[0] = SENSOR_OPTIC; 776 tmpSensorMap[0] = SENSOR_OPTIC;
716 tmpSensorMap[1] = SENSOR_OPTIC; 777 tmpSensorMap[1] = SENSOR_OPTIC;
717 tmpSensorMap[2] = SENSOR_OPTIC; 778 tmpSensorMap[2] = SENSOR_OPTIC;
778 } 839 }
779 else 840 else
780 { 841 {
781 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE; 842 tmpSensorMap[EXT_INTERFACE_SENSOR_CNT-1] = SENSOR_NONE;
782 } 843 }
783 externalAutoDetect = DETECTION_DIGO2_0; 844 externalAutoDetect = externalInterface_NextUartTypeDetection(&currentUartType);
784 uartO2_SetChannel(0); 845 externalInterface_CheckBaudrate(currentUartType);
785 activeUartChannel = 0; 846 break;
786 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; 847 case DETECTION_UART0:
787 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; 848 case DETECTION_UART1:
788 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); 849 case DETECTION_UART2:
789 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX) 850 case DETECTION_UART3: switch(currentUartType)
790 { 851 {
791 UART_MUX_SelectAddress(0); 852 case SENSOR_DIGO2: if(uartO2_isSensorConnected()) { sensorFound = 1; }
853 break;
854 case SENSOR_CO2: if(uartCo2_isSensorConnected()) { sensorFound = 1; nextType = 1;}
855 break;
856 #ifdef ENABLE_HUD_SUPPORT
857 case SENSOR_HUD: if(uartHUD_isSensorConnected()) { sensorFound = 1; nextType = 1;}
858 break;
859 #endif
860 default:
861 break;
792 } 862 }
793 break; 863 if(sensorFound)
794 case DETECTION_DIGO2_0:
795 case DETECTION_DIGO2_1:
796 case DETECTION_DIGO2_2:
797 case DETECTION_DIGO2_3:
798 if(uartO2_isSensorConnected())
799 { 864 {
800 foundSensorMap[externalAutoDetect - DETECTION_DIGO2_0 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; 865 foundSensorMap[externalAutoDetect - DETECTION_UART0 + EXT_INTERFACE_MUX_OFFSET] = currentUartType;
801 } 866 }
802 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; 867 if((externalAutoDetect == DETECTION_UART0) && (foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX))
803 if(uartMuxChannel)
804 { 868 {
805 externalInterface_SwitchUART(EXT_INTERFACE_UART_O2); 869 uartMuxChannel = 1;
870 }
871 tmpSensorMap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; /* reset detection slot */
872 if((uartMuxChannel) && (externalAutoDetect != DETECTION_UART3) && (nextType == 0))
873 {
874 externalInterface_CheckBaudrate(SENSOR_MUX);
806 UART_MUX_SelectAddress(uartMuxChannel); 875 UART_MUX_SelectAddress(uartMuxChannel);
807 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT; 876 externalInterface_SensorState[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
808 uartO2_SetChannel(uartMuxChannel); 877 externalInterface_CheckBaudrate(currentUartType);
878 switch(currentUartType)
879 {
880 case SENSOR_DIGO2: uartO2_SetChannel(uartMuxChannel);
881 break;
882 default:
883 break;
884 }
809 activeUartChannel = uartMuxChannel; 885 activeUartChannel = uartMuxChannel;
810 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE; 886 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = currentUartType;
811 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_DIGO2; 887
812 888 uartMuxChannel++;
813 if(uartMuxChannel < MAX_MUX_CHANNEL - 1) 889 externalAutoDetect++;
814 {
815 uartMuxChannel++;
816 }
817 } 890 }
818 else 891 else
819 { 892 {
820 externalAutoDetect = DETECTION_DIGO2_3; /* skip detection of other serial sensors */ 893 externalAutoDetect = externalInterface_NextUartTypeDetection(&currentUartType);
894 externalInterface_CheckBaudrate(currentUartType);
821 } 895 }
822 externalAutoDetect++; 896 break;
823 #ifdef ENABLE_CO2_SUPPORT 897
824 if(externalAutoDetect == DETECTION_CO2_0)
825 {
826 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
827 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
828 {
829 UART_MUX_SelectAddress(0);
830 }
831 activeUartChannel = 0;
832 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
833 uartMuxChannel = 1;
834 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_CO2;
835 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
836 externalInterface_CheckBaudrate(SENSOR_CO2);
837 }
838 break;
839 case DETECTION_CO2_0:
840 case DETECTION_CO2_1:
841 case DETECTION_CO2_2:
842 case DETECTION_CO2_3: if(uartCo2_isSensorConnected())
843 {
844 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_CO2;
845 #ifdef ENABLE_GNSS_EXTERN
846 externalAutoDetect = DETECTION_GNSS_0; /* only one CO2 sensor supported */
847 #else
848 externalAutoDetect = DETECTION_DONE; /* only one CO2 sensor supported */
849 #endif
850 }
851 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
852 {
853 externalInterface_CheckBaudrate(SENSOR_DIGO2);
854 UART_MUX_SelectAddress(uartMuxChannel);
855 activeUartChannel = uartMuxChannel;
856 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
857 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2;
858 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT;
859 externalInterface_CheckBaudrate(SENSOR_CO2);
860 externalAutoDetect++;
861 uartMuxChannel++;
862 }
863 else
864 {
865
866
867 #if defined ENABLE_SENTINEL_MODE || defined ENABLE_GNSS_EXTERN || defined ENABLE_HUD_SUPPORT
868 #ifdef ENABLE_GNSS_EXTERN
869 externalAutoDetect = DETECTION_GNSS_0;
870 externalInterface_SwitchUART(EXT_INTERFACE_UART_GNSS);
871 #else
872 #ifdef ENABLE_SENTINEL_MODE
873 externalAutoDetect = DETECTION_SENTINEL;
874 #else
875 #ifdef ENABLE_HUD_SUPPORT
876 externalAutoDetect = DETECTION_HUD_0;
877 #endif
878 #endif
879 #endif
880 #else
881 externalAutoDetect = DETECTION_DONE;
882 #endif
883 }
884 #endif
885
886 #ifdef ENABLE_GNSS_EXTERN
887 if(externalAutoDetect == DETECTION_GNSS_0)
888 {
889 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
890 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
891 {
892 externalInterface_CheckBaudrate(SENSOR_DIGO2);
893 UART_MUX_SelectAddress(0);
894 }
895 activeUartChannel = 0;
896 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
897 uartMuxChannel = 1;
898 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_GNSS;
899 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
900 externalInterface_CheckBaudrate(SENSOR_GNSS);
901 externalInterfaceMuxReqIntervall = 500; /* iterations needed for module config */
902 detectionDelayCnt = 6;
903 }
904 break;
905 case DETECTION_GNSS_0:
906 case DETECTION_GNSS_1:
907 case DETECTION_GNSS_2:
908 case DETECTION_GNSS_3: if(detectionDelayCnt == 0)
909 {
910 if(uartGnss_isSensorConnected())
911 {
912 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_GNSS;
913 #ifdef ENABLE_SENTINEL_MODE
914 externalAutoDetect = DETECTION_SENTINEL; /* only one GNSS sensor supported */
915 #else
916 externalAutoDetect = DETECTION_DONE; /* only one GNSS sensor supported */
917 #endif
918 }
919 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
920 {
921 externalInterface_CheckBaudrate(SENSOR_DIGO2);
922 UART_MUX_SelectAddress(uartMuxChannel);
923 activeUartChannel = uartMuxChannel;
924 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
925 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2;
926 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT;
927 externalInterface_CheckBaudrate(SENSOR_CO2);
928 // uartGnss_SendCmd(GNSSCMD_MODE_POLL, cmdString, &cmdLength);
929 externalAutoDetect++;
930 detectionDelayCnt = 3;
931 uartMuxChannel++;
932 }
933 else
934 {
935 #ifdef ENABLE_SENTINEL_MODE
936 externalAutoDetect = DETECTION_SENTINEL;
937 #else
938 externalAutoDetect = DETECTION_DONE;
939 #endif
940 }
941 }
942 else
943 {
944 detectionDelayCnt--;
945 }
946 #endif
947 #ifdef ENABLE_SENTINEL_MODE
948 if(externalAutoDetect == DETECTION_SENTINEL)
949 {
950 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
951 uartO2_SetChannel(0);
952 activeUartChannel = 0;
953 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_SENTINEL;
954 externalInterface_SwitchUART(EXT_INTERFACE_UART_SENTINEL);
955 externalInterface_CheckBaudrate(SENSOR_SENTINEL);
956 UART_StartDMA_Receiption(&Uart1Ctrl);
957 }
958 break;
959
960 case DETECTION_SENTINEL:
961 case DETECTION_SENTINEL2:
962 if(uartSentinel_isSensorConnected())
963 {
964 for(index = EXT_INTERFACE_MUX_OFFSET; index < EXT_INTERFACE_MUX_OFFSET+3; index++)
965 {
966 foundSensorMap[index] = SENSOR_SENTINEL;
967 }
968 }
969 externalAutoDetect++;
970 #endif
971
972 #ifdef ENABLE_HUD_SUPPORT
973 if(externalAutoDetect == DETECTION_HUD_0)
974 {
975 tmpSensorMap[uartMuxChannel + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
976 if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
977 {
978 externalInterface_CheckBaudrate(SENSOR_DIGO2);
979 UART_MUX_SelectAddress(0);
980 }
981 activeUartChannel = 0;
982 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
983 uartMuxChannel = 1;
984 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET] = SENSOR_HUD;
985 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET] = UART_COMMON_INIT;
986 externalInterface_CheckBaudrate(SENSOR_HUD);
987 externalInterfaceMuxReqIntervall = 500; /* iterations needed for module config */
988 }
989 break;
990 case DETECTION_HUD_0:
991 case DETECTION_HUD_1:
992 case DETECTION_HUD_2:
993 case DETECTION_HUD_3:
994 if(uartHUD_isSensorConnected())
995 {
996 foundSensorMap[EXT_INTERFACE_MUX_OFFSET + activeUartChannel] = SENSOR_HUD;
997 externalAutoDetect = DETECTION_DONE; /* only one HUD sensor supported */
998 }
999 else if(foundSensorMap[EXT_INTERFACE_SENSOR_CNT-1] == SENSOR_MUX)
1000 {
1001 externalInterface_CheckBaudrate(SENSOR_DIGO2);
1002 UART_MUX_SelectAddress(uartMuxChannel);
1003 activeUartChannel = uartMuxChannel;
1004 tmpSensorMap[uartMuxChannel - 1 + EXT_INTERFACE_MUX_OFFSET] = SENSOR_NONE;
1005 tmpSensorMap[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = SENSOR_CO2;
1006 externalInterface_SensorState[EXT_INTERFACE_MUX_OFFSET + uartMuxChannel] = UART_COMMON_INIT;
1007 externalInterface_CheckBaudrate(SENSOR_HUD);
1008 externalAutoDetect++;
1009 uartMuxChannel++;
1010 }
1011 else
1012 {
1013 externalAutoDetect = DETECTION_DONE;
1014 }
1015 #endif
1016 break;
1017 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF; 898 case DETECTION_DONE: externalAutoDetect = DETECTION_OFF;
1018 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF); 899 externalInterface_SwitchUART(EXT_INTERFACE_UART_OFF);
1019 activeUartChannel = 0xFF; 900 activeUartChannel = 0xFF;
1020 cntSensor = 0; 901 cntSensor = 0;
1021 cntUARTSensor = 0; 902 cntUARTSensor = 0;
1085 case EXT_INTERFACE_COPY_SENSORMAP: if(externalAutoDetect == DETECTION_OFF) 966 case EXT_INTERFACE_COPY_SENSORMAP: if(externalAutoDetect == DETECTION_OFF)
1086 { 967 {
1087 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap)); 968 memcpy(SensorMap, MasterSensorMap, sizeof(MasterSensorMap));
1088 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++) 969 for(index = 0; index < EXT_INTERFACE_SENSOR_CNT; index++)
1089 { 970 {
1090 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2) || (SensorMap[index] == SENSOR_GNSS) || (SensorMap[index] == SENSOR_SENTINEL)) 971 if((SensorMap[index] == SENSOR_DIGO2) || (SensorMap[index] == SENSOR_CO2) || (SensorMap[index] == SENSOR_GNSS)
972 || (SensorMap[index] == SENSOR_SENTINEL) || (SensorMap[index] == SENSOR_HUD))
1091 { 973 {
1092 cntUARTSensor++; 974 cntUARTSensor++;
1093 } 975 }
1094 } 976 }
1095 externalInface_MapUartToLegacyADC(SensorMap); 977 externalInface_MapUartToLegacyADC(SensorMap);
1188 { 1070 {
1189 case SENSOR_GNSS: 1071 case SENSOR_GNSS:
1190 case SENSOR_SENTINEL: 1072 case SENSOR_SENTINEL:
1191 case SENSOR_CO2: newBaudrate = 9600; 1073 case SENSOR_CO2: newBaudrate = 9600;
1192 break; 1074 break;
1075 case SENSOR_MUX:
1193 case SENSOR_HUD: 1076 case SENSOR_HUD:
1194 case SENSOR_DIGO2: 1077 case SENSOR_DIGO2:
1195 default: newBaudrate = 19200; 1078 default: newBaudrate = 19200;
1196 break; 1079 break;
1197 } 1080 }
1225 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]) 1108 switch(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET])
1226 { 1109 {
1227 case SENSOR_DIGO2: 1110 case SENSOR_DIGO2:
1228 case SENSOR_GNSS: 1111 case SENSOR_GNSS:
1229 case SENSOR_CO2: 1112 case SENSOR_CO2:
1113 case SENSOR_HUD:
1230 case SENSOR_SENTINEL: externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); 1114 case SENSOR_SENTINEL: externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]);
1231 break; 1115 break;
1232 default: externalInterface_CheckBaudrate(SENSOR_DIGO2); 1116 default: externalInterface_CheckBaudrate(SENSOR_DIGO2);
1233 break; 1117 break;
1234 } 1118 }
1320 switch(pmap[index + EXT_INTERFACE_MUX_OFFSET]) 1204 switch(pmap[index + EXT_INTERFACE_MUX_OFFSET])
1321 { 1205 {
1322 case SENSOR_DIGO2: uartO2_SetChannel(activeUartChannel); 1206 case SENSOR_DIGO2: uartO2_SetChannel(activeUartChannel);
1323 /* no break */ 1207 /* no break */
1324 case SENSOR_CO2: 1208 case SENSOR_CO2:
1209 case SENSOR_HUD:
1325 case SENSOR_GNSS: externalInterface_CheckBaudrate(SENSOR_MUX); 1210 case SENSOR_GNSS: externalInterface_CheckBaudrate(SENSOR_MUX);
1326 UART_MUX_SelectAddress(activeUartChannel); 1211 UART_MUX_SelectAddress(activeUartChannel);
1327 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]); 1212 externalInterface_CheckBaudrate(pmap[activeUartChannel + EXT_INTERFACE_MUX_OFFSET]);
1328 break; 1213 break;
1329 default: 1214 default: