fix flash programming, alarm handling. workaround I2C arbitration loast, remove all "wait forever" in I2C sem

8 files changed, 206 insertions, 130 deletions

diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index bea8547c7..7305cf9bb 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -7,8 +7,6 @@
 #include <driverlib/gpio.h>
 #include "common/report/report.h"
 
-
-
 //#define EVALUATION_BOARD // to use the LCD only when using the evaluation board
 //#define USE_USB
 #define Stub_Mode 1
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
index 48b6b7883..a9fcd4420 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
@@ -363,26 +363,30 @@ double Read_MidTank_Pressure_Sensor(MidTank_t MidTank_ID) //0-7
 
             break;
     }
-    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
+    if (Semaphore_pend(I2C_Sem, BIOS_NO_WAIT))
+    {
+        Status = I2C_ADC_Config(I2C_Slave_Add, Channel);
+        SysCtlDelay(1);
+        Status |= I2C_ADC_Set_For_Read_Ch(I2C_Slave_Add);
+        SysCtlDelay(1);
+        VsampleInBits = I2C_ADC_Read_Ch(I2C_Slave_Add);
 
-    Status = I2C_ADC_Config(I2C_Slave_Add, Channel);
-    SysCtlDelay(1);
-    Status |= I2C_ADC_Set_For_Read_Ch(I2C_Slave_Add);
-    SysCtlDelay(1);
-    VsampleInBits = I2C_ADC_Read_Ch(I2C_Slave_Add);
+        if (Status)
+            LOG_ERROR(Status, "I2C actions failed");
+        MidTank_Pressure_Bits[MidTank_ID] = VsampleInBits;//just for debug
 
-    if (Status)
-        LOG_ERROR(Status, "I2C actions failed");
-    MidTank_Pressure_Bits[MidTank_ID] = VsampleInBits;//just for debug
+        //MidTank_Pressure[MidTank_ID] = Calculate_Pressure(VsampleInBits) - MidThankReadingOffset;
 
-    //MidTank_Pressure[MidTank_ID] = Calculate_Pressure(VsampleInBits) - MidThankReadingOffset;
+        //MidTank_Pressure[MidTank_ID] = Calculate_correction_MidTank_Pressure(VsampleInBits);//use the Calibration correction equation
 
-    //MidTank_Pressure[MidTank_ID] = Calculate_correction_MidTank_Pressure(VsampleInBits);//use the Calibration correction equation
+        //MidTank_Pressure[MidTank_ID] = Calculate_MidTank_Liquid(VsampleInBits , Factor);//According to Gal (email 28-Aug-19)
 
-    //MidTank_Pressure[MidTank_ID] = Calculate_MidTank_Liquid(VsampleInBits , Factor);//According to Gal (email 28-Aug-19)
+        MidTank_Pressure[MidTank_ID] = Calc_Calibration_MidTank_Liquid(VsampleInBits, MidTank_ID );
+        Semaphore_post(I2C_Sem);
+    }
+    else
+        Report("Read_MidTank_Pressure_Sensor",__FILE__,__LINE__,255,RpWarning,0,0);
 
-    MidTank_Pressure[MidTank_ID] = Calc_Calibration_MidTank_Liquid(VsampleInBits, MidTank_ID );
-    Semaphore_post(I2C_Sem);
 
    return MidTank_Pressure[MidTank_ID];
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
index f5671d7f6..6e7205756 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.c
@@ -152,23 +152,47 @@ uint32_t Head_I2C_ADC_Calc()
 
     return Status;
 }
+bool Head_Current_Read_Enable[HEAD_NUM_OF_ADC] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+void Enable_Reading_Heaters_ADC(HEAD_ADC_t Heater_ID) //0-8
+{
+    assert (Heater_ID<HEAD_NUM_OF_ADC);
+    Head_Current_Read_Enable[Heater_ID] = true;
+}
+void Disable_Reading_Heaters_ADC(HEAD_ADC_t Heater_ID) //0-8
+{
+    assert (Heater_ID<HEAD_NUM_OF_ADC);
+    Head_Current_Read_Enable[Heater_ID] = false;
+}
 
 uint32_t Head_I2C_ADC()
 {
-    uint32_t Status = OK;
-    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
+    uint32_t Status = ERROR;
+    if (Semaphore_pend(I2C_Sem, BIOS_NO_WAIT))
+    {
+        Head_I2C_ADC_Read_ADC_8Bytes(0x50);
+        Head_I2C_ADC_Read_ADC_8Bytes(0x54);
+        Head_I2C_ADC_Read_ADC_8Bytes(0x56);
+        Semaphore_post(I2C_Sem);
 
-    Head_I2C_ADC_Read_ADC_8Bytes(0x50);
-    Head_I2C_ADC_Read_ADC_8Bytes(0x54);
-    Head_I2C_ADC_Read_ADC_8Bytes(0x56);
-    Semaphore_post(I2C_Sem);
+        Head_I2C_ADC_Calc();
+        Status = OK;
+    }
+    else
+        Report(" Head_I2C_ADC",__FILE__,__LINE__,255,RpWarning,0,0);
 
-    Head_I2C_ADC_Calc();
 
     return Status;
 }
 
-
+bool Get_Head_Current(HEAD_ADC_t Head_ADC_ID, double* value)
+{
+    if (Head_Current_Read_Enable[Head_ADC_ID] == false)
+           return ERROR; // Heaters_Current[Heater_ID]
+    else *value = (Head_ADC[Head_ADC_ID]);
+    //Report("Get_Heaters_Current_Integer ",__FILE__,Heater_ID,*value,RpWarning,(int)(Heaters_Current[Heater_ID]*100),0);
+    return OK;
+}
 double Read_Head_ADC(HEAD_ADC_t Head_ADC_ID)
 {
     Head_I2C_ADC();
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h
index 6d8721d9c..96903be71 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h
@@ -56,7 +56,11 @@ typedef enum
     HEAD_NUM_OF_ADC            //24
 }HEAD_ADC_t;
 
+void Enable_Reading_Heaters_ADC(HEAD_ADC_t Heater_ID);
+void Disable_Reading_Heaters_ADC(HEAD_ADC_t Heater_ID);
+
 double Read_Head_ADC(HEAD_ADC_t Head_ADC_ID);
+bool Get_Head_Current(HEAD_ADC_t Head_ADC_ID, double* value);
 uint32_t Head_I2C_ADC();
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
index 91e504c10..ca645444e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
@@ -669,97 +669,94 @@ uint32_t control_HeadCard_PT100(uint8_t HEAD_CONFIG_PT100_MUX)
     uint8_t Write_Buf[2];
     TEMPERATURE_SENSOR_ID_ENUM SensorId;
 
-    Semaphore_pend(I2C_Sem, BIOS_WAIT_FOREVER);
-    Select_Main_Head_Mux_Channel();
-    //delayms(5);
-    if(HEAD_CONFIG_PT100_MUX == HEAD_CONFIG_ODD_PT100_MUX)
+    if (Semaphore_pend(I2C_Sem, BIOS_NO_WAIT))
     {
-
-        //-------------------------------------- READ ODD --------------------------------------
-        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
-        {
-            //Read Data
-            HeadADCPT100_SendReadDataCommand(SensorId);
-        }
-
-        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+        Select_Main_Head_Mux_Channel();
+        //delayms(5);
+        if(HEAD_CONFIG_PT100_MUX == HEAD_CONFIG_ODD_PT100_MUX)
         {
-            //Calculate Temperature
-            TempSensorResponse[SensorId].Temperature_C_mult_by_100 = CalculateTemperatures(SensorId, TempSensorResponse[SensorId].PT100_ADC_Reading_Bits);
-        }
-
-//        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
-//        {
-//            HeadADCPT100_PowerDown(SensorId);
-//        }
-
-        //-------------------------------------- CONFIG EVEN --------------------------------------
-                //Config_SEL
-                HeadCard_Toggle_PT100_SEL(HEAD_CONFIG_EVEN_PT100_PT_SEL);
-                //delayms(5);
-                for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
-                {
-                    //Config_Mux
-                    HeadTempSensConfig[SensorId].Reg0.bits.MUX = HEAD_CONFIG_EVEN_PT100_MUX;
-                    Write_Buf[0] = ADS122X_WREG_CMD | (ADS122X_CONFIG_0_REG<<2);
-                    Write_Buf[1] = HeadTempSensConfig[SensorId].Reg0.Byte;
-                    Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 2);
-                }
-                //delayms(5);
-                for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
-                {
-                    //Sync
-                    Write_Buf[0] = ADS122X_START_CMD;
-                    Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
-                }
-                //delayms(5);
-
-    }
-    else if(HEAD_CONFIG_PT100_MUX == HEAD_CONFIG_EVEN_PT100_MUX)
-    {
+            //-------------------------------------- READ ODD --------------------------------------
+            for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+            {
+                //Read Data
+                HeadADCPT100_SendReadDataCommand(SensorId);
+            }
+            for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+            {
+                //Calculate Temperature
+                TempSensorResponse[SensorId].Temperature_C_mult_by_100 = CalculateTemperatures(SensorId, TempSensorResponse[SensorId].PT100_ADC_Reading_Bits);
+            }
+        //        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+        //        {
+        //            HeadADCPT100_PowerDown(SensorId);
+        //        }
 
-        //-------------------------------------- READ EVEN --------------------------------------
-        for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
-        {
-            //Read Data
-            HeadADCPT100_SendReadDataCommand(SensorId);
+            //-------------------------------------- CONFIG EVEN --------------------------------------
+            //Config_SEL
+            HeadCard_Toggle_PT100_SEL(HEAD_CONFIG_EVEN_PT100_PT_SEL);
+            //delayms(5);
+            for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+            {
+                //Config_Mux
+                HeadTempSensConfig[SensorId].Reg0.bits.MUX = HEAD_CONFIG_EVEN_PT100_MUX;
+                Write_Buf[0] = ADS122X_WREG_CMD | (ADS122X_CONFIG_0_REG<<2);
+                Write_Buf[1] = HeadTempSensConfig[SensorId].Reg0.Byte;
+                Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 2);
+            }
+            //delayms(5);
+            for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+            {
+                //Sync
+                Write_Buf[0] = ADS122X_START_CMD;
+                Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
+            }
+            //delayms(5);
         }
-
-        for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+        else if(HEAD_CONFIG_PT100_MUX == HEAD_CONFIG_EVEN_PT100_MUX)
         {
-            //Calculate Temperature
-            TempSensorResponse[SensorId].Temperature_C_mult_by_100 = CalculateTemperatures(SensorId, TempSensorResponse[SensorId].PT100_ADC_Reading_Bits);
-        }
+            //-------------------------------------- READ EVEN --------------------------------------
+            for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+            {
+                //Read Data
+                HeadADCPT100_SendReadDataCommand(SensorId);
+            }
 
-//        for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
-//        {
-//            HeadADCPT100_PowerDown(SensorId);
-//        }
+            for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+            {
+                //Calculate Temperature
+                TempSensorResponse[SensorId].Temperature_C_mult_by_100 = CalculateTemperatures(SensorId, TempSensorResponse[SensorId].PT100_ADC_Reading_Bits);
+            }
+    //        for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
+    //        {
+    //            HeadADCPT100_PowerDown(SensorId);
+    //        }
 
-        //-------------------------------------- CONFIG ODD --------------------------------------
-        //Config_SEL
-        HeadCard_Toggle_PT100_SEL(HEAD_CONFIG_ODD_PT100_PT_SEL);
-        //delayms(5);
-        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
-        {
-            //Config_Mux
-            HeadTempSensConfig[SensorId].Reg0.bits.MUX = HEAD_CONFIG_ODD_PT100_MUX;
-            Write_Buf[0] = ADS122X_WREG_CMD | (ADS122X_CONFIG_0_REG<<2);
-            Write_Buf[1] = HeadTempSensConfig[SensorId].Reg0.Byte;
-            Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 2);
-        }
-        //delayms(5);
-        for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
-        {
-            //Sync
-            Write_Buf[0] = ADS122X_START_CMD;
-            Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
+            //-------------------------------------- CONFIG ODD --------------------------------------
+            //Config_SEL
+            HeadCard_Toggle_PT100_SEL(HEAD_CONFIG_ODD_PT100_PT_SEL);
+            //delayms(5);
+            for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+            {
+                //Config_Mux
+                HeadTempSensConfig[SensorId].Reg0.bits.MUX = HEAD_CONFIG_ODD_PT100_MUX;
+                Write_Buf[0] = ADS122X_WREG_CMD | (ADS122X_CONFIG_0_REG<<2);
+                Write_Buf[1] = HeadTempSensConfig[SensorId].Reg0.Byte;
+                Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 2);
+            }
+            //delayms(5);
+            for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
+            {
+                //Sync
+                Write_Buf[0] = ADS122X_START_CMD;
+                Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
+            }
+            //delayms(5);
         }
-        //delayms(5);
-
-
+        Semaphore_post(I2C_Sem);
     }
-    Semaphore_post(I2C_Sem);
+    else
+        Report("control_HeadCard_PT100",__FILE__,__LINE__,255,RpWarning,0,0);
+
 
     return Status;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
index 26b0c86c9..57b64fdfa 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
@@ -25,7 +25,7 @@
 
 
 
-
+uint32_t Arb_Loss_Count = 0;
 //*****************************************************************************
 //! Indicates whether or not the I2C bus has timed out.
 //!
@@ -108,6 +108,15 @@ uint32_t I2C_WriteBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* dat
         SysCtlDelay(I2C_BUSY_DELAY);
     }
 
+    if (status == I2C_MASTER_ERR_ARB_LOST)
+    {
+        if (Arb_Loss_Count++ > 100)
+        {
+            Arb_Loss_Count= 0;
+            Init_All_I2C();
+            Report("Reinitializing I2C master", __FILE__,__LINE__,status, RpMessage,Task_self(), 0);
+        }
+    }
     return status;
 }
 
@@ -173,6 +182,15 @@ uint32_t I2C_ReadBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* data
         //return I2CMasterErr(I2C_BASE) == I2C_MASTER_ERR_NONE;
         status |= I2CMasterErr(I2C_BASE);
     }
+    if (status == I2C_MASTER_ERR_ARB_LOST)
+    {
+        if (Arb_Loss_Count++ > 100)
+        {
+            Arb_Loss_Count= 0;
+            Init_All_I2C();
+            Report("Reinitializing I2C master", __FILE__,__LINE__,status, RpMessage,Task_self(), 0);
+        }
+    }
     return status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
index 43a038996..9167a33d2 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
@@ -45,6 +45,7 @@ uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* b
     uint32_t ui32ProgAddr;
     uint32_t ui32BufferAddr;
     volatile uint32_t ui32Idx;
+    uint32_t status = OK;
     //uint32_t ui32FlashEnd;
 
 #ifdef FLASH_DEBUG
@@ -102,8 +103,11 @@ uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* b
         // Call the function to program a block of flash.  The length of the
         // block passed to the flash function must be divisible by 4.
         //
-        FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,
+
+        status = FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,
                          (ui32DataSize + 3) & ~3);
+        if (status)
+            LOG_ERROR(status,"ROM_FlashProgram");
 
         //
         // If there is more image to program, then update the programming
@@ -129,6 +133,7 @@ uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* b
 uint32_t EraseFlashSection(uint32_t ui32FlashStart,uint32_t ui32FileSize)
 {
     volatile uint32_t ui32Idx;
+    uint32_t status;
 #ifdef FLASH_DEBUG
     Address[RxIndex] = ui32FlashStart;
     Size[RxIndex] = ui32FileSize;
@@ -138,7 +143,7 @@ uint32_t EraseFlashSection(uint32_t ui32FlashStart,uint32_t ui32FileSize)
 #endif
     for(ui32Idx = ui32FlashStart; ui32Idx < ui32FlashStart+ui32FileSize; ui32Idx += 1024)
     {
-        FlashErase(ui32Idx);
+        //status = FlashErase(ui32Idx);
     }
     return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index a898d43e6..6b8f0716d 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -26,6 +26,7 @@
 #include "drivers/FPGA/FPGA.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"
+#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "modules/thread/thread_ex.h"
@@ -456,6 +457,7 @@ uint32_t AlarmHandlingLoadFile(void)
     uint32_t Bytes = 0,i,p_size = 0,F_count = 0,AlarmPtr;
     Fresult = FileRead(AlarmStorePath, &Bytes, &buffer);
     AlarmHandlingItemStruc  FileAlarmItem[4];
+    int maxAlarms = 0;
 
     if (Fresult == FR_OK)
     {
@@ -464,6 +466,7 @@ uint32_t AlarmHandlingLoadFile(void)
         {
             if (AlarmParametersTable->n_alarmitem)
             {
+                maxAlarms = AlarmParametersTable->n_alarmitem;
                 p_size = AlarmParametersTable->n_alarmitem*sizeof(AlarmHandlingItemStruc);
                 ReportWithPackageFilter(AlarmFilter,"Writing alarm size", __FILE__,pAlarmItemSize,AlarmParametersTable->n_alarmitem, RpMessage, p_size, 0);
                 EraseFlashSection(pAlarmItemSize,p_size+4);
@@ -522,7 +525,7 @@ uint32_t AlarmHandlingLoadFile(void)
         ReadAppAndProgram(pAlarmItemSize, 4,0);
         return 0;
     }
-    return AlarmParametersTable->n_alarmitem;
+    return maxAlarms;
 }
 
 void AlarmHandlingInit(void)
@@ -1145,32 +1148,55 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__CurrentAlarm:
                 if (CheckCurrentAlarms)
                  {
-#ifndef Use_Head_Card
-                    if (AlarmItem[Alarm_i].DeviceId >= NUM_OF_CURRENT_HEATERS)
-                        break;
-#endif
-                    if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
-                     {
-                         if (AlarmItem[Alarm_i].AlarmDirection == true)
+                    if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
+                    {
+                        if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
+                        {
+                            if (AlarmItem[Alarm_i].AlarmDirection == true)
+                            {
+                                if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                {
+                                    Status = true;
+                                    if (AlarmState[Alarm_i].Status == false)
+                                        ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                }
+                            }
+                            else
+                            {
+                                if (doubleValue <= 0.1)
+                                {
+                                    Status = true;
+                                    if (AlarmState[Alarm_i].Status == false)
+                                        ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                          {
-                             if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                             if (AlarmItem[Alarm_i].AlarmDirection == true)
                              {
-                                 Status = true;
-                                 if (AlarmState[Alarm_i].Status == false)
-									 ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                 if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                 {
+                                     Status = true;
+                                     if (AlarmState[Alarm_i].Status == false)
+                                         ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                 }
                              }
-                         }
-                         else
-                         {
-                             if (doubleValue <= 0.1)
+                             else
                              {
-                                 Status = true;
-                                 if (AlarmState[Alarm_i].Status == false)
-	                                 ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                 if (doubleValue <= 0.1)
+                                 {
+                                     Status = true;
+                                     if (AlarmState[Alarm_i].Status == false)
+                                         ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                 }
                              }
-                         }
 
-                     }
+                         }
+                    }
                  }
                  else
                  {