DL High Low 둘다 Alarm 울리도록 수정 ,Req Data 320Byte 전송 하도록 수정

Bluecell_Inc/Bluecell_operate.h

@@ -705,11 +705,11 @@ typedef struct{
     uint8_t DLI_Level_High_Low_Threshold_default;
     uint8_t ALARM_TEMP_HIGH; //bit
     uint8_t ALARM_DLI_Level;
-    uint8_t ALARM_DLI_AGC_SHTUTDOWN;
+    uint8_t ALARM_DLI_SHTUTDOWN;
     uint8_t ALARM_DLI_AGC_Alarm;
     uint8_t ALARM_ULO_ALC_Alarm;    
     uint8_t ALARM_ULO_Level;
-    uint8_t ALARM_ULO_ALC_SHTUTDOWN;
+    uint8_t ALARM_ULO_SHTUTDOWN;
     uint8_t ALARM_MASK1;
     uint8_t ALARM_TESTMODE;
     uint8_t ALARM_Test_Dummy1;
@@ -836,8 +836,8 @@ typedef struct{
     uint8_t Reserve3;
     uint8_t Reserve4;
     uint8_t Reserve5;
-    uint8_t Reserve6;
-    uint8_t bluecell_crc;
+    uint8_t bluecell_crc_H;
+    uint8_t bluecell_crc_L;
     uint8_t bluecell_etx;
 
 }BLUESTATUS_st;
@@ -1118,6 +1118,20 @@ typedef enum{
     DET_Alarm_UL4_Index,
     DET_Alarm_UL_Index_MAX,
 };
+typedef enum{
+    DET_Alarm_DL1_Shutdown_Index = 0,
+    DET_Alarm_DL2_Shutdown_Index,
+    DET_Alarm_DL3_Shutdown_Index,
+    DET_Alarm_DL4_Shutdown_Index,
+    DET_Alarm_DL_Shutdown_Index_MAX,
+};
+typedef enum{
+    DET_Alarm_UL1_Shutdown_Index = 0,
+    DET_Alarm_UL2_Shutdown_Index,
+    DET_Alarm_UL3_Shutdown_Index,
+    DET_Alarm_UL4_Shutdown_Index,
+    DET_Alarm_UL_Shutdown_Index_MAX,
+};
 #define ADC1_EA Bluecell_ADC1_MaxLength /2
 #define ADC3_EA Bluecell_ADC3_MaxLength /2
 

Bluecell_Inc/CRC.h

@@ -16,8 +16,9 @@ typedef enum{
 }etError;
 
 
-uint16_t CRC16_Generate(uint8_t *buf_ptr, int32_t len);
-etError CRC16_Check(uint8_t *buf_ptr, int32_t len,uint16_t checksum);
+uint16_t CRC16_Generate(uint8_t* buf_ptr, int len);
+etError CRC16_Check(uint8_t* buf_ptr, int len,uint16_t checksum);
+
 
 uint8_t STH30_CreateCrc(uint8_t *data, uint8_t nbrOfBytes);
 etError STH30_CheckCrc(uint8_t *data, uint8_t nbrOfBytes, uint8_t checksum);

Bluecell_Inc/uart.h

@@ -35,7 +35,7 @@ void InitUartQueue(pUARTQUEUE pQueue);
 void GetDataFromUartQueue(UART_HandleTypeDef *huart);
 bool Get_UartRcv(void);
 void Set_UartRcv(bool);
-void Uart1_Data_Send(uint8_t* data,uint8_t size);
+void Uart1_Data_Send(uint8_t* data,uint16_t size);
 void Uart_Check(void);
 
 #endif /* UART_H_ */

Bluecell_Src/Bluecell_operate.c

@@ -13,7 +13,7 @@
 /***************************************************************************************/
 
 extern void PE43711_atten_ctrl(PE43711_st ATT ,uint8_t data);
-extern void Uart1_Data_Send(uint8_t* data,uint8_t size);
+extern void Uart1_Data_Send(uint8_t* data,uint16_t size);
 extern HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address);
 /***************************************************************************************/
 /*                                  Extern Valuable                                    */
@@ -1469,9 +1469,13 @@ bool Bluecell_Operate(uint8_t* data){
     case ATT_TableGet:
         Bluecell_TableLoad(data, data[BLUECELL_DATA]);
         data[BLUECELL_TYPE] = ATT_TableGet;
-        data[data[BLUECELL_LENGTH] + 1] = STH30_CreateCrc(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]);
-        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 3);
-        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 3);
+
+        data[data[BLUECELL_LENGTH] + 1] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0xFF00) >> 8);
+        data[data[BLUECELL_LENGTH] + 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0x00FF;        
+        data[data[BLUECELL_LENGTH] + 3] = 0xEB;
+        
+        Bluecell_StructCpy(&Txdata[0],&data[0],data[BLUECELL_LENGTH] + 4);
+        Uart1_Data_Send(&Txdata[0], Txdata[BLUECELL_LENGTH] + 4);
 #if 0 // PYJ.2020.04.22_BEGIN -- 
         for(int i = 0 ; i < data[BLUECELL_LENGTH] + 3; i++ ){
 //            printf("%x ",data[i]);
@@ -1482,16 +1486,25 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_StatusReq:
         DataStatusSet();
+#if 0 // PYJ.2020.05.28_BEGIN -- 
         Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,94);
         Txdata[BLUECELL_LENGTH] = 94 - 3;//sizeof(BLUESTATUS_st) - 3;
         Txdata[94 - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
+#else        
+        Bluecell_StructCpy(&Txdata[0],&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
+        Txdata[BLUECELL_LENGTH] = sizeof(BLUESTATUS_st) - 3;//sizeof(BLUESTATUS_st) - 3;
+//        Txdata[sizeof(BLUESTATUS_st) - 2] = STH30_CreateCrc(&Txdata[BLUECELL_TYPE], Txdata[BLUECELL_LENGTH]);
+        Txdata[sizeof(BLUESTATUS_st) - 3] = ((CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0xFF00) >> 8);
+        Txdata[sizeof(BLUESTATUS_st) - 2] = CRC16_Generate(&data[BLUECELL_TYPE], data[BLUECELL_LENGTH]) & 0x00FF;        
+        
+#endif // PYJ.2020.05.28_END -- 
 #if 0 // PYJ.2020.04.22_BEGIN -- 
         for(int i = 0 ; i < sizeof(BLUESTATUS_st); i++ ){
             printf("%x ",Txdata[i]);
         }
         printf("\r\n");
 #endif // PYJ.2020.04.22_END --    
-        Uart1_Data_Send(&Txdata[0], 94);
+        Uart1_Data_Send(&Txdata[0], sizeof(BLUESTATUS_st));
         break;
     case Bluecell_StatusSave:
 //        printf("Copy Complete");
@@ -1596,8 +1609,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.DLI_Shutdown_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.DLI_Shutdown_Threshold_L ;
-//        tempdata /= 10;
-//        printf("tempdata : %d\r\n",tempdata);
+        tempdata /= 10;
+        printf("tempdata : %d\r\n",tempdata);
 //        bluecell_Currdatastatus.DLI_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
 //        bluecell_Currdatastatus.DLI_Shutdown_Threshold_L = (tempdata & 0x00FF);
 //        printf("tempdata %d \r\n",tempdata);
@@ -1656,7 +1669,11 @@ bool Bluecell_Operate(uint8_t* data){
         break;
     case Bluecell_Temp_High_Threshold                     :   
         bluecell_Currdatastatus.Temp_High_Threshold = data[BLUECELL_DATA + i++];
-        printf("%s : %d \r\n",__func__,__LINE__);
+        printf("%s : %d Temps_High_Threshold :  %d\r\n",__func__,__LINE__,bluecell_Currdatastatus.Temp_High_Threshold);
+        printf("Temp_High_Threshold : %d :   Det %d \r\n",bluecell_Currdatastatus.Temp_High_Threshold,bluecell_Currdatastatus.DET_TEMP);
+        printf("Temp_High_Alarm : %d \r\n",bluecell_Currdatastatus.Temp_High_Alarm);
+        printf("Txdata : %d \r\n",Txdata[201]);
+    
         break;
     case Bluecell_Temp_High_Threshold_Default             :   
         bluecell_Currdatastatus.Temp_High_Threshold_Default = data[BLUECELL_DATA + i++];
@@ -1715,8 +1732,8 @@ bool Bluecell_Operate(uint8_t* data){
         bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = data[BLUECELL_DATA + i++];
         tempdata = (( bluecell_Currdatastatus.ULO_Shutdown_Threshold_H << 8) & 0xFF00) ;
         tempdata +=  bluecell_Currdatastatus.ULO_Shutdown_Threshold_L ;
-//        tempdata /= 10;
-//        printf("tempdata : %d\r\n",tempdata);
+        tempdata /= 10;
+        printf("tempdata : %d\r\n",tempdata);
 //        bluecell_Currdatastatus.ULO_Shutdown_Threshold_H = ((tempdata & 0xFF00) >> 8);
 //        bluecell_Currdatastatus.ULO_Shutdown_Threshold_L = (tempdata & 0x00FF);     
 
@@ -1732,7 +1749,7 @@ bool Bluecell_Operate(uint8_t* data){
     case Bluecell_ULO_Shutdown_Retry_Count                :   
         break;
     case Bluecell_Alarm_Mask:
-        bluecell_Currdatastatus.ALARM_MASK1 = data[BLUECELL_DATA + i+ 1];
+        bluecell_Currdatastatus.ALARM_MASK1 = (data[BLUECELL_DATA + i+ 1] / 10);
          printf("%s : %d   ALARM_MASK1 : %d \r\n",__func__,__LINE__,bluecell_Currdatastatus.ALARM_MASK1);
         break;
   }
@@ -1901,9 +1918,9 @@ bool MBIC_Operate(uint8_t* data){
         /*ALARM BIT LIST*/
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_TEMP_HIGH;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_Level;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN;
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_ULO_Level;
-        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN;
+        data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN;
         /*ALARM BIT LIST*/
 
         data[MBIC_PAYLOADSTART + i++] = bluecell_Currdatastatus.ALARM_MASK1;
@@ -2790,8 +2807,13 @@ uint32_t SumFunc(uint16_t* data,uint16_t size){
 
 
 
-bool ADC_Alarm_DL_Set[DET_Alarm_DL_Index_MAX] = {false,} ;
+bool ADC_Alarm_DL_High_Set[DET_Alarm_DL_Index_MAX] = {false,} ;
+bool ADC_Alarm_DL_Low_Set[DET_Alarm_DL_Index_MAX] = {false,} ;
+
 bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX] = {false,} ;
+bool ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL_Shutdown_Index_MAX] = {false,} ;
+bool ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL_Shutdown_Index_MAX] = {false,} ;
+
 void DET_LevelAlarmCheck(){
     int16_t DL[DET_Alarm_DL_Index_MAX] = {0,};
     int16_t UL[DET_Alarm_UL_Index_MAX] = {0,};
@@ -2799,14 +2821,24 @@ void DET_LevelAlarmCheck(){
     
     int16_t LimitData_DL_High = 0;    
     int16_t LimitData_DL_Low = 0;    
+
+
+    int16_t LimitData_DL_Shutdown = 0;    
+    int16_t LimitData_UL_Shutdown = 0;    
+    
     double ret = 0;
     int8_t Res_DL_dBm[DET_Alarm_DL_Index_MAX] = {0,};
     int8_t Res_UL_dBm[DET_Alarm_UL_Index_MAX] = {0,};    
     
 
     LimitData_UL_High = ConvertTo2byte(bluecell_Currdatastatus.ULO_Level_High_Threshold_H,bluecell_Currdatastatus.ULO_Level_High_Threshold_L) / 10;
+
     LimitData_DL_High = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_High_Threshold_H,bluecell_Currdatastatus.DLI_Level_High_Threshold_L)/ 10;
     LimitData_DL_Low = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level_Low_Threshold_H,bluecell_Currdatastatus.DLI_Level_Low_Threshold_L)/ 10;
+
+    LimitData_DL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.DLI_Shutdown_Threshold_H,bluecell_Currdatastatus.DLI_Shutdown_Threshold_L)/ 10;
+    LimitData_UL_Shutdown = ConvertTo2byte(bluecell_Currdatastatus.ULO_Shutdown_Threshold_H,bluecell_Currdatastatus.ULO_Shutdown_Threshold_L)/ 10;
+    
     DL[DET_Alarm_DL1_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level1_H,bluecell_Currdatastatus.DLI_Level1_L);
     DL[DET_Alarm_DL2_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level2_H,bluecell_Currdatastatus.DLI_Level2_L);
     DL[DET_Alarm_DL3_Index] = ConvertTo2byte(bluecell_Currdatastatus.DLI_Level3_H,bluecell_Currdatastatus.DLI_Level3_L);
@@ -2879,6 +2911,9 @@ void DET_LevelAlarmCheck(){
 
 //    printf("LimitData_DL_High : %d \r\n",LimitData_DL_High);    
 //    printf("LimitData_DL_Low : %d \r\n",LimitData_DL_Low);   
+    /*
+        UL Level Alarm Check Part
+    */
     for(int i = 0 ; i < DET_Alarm_UL_Index_MAX; i++){
         if(LimitData_UL_High > Res_UL_dBm[DET_Alarm_UL1_Index + i]){
             ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] = true;
@@ -2889,16 +2924,45 @@ void DET_LevelAlarmCheck(){
 //            printf("ADC_Alarm_UL_Set %d ,Value : %d\r\n",DET_Alarm_UL1_Index + i,ADC_Alarm_UL_Set[DET_Alarm_UL1_Index + i] );            
         }
     }
-#if 1 // PYJ.2020.05.27_BEGIN -- 
+    /*
+        DL Level Alarm Check Part
+    */
     for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
-        if(LimitData_DL_High > Res_DL_dBm[DET_Alarm_DL1_Index + i]
-         &&LimitData_DL_Low < Res_DL_dBm[DET_Alarm_DL1_Index + i])
-            ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = true;
+        if(LimitData_DL_High > Res_DL_dBm[DET_Alarm_DL1_Index + i])
+            ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = true;
         else
-            ADC_Alarm_DL_Set[DET_Alarm_DL1_Index + i] = false;
+            ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index + i] = false;
     }    
-//    HAL_Delay(1000);
-#endif // PYJ.2020.05.27_END -- 
+    
+    for(int i = 0 ; i < DET_Alarm_DL_Index_MAX; i++){
+        if(LimitData_DL_Low < Res_DL_dBm[DET_Alarm_DL1_Index + i])
+            ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = true;
+        else
+            ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index + i] = false;
+    }       
+    /*
+        DL Shutdown Alarm Check Part
+    */
+
+    for(int i = 0 ; i < DET_Alarm_DL_Shutdown_Index_MAX; i++){
+        if(LimitData_DL_Shutdown < Res_DL_dBm[DET_Alarm_DL1_Shutdown_Index + i])
+            ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = true;
+        else
+            ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index + i] = false;
+    }  
+    
+    /*
+        UL Shutdown Alarm Check Part
+    */
+    for(int i = 0 ; i < DET_Alarm_UL_Shutdown_Index_MAX; i++){
+        if(LimitData_UL_Shutdown < Res_UL_dBm[DET_Alarm_UL1_Shutdown_Index + i]){
+            ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = true;
+        }
+        else{
+            ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index + i] = false;
+        }
+    }
+
 }
 void ADC_Check(void){
     //static uint8_t Cnt = 0;
@@ -3850,11 +3914,12 @@ void Alarm_Check(){
 
     if(bluecell_Currdatastatus.ALARM_TEMP_HIGH             > 0 
     || bluecell_Currdatastatus.ALARM_DLI_Level             > 0
-    || bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN     > 0
+    || bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN         > 0
     || bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm         > 0
     || bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm         > 0
     || bluecell_Currdatastatus.ALARM_ULO_Level             > 0
-    || bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN     > 0){
+    || bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN         > 0)
+    {
         AlarmTimerOnSet = true;
         AlarmTimerOffSet = false;
         if(AlarmTimerOnCnt > 3000){
@@ -3872,10 +3937,12 @@ void Alarm_Check(){
     /******************************TEMP START*******************************************/ 
     if(bluecell_Currdatastatus.Temp_High_Threshold < (bluecell_Currdatastatus.DET_TEMP )){
         bluecell_Currdatastatus.ALARM_TEMP_HIGH |= ENVIRONMENT_TEMPHIGH;
+        bluecell_Currdatastatus.Temp_High_Alarm = true;
+
         
     }else{
         bluecell_Currdatastatus.ALARM_TEMP_HIGH &= ~ENVIRONMENT_TEMPHIGH;
-        
+        bluecell_Currdatastatus.Temp_High_Alarm = false;        
     }
     /******************************TEMP END*******************************************/ 
 
@@ -4035,8 +4102,44 @@ void Alarm_Check(){
     /******************************ULO LEVEL END*******************************************/ 
     
     /******************************DLI LEVEL START*******************************************/ 
+    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL1_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P1_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm1 = false;
+    }
 
-    if(ADC_Alarm_DL_Set[DET_Alarm_DL1_Index] == true){
+    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL2_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm2 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P2_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm2 = false;
+    }
+
+    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL3_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm3 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P3_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm3 = false;
+    }
+
+    if(ADC_Alarm_DL_Low_Set[DET_Alarm_DL4_Index] == true){
+        bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm4 = true;
+
+    }else{
+        bluecell_Currdatastatus.ALARM_DLI_Level &= ~ALARM_DLI_P4_LEVEL_LOW;
+        bluecell_Currdatastatus.DLI_Level_Low_Alarm4 = false;
+    }     
+    
+
+    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL1_Index] == true){
         bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P1_LEVEL_HIGH;
         bluecell_Currdatastatus.DLI_Level_High_Alarm1 = true;
 
@@ -4045,7 +4148,7 @@ void Alarm_Check(){
         bluecell_Currdatastatus.DLI_Level_High_Alarm1 = false;
     }
 
-    if(ADC_Alarm_DL_Set[DET_Alarm_DL2_Index] == true){
+    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL2_Index] == true){
         bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P2_LEVEL_HIGH;
         bluecell_Currdatastatus.DLI_Level_High_Alarm2 = true;
 
@@ -4054,7 +4157,7 @@ void Alarm_Check(){
         bluecell_Currdatastatus.DLI_Level_High_Alarm2 = false;
     }
 
-    if(ADC_Alarm_DL_Set[DET_Alarm_DL3_Index] == true){
+    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL3_Index] == true){
         bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P3_LEVEL_HIGH;
         bluecell_Currdatastatus.DLI_Level_High_Alarm3 = true;
 
@@ -4063,7 +4166,7 @@ void Alarm_Check(){
         bluecell_Currdatastatus.DLI_Level_High_Alarm3 = false;
     }
 
-    if(ADC_Alarm_DL_Set[DET_Alarm_DL4_Index] == true){
+    if(ADC_Alarm_DL_High_Set[DET_Alarm_DL4_Index] == true){
         bluecell_Currdatastatus.ALARM_DLI_Level |= ALARM_DLI_P4_LEVEL_HIGH;
         bluecell_Currdatastatus.DLI_Level_High_Alarm4 = true;
 
@@ -4072,8 +4175,85 @@ void Alarm_Check(){
         bluecell_Currdatastatus.DLI_Level_High_Alarm4 = false;
     }     
     /******************************DLI LEVEL END*******************************************/     
+    /******************************ULO ShutDown Start******************************************/     
+    if(bluecell_Currdatastatus.ULO_Shutdown_ON_OFF == true){
+        if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL1_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P1;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P1;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm1 = false;
+        }
+
+        if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL2_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P2;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P2;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm2 = false;
+        }
+
+        if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL3_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P3;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P3;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm3 = false;
+        }
+
+        if(ADC_Alarm_UL_Shutdown_Set[DET_Alarm_UL4_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN |= ALARM_ULO_SHUTDOWN_P4;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN &= ~ALARM_ULO_SHUTDOWN_P4;
+            bluecell_Currdatastatus.ULO_Shutdown_Alarm4 = false;
+        } 
+    }
+
+    /******************************ULO ShutDown END******************************************/     
     
     /******************************DLI ShutDown Start******************************************/     
+    if(bluecell_Currdatastatus.DLI_Shutdown_ON_OFF == true){    
+        if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL1_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P1;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P1;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm1 = false;
+        }
+
+        if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL2_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P2;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P2;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm2 = false;
+        }
+
+        if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL3_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P3;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P3;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm3 = false;
+        }
+
+        if(ADC_Alarm_DL_Shutdown_Set[DET_Alarm_DL4_Shutdown_Index] == true){
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN |= ALARM_DLI_SHUTDOWN_P4;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = true;
+
+        }else{
+            bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN &= ~ALARM_DLI_SHUTDOWN_P4;
+            bluecell_Currdatastatus.DLI_Shutdown_Alarm4 = false;
+        }    
+    }
     /******************************DLI ShutDown END******************************************/     
 
     

Bluecell_Src/CRC.c

@@ -149,43 +149,27 @@ uint8_t Chksum_Create(uint8_t *data, uint32_t leng)
 }
 
 
-static
-const uint16_t crc16_tab[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
 
+etError CRC16_Check(uint8_t* buf_ptr, int len,uint16_t checksum)
+{
+    uint16_t crc = 0;
+    for (uint32_t counter = 0; counter < len; counter++)
+        crc = (uint16_t)((crc << 8) ^ Table_CRC16[(uint32_t)(((crc >> 8) ^ buf_ptr[counter]) & 0x00FF)]);
+
+    return (crc == checksum ? CHECKSUM_ERROR : NO_ERROR);
+}
+uint16_t CRC16_Generate(uint8_t* buf_ptr, int len)
+{
+    uint16_t crc = 0;
+    for (uint32_t counter = 0; counter < len; counter++)
+        crc = (uint16_t)((crc << 8) ^ Table_CRC16[(uint32_t)(((crc >> 8) ^ buf_ptr[counter]) & 0x00FF)]);
+
+    return crc;
+}   
+
+#if 0 // PYJ.2020.05.28_BEGIN -- 
 uint16_t crc16(uint16_t crc, uint8_t data)
 {
     return (uint16_t)((crc << 8) ^ crc16_tab[((crc >> 8) ^ data) & 0xff]);
 }
+#endif // PYJ.2020.05.28_END -- 

Bluecell_Src/eeprom.c

@@ -63,11 +63,11 @@ void EEPROM_M24C08_Init(void){
 
     bluecell_Currdatastatus.ALARM_TEMP_HIGH          = 0;
     bluecell_Currdatastatus.ALARM_DLI_Level          = 0;
-    bluecell_Currdatastatus.ALARM_DLI_AGC_SHTUTDOWN  = 0;
+    bluecell_Currdatastatus.ALARM_DLI_SHTUTDOWN  = 0;
     bluecell_Currdatastatus.ALARM_DLI_AGC_Alarm      = 0;
     bluecell_Currdatastatus.ALARM_ULO_ALC_Alarm      = 0;
     bluecell_Currdatastatus.ALARM_ULO_Level          = 0;
-    bluecell_Currdatastatus.ALARM_ULO_ALC_SHTUTDOWN  = 0;
+    bluecell_Currdatastatus.ALARM_ULO_SHTUTDOWN  = 0;
 
 //    printf("bluecell_Currdatastatus.ATT_DL1_H : %x\r\n",bluecell_Currdatastatus.ATT_DL1_H);
 //    printf("bluecell_Currdatastatus.ATT_DL1_L : %x\r\n",bluecell_Currdatastatus.ATT_DL1_L);        

Bluecell_Src/uart.c

@@ -115,7 +115,7 @@ void Uart_Check(void){
   while (TerminalQueue.data > 0 && UartRxTimerCnt > 50) GetDataFromUartQueue(&hTerminal);
 }
 
-void Uart1_Data_Send(uint8_t* data,uint8_t size){
+void Uart1_Data_Send(uint8_t* data,uint16_t size){
     HAL_UART_Transmit_DMA(&hTerminal, data,size); 
 }
 

Src/main.c

@@ -89,7 +89,9 @@ volatile uint32_t AlarmTimerOnCnt = 0;
 
 
 extern bool AGC_AlarmTimerSet[AGC_Alarm_DL_Index_MAX];
-extern bool ADC_Alarm_DL_Set[DET_Alarm_DL_Index_MAX];
+extern bool ADC_Alarm_DL_High_Set[DET_Alarm_DL_Index_MAX];
+extern bool ADC_Alarm_DL_Low_Set[DET_Alarm_DL_Index_MAX];
+
 extern bool ADC_Alarm_UL_Set[DET_Alarm_UL_Index_MAX];