Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

32 files changed, 1924 insertions, 908 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 5392a415e..a2a74b2e6 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,5,3,4};
+TangoVersion_t _gTangoVersion = {1,6,0,0};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
 
diff --git a/Software/Embedded_SW/Embedded/Common/Sys_PinOut_Config/MCU_MAIN_pinout.c b/Software/Embedded_SW/Embedded/Common/Sys_PinOut_Config/MCU_MAIN_pinout.c
index 93ce6cf51..fcede699f 100644
--- a/Software/Embedded_SW/Embedded/Common/Sys_PinOut_Config/MCU_MAIN_pinout.c
+++ b/Software/Embedded_SW/Embedded/Common/Sys_PinOut_Config/MCU_MAIN_pinout.c
@@ -859,9 +859,14 @@ PinoutSet(void)
     // Configure the GPIO Pin Mux for PR0
 	// for I2C1SCL
     //
-	MAP_GPIOPinConfigure(GPIO_PR0_I2C1SCL);
-	MAP_GPIOPinTypeI2CSCL(GPIO_PORTR_BASE, GPIO_PIN_0);
+	//MAP_GPIOPinConfigure(GPIO_PR0_I2C1SCL);
+	//MAP_GPIOPinTypeI2CSCL(GPIO_PORTR_BASE, GPIO_PIN_0);
 
+    #ifdef USE_UART4_FOR_BTSR
+	// Configure the GPIO Pin PR0 for BTSR RS485 UART  - Set as output to change to uart4 RS485 Direction:
+	ROM_GPIOPinTypeGPIOOutput(GPIO_PORTR_BASE, GPIO_PIN_0);
+	ROM_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_0, 0);
+    #endif
     //
     // Configure the GPIO Pin Mux for PR1
 	// for I2C1SDA
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index 2850f666e..8292cdeda 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -97,7 +97,10 @@ uint32_t OpenLogFile(void)
             if (LogFileHandle->fsize < 100000)
                 f_lseek(LogFileHandle, LogFileHandle->fsize);
             else
+            {
                 f_lseek(LogFileHandle, 0);
+                f_truncate (LogFileHandle);
+            }
             len = usnprintf(RepMessage, 80, "\r\n*******\r\nLog File start %s %s",__DATE__, __TIME__);
             LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
             ReportResetReason();
@@ -142,8 +145,6 @@ uint32_t LogToFile(char *message,       /* The formatted message
 
     len = usnprintf(RepMessage, 300, "\r\nfile %s\t  line %d\t code %d\t sev %d,\tparam %d,\t %s",FileName, LineNumber,errorCode, Severity, parameter,message);
     LogFresult = f_write(LogFileHandle,RepMessage,len,&Bytes );
-    if (LogFileHandle->fsize > 100000)
-        f_lseek(LogFileHandle, 0);
 
     return LogFresult;
 #endif	
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index c29f34c62..001303c88 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -36,6 +36,8 @@
 #endif
 //#define BTSR_ROTATED_WINDER_TFU
 
+//#define USE_UART4_FOR_BTSR // need change in FRPGA FPGA_1 yy > 0x20 + jumpers in main board need to read HW Version
+
 //#define USE_RFID_STUB //stub only. to use it undef USE_RFID_LOGIC
 //#define RFID_READ_ONLY //
 //#define USE_RFID_LOGIC //See more settings in RFID_Settings.h
@@ -154,6 +156,9 @@ typedef enum
 #define TX 0
 #define RX 1
 #define TXRX 2
+#define TX_FIRST_BYTE 3     //for BTSR
+#define TX_NOT_FIRST_BYTE 4 //for BTSR
+
 #define ODD         0
 #define EVEN        1
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.c
index ea45c89fe..30565df7d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.c
@@ -716,16 +716,18 @@ bool WHS_Reset_485(bool value)
 
 uint8_t RS485_Change_Direction(bool TX_OR_RX)//TX or RX - trigger i2c task
 {
-    if(TX_OR_RX == TX)
+    if((TX_OR_RX == TX) && (Whs_I2C_EXP_U4_0x42_VALUE.bits.VALUE_ACTLOW_DE_REn != true))
+    {
         Whs_I2C_EXP_U4_0x42_VALUE.bits.VALUE_ACTLOW_DE_REn = true;
-    else
+        WHS_Write_IO(I2CExp2_ADDRESS,D_TCA9555_PORT_0);
+    }
+    else if((TX_OR_RX == RX) && (Whs_I2C_EXP_U4_0x42_VALUE.bits.VALUE_ACTLOW_DE_REn != false))
+    {
         Whs_I2C_EXP_U4_0x42_VALUE.bits.VALUE_ACTLOW_DE_REn = false;
-
-    WHS_Write_IO(I2CExp2_ADDRESS,D_TCA9555_PORT_0);
-
+        WHS_Write_IO(I2CExp2_ADDRESS,D_TCA9555_PORT_0);
+    }
     return OK;
-
-};
+}
 
 uint8_t RS485_Direction(bool TX_OR_RX)//TX or RX
 {
diff --git a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
new file mode 100644
index 000000000..92337080d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
@@ -0,0 +1,793 @@
+/*
+ * BTSR.c
+ *
+ *  Created on: 1 Dec 2020
+ *      Author: avi
+ */
+
+#include "include.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <ti/sysbios/hal/Hwi.h>
+#include <xdc/runtime/Error.h>
+#include <xdc/runtime/System.h>
+
+#include <inc/hw_ints.h>
+
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "driverlib/gpio.h"
+#include "driverlib/pin_map.h"
+#include "driverlib/rom.h"
+#include "driverlib/rom_map.h"
+#include "driverlib/sysctl.h"
+#include "driverlib/interrupt.h"
+#include "utils/uartstdio.h"
+#include "driverlib/uart.h"
+
+//#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
+#include "Modules/Control/MillisecTask.h"
+#include <DataDef.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
+//#include "Drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
+#include "Drivers/FPGA/FPGA_Comm.h"
+#include "Drivers/Uart_Comm/BTSR/BTSR.h"
+
+
+
+static uint32_t GlobalClk;
+uint8_t BTSR_RX_Buff[Max_BTSR_RX_Bytes];
+uint16_t  TX_Timeout = 0xFFFF;//6250
+uint16_t  RX_Timeout = 0xFFFF;//1
+
+typedef enum
+{
+    BTSR_UART_CONFIG_PAR_1 = (UART_CONFIG_WLEN_8 |UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_ONE),
+    BTSR_UART_CONFIG_PAR_0 = (UART_CONFIG_WLEN_8 |UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_ZERO),
+}UAR_CFG;
+UAR_CFG BTSR_UART_CONFIG;
+
+uint8_t txlen = 0;
+uint8_t txcounter = 0, rxcounter = 0;
+uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes];
+
+
+uint8_t RX_Int_Counter = 0, RT_Int_Counter = 0, TX_Int_Counter = 0;
+
+uint8_t UART4_RS485_Direction(bool TX_OR_RX)//TX or RX
+{
+    ROM_GPIOPinWrite(GPIO_PORTR_BASE, GPIO_PIN_0, !(TX_OR_RX));
+
+    return OK;
+}
+void U4TX()
+{
+    UARTIntEnable(UART4_BASE, UART_INT_TX);
+    ROM_UARTCharPutNonBlocking(UART4_BASE,BTSR_TX_Buff[txcounter]);
+}
+void U4RX()
+{
+    UARTIntEnable(UART4_BASE, UART_INT_TX);
+    BTSR_RX_Buff[rxcounter] = ROM_UARTCharGetNonBlocking(UART4_BASE);//Receive data
+    rxcounter++;
+
+
+}
+
+void uart4_intHandler()
+{
+    //static uint8_t nop = 0;
+    //Get interrupt flags
+    unsigned long status = UARTIntStatus(UART4_BASE, 1);
+
+    //Clear flags
+    UARTIntClear(UART4_BASE, status);
+
+    //Treat both of these interrupts the same
+    if(status & UART_INT_RX)
+    {
+        RX_Int_Counter++;
+        U4RX();
+    }
+    else
+    if(status & UART_INT_RT) /// Receive Timeout Interrupt
+    {
+        RT_Int_Counter++;
+        U4RX();
+    }
+    if(status & UART_INT_TX)
+    {
+        UARTIntDisable(UART4_BASE, UART_INT_TX);
+
+        TX_Int_Counter++;
+
+        BTSR_Change_Comm_Mode(TX_NOT_FIRST_BYTE);
+        txcounter++;
+        if(txcounter >= txlen )
+         {
+            txcounter = 0;
+            rxcounter = 0;
+
+            BTSR_Change_Comm_Mode(RX);
+            UARTIntEnable(UART4_BASE, UART_INT_RT | UART_INT_RX);
+
+         }
+        else
+        {
+            U4TX();
+        }
+
+    }
+
+}
+
+
+
+
+void InitConsole_BTSR_UART4(int32_t ui32SysClock)
+{
+
+    ROM_IntMasterDisable();
+
+    GlobalClk = ui32SysClock;
+
+    //uint32_t ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), SYS_CLK_FREQ);
+
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
+    //
+    // Enable GPIO port A which is used for UART4 pins.
+    // TODO: change this to whichever GPIO port you are using.
+    //
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
+
+    SysCtlDelay(3);
+
+    //
+    // Configure the pin muxing for UART4 functions on port A0 and A1.
+    // This step is not necessary if your part does not support pin muxing.
+    //
+    MAP_GPIOPinConfigure(GPIO_PA2_U4RX);
+    MAP_GPIOPinConfigure(GPIO_PA3_U4TX);
+
+    //
+    // Enable UART4 so that we can configure the clock.
+    //
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
+
+    SysCtlDelay(3);
+
+    //
+    // Use the internal 16MHz oscillator as the UART clock source.
+    //
+    UARTClockSourceSet(UART4_BASE, UART_CLOCK_SYSTEM);//UART_CLOCK_PIOSC);
+
+    //
+    // Select the alternate (UART) function for these pins.
+    //
+    MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3);
+
+    //
+    // Initialize the UART for console I/O.
+    //
+    UARTFIFOEnable(UART4_BASE);
+
+    MAP_UARTConfigSetExpClk(UART4_BASE, ui32SysClock, 57600,(UART_CONFIG_WLEN_7 |UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_ONE));//BTSR protocol
+    UART4_RS485_Direction(TX);
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //Set UART FIFO level to 1/2
+    //UARTFIFOLevelSet(UART4_BASE, UART_FIFO_TX7_8, UART_FIFO_RX1_8);
+//
+//    //Register interrupt handler
+//    UARTIntRegister(UART4_BASE, uart4_intHandler);
+//
+    //
+        // Configure and enable UART interrupts.
+        //
+        ROM_UARTIntClear(UART4_BASE, ROM_UARTIntStatus(UART4_BASE, false));
+        //Declare HWI dynamically  "TI-RTOS Kernel User's Guide" Page. 167 or Section 8.2.1
+        Hwi_Handle Uart4Hwi;
+        Error_Block eb;
+        Error_init(&eb);
+        Uart4Hwi = Hwi_create(INT_UART4, uart4_intHandler, NULL, &eb);
+        if (Uart4Hwi == NULL)
+        {
+        System_abort("Uart4Hwi create failed");
+        }
+
+        UARTTxIntModeSet(UART4_BASE, UART_TXINT_MODE_EOT);//generate a TX interrupt when the last character has completed transmission
+
+        //Enable RX and RT interrupts
+    UARTIntEnable(UART4_BASE, /*UART_INT_RT | UART_INT_RX | */UART_INT_TX);
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+//#define UART4_CTL_R             (*((volatile uint32_t *)0x40010030))
+//
+//    UART4_CTL_R |= UART_CTL_EOT;// End of Transmission
+
+    ROM_UARTEnable(UART4_BASE);
+    //
+    // Enable interrupts now that the application is ready to start.
+    //
+    ROM_IntEnable(INT_UART4);
+
+
+
+    ROM_IntMasterEnable();
+}
+
+
+unsigned long UARTStatus()
+{
+    return(HWREG(UART4_BASE + UART_O_FR));
+}
+
+bool BTSR_Change_Comm_Mode(uint8_t Mode)
+{
+
+    if(Mode == TX_FIRST_BYTE)
+    {
+        UART4_RS485_Direction(TX);
+
+        Task_sleep (eOneMillisecond);//Doesn't work without it - maybe to change to TX after RX
+        if(BTSR_UART_CONFIG != BTSR_UART_CONFIG_PAR_1)
+        {
+            BTSR_UART_CONFIG = BTSR_UART_CONFIG_PAR_1;
+            MAP_UARTConfigSetExpClk(UART4_BASE, GlobalClk, 57600,BTSR_UART_CONFIG_PAR_1);
+        }
+    }
+    else if(Mode == TX_NOT_FIRST_BYTE)
+    {
+        UART4_RS485_Direction(TX);
+
+        //Task_sleep (eOneMillisecond);
+        if(BTSR_UART_CONFIG != BTSR_UART_CONFIG_PAR_0)
+        {
+            BTSR_UART_CONFIG = BTSR_UART_CONFIG_PAR_0;
+            MAP_UARTConfigSetExpClk(UART4_BASE, GlobalClk, 57600,BTSR_UART_CONFIG_PAR_0);
+        }
+    }
+    else if(Mode == RX)
+    {
+        UART4_RS485_Direction(RX);
+
+        //Task_sleep (eOneMillisecond);
+        if(BTSR_UART_CONFIG != BTSR_UART_CONFIG_PAR_0)
+        {
+            BTSR_UART_CONFIG = BTSR_UART_CONFIG_PAR_0;
+            MAP_UARTConfigSetExpClk(UART4_BASE, GlobalClk, 57600,BTSR_UART_CONFIG_PAR_0);
+        }
+    }
+    return OK;
+}
+
+int Uart4TransmitResult = 0;
+
+uint8_t BTSR_Auto_Identify(uint8_t BTSR_Id)//AUTOMATIC IDENTIFICATION PROCEDURE (IDENTIFY)
+{
+    uint8_t i = 0;
+    uint8_t FUNCTION_STRING_FD = 0xFD;
+    uint8_t TX_Timeout = 10;
+    uint8_t RX_Timeout = 10;
+
+    BTSR_Change_Comm_Mode(TX_FIRST_BYTE);
+    Task_sleep (eOneMillisecond);
+
+    for(i = 0 ;i < 3; i++)
+    {
+
+        Uart4TransmitResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,FUNCTION_STRING_FD);
+        Task_sleep (eOneMillisecond);
+    }
+
+    while(UARTBusy(UART4_BASE) == true)//true if the UART is transmitting, false if all transmissions are complete
+    {
+        if(TX_Timeout)
+        {
+            TX_Timeout--;
+            Task_sleep (eOneMillisecond);
+        }
+        else
+            return ERROR;
+    }
+
+    BTSR_Change_Comm_Mode(RX);
+
+    while(UARTCharsAvail(UART4_BASE) == false);//true if there is data in the receive FIFO or false if there is no data in the receive FIFO
+    {
+        if(RX_Timeout)
+        {
+            RX_Timeout--;
+            Task_sleep (eOneMillisecond);
+        }
+        else
+            return ERROR;
+    }
+    BTSR_RX_Buff[0] = ROM_UARTCharGetNonBlocking(UART4_BASE);//Receive data
+
+    if(BTSR_RX_Buff[0] == 0xFD)
+    {
+        BTSR_Change_Comm_Mode(TX_FIRST_BYTE);
+        Task_sleep (eOneMillisecond);
+        Uart4TransmitResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,BTSR_Id);
+        return OK; //Need to press ENTER in BTSR!
+    }
+    else
+    {
+        return ERROR;
+    }
+}
+
+//////////////////////////////////////////////////
+
+uint8_t BTSR_Calculate_CheckSum(uint8_t *Buf, uint8_t size_without_Checksum)
+{
+    uint8_t i = 0;
+    uint16_t Sum = 0;
+
+    for(i=0;i<(size_without_Checksum);i++)
+    {
+        Sum += Buf[i];
+    }
+    Buf[i] = Sum & 0xFF;
+    Buf[i+1] = Sum >> 8;
+
+    return OK;
+}
+
+uint8_t Check_Received_CheckSum(uint8_t CODE_STRING, uint8_t Function_Code, uint8_t *Buf, uint8_t size_include_Checksum)//Function_Code + CODE_STRING needed only for FUNCTION_STRING = 0x33
+{
+    uint8_t Status = OK;
+    uint8_t i = 0;
+    uint16_t Sum = 0;
+
+    //uint8_t temp[10];
+
+    if(size_include_Checksum > 2) // No checkSum for <=2
+    {
+        for(i = 0; i < (size_include_Checksum - 2); i++)
+        {
+            Sum += Buf[i];//Sum Of DATA_STRING
+        }
+
+//        for(i = 0; i < size_include_Checksum ; i++)//debug
+//        {
+//            temp[i] = Buf[i];
+//        }
+
+        if(size_include_Checksum == 6)  //FUNCTION_STRING = 0x33
+        {
+            //Sum Of DATA_STRING, Device Code, Function Code.
+            Sum += Function_Code + CODE_STRING;
+        }
+
+        if( (Buf[size_include_Checksum - 2] != (Sum & 0xFF)) ||
+            (Buf[size_include_Checksum - 1] != (Sum >> 8))      )
+        {
+            Status = ERROR;
+        }
+    }
+    return Status;
+}
+
+
+
+//APPLICATION AND YARN TYPOLOGY SET
+typedef union
+{
+    struct
+    {
+        uint8_t  Code;
+        uint8_t  Function;
+        uint8_t Data[2];
+        uint8_t Check[2];
+    }String;
+    uint8_t Buf[6];
+}BTSR_TYPOLOGY_SET;
+
+BTSR_TYPOLOGY_SET Typology_Set;
+
+uint8_t BTSR_Send_Buf(uint8_t *Buf, uint8_t size)
+{
+    int TxResult = 0;
+    uint8_t i;
+
+    txlen = size;
+    for(i=0;i<size;i++)
+        BTSR_TX_Buff[i]  = Buf[i];
+
+    UARTIntEnable(UART4_BASE, UART_INT_TX);
+    BTSR_Change_Comm_Mode(TX_FIRST_BYTE);
+    //Task_sleep (eOneMillisecond);
+    TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[0]);
+
+    return TxResult;
+}
+
+
+/*
+uint8_t BTSR_Send_Buf(uint8_t *Buf, uint8_t size)
+{
+    int TxResult = 0;
+    uint8_t i = 1;//change to ADD0 and send the rest of bytes (1..Size)
+    const uint8_t Save_Size = size;
+
+    BTSR_Change_Comm_Mode(TX_FIRST_BYTE);
+    Task_sleep (eOneMillisecond);
+    TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[0]);
+
+    BTSR_Change_Comm_Mode(TX_NOT_FIRST_BYTE);
+    Task_sleep (eOneMillisecond);
+
+    while(size)
+    {
+        if(size <= 16) //FIFO is working for data up to 16 bytes
+        {
+            for(; i < Save_Size; i++)
+            {
+                TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[i]);
+            }
+            size = 0;// all sent
+        }
+        else
+        {
+            for(; i < 16; i++)
+            {
+                TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[i]);
+            }
+            size -= 16;
+        }
+
+        while(HWREG(UART4_BASE + UART_O_FR) & UART_FR_BUSY)//UARTFR
+        {
+            if(TX_Timeout)
+            {
+                TX_Timeout--;
+            }
+            else
+                return ERROR;
+        }
+    }
+
+    UART4_RS485_Direction(RX);
+
+    return TxResult;
+}
+*/
+uint8_t BTSR_Send_Buf_3xADD1(uint8_t *Buf, uint8_t size)//Only for commands with 3 bytes with Address 1 (0x06/0xFD)
+{
+    int TxResult = 0;
+    uint8_t i = 0;
+
+    if((Buf[4] != 0x06) || (size < 3))
+        return ERROR;
+
+    BTSR_Change_Comm_Mode(TX_FIRST_BYTE);
+    Task_sleep (eOneMillisecond);
+
+    for(i = 0; i < 3; i++)
+    {
+        TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[i]);
+        Task_sleep (eOneMillisecond);
+    }
+
+    BTSR_Change_Comm_Mode(TX_NOT_FIRST_BYTE);
+    Task_sleep (eOneMillisecond);
+
+    for(; i < size; i++)
+    {
+        TxResult |=ROM_UARTCharPutNonBlocking(UART4_BASE,Buf[i]);
+    }
+
+    while(HWREG(UART4_BASE + UART_O_FR) & UART_FR_BUSY)//UARTFR
+    {
+        if(TX_Timeout)
+        {
+            TX_Timeout--;
+        }
+        else
+            return ERROR;
+    }
+    UART4_RS485_Direction(RX);
+
+    return TxResult;
+}
+
+uint8_t BTSR_RECEIVE_Buf(uint8_t *Buf, uint8_t size) //to test with BTSR_Set_Parmeters(0x01,SHOES,ALL_YARNS);
+{
+    uint8_t i = 0;
+
+    BTSR_Change_Comm_Mode(RX);
+
+    while(UARTCharsAvail(UART4_BASE) == false)//true if there is data in the receive FIFO or false if there is no data in the receive FIFO
+    {
+        if(RX_Timeout)
+        {
+            RX_Timeout--;
+        }
+        else
+            return ERROR;
+    }
+
+    memset (BTSR_RX_Buff,0,sizeof(BTSR_RX_Buff));
+
+    i=0;
+    while(UARTCharsAvail(UART4_BASE) == true)
+    {
+        BTSR_RX_Buff[i] = ROM_UARTCharGetNonBlocking(UART4_BASE);//Receive data
+        i++;
+    }
+//    for(i=0;i<4;i++)
+//    {
+//        BTSR_RX_Buff[i] = ROM_UARTCharGetNonBlocking(UART4_BASE);//Receive data
+//    }
+
+    if(size == i)
+        return OK;//as expected
+    return ERROR;
+}
+
+uint8_t BTSR_Set_Parmeters(uint8_t BTSR_Id, uint8_t Application, uint8_t Yarn_Type )
+{
+    //uint16_t Sum = 0;
+    //uint8_t i = 0;
+
+    //BTSR_RX_Buff[0] = 0;
+
+    Typology_Set.String.Code = BTSR_Id;
+    Typology_Set.String.Function = 0x3F;
+    Typology_Set.String.Data[0] = Application;
+    Typology_Set.String.Data[1] = Yarn_Type;
+    BTSR_Calculate_CheckSum(Typology_Set.Buf,(sizeof(Typology_Set.Buf))- 2);
+    /*
+    for(i=0;i<(sizeof(Typology_Set) - sizeof(Typology_Set.String.Check));i++)
+    {
+        Sum += Typology_Set.Buf[i];
+    }
+    Typology_Set.String.Check[0] = Sum & 0xFF;
+    Typology_Set.String.Check[1] = Sum >> 8;
+*/
+
+
+    BTSR_Send_Buf(Typology_Set.Buf, sizeof(Typology_Set));
+
+    //BTSR_RECEIVE_Buf(BTSR_RX_Buff, 1);
+
+/*
+    if(BTSR_RX_Buff[0] == 0xFB)
+        return OK;
+    else
+        return ERROR;
+        */
+    return BTSR_RX_Buff[0];
+}
+
+
+//------------------------------------------------------------------------
+
+
+typedef union
+{
+    struct
+    {
+        uint8_t Data[2];
+        uint8_t Check[2];
+    }String;
+    uint8_t Buf[4];
+}BTSR_2_2;
+
+typedef union
+{
+    struct
+    {
+        uint8_t  Code;
+        uint8_t  Function;
+        uint8_t Check[2];
+    }String;
+    uint8_t Buf[4];
+}BTSR_1_1_2;
+
+BTSR_1_1_2 Status_Read_Command;//ALARM AND ENABLING STATUS READ
+BTSR_2_2   Status_Read_Response;
+
+uint8_t BTSR_Read_Status(uint8_t BTSR_Id, uint8_t Application, uint8_t Yarn_Type )
+{
+    uint16_t Sum = 0;
+    uint8_t i = 0;
+
+    Typology_Set.String.Code = BTSR_Id;
+    Typology_Set.String.Function = 0x1F;
+    for(i=0;i<(sizeof(Typology_Set) - sizeof(Typology_Set.String.Check));i++)
+    {
+        Sum += Typology_Set.Buf[i];
+    }
+    Typology_Set.String.Check[0] = Sum & 0xFF;
+    Typology_Set.String.Check[1] = Sum >> 8;
+
+    BTSR_Send_Buf(Typology_Set.Buf, sizeof(Typology_Set));
+
+    BTSR_RECEIVE_Buf(BTSR_RX_Buff, 6);
+
+    for(i=0;i<(sizeof(Status_Read_Response) - sizeof(Status_Read_Response.String.Check));i++)
+    {
+        Sum += BTSR_RX_Buff[i];
+    }
+    if( (BTSR_RX_Buff[sizeof(Status_Read_Response) - 2] == Sum & 0xFF) &&
+        (BTSR_RX_Buff[sizeof(Status_Read_Response) - 1] == Sum >> 8)      )
+    {
+        for(i=0;i<(sizeof(Status_Read_Response) - sizeof(Status_Read_Response.String.Check));i++)
+        {
+            Status_Read_Response.Buf[i] = BTSR_RX_Buff[i];
+        }
+        return OK;
+    }
+    else
+        return ERROR;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+
+//BTSR_ALARM_AND_ENABLING_STATUS_READ
+typedef struct
+{
+    bool D0 : 1;//0
+    bool D1 : 1;//1
+    bool D2 : 1;//2
+    bool D3 : 1;//3
+    bool D4 : 1;//4
+    bool D5 : 1;//5
+    bool D6 : 1;//6
+    bool D7 : 1;//7
+}BITS;
+
+
+typedef union
+{
+    BITS Bit[4];
+    uint8_t Byte[4];
+}BTSR_ALARM_AND_ENABLING_STATUS_READ;
+
+BTSR_ALARM_AND_ENABLING_STATUS_READ BTSR_Status;
+
+void BTSR_Configuration_Set(uint8_t UFeeder_ID)
+{
+    memset(BTSR_TX_Buff, 0, Max_BTSR_TX_Bytes);
+
+    BTSR_TX_Buff[0] = UFeeder_ID;
+    BTSR_TX_Buff[1] = 0x36;
+    BTSR_TX_Buff[2] = 0x80;//CCW
+    BTSR_TX_Buff[3] = 0x01;//YYT OFF, UNICO OFF
+    BTSR_TX_Buff[4] = 0x40;//FLIP DISPLAY
+
+    BTSR_Calculate_CheckSum(BTSR_TX_Buff,18);
+
+    BTSR_Send_Buf(Typology_Set.Buf, 20);
+
+}
+
+void BTSR_Alarm_and_Enabling_Status_Read(uint8_t UFeeder_ID)
+{
+    memset(BTSR_TX_Buff, 0, Max_BTSR_TX_Bytes);
+
+    BTSR_TX_Buff[0] = UFeeder_ID;
+    BTSR_TX_Buff[1] = 0x1C;
+
+    BTSR_Calculate_CheckSum(BTSR_TX_Buff,2);
+
+    BTSR_Send_Buf(Typology_Set.Buf, 4);
+}
+
+typedef enum
+{
+    //BTSR_READ
+    DEVICE_INFORMATION_READ_10               ,
+    ADVANCED_PROGRAMMING_READ_18             ,
+    ADVANCED_TENSION_READ_23                 ,
+    APPLICATION_AND_YARN_TYPOLOGY_READ_28    ,
+    ALARM_AND_ENABLING_STATUS_READ_30        ,
+    PC_LINK_READ_32                          ,
+    METERS_TOTAL_COUNTER_READ_LOW_37         ,
+    METERS_TOTAL_COUNTER_READ_HIGH_39        ,
+    METER_TOTAL_COUNTER_READ_HIGHEST_41      ,
+    MAX_BTSR_READ                            ,
+
+    //BTSR_SET
+    //return 0xFA/0xFB/0xF9
+    DEVICE_CALIBRATION_11                    ,
+    BAUDRATE_SET_13                          ,
+    DISPLAY_LANGUAGE_SET_14                  ,
+    CONFIGURATION_SET_15                     ,
+    ADVANCED_CONFIGURATION_SET_17            ,
+    INPUT_CURRENT_CONTROL_SET_20             ,
+    ADVANCED_TENSION_PROGRAMMING_21          ,
+    ADVANCED_STYLE_LOAD_25                   ,
+    APPLICATION_AND_YARN_TYPOLOGY_SET_27     ,
+    WORK_TENSION_AND_OPERATION_STATUS_SET_29 ,
+    ALARM_STATUS_RESET_35                    ,
+    RESETS_ALL_THE_COUNTERS_36               ,
+    //return device + Function code
+    METERS_TOTAL_COUNTER_RESET_LOW_38        ,
+    METERS_TOTAL_COUNTER_RESET_HIGH_40       ,
+    METERS_TOTAL_COUNTER_RESET_HIGHEST_42    ,
+    MAX_BTSR_SET
+}BTSR_CMD;
+
+#define Get_Set_resp 5
+#define Set_Command 6
+
+#define Get_Read_resp 7
+#define Read_Command 8
+
+BTSR_CMD BTSR_command_Stage[MAX_BTSR_SET];
+
+uint8_t BTSR_State_Machine(uint8_t UFeeder_ID)
+{
+    uint8_t status = OK;
+    uint8_t i;
+
+    for(i = DEVICE_CALIBRATION_11; i < MAX_BTSR_SET; i++)
+    {
+        if(BTSR_command_Stage[i] == Get_Set_resp)
+        {
+            if((i >= DEVICE_CALIBRATION_11) && (i <= RESETS_ALL_THE_COUNTERS_36) /*&& (BTSR_RX_Buff[0] != BTSR_RISP_OK)*/)
+            {
+                    status = ERROR;
+                    BTSR_command_Stage[i] = BTSR_RX_Buff[0];
+                    //print response + command ID
+            }
+            else if(((i == METERS_TOTAL_COUNTER_RESET_LOW_38)     && (BTSR_RX_Buff[1] != 0x06)) ||
+                    ((i == METERS_TOTAL_COUNTER_RESET_HIGH_40)    && (BTSR_RX_Buff[1] != 0x1E)) ||
+                    ((i == METERS_TOTAL_COUNTER_RESET_HIGHEST_42) && (BTSR_RX_Buff[1] != 0x48))   )
+            {
+                    status = ERROR;
+                    BTSR_command_Stage[i] = BTSR_RX_Buff[1];
+                    //print response + command ID
+            }
+            //print response + command ID
+            BTSR_command_Stage[i] = OK;
+        }
+
+        if(BTSR_command_Stage[i] == Set_Command)
+        {
+            if(i == CONFIGURATION_SET_15)
+            {
+                BTSR_Configuration_Set(UFeeder_ID);
+            }
+
+            BTSR_command_Stage[i] = Get_Set_resp;
+            return status;//Only one command in cycle
+        }
+    }
+
+
+    for(i = DEVICE_INFORMATION_READ_10; i < MAX_BTSR_READ; i++)
+    {
+        if(BTSR_command_Stage[i] == Get_Read_resp)
+        {
+            // Add CRC check
+            if(i == ALARM_AND_ENABLING_STATUS_READ_30)
+            {
+                for(i = 0; i < 4; i++)
+                    BTSR_Status.Byte[i] = BTSR_RX_Buff[i];
+            }
+            BTSR_command_Stage[i] = 0;
+        }
+
+        if(BTSR_command_Stage[i] == Read_Command)
+        {
+
+            if(i == ALARM_AND_ENABLING_STATUS_READ_30)
+            {
+                BTSR_Alarm_and_Enabling_Status_Read(UFeeder_ID);
+            }
+            BTSR_command_Stage[i] = Get_Read_resp;
+            return status;//Only one command in cycle
+        }
+    }
+
+        return status;
+}
+
diff --git a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.h b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.h
new file mode 100644
index 000000000..14fda8f19
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.h
@@ -0,0 +1,65 @@
+/*
+ * BTSR.h
+ *
+ *  Created on: 1 Dec 2020
+ *      Author: avi
+ */
+
+#ifndef DRIVERS_UART_COMM_BTSR_BTSR_H_
+#define DRIVERS_UART_COMM_BTSR_BTSR_H_
+
+#define  Max_BTSR_RX_Bytes 55
+#define  Max_BTSR_TX_Bytes 40
+
+typedef enum
+{
+    SOCKS          = 1 ,
+    REVERSE_SOCKS  = 2 ,
+    MEDICAL_SOCKS  = 3 ,
+    PANTYHOSE      = 4 ,
+    SEAMLESS       = 5 ,
+    KNIT           = 6 ,
+    REVERSE_KNIT   = 7 ,
+    RASCHEL        = 8 ,
+    SEWING         = 9 ,
+    FLAT_KNIT      = 10,
+    SMALL_LOOM     = 11,
+    SHOES          = 12,
+    FLAT_SHOES     = 21,
+    INLAY          = 22,
+    WARP           = 34,
+    REWIND         = 35,
+}BTSR_APPLICATION;
+
+typedef enum
+{
+    ELASTOMERIC_YARN = 1,
+    ALL_YARNS        = 2,
+    ALL_YARNS2       = 3,
+    ALL_YARNS3       = 4,
+    ELASTIC2         = 5,
+    ELASTIC3         = 6,
+}BTSR_YARN_TYPE;
+
+typedef enum
+{
+    BTSR_RISP_OK = 0xFB,
+    BTSR_RISP_FAILED = 0xFA,
+    BTSR_RISP_OUT_OF_RANFE = 0xF9,
+}BTSR_RISP_BYTE;
+
+extern uint8_t BTSR_RX_Buff[Max_BTSR_RX_Bytes];
+
+unsigned long UARTStatus();
+bool BTSR_Change_Comm_Mode(uint8_t Mode);
+uint8_t BTSR_Auto_Identify(uint8_t BTSR_Id);//AUTOMATIC IDENTIFICATION PROCEDURE (IDENTIFY)
+uint8_t BTSR_Set_Parmeters(uint8_t BTSR_Id, uint8_t Application, uint8_t Yarn_Type );
+
+uint8_t BTSR_Send_Buf(uint8_t *Buf, uint8_t size);
+uint8_t BTSR_RECEIVE_Buf(uint8_t *Buf, uint8_t size);
+uint8_t BTSR_Calculate_CheckSum(uint8_t *Buf, uint8_t size_without_Checksum);
+uint8_t Check_Received_CheckSum(uint8_t CODE_STRING, uint8_t Function_Code, uint8_t *Buf, uint8_t size_include_Checksum);
+uint8_t BTSR_Send_Buf_3xADD1(uint8_t *Buf, uint8_t size);//Only for commands with 3 bytes with Address 1 (0x06/0xFD)
+void InitConsole_BTSR_UART4(int32_t ui32SysClock);
+
+#endif /* DRIVERS_UART_COMM_BTSR_BTSR_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.c b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.c
index 771a67f81..17427407e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.c
@@ -112,6 +112,7 @@ uint8_t Uart3_Transmit(uint8_t * Uart3_Tx_Buff, uint32_t Length)
 uint8_t Uart3_Receive(uint8_t * Uart3_Rx_Buff, uint32_t RX_Length)
 {
     uint8_t i,Status = OK;
+    uint8_t timeout = 5;
 
     uint8_t temp_buf[Size_Shinko_Res];
 
@@ -119,7 +120,11 @@ uint8_t Uart3_Receive(uint8_t * Uart3_Rx_Buff, uint32_t RX_Length)
     {
         for(i=0;i<RX_Length;i++)
         {
-            temp_buf[i] = ROM_UARTCharGet/*NonBlocking*/(UART3_BASE);//Receive data
+            while((UARTCharsAvail(UART3_BASE) != true) && timeout)
+            {
+                Task_sleep (eOneMillisecond);
+            }
+            temp_buf[i] = ROM_UARTCharGetNonBlocking(UART3_BASE);//Receive data
             if ((i == 0) && (temp_buf[0] == 0) )// There isn't communication / The controller is not connected - Shinko_Header_Asccii_ACK = 0x06
             {
                     Status = ERROR;
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
index 10f65db1d..c757c3a3b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.c
@@ -132,18 +132,16 @@ uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* b
     return(1);
 }
 int base_flashErased = false;
-uint32_t EraseFlashSection(uint32_t ui32FlashStart)
+uint32_t EraseFlashSection(void)
 {
-    volatile uint32_t ui32Idx = ui32FlashStart;
+    volatile uint32_t ui32Idx = FLASH_RAM_BASE;
     uint32_t status;
-    if (ui32FlashStart<GENHWCFG_SECTION_FLASH)
-    {
-        if (base_flashErased == true)
-            return ERROR;
-        else
-            base_flashErased = true; //once in a run
 
-    }
+    if (base_flashErased == true)
+        return WARNING;
+    else
+        base_flashErased = true; //once in a run
+
 #ifdef FLASH_DEBUG
     Address[RxIndex] = ui32FlashStart;
     Size[RxIndex] = ui32FileSize;
@@ -152,9 +150,27 @@ uint32_t EraseFlashSection(uint32_t ui32FlashStart)
         RxIndex = 0;
 #endif
     status = FlashErase(ui32Idx);
+    //FlashErase returns 0 or -1
     return status;
 
 }
+/*void FlashTest(void)
+{
+    int i;
+    uint32_t stack[0x200];
+    uint32_t offset = 0;
+
+    for (i = 0; i < 0x200; i++)
+        stack[i] = i;
+
+    while (offset < FLASH_SIZE)
+    {
+        ReadAppAndProgram(FLASH_RAM_BASE+offset,0x200,stack);
+        offset+=0x200;
+    }
+    EraseFlashSection();
+
+}*/
 //Each word may not be subject to more than a specific number of programming cycles before an
 //erase cycle is required. In other words, for any given word, FlashProgram can only be called
 //twice before FlashErase is called.
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.h b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.h
index 7da9f92a7..ab2c87acc 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.h
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/FlashProgram.h
@@ -8,23 +8,23 @@
 #ifndef DRIVERS_FLASH_RAM_FLASHPROGRAM_H_
 #define DRIVERS_FLASH_RAM_FLASHPROGRAM_H_
 
-#define FLASH_RAM_BASE 0x000F8000
+#define FLASH_RAM_BASE 0x000FC000
 
-#define EMBEDDED_PARAMETERS_SECTION_FLASH  (FLASH_RAM_BASE + 0X0000 ) //512
-#define PROCESS_PARAMETERS_SECTION_FLASH   (FLASH_RAM_BASE + 0X0000 )//512
-#define DANCERS_SECTION_FLASH  (FLASH_RAM_BASE + 0X0000)
-#define DISPENSERS_SECTION_FLASH (FLASH_RAM_BASE + 0X0000)
-#define GENHWCFG_SECTION_FLASH (FLASH_RAM_BASE + 0X2000)
-#define ALARM_SECTION_FLASH    (FLASH_RAM_BASE + 0X4000 )
+//#define EMBEDDED_PARAMETERS_SECTION_FLASH  (FLASH_RAM_BASE + 0X0000 ) //512
+//#define PROCESS_PARAMETERS_SECTION_FLASH   (FLASH_RAM_BASE + 0X0000 )//512
+//#define DANCERS_SECTION_FLASH  (FLASH_RAM_BASE + 0X0000)
+//#define DISPENSERS_SECTION_FLASH (FLASH_RAM_BASE + 0X0000)
+//#define GENHWCFG_SECTION_FLASH (FLASH_RAM_BASE + 0X0000)
+//#define ALARM_SECTION_FLASH    (FLASH_RAM_BASE + 0X0000 )
 
+//#define PROCESS_PARAMETERS_MAP_IN_FLASH   (FLASH_RAM_BASE + 0X0200 )
+//#define DANCERS_MAP_IN_FLASH  (FLASH_RAM_BASE + 0X0400)
+//#define DISPENSERS_MAP_IN_FLASH (FLASH_RAM_BASE + 0X500)
+//#define GENHWCFG_MAP_IN_FLASH (FLASH_RAM_BASE + 0x0300)
 #define EMBEDDED_PARAMETERS_MAP_IN_FLASH  (FLASH_RAM_BASE + 0X0000 )
-#define PROCESS_PARAMETERS_MAP_IN_FLASH   (FLASH_RAM_BASE + 0X0200 )
-#define DANCERS_MAP_IN_FLASH  (FLASH_RAM_BASE + 0X0400)
-#define DISPENSERS_MAP_IN_FLASH (FLASH_RAM_BASE + 0X500)
-#define GENHWCFG_MAP_IN_FLASH (FLASH_RAM_BASE + 0X2000)
-#define ALARM_MAP_IN_FLASH    (FLASH_RAM_BASE + 0X4000 )
+#define ALARM_MAP_IN_FLASH    (FLASH_RAM_BASE + 0X0300)
 
-#define FLASH_SIZE 0X8000
+#define FLASH_SIZE 0X4000
 
 extern int base_flashErased;
 
@@ -38,7 +38,7 @@ extern int base_flashErased;
 //*****************************************************************************
 uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* buffer);
 void FlashInit(void);
-uint32_t EraseFlashSection(uint32_t ui32FlashStart);
+uint32_t EraseFlashSection(void);
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
index e9d5cfc07..71d26888d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
@@ -60,6 +60,42 @@ uint32_t MCU_E2PromRead(int Address,uint32_t *Data)
     return OK;
 
 }
+/**************************************************/
+uint32_t MCU_E2PromProgramChunk(int Address,uint16_t Length,uint32_t Data)
+{
+    uint32_t Buffer = Data;
+#ifdef EVALUATION_BOARD
+    return 0;
+#else
+    Report("MCU_E2PromProgramChunk",__FILE__,Length,Address,RpWarning,Data,0);
+    return (EEPROMProgram((uint32_t *)Buffer, Address, Length));
+#endif
+}
+uint32_t MCU_E2PromReadChunk(int Address,uint16_t Length,uint32_t *Data)
+{
+#ifndef EVALUATION_BOARD
+    EEPROMRead((uint32_t *)Data,Address, Length);
+#endif
+    Report("MCU_E2PromReadChunk",__FILE__,Length,Address,RpWarning,*Data,0);
+
+    return OK;
+
+}
+void MCU_E2PromUpdateResetReason(int i)
+{
+    uint32_t Head;
+    uint32_t RESC = SysCtlResetCauseGet();
+
+    EEPROMRead(&Head,EEPROM_RESET_REASON_HEAD_ADDRESS, 4);
+    if (Head>=EEPROM_RESET_REASON_MAX_DATA) Head=0;
+    Head++;
+    RESC+=(i*0x1000);
+    EEPROMProgram(&Head, EEPROM_RESET_REASON_HEAD_ADDRESS, 4);
+    EEPROMProgram(&RESC, (EEPROM_RESET_REASON_HEAD_ADDRESS+(Head*4)), 4);
+
+}
+
+/*************************************************/
 void MCU_E2PromProgramMidTank(int midtankId,float a,float b)
 {
     float A,B;
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
index 12598ed07..2102d1716 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
@@ -61,6 +61,18 @@ typedef enum {
     ORIFICE3_ZERO_VALUE_ADDR,
 }EEPROM_ADDRESSES;*/
 
+#define EEPROM_RESET_REASON_HEAD_ADDRESS 160
+#define EEPROM_RESET_REASON_MAX_DATA 80
+
+#define DISPENSERS_MAP_IN_EEPROM 0x200
+#define PROCESS_PARAMATERS_IN_EEPROM 0x400
+
+uint32_t MCU_E2PromProgramChunk(int Address,uint16_t Length,uint32_t Data);
+uint32_t MCU_E2PromReadChunk(int Address,uint16_t Length,uint32_t *Data);
+
+void MCU_E2PromUpdateResetReason(int i);
+
+
 uint32_t MCU_E2PromProgram(int Address,uint32_t Data);
 uint32_t MCU_E2PromRead(int Address,uint32_t *Data);
 void MCU_E2PromProgramMidTank(int midtankId,float a,float b);
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 16334a0ad..541fff0a7 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -44,6 +44,7 @@
 #include <Drivers/I2C_Communication/I2C.h>
 #include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
+#include "Drivers/Uart_Comm/BTSR/BTSR.h"
 
 /*
 #include "Drivers/SPI_SDCARD/SDSPI.h"
@@ -136,21 +137,6 @@ Void MyswitchFxn(Task_Handle prev, Task_Handle next)
     PrevTask = prev;
     NextTask = next;
 }
-void updateresetreasonineeprom(int i)
-{
-#define Head_Address 40
-#define Max_Address 100
-    uint32_t Head;
-    uint32_t RESC = SysCtlResetCauseGet();
-
-    EEPROMRead(&Head,Head_Address*4, 4);
-    if (Head>=Max_Address) Head=0;
-    Head++;
-    RESC+=(i*0x1000);
-    EEPROMProgram(&Head, Head_Address*4, 4);
-    EEPROMProgram(&RESC, (Head_Address+Head)*4, 4);
-
-}
 /* ======== errHook ======== */
 Void errHook(Error_Block *eb)
 {
@@ -160,7 +146,7 @@ Void errHook(Error_Block *eb)
     //char File[50] = "";*/
     char message[300];
     int len;
-    updateresetreasonineeprom(InitFailures);
+    MCU_E2PromUpdateResetReason(InitFailures);
 
     //STATUS_GREEN_LED_OFF;
     ACTIVITY_GREEN_LED_OFF;
@@ -269,7 +255,7 @@ int main(void)
     uint32_t Data,i;
 
    MCU_E2PromInit();
-   updateresetreasonineeprom(0);
+   MCU_E2PromUpdateResetReason(0);
 
 #endif
     #ifdef EVALUATION_BOARD
@@ -396,6 +382,9 @@ int main(void)
         Trigger_RS485_Direction_Init();//init i/o
     }
 
+    #ifdef USE_UART4_FOR_BTSR
+        InitConsole_BTSR_UART4(ui32SysClock);
+    #endif
 	//EMAC_initEMAC();
     ControlInit();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 07ebfa747..6a952a3cd 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -154,17 +154,15 @@ typedef enum
 
 typedef struct
 {
-    //uint16_t Frequency;  //1/10/100/1000
-    AlarmSourceType AlarmSource;
-    uint16_t DeviceId;
-    uint8_t ModuleDeviceId;
+    uint16_t EventType;
     uint16_t AlarmValue;
-    bool AlarmDirection;
-    DebugLogCategory Severity;
-    //uint16_t Predecessor;
+    uint8_t AlarmSource;
+    uint8_t DeviceId;
+    uint8_t ModuleDeviceId;
+    uint8_t Severity;
     uint8_t DebounceValue;
-    EventType EventType;
     bool isPersistent;
+    bool AlarmDirection;
 }AlarmHandlingItemStruc;
 typedef struct
 {
@@ -184,268 +182,6 @@ uint32_t * pAlarmItemSize = (uint32_t *)(ALARM_MAP_IN_FLASH);
 uint32_t AlarmItemSize ;
 AlarmHandlingItemStruc  *AlarmItem  = NULL;//(AlarmHandlingItemStruc *)(ALARM_MAP_IN_FLASH+4);
 AlarmHandlingItemStruc  *HardCodedAlarmItem=NULL;
-//AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
-//* 7016    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
-//* 7017    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
-//* 7018    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
-//* 7019    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
-//* 7020    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
-//* 7021    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
-//* 7022    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
-//* 7023    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},
-
-//* 7064    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
-//* 7065    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
-//* 7066    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
-//* 7067    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
-//* 7068    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
-//* 7069    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
-//* 7070    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
-//* 7071    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
-//* 7072    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
-//* 7073    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
-//* 7074    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
-//* 7075    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
-//* 7076    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
-//* 7077    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
-//* 7078    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
-//* 7079    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},
-
-//* 7080    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
-//* 7081    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
-//* 7082    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
-//* 7083    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
-//* 7084    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
-//* 7085    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
-//* 7086    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
-//* 7087    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},
-
-//* 7000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
-//* 7001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
-//* 7002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
-//* 7003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
-//* 7004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
-//* 7005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
-//* 7006    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
-//* 7007    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
-
-//* 8000    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
-//* 8001    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
-//* 8002    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
-//* 8003    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
-//* 8004    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
-//* 8005    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
-//* 8006    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
-//* 8007    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
-//* 8008    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
-//* 8009    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
-//* 8010    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
-//* 8011    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
-//* 8012    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
-//* 8013    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
-//* 8014    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
-//* 8015    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
-
-//* 8016    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
-//* 8017    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
-//* 8018    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
-//* 8019    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
-//* 8020    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
-//* 8021    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
-//* 8022    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
-//* 8023    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
-
-
-//* 4000    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
-//* 3003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT },
-//* 3008    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT  },
-//* 3007    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT },
-//* 3005    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT },
-//* 7032    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT},
-//* 7033    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT},
-//* 7034    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT},
-//* 7035    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT},
-//* 7036    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT},
-//* 7037    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT},
-//* 7038    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT},
-//* 7039    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT},
-//* 4001    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE},
-//* 3010    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE},
-//* 3015    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE },
-//* 3014    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE},
-//* 3012    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE},
-//* 7040    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE},
-//* 7041    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE},
-//* 7042    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE},
-//* 7043    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE},
-//* 7044    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE},
-//* 7045    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE},
-//* 7046    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE},
-//* 7047    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE},
-//* 4003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE },
-//* 3024    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE},
-//* 3029    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE },
-//* 3028    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE},
-//* 3026    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE},
-//* 7056    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE},
-//* 7057    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE},
-//* 7058    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE},
-//* 7059    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE},
-//* 7060    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE},
-//* 7061    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE},
-//* 7062    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE},
-//* 7063    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE},
-//* 4002    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL    },
-//* 3017    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL   },
-//* 3022    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL    },
-//* 3021    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL   },
-//* 3019    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL   },
-//* 7048    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL},
-//* 7049    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL},
-//* 7050    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL},
-//* 7051    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL},
-//* 7052    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL},
-//* 7053    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL},
-//* 7054    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL},
-//* 7055    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL},
-
-//* 6000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
-//* 5000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE},
-//* 5001    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE},
-//* 5002    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE},
-//* 5003    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE},
-//* 5004    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE},
-//* 5005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE                   },
-//* 4005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE      },
-
-//* 2008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
-//* 2017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
-
-//* 2002    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
-//* 2003    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
-//* 2004    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
-//* 2005    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
-//* 2007    */  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
-
-//* 2006    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
-
-//* 6001    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
-//* 5006    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
-//* 5007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
-//* 5008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
-//* 5009    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
-//* 5010    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
-//* 5011    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},
-
-//* 4007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
-//* 6002    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B},
-//* 5012    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B},
-//* 5013    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B},
-//* 5014    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B},
-//* 5015    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B},
-//* 5016    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B},
-//* 5017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B                   },
-//* 4008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B      },
-
-//* 3004    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3004 */
-//* 3006    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3006 */
-//* 3009    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                            },                                           //* 3009 */
-//* 3036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT //*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3036 */
-//* 3037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT //*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3037 */
-//* 3038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT //*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3038 */
-//* 4017    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  //*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                },   //* 4017 */
-//* 5031    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    },                                       //* 5031 */
-//* 5035    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       },                                       //* 5035 */
-//* 5039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            },                                       //* 5039 */
-
-//* 3011    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     },                                           //* 3011 */
-//* 3013    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      },                                           //* 3013 */
-//* 3016    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      },                                           //* 3016 */
-//* 3039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    },                                           //* 3039 */
-//* 3040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                                },                                           //* 3040 */
-//* 3041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                   },                                           //* 3041 */
-//* 4018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                       },                                           //* 4018 */
-//* 5032    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE          },                                           //* 5032 */
-//* 5036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE  },                                           //* 5036 */
-//* 5040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE       },                                           //* 5040 */
-
-//* 3018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3018 */
-//* 3020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3020 */
-//* 3023    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3023 */
-//* 3042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3042 */
-//* 3043    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                                       },                                           //* 3043 */
-//* 3044    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                                        },                                           //* 3044 */
-//* 4019    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  },                                           //* 4019 */
-//* 5033    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                         },                                           //* 5033 */
-//* 5037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL            },                                           //* 5037 */
-//* 5041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                 },                                           //* 5041 */
-
-//* 3025    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                         },                                           //* 3025 */
-//* 3027    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                          },                                           //* 3027 */
-//* 3030    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         },                                           //* 3030 */
-//* 3045    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                      },                                           //* 3045 */
-//* 3046    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                                },                                           //* 3046 */
-//* 3047    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                                    },                                           //* 3047 */
-//* 4020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           },                                           //* 4020 */
-//* 5034    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                  },                                           //* 5034 */
-//* 5038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE         },                                           //* 5038 */
-//* 5042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE             },                                           //* 5042 */
-
-//* 5018    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           //* 5018 */
-//* 5019    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           //* 5019 */
-//* 5020    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           //* 5020 */
-//* 5021    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           //* 5021 */
-//* 5022    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           //* 5022 */
-//* 6004    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       //* 6004 */
-//* 4011    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
-//* 4012    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
-
-//* 5023    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           //* 5018 */
-//* 5024    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           //* 5019 */
-//* 5025    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           //* 5020 */
-//* 5026    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           //* 5021 */
-//* 5027    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           //* 5022 */
-//* 6005    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        //* 6004 */
-//* 4013    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           //* 6004 */
-//* 4014    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           //* 6004 */
-//* 5028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
-
-//* 9005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
-//* 9008    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
-
-//* 3000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
-//* 3001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
-//* 3048    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
-//* 3049    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
-//* 3002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},
-
-//* 4004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
-//* 9003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
-//* 9000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
-//* 9002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},
-
-//* 2014    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},
-
-//* 2009    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, //*2009*/
-//* 2010    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, //*2010*/
-//* 2011    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, //*2011*/
-//* 2012    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, //*2012*/
-//* 4015    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, //*4015*/
-//* 4016    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, //*4016*/
-
-//*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
-//*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
-//*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
-//*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
-//*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
-//*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
-//*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
-//*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},
-
-//*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
-//*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}
-
-//};
 
 char AlarmStorePath[30] ="0://SysInfo//Alarm.cfg";
 uint16_t FluidLevelWarning = 20,FluidLevelError = 50;
@@ -453,17 +189,9 @@ int NumOfSystemAlarms = MAX_SYSTEM_ALARMS;
 //bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool EventsNotificationRequestAccepted = false;
 char AlarmReasonStr[100];
-//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
-//Cone missing
-//Dyeing head over temperature
-//mixer over temperature
-//dryer over temperature
-//heaters failure
-//dispenser pressure
-//valve OCD
-//Motor Status
-//machine cover open
+
 AlarmParameters * AlarmParametersTable = NULL;
+
 uint32_t AlarmHandlingLoadFile(void)
 {
     FRESULT Fresult = FR_OK;
@@ -483,7 +211,7 @@ uint32_t AlarmHandlingLoadFile(void)
                 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(ALARM_SECTION_FLASH);
+                EraseFlashSection();
                 ReadAppAndProgram(pAlarmItemSize, 4,&p_size);
                 AlarmPtr = (int)pAlarmItemSize+4;
                 p_size = 0;
@@ -863,25 +591,6 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
         return JOB_NO_ALARM_FILE;
     }
 
-    /*for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++)
-        {
-        for (Brush_i=0;Brush_i<JobTicket->segments[Segment_i]->n_brushstops;Brush_i++)
-            {
-                if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers)
-                {
-                    for (Dispenser_i = 0;Dispenser_i < JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers;Dispenser_i++)
-                    {
-                        //prepare the SW structures
-                        DispenserId = JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->index;
-                        if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->nanolitterpersecond>0.0)
-                        {
-                            DispenserInUse[DispenserId] = true;
-                        }
-                    }//for dispenser
-                }//if dispensers
-            }//for brush
-        }//for segments
-        */
     if (Configured[Module_IDS])
     {
         for (Dispenser_i=0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index ad5a1d5ca..5c0ff852c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -610,18 +610,22 @@ void setRapidPressureRead(bool value)
 }
 uint16_t PumpCounter = 0;
 uint16_t realtimetest[101];
+uint16_t dbgflag[50];
+uint32_t dbttime[50];
+bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,TenMinutes_Tick,OneHourTick,Gradient_Tick;
+bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick;
+
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,temp;
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
+#ifdef USE_RFID_LOGIC
     RFID_READER_ID readerID;
-
+#endif
     //static int temp=0;
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,TenMinutes_Tick,OneHourTick,Gradient_Tick;
-    bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick;
     //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Fifty_msTick      =   (tick%eHundredMillisecond == 40)      ?true:false; //eFiftyMillisecond
@@ -643,6 +647,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     TenMinutes_Tick  =   (tick%eTenMinutes == 0)           ?true:false;
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
     realtimetest[(tick%1000)/10]++;
+    dbttime[0] = msec_millisecondCounter;
     //gather Motor data from FPGA
     //ROM_IntMasterDisable();
     int StartPT100 = 0;
@@ -656,7 +661,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
         //if (Sensor_Read++ >= MAX_MAIN_CARD_TEMPERATURE_SENSOR_ID) Sensor_Read = 0;
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
+        dbgflag[1]++;
+        dbttime[1] = msec_millisecondCounter;
         Trigger_HeaterWriting();
+        dbgflag[2]++;
+        dbttime[2] = msec_millisecondCounter;
         Read_Dryer_ENC_Position();
     }
     if (m20msecTick)
@@ -669,10 +678,6 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Trigger_PT100_Read();//call every 50mSec (minimum delay 30mSec)
         //Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
     }
-    /*if(m70msecTick)
-    {
-        AlarmHandling_ControlTrigger(0,0);
-    }*/
     if (m90msecTick)
     {
         for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
@@ -701,6 +706,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 //LOG_ERROR (1111, "Control_WD");
             }
         }
+        dbgflag[3]++;
+        dbttime[3] = msec_millisecondCounter;
         if (RapidPressureRead == true)
         {
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
@@ -777,6 +784,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         KeepAliveOneSecondCall();
         //TemperatureListString(Lenstr);
         //ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
+        dbgflag[4]++;
+        dbttime[4] = msec_millisecondCounter;
         for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
@@ -834,8 +843,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
 
         //call IFS state machine
         midTankStateMachine();
-
-
+        dbgflag[5]++;
+        dbttime[5] = msec_millisecondCounter;
     }
     if (Tensecond_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 12842177c..b9f2a8a9e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -38,7 +38,7 @@
 
 #include "StateMachines/Printing/PrintingSTM.h"
 
-char HomingToken[NUM_OF_MOTORS][36+1]={0};
+char *HomingToken[NUM_OF_MOTORS]={0};
 int HomingCounter[NUM_OF_MOTORS];
 uint32_t HomingControlId[NUM_OF_MOTORS];
 
@@ -51,7 +51,7 @@ void HomingStopReporting(void)
     int i;
     for (i = 0; i< NUM_OF_MOTORS;i++)
     {
-        HomingToken[i][0] = 0;
+        HomingToken[i] = NULL;
     }
     LOG_ERROR(0,"HomingStopReporting");
 }
@@ -62,7 +62,7 @@ void HomingStopReporting(void)
 int32_t keepkvalright,keepkvalleft;
 uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
 {
-    if (HomingToken[deviceID][0] == 0)
+    if (HomingToken[deviceID] == NULL)
         return OK;
 
     MessageContainer responseContainer;
@@ -126,7 +126,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     {
         MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,NumberOfCycles);//it takes two cycles to identify a stop of the arm
     }*/
-    if (HomingToken[deviceID][0] == 0)
+    if (HomingToken[deviceID] == NULL)
         return OK;
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
@@ -135,7 +135,9 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
-    HomingToken[deviceID][0] = 0;
+    if (HomingToken[deviceID])
+        my_free(HomingToken[deviceID]);
+    HomingToken[deviceID] = NULL;
 
 return OK;
 
@@ -175,6 +177,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     {
         if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
         {
+            HomingToken[MotorId] = my_malloc(36);
             ustrncpy (HomingToken[MotorId], requestContainer->token,36);
             if (request->direction == MOTOR_DIRECTION__Backward) //opening the loading system
             {
@@ -339,7 +342,7 @@ uint32_t DispenserHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
     DispenserHomingResponse response = DISPENSER_HOMING_RESPONSE__INIT;
 
     uint8_t MotorId = deviceID+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
-    if (HomingToken[MotorId][0] == 0)
+    if (HomingToken[deviceID] == NULL)
         return OK;
 
     bool last = false;
@@ -377,7 +380,7 @@ uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     //Valve_Set((Valves_t) (DispenserId+VALVE_2W_MID_AIR_8), Atm_MidTank_OFF);
     //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
 
-    if (HomingToken[MotorId][0] == 0)
+    if (HomingToken[deviceID] == NULL)
         return OK;
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], true, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
@@ -386,7 +389,9 @@ uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
-    HomingToken[MotorId][0] = 0;
+    if (HomingToken[deviceID])
+        my_free(HomingToken[deviceID]);
+    HomingToken[deviceID] = NULL;
 
 return OK;
 
@@ -404,6 +409,7 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
 
     TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
 
+    HomingToken[MotorId] = my_malloc(36);
     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
     int speed = request->speed;
     if (speed == 0) speed = 500;
@@ -514,7 +520,9 @@ uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
-    HomingToken[deviceID][0] = 0;
+    if (HomingToken[deviceID])
+        my_free(HomingToken[deviceID]);
+    HomingToken[deviceID] = NULL;
 
     return OK;
 }
@@ -611,7 +619,9 @@ uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
-    HomingToken[MotorId][0] = 0;
+    if (HomingToken[MotorId])
+        my_free(HomingToken[MotorId]);
+    HomingToken[MotorId] = NULL;
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 010fc9607..4c727d377 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -105,33 +105,19 @@ uint32_t HWConfigurationInit(void)
     GeneralHwReady = false;
     //Control_WD(ENABLE,250);
 
-    memcpy(&Bytes,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(Bytes));
-
-    if ((Bytes)&&(Bytes < 5000))
+    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
+    if (buffer)
     {
-        buffer = my_malloc (Bytes);
-        if (buffer)
-        {
-            memcpy(buffer, (void *)(GENHWCFG_MAP_IN_FLASH+4),Bytes);
-            UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
-            Report("HWConfigurationInit from flash", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
-        }
+       //EraseFlashSection(GENHWCFG_SECTION_FLASH);
+       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
+       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
+       UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
+       Report("HWConfigurationInit from file", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
+       //AlarmHandlingLoadFile();
     }
-    if (UploadRequest == NULL)
-    {
-        buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
-        if (buffer)
-        {
-           EraseFlashSection(GENHWCFG_SECTION_FLASH);
-           ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
-           ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
-           UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
-           Report("HWConfigurationInit from file", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
-        }
-        else
-            Report("HWConfigurationInit Not available", __FILE__,__LINE__,Bytes, RpMessage, 0, 0);
+    else
+        Report("HWConfigurationInit Not available", __FILE__,__LINE__,Bytes, RpMessage, 0, 0);
 
-    }
 
     //buffer = HWConfigurationLoadFromFile(&Bytes);
     //status= memcmp(buffer,buffer1,Bytes);
@@ -323,9 +309,10 @@ uint32_t EmbeddedParametersInit(void)
     FRESULT Fresult = FR_OK;
     uint32_t Bytes = 0;
     uint8_t* buffer = NULL;
-
+    bool success=false;
     ConfigurationParameters *Params;
 
+    // try loading from flash
     memcpy(&Bytes,(void *)EMBEDDED_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
 
     if ((Bytes)&&(Bytes < 1000))
@@ -339,26 +326,23 @@ uint32_t EmbeddedParametersInit(void)
             LoadConfigurationParameters(Params);
             Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
             free(buffer);
-        }
-        else
-        {
-            LoadConfigurationParameters(0);
-            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
+            success = true;
         }
     }
-    else
+    if (success == false)
     {
-        if (LoadConfigurationParamsFromFile(false)!=OK)
-        {
-            LoadConfigurationParameters(0);
-            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
-        }
-        else
+        if (LoadConfigurationParamsFromFile(false)==OK)
         {
+            success = true;
             Report("LoadConfigurationParameters from file", __FILE__,__LINE__,EmbeddedParameters->closevalvetimeout, RpMessage, Fresult, 0);
         }
     }
-
+    if (success == false)
+    {
+        LoadConfigurationParameters(0);
+        Report("LoadConfigurationParameters default. flash and file error!!!", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
+        AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
+    }
     if (EmbeddedParameters->n_generalparameters >= 6)
     {
         IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
@@ -734,9 +718,6 @@ uint32_t MidTankDataSetupFunc(MessageContainer* requestContainer)
 uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
 {
     uint32_t status  = 0;
-    uint32_t DataLen  = 0;
-    uint32_t ExistingDataLen  = 0;
-    int compare = 0;
     MessageContainer responseContainer;
     UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;
     UploadHardwareConfigurationRequest* UploadRequest = NULL;
@@ -750,7 +731,7 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
         GeneralHwReady = false;
         Control_WD(ENABLE,250);
         //compare existing data to new data. update if different
-        memcpy(&ExistingDataLen,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(ExistingDataLen));
+        /*memcpy(&ExistingDataLen,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(ExistingDataLen));
         if (ExistingDataLen == requestContainer->data.len)
         {
             compare = memcmp (requestContainer->data.data,((void *)(GENHWCFG_MAP_IN_FLASH+4)),requestContainer->data.len);
@@ -766,15 +747,17 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
             ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
             ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, DataLen, requestContainer->data.data);
             Report("store hw configuration", __FILE__,compare,requestContainer->data.len,RpMessage,ExistingDataLen,0);
-
+            AlarmHandlingLoadFile();
             FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
-        }
+        }*/
         UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
-
-
-        status = HWConfiguration(UploadRequest);
-
-        GeneralHwReady = true;
+        if (UploadRequest)
+        {
+            FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
+            Report("store hw configuration", __FILE__,__LINE__,requestContainer->data.len,RpMessage,UploadRequest->hardwareconfiguration->n_motors,0);
+            status = HWConfiguration(UploadRequest);
+            GeneralHwReady = true;
+        }
     }
 
 
@@ -833,7 +816,7 @@ void HWSystemResetRequest(MessageContainer* requestContainer)
     HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY |  NVIC_APINT_SYSRESETREQ;
 
 }
-uint32_t FlashInitResults[5] = {0,0,0,0,0};
+//uint32_t FlashInitResults[5] = {0,0,0,0,0};
 uint32_t LoadConfigurationParamsFromFile(bool Initialize)
 {
     FRESULT Fresult = FR_OK;
@@ -849,9 +832,9 @@ uint32_t LoadConfigurationParamsFromFile(bool Initialize)
         LoadConfigurationParameters(Params);
         free (buffer);
         //configuration_parameters__free_unpacked(Params,NULL);
-        FlashInitResults[1] = true;
+        //FlashInitResults[1] = true;
         Report("Parameters Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
-        EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);
+        EraseFlashSection();
         ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
         ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
         if (Initialize)
@@ -863,16 +846,16 @@ void HWConfigurationLoadFile(void)
 {
     uint8_t* buffer = NULL;
     uint32_t Bytes = 0;
+    UploadHardwareConfigurationRequest* UploadRequest = NULL;
+
     buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
     if (buffer)
     {
-       EraseFlashSection(GENHWCFG_SECTION_FLASH);
-       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
-       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
-       free (buffer);
-       FlashInitResults[0] = true;
+       UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
+       Report("HWConfigurationInit from file", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
     }
-    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);
+    else
+        Report("HWConfigurationInit Not available", __FILE__,__LINE__,Bytes, RpMessage, 0, 0);
 }
 void FlashInitAndLoad(void)
 {
@@ -895,7 +878,7 @@ void FlashInitAndLoad(void)
     FlashInit(); //initialize flash
     Report("Flash Initialized", __FILE__,__LINE__,FLASH_SIZE, RpMessage, FLASH_RAM_BASE, 0);
 
-    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
+    /*buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
     if (buffer)
     {
         EraseFlashSection(GENHWCFG_SECTION_FLASH);
@@ -904,7 +887,7 @@ void FlashInitAndLoad(void)
        free (buffer);
        FlashInitResults[0] = true;
     }
-    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);
+    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);*/
 
     StoreDancerConfigMessage(0);
     StoreDancerConfigMessage(1);
@@ -915,7 +898,7 @@ void FlashInitAndLoad(void)
     {
         Report("Alarm Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
     }*/
-    EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);
+    EraseFlashSection();
 
     Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
     if (Fresult == FR_OK)
@@ -927,33 +910,14 @@ void FlashInitAndLoad(void)
         ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
         free (buffer);
         //configuration_parameters__free_unpacked(Params,NULL);
-        FlashInitResults[1] = true;
         Report("Parameters Initialized from file", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
     }
     else
     {
         LoadConfigurationParameters(0);
-        FlashInitResults[1] = 2;
         Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
     }
 
-    /*Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer);
-    if (Fresult == FR_OK)
-    {
-        request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
-        if (request)
-        {
-            ProcessParams = request->processparameters;
-            Bytes = sizeof(ProcessParams);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, &ProcessParams);
-            upload_process_parameters_request__free_unpacked(request,NULL);
-            FlashInitResults[2] = true;
-            Report("Process Initialized", __FILE__,__LINE__,Bytes, RpMessage, (int)ProcessParams->dryerzone1temp, 0);
-        }
-    }
-    else
-        Report("Process not Initialized", __FILE__,__LINE__,0, RpMessage, 0, 0);*/
 #ifdef WATCHDOG
         ROM_WatchdogResetEnable(WATCHDOG0_BASE);
         timeout = 120000000*3;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 807e9f8e9..137b5a19f 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -124,9 +124,11 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             Bytes = sizeof(ProcessParameters);
             FileWrite(ProcessParams,Bytes,ProcessParamsConfigPath,BIOS_WAIT_FOREVER);
-            EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
+            MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes);
+            MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM+4, Bytes, ProcessParams);
+            /*EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
             ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);*/
             REPORT_MSG(Bytes,"Bytes write to flash");
         }
         else
@@ -386,9 +388,11 @@ uint32_t LoadProcessParamsFromFile(void)
             if ((ProcessParams->dryerzone1temp > 0.1)||(ProcessParams->headzone2temp > 0.1)||(ProcessParams->headzone3temp > 0.1)||(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
             {
                 Bytes = sizeof(ProcessParameters);
-                EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
+                MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes);
+                MCU_E2PromProgramChunk(PROCESS_PARAMATERS_IN_EEPROM+4, Bytes, ProcessParams);
+                /*EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
                 ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+                ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);*/
                 REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
                 free (buffer);
             }
@@ -406,26 +410,32 @@ uint32_t ProcessParamsInit(void)
 {
     FRESULT Fresult = FR_NOT_READY;
     uint32_t Bytes;
+    ProcessParameters  ProcessParams;
 
-    memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
-    REPORT_MSG(Bytes,"Bytes read from flash");
+    //memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
+    MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes);
+
+    REPORT_MSG(Bytes,"Bytes read from EEPROM");
 
     if ((Bytes)&&(Bytes < 1000))
     {
-        ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
-        Fresult = HandleProcessParameters(ProcessParams,false);
+        //ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
+        MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM+4,Bytes,&ProcessParams);
+        Fresult = HandleProcessParameters(&ProcessParams,false);
     }
     else
     {
         if (LoadProcessParamsFromFile()==OK)
         {
-            memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
-            REPORT_MSG(Bytes,"ProcessParams Bytes read from flash");
+            MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM,4,&Bytes);
+            //memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
+            REPORT_MSG(Bytes,"ProcessParams Bytes read from EEPROM");
 
             if ((Bytes)&&(Bytes < 1000))
             {
-                ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
-                Fresult = HandleProcessParameters(ProcessParams,false);
+                MCU_E2PromReadChunk(PROCESS_PARAMATERS_IN_EEPROM+4,Bytes,&ProcessParams);
+                //ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
+                Fresult = HandleProcessParameters(&ProcessParams,false);
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index 76c679d80..ed3ae9bab 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -228,16 +228,7 @@ void setArcHeadAlarms(uint32_t AlarmId, bool value)
     {
         switch(AlarmId)
         {
-            case EVENT_TYPE__DYEING_HEAD_COVER_IS_OPEN:
-                ReportWithPackageFilter(HeatersFilter,"FlatHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
-                break;
-            /*case EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN:
-                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
-                break;
-            case EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN:
-                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
-                break;
-            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED:
+            /*case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED:
                 ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
                 break;
             case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED:
@@ -261,6 +252,17 @@ void setArcHeadAlarms(uint32_t AlarmId, bool value)
             case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW:
                 ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count8,RpError, PressureSensorGetPressure(HEAD_FAN_LEFT),0);
                 break;
+                /*case EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN:
+                    ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                    break;
+                case EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN:
+                    ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                    break;*/
+            case EVENT_TYPE__DYEING_HEAD_COVER_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"FlatHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            default:
+                break;
         }
     }
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index c8f435cb9..4ee94dae4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -17,7 +17,8 @@
 #include "Common/SWUpdate/FileSystem.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
 
-#include "drivers/Flash_ram/FlashProgram.h"
+//#include "drivers/Flash_ram/FlashProgram.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 
@@ -249,7 +250,10 @@ void IDS_Dispenser_Content_Init (void)
     }
     //==================================
 
-    memcpy(&Bytes,(void *)DISPENSERS_MAP_IN_FLASH,sizeof(Bytes));
+    //MCU_E2PromProgramChunk(DISPENSERS_MAP_IN_EEPROM,4,&Bytes);
+
+    MCU_E2PromReadChunk(DISPENSERS_MAP_IN_EEPROM,4,&Bytes);
+    //memcpy(&Bytes,(void *)DISPENSERS_MAP_IN_FLASH,sizeof(Bytes));
     bool havedata = false;
     DispenserData* StoredDispenserData;
     if ((Bytes)&&(Bytes < 500))
@@ -257,9 +261,11 @@ void IDS_Dispenser_Content_Init (void)
         buffer = my_malloc (Bytes);
         if (buffer)
         {
-            memcpy(buffer, (void *)(DISPENSERS_MAP_IN_FLASH+4),Bytes);
+            MCU_E2PromReadChunk(DISPENSERS_MAP_IN_EEPROM+4,Bytes,buffer);
+            //memcpy(buffer, (void *)(DISPENSERS_MAP_IN_FLASH+4),Bytes);
             StoredDispenserData = dispenser_data__unpack(NULL,Bytes,buffer);
-            havedata = true;
+            if (StoredDispenserData)
+                havedata = true;
             free(buffer);
         }
     }
@@ -323,11 +329,14 @@ uint32_t IDS_Dispenser_Store_Data (void)
     if (JobIsActive()==false)
     {
         response_size = dispenser_data__pack(&StoreDispenserData, dispensers_container_buffer);
-        EraseFlashSection(DISPENSERS_SECTION_FLASH);
+
+        MCU_E2PromProgramChunk(DISPENSERS_MAP_IN_EEPROM,4,&response_size);
+        MCU_E2PromProgramChunk(DISPENSERS_MAP_IN_EEPROM+4, response_size, dispensers_container_buffer);
+        /*EraseFlashSection(DISPENSERS_SECTION_FLASH);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, dispensers_container_buffer);
         //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
-
+         */
         /*Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
         if (Status == FR_OK)
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index a1aa37c07..1528a9a3b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -83,6 +83,7 @@ uint32_t InitialDispenserTimeout = INITIAL_DISPENSER_TIMEOUT_LIMIT;
 uint32_t InitialDispenserTimeLag = INITIAL_DISPENSER_TIMEOUT;
 uint32_t InitialDispenserSpeed = INITIAL_DISPENSER_SPEED;
 
+uint32_t DispenserHomingTimeoutControlId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 uint32_t    ControlIdtoInactiveDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 
 //uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t deviceID);
@@ -189,6 +190,13 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
     }
     return OK;
 }*/
+uint32_t IDS_Honing_Timeout_Callback(uint32_t DispenserId, uint32_t ReadValue)
+{
+    ReportWithPackageFilter(IDSFilter,"IDS_Honing_Timeout_Callback",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
+    SafeRemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
+    AlarmHandlingSetAlarm (DispenserId+EVENT_TYPE__DISPENSER_1_REFILL_FAILURE,true);
+}
+
 uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 {
     uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
@@ -203,7 +211,8 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
         HomingRequestCallback[DispenserId](DispenserId,0);
         HomingRequestCallback[DispenserId] = NULL;
     }
-//    HomingActive[DispenserId]= false;
+    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
+    //    HomingActive[DispenserId]= false;
     IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
     ReportWithPackageFilter(IDSFilter,"Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
 //    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
@@ -295,17 +304,23 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         Enable_MidTank_Pressure_Reading(DispenserId);
 
         IDS_Dispenser_RefillStarted(DispenserId,1);
+        AlarmHandlingSetAlarm (DispenserId+EVENT_TYPE__DISPENSER_1_REFILL_FAILURE,false);
         if (DispenserId== LUBRICANT_DISPENSER)
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/4,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed/4;
             ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
+            if (DispenserHomingTimeoutControlId[DispenserId] == 0xFF)
+                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Honing_Timeout_Callback, eOneHour*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
+
         }
         else
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed;
             ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
+            if (DispenserHomingTimeoutControlId[DispenserId] == 0xFF)
+                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Honing_Timeout_Callback, eOneHour,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         DispenserLastMovementDown[DispenserId] = true;
@@ -327,6 +342,7 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 
     TimerMotors_t MotorId = (DispenserId)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorAbortMovetoLimitSwitch(MotorId);
+    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
     //close dry air valve in the dispenser
     Disable_MidTank_Pressure_Reading(DispenserId);
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 559ffdecc..fb7529b46 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -134,7 +134,7 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
 
 /*uint32_t IDS_DispenserControlInit()
 {
-    DispensersControl = (void *)(DISPENSERS_MAP_IN_FLASH);
+    DispensersControl = (void *)(?/);
     DispensersControl = DispensersCtrl;
 
     //EraseFlashSection(DispensersControl,sizeof(HardwarePidControl)*MAX_SYSTEM_DISPENSERS);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 73282fa97..659a308db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -52,6 +52,7 @@
 
 #include "StateMachines/Initialization/PowerOffSequence.h"
 #include "StateMachines/Initialization/PowerIdle.h"
+#include "Drivers/Uart_Comm/BTSR/BTSR.h"
 
 extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
@@ -90,7 +91,19 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
     uint8_t ReadBackReg[1];
 
-
+    if(request->amount == 0xFEED)//BTSR Feeder
+    {
+        if((request->delay) >> 4 == 0)
+        {
+            response.progress = BTSR_Auto_Identify(request->delay & 0xF);
+        }
+        else
+        {
+            response.progress = BTSR_Set_Parmeters(request->delay & 0xF,(request->delay & 0xFF00)>>8,(request->delay & 0xFF0000)>>16);
+        }
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xacc1e)
     {
         response.progress = IDS_Cleaning_Move_Actuators();
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
index f4b1f7463..7161da796 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
@@ -25,16 +25,16 @@
 
 void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = PASSED;
+    //uint32_t status = PASSED;
     MessageContainer responseContainer;
 
-    static bool first_time = true;
+    //static bool first_time = true;
 
     StubCartridgeReadRequest* request = stub_cartridge_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     Cartridge CartridgeRead = CARTRIDGE__INIT;
     CartridgeTagContent TagRead = CARTRIDGE_TAG_CONTENT__INIT;
-    NFC_Tag NFC_TagRead;
+    //NFC_Tag NFC_TagRead;
 
     StubCartridgeReadResponse response =   STUB_CARTRIDGE_READ_RESPONSE__INIT;
 
@@ -127,7 +127,7 @@ void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 
 void Stub_CartridgeWriteRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = NOT_SUPPORTED;
+    //uint32_t status = NOT_SUPPORTED;
     MessageContainer responseContainer;
 
     StubCartridgeWriteRequest* request = stub_cartridge_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c
index 3d1809b37..feabbeb58 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c
@@ -322,7 +322,7 @@ void Stub_ExtFlashWriteWordsRequest(MessageContainer* requestContainer)
 
 void Stub_ExtFlashReadWordsRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = PASSED;
+    //uint32_t status = PASSED;
 
     /*MessageContainer responseContainer;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_I2C.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_I2C.c
index e749b41ec..d07a4de59 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_I2C.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_I2C.c
@@ -28,6 +28,12 @@
 #include "Stub_Status.h"
 #include "drivers/I2C_Communication/I2C.h"
 
+
+#include "Drivers/Uart_Comm/BTSR/BTSR.h"
+
+static uint8_t CODE_STRING;//BTSR ID needed to check the checksum, in the response for FUNCTION_STRING = 0x33/0x1C
+static uint8_t Function_Code;//needed to check the checksum, in the response for FUNCTION_STRING = 0x33/0x1C
+
 void Stub_I2CRequest(MessageContainer* requestContainer)
 {
 
@@ -91,33 +97,134 @@ void Stub_I2CWriteBytesRequest(MessageContainer* requestContainer)
     response.slaveaddress = request->slaveaddress;
     response.has_slaveaddress = true;
 
-    //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
-    //response.has_readbyte= true;
+//    if(request->i2cid != 0xFEED)//BTSR FEEDR (Script identification)
+//    {
+//
+//        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
+//        //response.has_readbyte= true;
+//
+//        //--------------------------
+//
+//        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
+//        //response.has_readbyte= true;
+//
+//        uint8_t I2C_W_buf[256] = {0},i;
+//
+//        for(i = 0; i < request->n_bytestwrite;i++)
+//        {
+//            I2C_W_buf[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
+//        }
+//
+//        //response.readbytes = I2C_W_buf;
+//        //response.n_readbytes = request->n_bytestwrite;
+//
+//        //-------------------------------
+//
+//
+//        //----------------------
+//
+//        status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);
+//
+//    }
+//    else
+//    {
+//        //--------------- RS485 BTSR FEEDR ---------------
+//
+//
+//        uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes] = {0},i;
+//
+//        for(i = 0; i < request->n_bytestwrite;i++)
+//        {
+//            BTSR_TX_Buff[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
+//        }
+//
+//        CODE_STRING = BTSR_TX_Buff[0];
+//        Function_Code = BTSR_TX_Buff[1];
+//
+//        if(request->slaveaddress)//Auto_Calc_CheckSum
+//        {
+//            BTSR_Calculate_CheckSum(BTSR_TX_Buff,request->n_bytestwrite);
+//            BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite + 2);//2 bytes of CheckSum
+//        }
+//        else
+//        {
+//            BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite);
+//        }
+//
+//        Task_sleep (10);
+//        BTSR_RECEIVE_Buf(BTSR_RX_Buff, 0);//size not in use (need to ignore the returned error)
+//
+//
+//    }
+    if((request->i2cid != 0xFEED) && (request->i2cid != 0xFEED3ADD))//BTSR FEEDR (Script identification)
+    {
 
-    //--------------------------
+        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
+        //response.has_readbyte= true;
 
-    //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
-    //response.has_readbyte= true;
+        //--------------------------
 
-    uint8_t I2C_W_buf[256] = {0},i;
+        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
+        //response.has_readbyte= true;
+
+        uint8_t I2C_W_buf[256] = {0},i;
+
+        for(i = 0; i < request->n_bytestwrite;i++)
+        {
+            I2C_W_buf[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
+        }
+
+        //response.readbytes = I2C_W_buf;
+        //response.n_readbytes = request->n_bytestwrite;
+
+        //-------------------------------
+
+
+        //----------------------
+
+        status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);
 
-    for(i = 0; i < request->n_bytestwrite;i++)
-    {
-        I2C_W_buf[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
     }
+    else
+    {
+        //--------------- RS485 BTSR FEEDR ---------------
 
-    //response.readbytes = I2C_W_buf;
-    //response.n_readbytes = request->n_bytestwrite;
 
-    //-------------------------------
+        uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes] = {0},i;
 
+        for(i = 0; i < request->n_bytestwrite;i++)
+        {
+            BTSR_TX_Buff[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
+        }
 
-    //----------------------
+        CODE_STRING = BTSR_TX_Buff[0];
 
-    status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);
+        if(request->i2cid == 0xFEED3ADD)//Only for commands with 3 bytes with Address 1 (0x06/0xFD)
+        {
 
+            Function_Code = BTSR_TX_Buff[4];
 
-    //--------------------------
+            BTSR_Send_Buf_3xADD1(BTSR_TX_Buff, request->n_bytestwrite);
+        }
+        else
+        {
+            Function_Code = BTSR_TX_Buff[1];
+
+            if(request->slaveaddress)//Auto_Calc_CheckSum
+            {
+                BTSR_Calculate_CheckSum(BTSR_TX_Buff,request->n_bytestwrite);
+                BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite + 2);//2 bytes of CheckSum
+            }
+            else
+            {
+                BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite);
+            }
+        }
+        //Task_sleep (10);
+        //BTSR_RECEIVE_Buf(BTSR_RX_Buff, 0);//size not in use (need to ignore the returned error)
+
+
+    }
 
     status_response(status,&response.status, &response.statusword ,&response.has_statusword);
 
@@ -150,27 +257,48 @@ void Stub_I2CReadBytesRequest(MessageContainer* requestContainer)
     response.slaveaddress = request->slaveaddress;
     response.has_slaveaddress = true;
 
-    status = I2C_Read/*Read_I2C*/(request->i2cid, request->slaveaddress, I2C_R_buf, request->numberofbytestoread);
+    if(request->i2cid != 0xFEED)//BTSR FEEDR (Script identification)
+    {
 
-    //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
-    //response.has_readbyte= true;
+        status = I2C_Read/*Read_I2C*/(request->i2cid, request->slaveaddress, I2C_R_buf, request->numberofbytestoread);
 
-    //--------------------------
+        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
+        //response.has_readbyte= true;
 
-    //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
-    //response.has_readbyte= true;
+        //--------------------------
 
-    //uint32_t I2C_W_buf[256] = {0},i;
+        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
+        //response.has_readbyte= true;
 
-    for(i = 0; i < request->numberofbytestoread;i++)
-    {
-        I2C_R32_buf[i]= (uint32_t)I2C_R_buf[i] ;
+        //uint32_t I2C_W_buf[256] = {0},i;
+
+        for(i = 0; i < request->numberofbytestoread;i++)
+        {
+            I2C_R32_buf[i]= (uint32_t)I2C_R_buf[i] ;
+        }
+
+
+        response.readbytes = I2C_R32_buf;
+        response.n_readbytes = request->numberofbytestoread;
+
+        //-------------------------------
     }
+    else
+    {
+        //--------------- RS485 BTSR FEEDR ---------------
+        for(i = 0; i < request->numberofbytestoread - request->slaveaddress;i++)
+        {
+            I2C_R32_buf[i]= (uint32_t)BTSR_RX_Buff[i] ;
+        }
 
-    response.readbytes = I2C_R32_buf;
-    response.n_readbytes = request->numberofbytestoread;
+        if(((request->numberofbytestoread- request->slaveaddress) > 2) && (request->slaveaddress))//Verify_Received_CheckSum
+        {
+            I2C_R32_buf[i] = Check_Received_CheckSum(CODE_STRING, Function_Code, BTSR_RX_Buff, (request->numberofbytestoread - request->slaveaddress));//use the next byte to return the checksum status
+        }
+        response.readbytes = I2C_R32_buf;
+        response.n_readbytes = request->numberofbytestoread;
+    }
 
-    //-------------------------------
 
     status_response(status,&response.status, &response.statusword ,&response.has_statusword);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 869485b71..588b1b391 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -218,22 +218,6 @@ uint32_t StoreDancerConfigMessage(int DancerId)
 
     status |= MCU_E2PromProgram(DancerAddress[Dancer_i],DancersCfg[Dancer_i].zeropoint);
     Report("~~~~~~Store eeprom dancer",__FILE__,__LINE__,Dancer_i,RpWarning,(int)DancersCfg[Dancer_i].zeropoint,0);
-    /*
-    response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
-    if (response_buffer)
-    {
-        response_size = hardware_configuration__pack(&DancerConfig, response_buffer);
-    }
-    Fresult = FileWrite(response_buffer,response_size,DancerConfigPath,BIOS_WAIT_FOREVER);
-    EraseFlashSection(DANCERS_MAP_IN_FLASH,1024);
-    for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++)
-    {
-        ReadAppAndProgram(DANCERS_MAP_IN_FLASH, sizeof(Dancers), Dancers);
-    }
-
-
-    my_free(response_buffer);
-*/
     return status;
 }
 uint32_t LoadDancerConfigMessage()
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 4ced1e5fe..8b72c1a30 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -714,10 +714,6 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             NormalizedError = (-1*NormalizedError);
         }
-/*#ifdef BTSR_ROTATED_WINDER_TFU
-        if (index == WINDER_MOTOR)
-                TranslatedReadValue = (-1*TranslatedReadValue);
-#endif*/
 
         MotorControlConfig[index].m_mesuredParam = NormalizedError;
         DancerError[DancerId] = NormalizedError;
diff --git a/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd b/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd
index be42101c4..b3e3ca9f0 100644
--- a/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd
+++ b/Software/Embedded_SW/Embedded/tm4c129xnczad.cmd
@@ -34,7 +34,7 @@
 /* The starting address of the application.  Normally the interrupt vectors  */
 /* must be located at the beginning of the application.                      */
 #define APP_BASE 0x00000000
-#define FLASH_RAM_BASE 0x000F8000
+#define FLASH_RAM_BASE 0x000FC000
 #define RAM_BASE 0x20000000
 
 /* System memory map */
@@ -42,9 +42,9 @@
 MEMORY
 {
     /* Application stored in and executes from internal flash */
-    FLASH (RX) : origin = APP_BASE, length = 0x000F8000
+    FLASH (RX) : origin = APP_BASE, length = 0x000FC000
     /* Application stored in and executes from internal flash */
-    FLASH_RAM (RWX) : origin = FLASH_RAM_BASE, length = 0x00008000
+    FLASH_RAM (RWX) : origin = FLASH_RAM_BASE, length = 0x00004000
     /* Application uses internal RAM for data */
     SRAM (RWX) : origin = 0x20000000, length = 0x00040000
 }
diff --git a/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.cpp b/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.cpp
index 96d5108f2..a4f45ae19 100644
--- a/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.cpp
+++ b/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.cpp
@@ -58,6 +58,8 @@
 #define LowVolumeThreshold  0.5
 #define LowVolHalf  LowVolumeThreshold/2
 #define GradientEndThr 0.95
+#define DilutionFactor 10
+#define LightInksThr 5
 
 
 Tango::ColorLib::ColorConverter::ColorConverter() : 
@@ -65,8 +67,8 @@ Tango::ColorLib::ColorConverter::ColorConverter() :
 m_maxNlPerCM(NULL), 
 m_nInks(0), m_nVolumes(0),  
   m_GradStops(NULL), m_nGradStops(0), m_colortable(NULL), m_ProcessRangesMaxP(NULL),
-	m_nProcessRanges(0), m_NormGamutRegionMaxLim(NULL), m_LowVolThr_nlcm(NULL),
-	m_LowVolThrHalf_nlcm(NULL)
+	m_ProcessRangesMinP(NULL), m_nProcessRanges(0), m_NormGamutRegionMaxLim(NULL), 
+	m_LowVolThr_nlcm(NULL), m_LowVolThrHalf_nlcm(NULL), m_hasLightInks(false), m_InkNames(NULL)
 {
 	m_whitepointLab.Set(-1, -1, -1);
 	m_whitepointXYZ_Strip.Set(-1, -1, -1);
@@ -105,6 +107,11 @@ Tango::ColorLib::ColorConverter::~ColorConverter()
 		delete[] m_ProcessRangesMaxP;
 		m_ProcessRangesMaxP = NULL;
 	}
+	if (m_ProcessRangesMinP != NULL)
+	{
+		delete[] m_ProcessRangesMinP;
+		m_ProcessRangesMaxP = NULL;
+	}
 	if (m_LowVolThr_nlcm != NULL)
 	{
 		delete[]m_LowVolThr_nlcm;
@@ -116,6 +123,11 @@ Tango::ColorLib::ColorConverter::~ColorConverter()
 		delete[]m_LowVolThrHalf_nlcm;
 		m_LowVolThrHalf_nlcm = NULL;
 	}
+	if (m_InkNames != NULL)
+	{
+		delete[] m_InkNames;
+		m_InkNames = NULL;
+	}
 	/*	if (m_ProcessRangesMinP != NULL)
 		{
 			delete[] m_ProcessRangesMinP;
@@ -203,7 +215,7 @@ void Tango::ColorLib::ColorConverter::ProcessHiveNeighbors(ConversionInput *conv
 	}
 
 	MatrixXd RGBTmpVec(nHive + 1, 3);
-	MatrixXd VolumeHive(nHive + 1, m_nVolumes);
+	MatrixXd VolumeHive(nHive + 1, m_TotalNumberofInks);
 	MatrixXd LabHive(nHive + 1, 3);
 	VectorXd xyz(3);
 	C_RGB_XYZ_Lab xyzVal, LabVal;
@@ -215,7 +227,7 @@ void Tango::ColorLib::ColorConverter::ProcessHiveNeighbors(ConversionInput *conv
 	//int *GamutRegion = DBG_NEW int[nHive + 1];
 	double *Lab1P = new double[3];
 	//double *Lab1P = DBG_NEW double[3];
-	VectorXd Vol(m_nVolumes);
+	VectorXd Vol(m_nInks);
 	int j = 0;
 	double * LabInFinal1 = new double[3];
 	//double * LabInFinal1 = DBG_NEW double[3];
@@ -223,11 +235,11 @@ void Tango::ColorLib::ColorConverter::ProcessHiveNeighbors(ConversionInput *conv
 	double * LabOnGamut = new double[3];
 	double *InkOutP = new double[m_nInks];
 	bool InGamut = true;
-	for (int i = 0; i < nHive; ++i)
+	for (int iHive = 0; iHive < nHive; ++iHive)
 	{
 		//Get Lab's inGamut
 		for (j = 0; j < 3; ++j)
-			Lab1P[j] = Lab1(i, j);
+			Lab1P[j] = Lab1(iHive, j);
 		//Check if whitepoints match
 /*		if (m_AdaptWP)
 		{
@@ -238,23 +250,32 @@ void Tango::ColorLib::ColorConverter::ProcessHiveNeighbors(ConversionInput *conv
 		*/
 //		ColConv.ChangeWP(Lab1P, Lab1P, m_WP, m_whitepointXYZ_CT); //to Relative
 		ColConv.ChangeWP(Lab1P, Lab1P, m_WP, m_whitepointXYZ_Strip); //to Relative
-		m_colortable->m_B2ATransform->evalLab2InkP(Lab1P, InkOut, GamutRegion[i]); //InkOut is in units of 16 bits
-		for (int i = 0; i <m_nInks; ++i)
+		m_colortable->m_B2ATransform->evalLab2InkP(Lab1P, InkOut, GamutRegion[iHive]); //InkOut is in units of 16 bits
+		for (int iInk = 0; iInk <m_nInks; ++iInk)
 		{
-			InkOut[i] *= m_colortable->GetNormFactor();
-			if (InkOut[i] <= m_NormGamutRegionMaxLim[0])
+			InkOut[iInk] *= m_colortable->GetNormFactor();
+			if (InkOut[iInk] <= m_NormGamutRegionMaxLim[0])
 			{
-				m_colortable->m_LinCurves->m_InterpCurves[i].Eval(InkOut[i] * 655.35, InkOut[i]);
-				InkOut[i] /= 655.35;
+				m_colortable->m_LinCurves->m_InterpCurves[iInk].Eval(InkOut[iInk] * 655.35, InkOut[iInk]);
+				InkOut[iInk] /= 655.35;
 			}
 		}
 		InGamut = IsInGamut(Lab1P, sur, CS, LabOnGamut);
 		LimitLab(LabOnGamut);
 		VectorXd NLInkOut(m_nInks);
 		ConvertToNLInks(DoubleToVector(InkOut, m_nInks), NLInkOut);
-
-		LimitNLInks2Volume(NLInkOut, GamutRegion[i], Vol);
-		
+		LimitNLInks2Volume(NLInkOut, GamutRegion[iHive], Vol);
+		/////////////////////////////////////
+		VectorXd VolumeLI(m_TotalNumberofInks);
+		if (m_hasLightInks)
+		{
+			SplitVolume(Vol, VolumeLI, GamutRegion[iHive]);
+		}
+		else
+		{
+			for (int iVol = 0; iVol < m_TotalNumberofInks; ++iVol)
+				VolumeLI(iVol) = Vol(iVol);
+		}
 		//m_A2BTransform->evalInkP2Lab(InkOut, Lab1P, GamutRegion[i]);
 
 		//Convert to CT WP
@@ -271,29 +292,36 @@ void Tango::ColorLib::ColorConverter::ProcessHiveNeighbors(ConversionInput *conv
 		}*/
 		m_Conv02->SetReferenceWhite(D65);
 		for (int j = 0; j < 3; ++j)
-			LabHive(i, j) = LabInFinal1[j];
+			LabHive(iHive, j) = LabInFinal1[j];
 
 		//Convert to RGB, relative col is converted
 		m_Conv02->LabtoRGB(LabOnGamut, tmpRGB);
 		//m_Conv02->LabtoRGB(Lab1P, tmpRGB);
 		for (int j = 0; j < 3; ++j)
-			RGBTmpVec(i, j) = std::min(std::max(tmpRGB[j], 0.0), 255.0);
+			RGBTmpVec(iHive, j) = std::min(std::max(tmpRGB[j], 0.0), 255.0);
 		
-		//make sure the rounded sum does not exceed the limit in the gamut region
-		for (int j = 0; j < m_nInks; ++j)
-			VolumeHive(i, j) = Vol(j);
+		for (int j = 0; j < m_TotalNumberofInks; ++j)
+			VolumeHive(iHive, j) = VolumeLI(j);
 	}
-	for (int i = 0; i < 1; ++i)
+	
+	VectorXd VolumeLI_s(m_TotalNumberofInks);
+	if (m_hasLightInks)
 	{
-		for (j = 0; j < m_nInks; ++j)
-			VolumeHive(nHive + i, j) = Volume(j);
-		for (j = 0; j < 3; ++j)
-		{
-			RGBTmpVec(nHive + i, j) = RGB(j);
-			LabHive(nHive + i, j) = Lab(j);
-		}
-		GamutRegion[nHive + i] = InGamutRegion;
+		SplitVolume(Volume, VolumeLI_s, InGamutRegion);
+	}
+	else
+	{
+		for (int iVol = 0; iVol < m_TotalNumberofInks; ++iVol)
+			VolumeLI_s(iVol) = Volume(iVol);
+	}
+	for (j = 0; j < m_TotalNumberofInks; ++j)
+		VolumeHive(nHive , j) = VolumeLI_s(j);
+	for (j = 0; j < 3; ++j)
+	{
+		RGBTmpVec(nHive , j) = RGB(j);
+		LabHive(nHive , j) = Lab(j);
 	}
+	GamutRegion[nHive ] = InGamutRegion;
 
 	//Organize hive into 5x5 matrix
 	//Hive Vector follows the ordering 0-(0,0) 1-(0,1) 2-(0,2),....,
@@ -437,7 +465,7 @@ void  Tango::ColorLib::ColorConverter::ArrangeHiveData(MatrixXd LabHive, MatrixX
 		for (j = 0; j < 3; ++j)
 			RGBHive(index, j) = RGBTmpVec(i, j);
 
-		for (j = 0; j < m_nVolumes; ++j)
+		for (j = 0; j < m_TotalNumberofInks; ++j)
 			OVolumeHive(index, j) = VolumeHive(i, j);
 
 		OGamutRegion[index] = GamutRegion[i];
@@ -448,22 +476,25 @@ void  Tango::ColorLib::ColorConverter::ArrangeHiveData(MatrixXd LabHive, MatrixX
 void  Tango::ColorLib::ColorConverter::fillVolume(OutputCoordinates *&outputCoords, VectorXd Volume)
 {
 	int i = 0;
-	OutputLiquid** outputLiquids = (OutputLiquid**)malloc(sizeof(OutputLiquid*) * m_nVolumes);
-	for (i = 0; i < m_nVolumes; ++i)
+	OutputLiquid** outputLiquids = (OutputLiquid**)malloc(sizeof(OutputLiquid*) * m_TotalNumberofInks);
+	for (i = 0; i < m_TotalNumberofInks; ++i)
 	{
 		//	*outputLiquids[0] = OUTPUT_LIQUID__INIT;
 		outputLiquids[i] = (OutputLiquid*)malloc(sizeof(OutputLiquid));
 		output_liquid__init(outputLiquids[i]);
-		switch (m_CalibCurves[i].getInkName())
+		switch (m_InkNames[i])
 		{
 		case LIQUID_TYPE__Cyan:
 		case LIQUID_TYPE__Magenta:
 		case LIQUID_TYPE__Yellow:
 		case LIQUID_TYPE__Black:
+		case LIQUID_TYPE__LightCyan:
+		case LIQUID_TYPE__LightMagenta:
+		case LIQUID_TYPE__LightYellow:
 		{
 			outputLiquids[i]->has_volume = true;
 			outputLiquids[i]->has_liquidtype = true;
-			outputLiquids[i]->liquidtype = (LiquidType)(m_CalibCurves[i].getInkName());
+			outputLiquids[i]->liquidtype = (LiquidType)(m_InkNames[i]);
 			outputLiquids[i]->volume = Volume(i);
 			break;
 		}
@@ -472,7 +503,7 @@ void  Tango::ColorLib::ColorConverter::fillVolume(OutputCoordinates *&outputCoor
 		}
 	}
 	outputCoords->outputliquids = outputLiquids;
-	outputCoords->n_outputliquids = m_nVolumes;
+	outputCoords->n_outputliquids = m_TotalNumberofInks;
 	return;
 }
 
@@ -1053,7 +1084,7 @@ void Tango::ColorLib::ColorConverter::ConvertColorToLinearInks(InputCoordinates*
 
 void Tango::ColorLib::ColorConverter::ConvertToNLInks(VectorXd  InkIn, VectorXd &InkOut)
 {
-	for (int i = 0; i < m_nVolumes; ++i)
+	for (int i = 0; i < m_nInks; ++i)
 	{
 		if (InkIn(i) <= m_NormGamutRegionMaxLim[0])
 			m_CalibCurves[i].m_InvLinearInterp->Eval(InkIn(i), InkOut(i));
@@ -1065,7 +1096,7 @@ void Tango::ColorLib::ColorConverter::ConvertToNLInks(VectorXd  InkIn, VectorXd
 
 void Tango::ColorLib::ColorConverter::ConvertToLinearInks(VectorXd  InkIn, VectorXd &InkOut)
 {
-	for (int i = 0; i < m_nVolumes; ++i)
+	for (int i = 0; i < m_nInks; ++i)
 	{
 		m_CalibCurves[i].m_LinearInterp->Eval(InkIn(i), InkOut(i));
 	}
@@ -1076,13 +1107,34 @@ void Tango::ColorLib::ColorConverter::ConvertToLinearInks(VectorXd  InkIn, Vecto
 void Tango::ColorLib::ColorConverter::VolumeToNLInkP(VectorXd Volume, VectorXd &NLInkP)
 {
 	//Volume is in %. In order to be compatible with NL to volume it has to be tranlated to nl/cm
-	VectorXd InkP(m_nVolumes);
+	VectorXd InkP(m_TotalNumberofInks);
 	int MaxInd = -1;
 	double InkMax = -1.;
 	double InkSum = 0.;
-	for (int i = 0; i < m_nVolumes; ++i)
+	//Convert volume to Volume without Light Inks
+	VectorXd VolumeNoLI((int)(m_nInks));
+	if (m_hasLightInks)
 	{
-		InkP(i) =   Volume(i)* m_maxNlPerCM(i)/100;  //Volume is in %, InkP is in [nl/cm]
+		//Convert Light Ink Volumes to Ink Volumes
+		for (int i = 0; i < m_nInks; ++i)
+			VolumeNoLI(i) = Volume(i);
+
+		for (int i = 4; i < m_nVolumes; ++i)
+		{
+			if ((Volume(i) > 0) & (Volume(i - 4) == 0))
+			{
+				VolumeNoLI(i - 4) = Volume(i) / DilutionFactor;
+			}
+		}
+	}
+	else
+	{
+		for (int i = 0; i < m_nInks; ++i)
+			VolumeNoLI(i) = Volume(i);
+	}
+	for (int i = 0; i < m_nInks; ++i)
+	{
+		InkP(i) = VolumeNoLI(i)* m_maxNlPerCM(i)/100;  //Volume is in %, InkP is in [nl/cm]
 		if (InkMax < InkP(i))
 		{
 			InkMax = InkP(i);
@@ -1208,19 +1260,19 @@ void Tango::ColorLib::ColorConverter::SetMaxNLperCM(double maxNlPerCM, int i)
 	m_maxNlPerCM(i) = maxNlPerCM;
 }
 
-void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates *inputcoordinates, int n_processRanges, 
-	int colorspace, VectorXd &Volume, VectorXd &RGBOut, VectorXd &LabOut, int &GamutRegion)
+void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates *inputcoordinates, int n_processRanges,
+	int colorspace, VectorXd &VolumeNoLI, VectorXd &RGBOut, VectorXd &LabOut, int &GamutRegion)
 {
-	SetNumberOfVolumes((int)(inputcoordinates->n_inputliquids));
+	//SetNumberOfVolumes((int)(inputcoordinates->n_inputliquids));
 	// Set Calibration Data
 	LiquidType LQ;
 	if (m_CalibCurves == NULL)
 	{
 		m_CalibCurves = new CalibData[m_nInks];
 		//m_CalibCurves = DBG_NEW CalibData[m_nInks];
-		for (int i = 0; i < m_nVolumes; ++i)
+		for (int i = 0; i < m_nInks; ++i)
 		{
-			LQ =inputcoordinates->inputliquids[i]->calibrationdata->liquidtype;
+			LQ = inputcoordinates->inputliquids[i]->calibrationdata->liquidtype;
 			if (LQ == LIQUID_TYPE__Cyan || LQ == LIQUID_TYPE__Magenta || LQ == LIQUID_TYPE__Yellow || LQ == LIQUID_TYPE__Black)
 			{
 				//Get calibration data.
@@ -1237,16 +1289,37 @@ void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates
 	//July 29 2020
 	//Limit inks based on m_maxNlpercm
 	//Inks are limited in their nonlinear form
-	VectorXd NLInkP((int)(m_nVolumes));
-	VectorXd InkOut((int)(m_nVolumes));
+	VectorXd NLInkP((int)(m_nInks));
+	VectorXd InkOut((int)(m_nInks));
+	VectorXd Volume((int)(m_TotalNumberofInks));
+
 	//Convert to Nonlinear Inks
 	double SumVol_Ink = 0.0;
 	//Get Gamut Region
-	for (int i = 0; i < m_nVolumes; ++i)
-		Volume(i) = inputcoordinates->inputliquids[i]->volume;  //volume is given in %
+	for (int i = 0; i < m_TotalNumberofInks; ++i)
+		Volume(i) = inputcoordinates->inputliquids[i]->volume;
 
-	GamutRegion = GetGamutRegion(Volume, m_NormGamutRegionMaxLim);
-	VolumeToNLInkP(Volume, NLInkP);
+	if (m_hasLightInks)
+	{
+		//Convert Light Ink Volumes to Ink Volumes
+		for (int i = 0; i < m_nInks; ++i)
+			VolumeNoLI(i) = Volume(i);
+
+		for (int i = 4; i < m_TotalNumberofInks; ++i)
+		{
+			if ((Volume(i) > 0) & (Volume(i - 4) == 0))
+			{ 
+				VolumeNoLI(i - 4) = inputcoordinates->inputliquids[i]->volume / DilutionFactor;
+			}
+		}
+	}
+	else
+	{
+		for (int i = 0; i < m_nInks; ++i)
+			VolumeNoLI(i) = Volume(i);
+	}
+	GamutRegion = GetGamutRegion(VolumeNoLI, m_NormGamutRegionMaxLim);
+	VolumeToNLInkP(VolumeNoLI, NLInkP);
 	//Limit Inks
 	double *InkOutP = new double[m_nInks];
 	VectorToDouble(NLInkP, InkOutP);
@@ -1266,7 +1339,7 @@ void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates
 			}
 
 		}
-		for (int i = 0; i < (int)(m_nVolumes); ++i)
+		for (int i = 0; i < (int)(m_nInks); ++i)
 		{
 			if (NLInkP(i) <= m_NormGamutRegionMaxLim[0])
 			{
@@ -1282,12 +1355,12 @@ void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates
 	//Inks are limited in their nonlinear form
 	//Output Volume is in %
 	LimitInks(NLInkP, InkOutP);
-	NLInkPToVolume(DoubleToVector(InkOutP, m_nInks), Volume);
-	GamutRegion = GetGamutRegion(Volume, m_ProcessRangesMaxP);
+	NLInkPToVolume(DoubleToVector(InkOutP, m_nInks), VolumeNoLI);
+	GamutRegion = GetGamutRegion(VolumeNoLI, m_ProcessRangesMaxP);
 //	LimitLowVolume(Volume, GamutRegion, Volume);
-	NLcmtoPercentage(Volume, Volume);
+	NLcmtoPercentage(VolumeNoLI, VolumeNoLI);
 //	LimitNLInks2Volume(NLInkP, GamutRegion, Volume);
-	VolumeToNLInkP(Volume, NLInkP);
+	VolumeToNLInkP(VolumeNoLI, NLInkP);
 	VectorToDouble(NLInkP, InkOutP);
 	//Convert to RGB
 	//GamutRegion = 0;
@@ -1312,12 +1385,6 @@ void Tango::ColorLib::ColorConverter::ConvertVolumeToRGBDisplay(InputCoordinates
 	for (int i = 0; i < 3; ++i)
 		LabOutFinal[i] = LabOutFinal1[i];
 
-/*	
-	if (m_AdaptWP)
-	{
-		CConvertD65.ChangeWP(LabOutFinal, LabOutFinal, m_whitepointXYZ_Strip, m_whitepointXYZ_CT);
-	}
-	*/
 	LabOut = DoubleToVector(LabOutFinal, 3);
 
 	CConvertD65.SetReferenceWhite(D65);
@@ -1370,13 +1437,6 @@ void Tango::ColorLib::ColorConverter::VectorToDouble(VectorXd VecIn, double * do
 		doubOut[i] = VecIn(i);
 }
 
-/*void Tango::ColorLib::ColorConverter::VectorToDouble(VectorXd VecIn, std::vector<double> &doubOut)
-{
-	int nSize = VecIn.size();
-	for (int i = 0; i < nSize && i < doubOut.size(); ++i)
-		doubOut.push_back(VecIn(i));
-}*/
-
 
 VectorXd Tango::ColorLib::ColorConverter::DoubleToVector(double *doub, int nSize)
 {
@@ -1407,15 +1467,19 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		conversionInput = conversion_input__unpack(NULL, input_buffer_size, input_buffer);
 
 		//Filter and arrange colors (Should change from 3 to 4 if black ink is included)
-
-		int numofInks = CountNumberofInks(conversionInput);
+		int numofInks = 0;
+		int numLightInks = 0;
+		CountNumberofInks(conversionInput, numofInks, numLightInks);
 		if (numofInks < 0)
 			throw std::exception("Duplicate inks");
+		if (numLightInks > 0)
+			m_hasLightInks = true;
 		int expected_liquids = numofInks;
+		m_TotalNumberofInks = numofInks;
 		original_input_liquids_count = conversionInput->inputcoordinates->n_inputliquids;
 		original_input_liquids = conversionInput->inputcoordinates->inputliquids;
-
-		InputLiquid** filteredInputLiquids = (InputLiquid**)malloc(sizeof(InputLiquid*) * expected_liquids);
+		m_InkNames = new LiquidType[m_TotalNumberofInks];
+		InputLiquid** filteredInputLiquids = (InputLiquid**)malloc(sizeof(InputLiquid*) * m_TotalNumberofInks);
 
 		for (size_t i = 0; i < conversionInput->inputcoordinates->n_inputliquids; i++)
 		{
@@ -1425,15 +1489,31 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 			{
 			case LIQUID_TYPE__Cyan:
 				filteredInputLiquids[0] = liquid;
+				m_InkNames[0] = liquid->liquidtype;
 				break;
 			case LIQUID_TYPE__Magenta:
 				filteredInputLiquids[1] = liquid;
+				m_InkNames[1] = liquid->liquidtype;
 				break;
 			case LIQUID_TYPE__Yellow:
 				filteredInputLiquids[2] = liquid;
+				m_InkNames[2] = liquid->liquidtype;
 				break;
 			case LIQUID_TYPE__Black:
 				filteredInputLiquids[3] = liquid;
+				m_InkNames[3] = liquid->liquidtype;
+				break;
+			case LIQUID_TYPE__LightCyan:
+				filteredInputLiquids[4] = liquid;
+				m_InkNames[4] = liquid->liquidtype;
+				break;
+			case LIQUID_TYPE__LightMagenta:
+				filteredInputLiquids[5] = liquid;
+				m_InkNames[5] = liquid->liquidtype;
+				break;
+			case LIQUID_TYPE__LightYellow:
+				filteredInputLiquids[6] = liquid;
+				m_InkNames[6] = liquid->liquidtype;
 				break;
 			}
 		}
@@ -1455,8 +1535,8 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		size_t n_elements = 0;
 		bool InGamut = false;
 		m_WP.Set(0.9505, 1.00, 1.0888); //D65
-		//count number if inks
-	//	int numofInks = CountNumberofInks(conversionInput);
+
+
 		if(m_colortable ==NULL)
 			m_colortable = new ColorTable();
 		readColorTransformations(conversionInput);
@@ -1471,7 +1551,8 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 			m_NormGamutRegionMaxLim[i] = tmpVal[i];
 		//read calibration tables and store them in m_CalibCurves
 		InputLiquid **inputliquids = conversionInput->inputcoordinates->inputliquids;
-		int n_inputliquids = conversionInput->inputcoordinates->n_inputliquids;
+	//	int n_inputliquids = conversionInput->inputcoordinates->n_inputliquids;
+		int n_inputliquids = numofInks - numLightInks;
 		readCalibrationTables(inputliquids, n_inputliquids);
 
 		//Initialize CIECAM02 transformation
@@ -1485,7 +1566,7 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		// Compare Strip White point to Color Table White Point
 		//CompareWhitePoints();
 
-		if (numofInks != m_nInks)
+		if (n_inputliquids  != m_nInks)
 			throw std::exception("Number of available inks does not match ink tables\0");
 
 		//Tables have been filled
@@ -1499,8 +1580,8 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		for (int i = 1; i < m_nProcessRanges; ++i)
 		{
 			diff = conversionInput->processranges[i]->maxinkuptake - conversionInput->processranges[i - 1]->maxinkuptake;
-			if(diff<=0)
-				throw std::exception("Process Rangesare not monotonic\0");
+			if(diff<0)
+				throw std::exception("Process Ranges are not monotonic\0");
 		}
 		if(m_ProcessRangesMaxP == NULL)
 			m_ProcessRangesMaxP = new double[m_nProcessRanges];
@@ -1508,6 +1589,12 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		{
 			m_ProcessRangesMaxP[i] = conversionInput->processranges[i]->maxinkuptake;
 		}
+		if (m_ProcessRangesMinP == NULL)
+			m_ProcessRangesMinP = new double[m_nProcessRanges];
+		for (int i = 0; i < m_nProcessRanges; ++i)
+		{
+			m_ProcessRangesMinP[i] = conversionInput->processranges[i]->mininkuptake;
+		}
 		
 		SetLowVolThr_nlcm();
 		VectorXd InkOut(m_nInks);
@@ -1540,14 +1627,18 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 			// Right now calibration is in the [0-100] range, values exceeding [0-100] are not transformed
 			ConvertToNLInks(InkOut, NLInkOut);
 			
-			LimitNLInks2Volume(NLInkOut, GamutRegion, Volume);
-			//OutputCoordinates outputCoords = OUTPUT_COORDINATES__INIT;
-		/*	if (InkOutP != NULL)
-			{
-				delete[] InkOutP;
-				InkOutP = NULL;
-			}*/
-				
+			LimitNLInks2Volume(NLInkOut, GamutRegion, Volume);			
+		}
+		//Split Volume into inks and Light Inks
+		VectorXd VolumeLI(m_TotalNumberofInks);
+		if (m_hasLightInks)
+		{ 			
+			SplitVolume(Volume, VolumeLI, GamutRegion);
+		}
+		else
+		{
+			for (int i = 0; i < m_TotalNumberofInks; ++i)
+				VolumeLI(i) = Volume(i);
 		}
 		OutputCoordinates *outputCoords = (OutputCoordinates*)malloc(sizeof(OutputCoordinates));
 		output_coordinates__init(outputCoords);
@@ -1555,7 +1646,7 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		fillLab(outputCoords, LabOut);
 		outputCoords->has_processparameterstableindex = true;
 		outputCoords->processparameterstableindex = GamutRegion;
-		fillVolume(outputCoords, Volume);
+		fillVolume(outputCoords, VolumeLI);
 		conversionOutput->has_outofgamut = true;
 		conversionOutput->outofgamut = !(InGamut);
 		conversionOutput->singlecoordinates = outputCoords;
@@ -1574,8 +1665,8 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 			MatrixXd RGBHive(MatHive, 3);
 			VectorXd RGBHive1(3);
 			VectorXd LabHive1(3);
-			VectorXd  VolumeHive1(m_nVolumes);
-			MatrixXd VolumeHive(MatHive, m_nVolumes);
+			VectorXd  VolumeHive1(m_TotalNumberofInks);
+			MatrixXd VolumeHive(MatHive, m_TotalNumberofInks);
 			MatrixXd LabHive(MatHive, 3);
 
 			int *GamutRegionV = new int[MatHive];
@@ -1603,7 +1694,7 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 					for (j = 0; j < 3; ++j)
 						RGBHive1(j) = RGBHive(i, j);
 					fillRGB(hiveData[i], RGBHive1);
-					for (j = 0; j < m_nVolumes; ++j)
+					for (j = 0; j < m_TotalNumberofInks; ++j)
 						VolumeHive1(j) = VolumeHive(i, j);
 					fillVolume(hiveData[i], VolumeHive1);
 					for (j = 0; j < 3; ++j)
@@ -1611,7 +1702,7 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 					fillLab(hiveData[i], LabHive1);
 					hiveData[i]->has_processparameterstableindex = true;
 					hiveData[i]->processparameterstableindex = GamutRegionV[i];
-					hiveData[i]->n_outputliquids = m_nInks;
+					hiveData[i]->n_outputliquids = m_TotalNumberofInks;
 				}
 				conversionOutput->hivecoordinates[i] = hiveData[i];
 			}
@@ -1637,7 +1728,7 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 				fillLab(TripletData[i], LabHive1);
 				TripletData[i]->has_processparameterstableindex = true;
 				TripletData[i]->processparameterstableindex = GamutRegionV[tripletIndex[i]];
-				TripletData[i]->n_outputliquids = m_nInks;
+				TripletData[i]->n_outputliquids = m_TotalNumberofInks;
 				conversionOutput->triplecoordinates[i] = TripletData[i];
 			}
 
@@ -1721,13 +1812,106 @@ size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t i
 		InvLinearInterp[i].SetNPoints(npts);
 	}
 }*/
+void Tango::ColorLib::ColorConverter::CountNumberofInks(GradientConversionInput* conversionInput, int &numInks, int &numLightInks)
+{
+	int nLiquids = conversionInput->n_inputliquids;
+	//	int numberofInks = 0;
+		//Cyan
+	int nCyan = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__Cyan)
+			nCyan++;
+	}
+	if (nCyan > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nMagenta = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__Magenta)
+			nMagenta++;
+	}
+	if (nMagenta > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nYellow = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__Yellow)
+			nYellow++;
+	}
+	if (nYellow > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nBlack = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__Black)
+			nBlack++;
+	}
+	if (nBlack > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nLightCyan = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__LightCyan)
+			nLightCyan++;
+	}
+	if (nLightCyan > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nLightMagenta = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__LightMagenta)
+			nLightMagenta++;
+	}
+	if (nLightMagenta > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nLightYellow = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputliquids[i]->liquidtype == LIQUID_TYPE__LightYellow)
+			nLightYellow++;
+	}
+	if (nLightYellow > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	numInks = nCyan + nMagenta + nYellow + nBlack + nLightCyan + nLightMagenta + nLightYellow;
+	numLightInks = nLightCyan + nLightMagenta + nLightYellow;;
+	return;
+}
 
-int Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversionInput)
+void Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversionInput, int &numInks, int &numLightInks)
 {
 	int nLiquids = conversionInput->inputcoordinates->n_inputliquids;
-	int numberofInks = 0;
+//	int numberofInks = 0;
 	//Cyan
-	int nCyan = 0;;
+	int nCyan = 0;
 	for (int i = 0; i < nLiquids; ++i)
 	{
 		if (conversionInput->inputcoordinates->inputliquids[i]->liquidtype == LIQUID_TYPE__Cyan)
@@ -1735,8 +1919,9 @@ int Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversi
 	}
 	if (nCyan > 1)
 	{
-		numberofInks = -1;
-		return(numberofInks);
+		numInks = -1;
+		numLightInks = -1;
+			return;
 	}
 	int nMagenta = 0;
 	for (int i = 0; i < nLiquids; ++i)
@@ -1746,8 +1931,9 @@ int Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversi
 	}
 	if (nMagenta > 1)
 	{
-		numberofInks = -1;
-		return(numberofInks);
+		numInks = -1;
+		numLightInks = -1;
+			return;
 	}
 	int nYellow = 0;
 	for (int i = 0; i < nLiquids; ++i)
@@ -1757,8 +1943,9 @@ int Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversi
 	}
 	if (nYellow > 1)
 	{
-		numberofInks = -1;
-		return(numberofInks);
+		numInks = -1;
+		numLightInks = -1;
+			return;
 	}
 	int nBlack = 0;
 	for (int i = 0; i < nLiquids; ++i)
@@ -1768,11 +1955,49 @@ int Tango::ColorLib::ColorConverter::CountNumberofInks(ConversionInput* conversi
 	}
 	if (nBlack > 1)
 	{
-		numberofInks = -1;
-		return(numberofInks);
+		numInks = -1;
+		numLightInks = -1;
+		return;
+	}
+	int nLightCyan = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputcoordinates->inputliquids[i]->liquidtype == LIQUID_TYPE__LightCyan)
+			nLightCyan++;
+	}
+	if (nLightCyan > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+			return;
 	}
-	numberofInks = nCyan + nMagenta + nYellow + nBlack;
-	return(numberofInks);
+	int nLightMagenta = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputcoordinates->inputliquids[i]->liquidtype == LIQUID_TYPE__LightMagenta)
+			nLightMagenta++;
+	}
+	if (nLightMagenta > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+			return;
+	}
+	int nLightYellow = 0;
+	for (int i = 0; i < nLiquids; ++i)
+	{
+		if (conversionInput->inputcoordinates->inputliquids[i]->liquidtype == LIQUID_TYPE__LightYellow)
+			nLightYellow++;
+	}
+	if (nLightYellow > 1)
+	{
+		numInks = -1;
+		numLightInks = -1;
+			return;
+	}
+	numInks = nCyan + nMagenta + nYellow + nBlack + nLightCyan + nLightMagenta + nLightYellow;
+	numLightInks = nLightCyan + nLightMagenta + nLightYellow;;
+	return;
 }
 
 bool  Tango::ColorLib::ColorConverter::IsInGamut(double *InLab, SURROUND sur, CAM02CS  CS, double *LabCoord)
@@ -2099,12 +2324,16 @@ size_t Tango::ColorLib::ColorConverter::P_IsInGamut(uint8_t * input_buffer, size
 	bool InGamut = false;
 	m_WP.Set(0.9505, 1.00, 1.0888); //D65
 									//count number if inks
-	int numofInks = CountNumberofInks(conversionInput);
+	int numofInks = 0;
+	int numLightInks = 0;
+	CountNumberofInks(conversionInput, numofInks, numLightInks);
 	readColorTransformations(conversionInput);
 
 	//read calibration tables and store them in m_CalibCurves
-	int n_inputliquids = conversionInput->inputcoordinates->n_inputliquids;
+	int n_inputliquids = numofInks - numLightInks;
 	InputLiquid **inputliquid = conversionInput->inputcoordinates->inputliquids;
+	//Read CMYK Calibration Tables only. Light Inks have no calibration tables
+
 	readCalibrationTables(inputliquid, n_inputliquids);
 
 	//Initialize CIECAM02 transformation
@@ -2118,7 +2347,7 @@ size_t Tango::ColorLib::ColorConverter::P_IsInGamut(uint8_t * input_buffer, size
 	// Compare Strip White point to Color Table White Point
 	//CompareWhitePoints();
 
-	if (numofInks != m_nInks)
+	if ((numofInks - numLightInks) != m_nInks)
 		throw std::exception("Number of available inks does not match ink tables");
 
 	VectorXd InkOut(m_nInks);
@@ -2295,31 +2524,7 @@ size_t Tango::ColorLib::ColorConverter::GenerateGradient(uint8_t * input_buffer,
 		if (m_colortable == NULL)
 			m_colortable = new ColorTable();
 		PrepareGradient(conversionInput, conversionOutput);
-		//Get liquid types info...
-	/*	InputLiquid* cyan = NULL;
-		InputLiquid* magenta = NULL;
-		InputLiquid* yellow = NULL;
-		InputLiquid* black = NULL;
-
-		for (size_t i = 0; i < conversionInput->n_inputliquids; i++)
-		{
-			switch (conversionInput->inputliquids[i]->liquidtype)
-			{
-			case LIQUID_TYPE__Cyan:
-				cyan = conversionInput->inputliquids[i];
-				break;
-			case LIQUID_TYPE__Magenta:
-				magenta = conversionInput->inputliquids[i];
-				break;
-			case LIQUID_TYPE__Yellow:
-				yellow = conversionInput->inputliquids[i];
-				break;
-			case LIQUID_TYPE__Black:
-				black = conversionInput->inputliquids[i];
-				break;
-			}
-		}*/
-
+	
 		//Pack output...
 		output_buffer = (uint8_t*)malloc(gradient_conversion_output__get_packed_size(conversionOutput));
 		int size = gradient_conversion_output__pack(conversionOutput, output_buffer);
@@ -2388,10 +2593,10 @@ void Tango::ColorLib::ColorConverter::fillGradientStops(GradientConversionInput
 			m_GradStops[i].Set_ColorSpace(COLOR_SPACE__LAB);
 			m_GradStops[i].Set_Offset(conversionInput->stops[i]->offset);
 			break;
-		case COLOR_SPACE__Volume: //Case Volume
+		case COLOR_SPACE__Volume: //Case Volume // No Light Inks implementation for Volume
 			m_GradStops[i].Set_ColorSpace(COLOR_SPACE__Volume);
 			m_GradStops[i].Set_Offset(conversionInput->stops[i]->offset);
-			for (int j = 0; j < (int)conversionInput->stops[i]->n_liquidvolumes; j++)
+			for (int j = 0; j < m_TotalNumberofInks; j++)
 			{
 				LiquidVolume* liquidVolume = conversionInput->stops[i]->liquidvolumes[j];
 
@@ -2776,12 +2981,18 @@ void Tango::ColorLib::ColorConverter::PrepareGradient(GradientConversionInput* c
 	//fill input stops...
 	//All calculations are done in Relative Colorimetric Color Space
 	m_nGradStops = conversionInput->n_stops;
-	int nInks = conversionInput->n_inputliquids;
-	m_nVolumes = nInks;
+	int numofInks = 0;
+	int numLightInks = 0;
+	CountNumberofInks(conversionInput, numofInks, numLightInks);
+	if (numofInks < 0)
+		throw std::exception("Duplicate inks");
+	m_hasLightInks = false;  //Gradients do not use light inks
+	m_TotalNumberofInks = numofInks - numLightInks;
+	m_nVolumes = m_TotalNumberofInks;
 	if(m_GradStops == NULL)
 		m_GradStops = new Gradient[m_nGradStops];
 	for (int i = 0; i < m_nGradStops; ++i)
-		m_GradStops[i].SetVolumeSize(nInks);
+		m_GradStops[i].SetVolumeSize(m_TotalNumberofInks);
 
 	InputCoordinates **inputcoordinates = (InputCoordinates**)malloc(sizeof(InputCoordinates*)*m_nGradStops);
 	for (int i = 0; i < m_nGradStops; ++i)
@@ -2805,9 +3016,9 @@ void Tango::ColorLib::ColorConverter::PrepareGradient(GradientConversionInput* c
 	double *tmpVal = m_colortable->GetNormGamutRegionMaxLim();
 	for (int i = 0; i < m_nProcessRanges; ++i)
 		m_NormGamutRegionMaxLim[i] = tmpVal[i];
-	int n_inputliquids = conversionInput->n_inputliquids;
+	//int n_inputliquids = conversionInput->n_inputliquids;
 	InputLiquid **inputliquid = conversionInput->inputliquids;
-	readCalibrationTables(inputliquid, n_inputliquids);
+	readCalibrationTables(inputliquid, m_TotalNumberofInks);
 	if (m_colortable->GetTableVersion() <= 1)
 	{
 		throw std::exception("Color Table Version does not support gradients\0");
@@ -2836,7 +3047,7 @@ void Tango::ColorLib::ColorConverter::PrepareGradient(GradientConversionInput* c
 	// Compare Strip White point to Color Table White Point
 	//CompareWhitePoints();
 	ColorConvert CConvertD65(D65, D65);  //Destination, source
-	if (n_inputliquids != m_nInks)
+	if (m_TotalNumberofInks != m_nInks)
 		throw std::exception("Number of available inks does not match ink tables\0");
 
 	if (m_ProcessRangesMaxP == NULL)
@@ -2845,6 +3056,12 @@ void Tango::ColorLib::ColorConverter::PrepareGradient(GradientConversionInput* c
 	{
 		m_ProcessRangesMaxP[i] = conversionInput->processranges[i]->maxinkuptake;
 	}
+	if (m_ProcessRangesMinP == NULL)
+		m_ProcessRangesMinP = new double[m_nProcessRanges];
+	for (int i = 0; i < m_nProcessRanges; ++i)
+	{
+		m_ProcessRangesMinP[i] = conversionInput->processranges[i]->mininkuptake;
+	}
 	SetLowVolThr_nlcm();
 	VectorXd InkOut(m_nInks);
 	VectorXd RGBOut(3);
@@ -3150,14 +3367,14 @@ void  Tango::ColorLib::ColorConverter::GradInput2InputCoords(GradientConversionI
 			inputcoordinates[i]->has_b = true;
 			break;
 		case COLOR_SPACE__Volume: //Case Volume	
-			int  size= (int)conversionInput->stops[i]->n_liquidvolumes;
-			InputLiquid** InputLiquidsIC = (InputLiquid**)malloc(sizeof(InputLiquid*) *size);
-			for (int j = 0; j < size; j++)
+			//int  size= (int)conversionInput->stops[i]->n_liquidvolumes;
+			InputLiquid** InputLiquidsIC = (InputLiquid**)malloc(sizeof(InputLiquid*) *m_TotalNumberofInks);
+			for (int j = 0; j < m_TotalNumberofInks; j++)
 			{
 				InputLiquidsIC[j] = (InputLiquid*)malloc(sizeof(InputLiquid));
 				input_liquid__init(InputLiquidsIC[j]);
 			}
-			for (size_t j= 0; j< (int)conversionInput->stops[i]->n_liquidvolumes; j++)
+			for (size_t j= 0; j< (size_t)m_TotalNumberofInks; j++)
 			{
 				LiquidVolume* liquidVolume = conversionInput->stops[i]->liquidvolumes[j];
 				switch (liquidVolume->liquidtype)
@@ -3183,7 +3400,7 @@ void  Tango::ColorLib::ColorConverter::GradInput2InputCoords(GradientConversionI
 				
 			}
 			inputcoordinates[i]->inputliquids = InputLiquidsIC;
-			inputcoordinates[i]->n_inputliquids = size;
+			inputcoordinates[i]->n_inputliquids = m_TotalNumberofInks;
 		}
 	}
 }
@@ -3205,27 +3422,53 @@ void Tango::ColorLib::ColorConverter::NLcmtoPercentage(VectorXd InVolume, Vector
 void Tango::ColorLib::ColorConverter::LimitLowVolume(VectorXd InVolume, int &GamutRegion, VectorXd &OutVolume)
 {
 	int indGR = 0;
-	//Find Gamut Region
 	for (int i = 1; i < m_nProcessRanges; ++i)
 	{
 		if (GamutRegion == i)
 			indGR = i;
 	}
-	//Limit Volume based on Gamut Region
+	//InVolume is in [nl/cm]
+	double TotalVolume = 0.0;
+	for (int i = 0; i < m_nInks; ++i)
+		TotalVolume += InVolume(i);
+	
+	double low = 0.0;
+	double high = 0.0;
+
+	if (TotalVolume <= m_ProcessRangesMinP[0])
+	{
+		//Calculate minVolumeThreshold based on m_ProcessRangesMinP[0]
+		high = LowVolumeThreshold * m_ProcessRangesMinP[0]/100.0;
+	}
+	else if (TotalVolume <= m_ProcessRangesMaxP[0])
+	{
+		//Calculate  minVolumeThreshold based on Total Volume
+		high = LowVolumeThreshold * TotalVolume/100.0;
+	}
+	else if (TotalVolume <= m_ProcessRangesMinP[1])
+	{
+		//Calculate  minVolumeThreshold based on m_ProcessRangesMinP[1]
+		high = LightInksThr * m_ProcessRangesMinP[1]/100.0;
+	}
+	else
+	{
+		high = LightInksThr * TotalVolume/100.0;
+	}
+	//Limit Volume based on Total Ink Volume
 	double sumVol = 0;
 	for (int i = 0; i < m_nInks; ++i)
 	{
-		if (InVolume(i) >= m_LowVolThr_nlcm[indGR])
+		if (InVolume(i) >= high)
 			OutVolume(i) = InVolume(i);
-		else if (InVolume(i) < m_LowVolThrHalf_nlcm[indGR])
+		else if (InVolume(i) <(high/2.0))
 			OutVolume(i) = 0.0;
 		else
-			OutVolume(i) = m_LowVolThr_nlcm[indGR];
+			OutVolume(i) =high;
 		sumVol += OutVolume(i);
 	}
 	//recalculate GamutRegion
-	if (indGR == 0)
-		return;
+	if (sumVol <= m_ProcessRangesMaxP[0])
+		GamutRegion = 0;
 	else
 	{ 
 		for (int i = 1; i < indGR+1; ++i)
@@ -3238,6 +3481,7 @@ void Tango::ColorLib::ColorConverter::LimitLowVolume(VectorXd InVolume, int &Gam
 
 void Tango::ColorLib::ColorConverter::LimitLowVolumeP(VectorXd InVolume, int &GamutRegion, VectorXd &OutVolume)
 {
+	//InVolume is in %
 	int indGR = 0;
 	//Find Gamut Region
 	for (int i = 1; i < m_nProcessRanges; ++i)
@@ -3483,10 +3727,10 @@ void Tango::ColorLib::ColorConverter::LimitNLInks2VolumeThr(VectorXd NLInks, int
 	double *InkOutL = new double[m_nInks];
 //	ConvertToNLInks(NLInks, NLInkOut);
 	LimitInks(NLInks, InkOutL); // InkOutL in [nl/cm]
-	NLInkPToVolume(DoubleToVector(InkOutL, m_nInks), Volume);
+	NLInkPToVolume(DoubleToVector(InkOutL, m_nInks), Volume); // [nl/cm]
 	GamutRegion = GetGamutRegion(Volume, m_ProcessRangesMaxP);
-	LimitLowVolume(Volume, GamutRegion, Volume);
-	NLcmtoPercentage(Volume, Volume);
+	LimitLowVolume(Volume, GamutRegion, Volume);  // [nl/cm]
+	NLcmtoPercentage(Volume, Volume);  // output volume in %
 
 	if (InkOutL != NULL)
 	{
@@ -3665,4 +3909,104 @@ void Tango::ColorLib::ColorConverter::ConvertVolumeToLabRel(VectorXd &Volume,  V
 	}
 	return;
 
-}
\ No newline at end of file
+}
+
+void Tango::ColorLib::ColorConverter::SplitVolume(VectorXd Volume, VectorXd &VolumeLI, int &GamutRegion)
+{
+//mark split candidates
+	int ind = 0;
+	int *LISplitInd = new int[m_nInks - 1];
+	VectorXd Vol_nlcm(m_nInks);
+	double TotalVolume = 0;
+	double low = 0;
+	double high = 0;
+	for (int i = 0; i < m_nInks ; ++i)
+	{	
+		Vol_nlcm(i) = Volume(i)*m_maxNlPerCM(i)/100;
+		VolumeLI(i) = Vol_nlcm(i);
+		TotalVolume += Vol_nlcm(i);
+	}
+	int indGR = 0;
+	//Find Gamut Region
+	for (int i = 1; i < m_nProcessRanges; ++i)
+	{
+		if (GamutRegion == i)
+			indGR = i;
+	}
+	double lim1 = 0;
+	double lim2 = m_ProcessRangesMinP[0];
+	double lim3 = m_ProcessRangesMaxP[0];
+	for (int iReg = 0; iReg<m_nProcessRanges-1; ++iReg)
+	{ 
+		if ((TotalVolume >= lim1) & (TotalVolume <= lim2))
+		{
+			//Calculate Ink Split Based on m_ProcessRangesMinP[iReg]
+			low = LowVolumeThreshold * m_ProcessRangesMinP[iReg] / 100.0;
+			high = LightInksThr * m_ProcessRangesMinP[iReg] / 100.0;
+		}
+		else if ((TotalVolume <= lim3) & (TotalVolume >  lim2))
+		{
+			//Calculate Ink Split Based on Total Volume
+			low = LowVolumeThreshold * TotalVolume / 100.0;
+			high = LightInksThr * TotalVolume / 100.0;
+		}
+		 lim1 = m_ProcessRangesMaxP[iReg];
+		 lim2 = m_ProcessRangesMinP[iReg+1];
+		 lim3 = m_ProcessRangesMaxP[iReg+1];
+	}
+	if ((TotalVolume >= lim1) & (TotalVolume <= lim2))
+	{
+		//Calculate Ink Split Based on m_ProcessRangesMinP[iReg]
+		low = LowVolumeThreshold * m_ProcessRangesMinP[m_nProcessRanges-1] / 100.0;
+		high = LightInksThr * m_ProcessRangesMinP[m_nProcessRanges-1] / 100.0;
+	}
+	else if ((TotalVolume <= lim3) & (TotalVolume > lim2))
+	{
+		//Calculate Ink Split Based on Total Volume
+		low = LowVolumeThreshold * TotalVolume / 100.0;
+		high = LightInksThr * TotalVolume / 100.0;
+	}
+
+	for (int i = 0; i < m_nInks - 1; ++i)
+	{
+		if ((Vol_nlcm(i) >= low) & (Vol_nlcm(i) <= high))
+		{
+			VolumeLI(i + m_nInks) = DilutionFactor * Vol_nlcm(i);
+			VolumeLI(i) = 0.0;
+		}
+		else
+		{
+			VolumeLI(i) = Vol_nlcm(i);
+			VolumeLI(i + m_nInks) = 0;
+		}
+	}
+	//Check if  Split Volume exceeds MaxInkUptake[1]
+	double UpperLimit = m_ProcessRangesMaxP[m_nProcessRanges - 1];
+	TotalVolume = 0.0;
+	for (int i = 0; i < m_TotalNumberofInks; ++i)
+		TotalVolume += VolumeLI(i);
+	if (TotalVolume > UpperLimit)
+	{
+		//go back to CMYK inks
+		for (int iBack = 0; iBack < m_nInks - 1; ++iBack)
+		{
+			if ((VolumeLI(iBack) == 0) & (VolumeLI(iBack + m_nInks) > 0))
+			{
+				VolumeLI(iBack) = VolumeLI(iBack + m_nInks)/DilutionFactor;
+				TotalVolume += (VolumeLI(iBack) - VolumeLI(iBack + m_nInks));
+				VolumeLI(iBack + m_nInks) = 0.0;				
+			}
+		}
+	}
+	NLcmtoPercentage(VolumeLI, VolumeLI);
+	if (TotalVolume <= m_ProcessRangesMaxP[0])
+		GamutRegion = 0;
+	else
+	{
+		for (int i = 1; i < indGR + 1; ++i)
+		{
+			if ((TotalVolume > m_ProcessRangesMaxP[i - 1]) & (TotalVolume <= m_ProcessRangesMaxP[i]))
+				GamutRegion = i;
+		}
+	}
+}
diff --git a/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.h b/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.h
index 3c75124e5..3f84b9304 100644
--- a/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.h
+++ b/Software/Visual_Studio/ColorLib/Tango.ColorLib_v4/ColorConverter.h
@@ -79,6 +79,7 @@ namespace Tango
 				VectorXd &InkOut, VectorXd &RGBOut,
 				VectorXd &LabOut, int &GamutRegion);
 			void ConvertVolumeToLabRel(VectorXd &Volume, VectorXd &LabOut, int GamutRegion);
+			void SplitVolume(VectorXd Volume, VectorXd &VolumeLI, int &GamutRegion);
 			size_t Tango::ColorLib::ColorConverter::Convert(uint8_t * input_buffer, size_t input_buffer_size, uint8_t *& output_buffer);
 			size_t Tango::ColorLib::ColorConverter::GenerateGradient(uint8_t * input_buffer, size_t input_buffer_size, uint8_t *& output_buffer);
 			void ConvertToNLInks(VectorXd InkIn, VectorXd &InkOut);
@@ -91,13 +92,17 @@ namespace Tango
 		private:
 			ColorTable *m_colortable;
 			ColorConvert *m_Conv02;
+			LiquidType *m_InkNames;
 //			Interp *m_LinInterp;
 //			Interp *m_InvLinInterp;
 			C_RGB_XYZ_Lab m_whitepointLab;
 			C_RGB_XYZ_Lab m_whitepointXYZ_Strip;
 			double *m_NormGamutRegionMaxLim;
 			double *m_ProcessRangesMaxP;
+			double *m_ProcessRangesMinP;
 			int m_nProcessRanges;
+			bool m_hasLightInks;
+			int m_TotalNumberofInks;
 			void LimitLab(double* LabIn);
 			int m_nGradStops;
 			Gradient *m_GradStops;
@@ -131,7 +136,8 @@ namespace Tango
 				VectorXd xpos, VectorXd ypos, int nHive, MatrixXd &OLabHive, 
 				MatrixXd &ORGBHive, MatrixXd &OVolumeHive, int *&OGamutRegion);
 			void  FindTriplet(VectorXd Lab, MatrixXd Lab1, int nHive, int*indDataMax);
-			int CountNumberofInks(ConversionInput* conversionInput);
+			void CountNumberofInks(ConversionInput* conversionInput, int &numInks, int &numLightInks);
+			void CountNumberofInks(GradientConversionInput* conversionInput, int &numInks, int &numLightInks);
 			void SetStripWhitepoint(double threadl, double threada, double threadb);
 			void VectorToDouble(VectorXd Vec, double *doub);
 //			void VectorToDouble(VectorXd VecIn, std::vector<double> &doubOut);
diff --git a/Software/Visual_Studio/Tango.ColorLib.GradientTest.CLI/Program.cs b/Software/Visual_Studio/Tango.ColorLib.GradientTest.CLI/Program.cs
index 82049fa37..2a8077669 100644
--- a/Software/Visual_Studio/Tango.ColorLib.GradientTest.CLI/Program.cs
+++ b/Software/Visual_Studio/Tango.ColorLib.GradientTest.CLI/Program.cs
@@ -18,9 +18,9 @@ namespace Tango.ColorLib.GradientTest.CLI
             GradientGenerator generator = new GradientGenerator();
             //RGB, Gamut Region 0, In Gamut
             //TEST1
-      //      TestRGBGamutRegion0(generator);
-     //       Console.WriteLine("Press enter to nextTestLABGamutRegion0 test...");
-    //        Console.ReadLine();
+            TestRGBGamutRegion0(generator);
+            Console.WriteLine("Press enter to nextTestLABGamutRegion0 test...");
+            Console.ReadLine();
             // Lab, Gamut Region 0, In Gamut
             //TEST2
             TestLABGamutRegion0(generator);
@@ -28,32 +28,32 @@ namespace Tango.ColorLib.GradientTest.CLI
             Console.ReadLine();
             //Volume, Gamut Region 0, In Gamut
             //TEST3
-    //        TestVolumeGamutRegion0(generator);
-     //       Console.WriteLine("Press enter to next TestVolumeGamutRegion1 test...");
-    //        Console.ReadLine();
+            TestVolumeGamutRegion0(generator);
+            Console.WriteLine("Press enter to next TestVolumeGamutRegion1 test...");
+            Console.ReadLine();
             //Volume, Gamut Region 1, In Gamut
             //TEST4
-     //       TestVolumeGamutRegion1(generator);
-    //        Console.WriteLine("Press enter to next TestRGBMixedGamut test...");
-    //        Console.ReadLine();
+            TestVolumeGamutRegion1(generator);
+            Console.WriteLine("Press enter to next TestRGBMixedGamut test...");
+            Console.ReadLine();
 
             //RGB, Mixed Gamut Regions, In Gamut
             //TEST5
-   //         TestRGBMixedGamut(generator);
-  //          Console.WriteLine("Press enter to next TestLABOutOfGamut test...");
-  //          Console.ReadLine();
+            TestRGBMixedGamut(generator);
+            Console.WriteLine("Press enter to next TestLABOutOfGamut test...");
+            Console.ReadLine();
 
             //LAB, Gamut Region 0, Out of Gamut
             //TEST6
- //           TestLABOutOfGamut(generator);
-//            Console.WriteLine("Press enter to next TestLABMixedGamut test...");
-//            Console.ReadLine();
+            TestLABOutOfGamut(generator);
+            Console.WriteLine("Press enter to next TestLABMixedGamut test...");
+            Console.ReadLine();
 
             //7.	Lab, Mixed Gamut Regions, In Gamut
             //TEST7
- //           TestLABMixedGamut(generator);
- //           Console.WriteLine("Press enter to next TestMixedEnvironment test...");
- //          Console.ReadLine();
+            TestLABMixedGamut(generator);
+            Console.WriteLine("Press enter to next TestMixedEnvironment test...");
+            Console.ReadLine();
 
             //8.	Mixed Environment
             //TEST8
@@ -114,184 +114,111 @@ namespace Tango.ColorLib.GradientTest.CLI
                 //Segment length
                 input.SegmentLength = 1000;*/
             }
-            { 
-           /*
-                 input.Stops.Add(new GradientInputStop()
-                 {
-                     ColorSpace = ColorSpace.Rgb,
-                     Offset = 0,
-                     Red = 93,
-                     Green = 123,
-                     Blue = 95,
-                 });
-                 //Lab Stop 2
-                 input.Stops.Add(new GradientInputStop()
-                 {
-                     ColorSpace = ColorSpace.Lab,
-                     Offset = 0.6,
-                     L = 50,
-                     A = -10,
-                     B = -10,
-                 });
-                 //Volume Stop 3
-                 GradientInputStop c = new GradientInputStop()
-                 {
-                     ColorSpace = ColorSpace.Volume,
-                     Offset = 1,
-                 };
-                 c.LiquidVolumes.Add(new LiquidVolume()
-                 {
-                     LiquidType = LiquidType.Cyan,
-                     Volume = 50
-                 });
-                 c.LiquidVolumes.Add(new LiquidVolume()
-                 {
-                     LiquidType = LiquidType.Magenta,
-                     Volume = 0
-                 });
-                 c.LiquidVolumes.Add(new LiquidVolume()
-                 {
-                     LiquidType = LiquidType.Yellow,
-                     Volume = 50
-                 });
-                 c.LiquidVolumes.Add(new LiquidVolume()
-                 {
-                     LiquidType = LiquidType.Black,
-                     Volume = 0
-                 });
-                 input.Stops.Add(c);
+            {
+                /*
+                      input.Stops.Add(new GradientInputStop()
+                      {
+                          ColorSpace = ColorSpace.Rgb,
+                          Offset = 0,
+                          Red = 93,
+                          Green = 123,
+                          Blue = 95,
+                      });
+                      //Lab Stop 2
+                      input.Stops.Add(new GradientInputStop()
+                      {
+                          ColorSpace = ColorSpace.Lab,
+                          Offset = 0.6,
+                          L = 50,
+                          A = -10,
+                          B = -10,
+                      });
+                      //Volume Stop 3
+                      GradientInputStop c = new GradientInputStop()
+                      {
+                          ColorSpace = ColorSpace.Volume,
+                          Offset = 1,
+                      };
+                      c.LiquidVolumes.Add(new LiquidVolume()
+                      {
+                          LiquidType = LiquidType.Cyan,
+                          Volume = 50
+                      });
+                      c.LiquidVolumes.Add(new LiquidVolume()
+                      {
+                          LiquidType = LiquidType.Magenta,
+                          Volume = 0
+                      });
+                      c.LiquidVolumes.Add(new LiquidVolume()
+                      {
+                          LiquidType = LiquidType.Yellow,
+                          Volume = 50
+                      });
+                      c.LiquidVolumes.Add(new LiquidVolume()
+                      {
+                          LiquidType = LiquidType.Black,
+                          Volume = 0
+                      });
+                      input.Stops.Add(c);
 
-                 Console.WriteLine($"Testing input:\n{input.ToJsonString(nameof(input.ForwardData),nameof(CalibrationData))}");
+                      Console.WriteLine($"Testing input:\n{input.ToJsonString(nameof(input.ForwardData),nameof(CalibrationData))}");
 
-                 Console.WriteLine();
+                      Console.WriteLine();
 
-                 Console.WriteLine("Processing...");
+                      Console.WriteLine("Processing...");
 
-                 Stopwatch watch = new Stopwatch();
-                 watch.Start();
+                      Stopwatch watch = new Stopwatch();
+                      watch.Start();
 
-                 GradientConversionOutput output = generator.GenerateGradient(input);
+                      GradientConversionOutput output = generator.GenerateGradient(input);
 
-                 watch.Stop();
-                 Console.WriteLine($"Processing completed after: {watch.Elapsed.Milliseconds.ToString("00000.00")} mseconds.");
+                      watch.Stop();
+                      Console.WriteLine($"Processing completed after: {watch.Elapsed.Milliseconds.ToString("00000.00")} mseconds.");
 
-     //watch.Elapsed.TotalSeconds.ToString("0.0")}
+          //watch.Elapsed.TotalSeconds.ToString("0.0")}
 
-                 Console.WriteLine();
-                 Console.WriteLine($"Result:\n{output.ToJsonString()}");
-                 Console.WriteLine();*/
+                      Console.WriteLine();
+                      Console.WriteLine($"Result:\n{output.ToJsonString()}");
+                      Console.WriteLine();*/
             }
 
             Console.WriteLine("Press return to exit...");
             Console.ReadLine();
         }
 
-        public static CalibrationData CreateCalibrationData(PMR.ColorLab.LiquidType liquidType, CalibrationData tmpData, int nsize)
-        {
-            CalibrationData data = new CalibrationData();
-            data.LiquidType = liquidType;
-            
-            for (int i = 0; i < nsize; i++)
-            {
-                data.CalibrationPoints.Add(new CalibrationPoint()
-                {
-                    X = tmpData.CalibrationPoints[i].X,
-                    Y = tmpData.CalibrationPoints[i].Y,
-                });
-            }
-
-            return data;
-        }
-
         static GradientConversionInput CreateBaseGradientConversionInput()
         {
             GradientConversionInput input = new GradientConversionInput();
-        
-           //CCT
-           input.ForwardData = ByteString.CopyFrom(File.ReadAllBytes(@"Sylko_HV_IL400Bl95R_1.cct")); //TODO: Load CCT file from local drive.
-            CalibrationData tmpCyanData = new CalibrationData();
-            tmpCyanData.LiquidType = LiquidType.Cyan;
-            double [] XValC  = {0, 1, 2, 3, 7, 19, 47, 76, 86, 100 };
-            double[] YValC = {0 ,6.9665 ,13.1381, 18.1474, 30.80, 50.7896, 73.1757, 89.37837, 94.20457, 100 };
-            int nsizeC = XValC.Length;
-           
-            for (int i = 0; i < nsizeC; i++)
-            {
-                tmpCyanData.CalibrationPoints.Add(new CalibrationPoint()
-                {
-                    X = XValC[i],
-                    Y = YValC[i],
-                });
-            }
-            CalibrationData tmpMagentaData = new CalibrationData();
-            tmpMagentaData.LiquidType = LiquidType.Magenta;
-            double[] XValM = { 0, 1, 2, 4, 7, 10, 31, 63, 80, 100 };
-            double[] YValM = { 0, 11.6638, 21.7132, 34.7811, 45.3282, 53.6154, 74.9858, 90.2901,94.5245,100};
-            int nsizeM = XValM.Length;
-
-            for (int i = 0; i < nsizeM; i++)
-            {
-                tmpMagentaData.CalibrationPoints.Add(new CalibrationPoint()
-                {
-                    X = XValM[i],
-                    Y = YValM[i],
-                });
-            }
-            CalibrationData tmpYellowData = new CalibrationData();
-            tmpYellowData.LiquidType = LiquidType.Yellow;
-            double[] XValY = {0, 1, 2, 4, 7, 11, 23, 39, 67, 100 };
-            double[] YValY = { 0, 9.8895, 18.4570, 29.6694, 37.7121, 45.4408, 63.6478, 75.8076, 93.9226, 100 };
-            int nsizeY = XValY.Length;
-
-            for (int i = 0; i < nsizeY; i++)
-            {
-                tmpYellowData.CalibrationPoints.Add(new CalibrationPoint()
-                {
-                    X = XValY[i],
-                    Y = YValY[i],
-                });
-            }
 
-            CalibrationData tmpBlackData = new CalibrationData();
-            tmpBlackData.LiquidType = LiquidType.Yellow;
-            double[] XValK = { 0, 1, 2,4,7,10,20,30,50,75,80,85,100 };
-            double[] YValK = { 0, 10.4656,19.5667, 31.6627, 40.6020, 46.9257, 63.1965, 70.9355, 83.4647, 94.4979, 95.7233, 96.3631,100 };
-            int nsizeK = XValY.Length;
+            //CCT
+            input.ForwardData = ByteString.CopyFrom(File.ReadAllBytes(@"Sylko_HV_IL350R.cct")); //TODO: Load CCT file from local drive.
 
-            for (int i = 0; i < nsizeK; i++)
-            {
-                tmpBlackData.CalibrationPoints.Add(new CalibrationPoint()
-                {
-                    X = XValK[i],
-                    Y = YValK[i],
-                });
-            }
             //RML Liquid Factors
             input.InputLiquids.Add(new InputLiquid()
             {
                 LiquidType = LiquidType.Cyan,
-                CalibrationData = CreateCalibrationData(LiquidType.Cyan, tmpCyanData, nsizeC),
+                CalibrationData = BL.Entities.Cat.CreateDemoCalibrationData(LiquidType.Cyan),
                 MaxNanoliterPerCentimeter = 200,
             });
 
             input.InputLiquids.Add(new InputLiquid()
             {
                 LiquidType = LiquidType.Magenta,
-                CalibrationData = CreateCalibrationData(LiquidType.Magenta, tmpMagentaData, nsizeM),
+                CalibrationData = BL.Entities.Cat.CreateDemoCalibrationData(LiquidType.Magenta),
                 MaxNanoliterPerCentimeter = 200,
             });
 
             input.InputLiquids.Add(new InputLiquid()
             {
                 LiquidType = LiquidType.Yellow,
-                CalibrationData = CreateCalibrationData(LiquidType.Yellow, tmpYellowData, nsizeY),
+                CalibrationData = BL.Entities.Cat.CreateDemoCalibrationData(LiquidType.Yellow),
                 MaxNanoliterPerCentimeter = 200,
             });
 
             input.InputLiquids.Add(new InputLiquid()
             {
                 LiquidType = LiquidType.Black,
-                CalibrationData = CreateCalibrationData(LiquidType.Black, tmpBlackData, nsizeK),
+                CalibrationData = BL.Entities.Cat.CreateDemoCalibrationData(LiquidType.Black),
                 MaxNanoliterPerCentimeter = 200,
             });
 
@@ -374,65 +301,25 @@ namespace Tango.ColorLib.GradientTest.CLI
             {
                 ColorSpace = ColorSpace.Lab,
                 Offset = 0.0,
-                L = 52,
-                A =-40,
-                B = -48,
-            });
-          input.Stops.Add(new GradientInputStop()
-            {
-                ColorSpace = ColorSpace.Lab,
-                Offset = 0.15,
-               L = 44,
-               A = 2.88,
-               B = -38.36,
-           });
-            input.Stops.Add(new GradientInputStop()
-            {
-                ColorSpace = ColorSpace.Lab,
-                Offset = 0.30,
-                L = 47.21,
-                A = 63.70,
-                B = 2.57,
+                L = 44.75,
+                A = 15.14,
+                B = -32.5,
             });
             input.Stops.Add(new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Lab,
-                Offset = 0.45,
-                L = 51.92,
-                A = 54.73,
-                B = 35.87,
-            });
-           input.Stops.Add(new GradientInputStop()
-           {
-               ColorSpace = ColorSpace.Lab,
-               Offset = 0.60,
-               L = 56.34,
-               A = 50.22,
-               B = 49.18,
-           });
-            input.Stops.Add(new GradientInputStop()
-            {
-                ColorSpace = ColorSpace.Lab,
-                Offset = 0.75,
-                L =82,
-                A =-0.52,
-                B = 85,
-            });
-            input.Stops.Add(new GradientInputStop()
-            {
-                ColorSpace = ColorSpace.Lab,
-                Offset = 0.90,
-                L = 51,
-                A =-32,
-                B =18,
+                Offset = 0.5,
+                L = 39.70,
+                A = 25.0,
+                B = -4.8,
             });
             input.Stops.Add(new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Lab,
                 Offset = 1,
-                L = 52,
-                A = -40,
-                B = -48,
+                L = 53,
+                A = -15.0,
+                B = -35,
             });
 
             Console.WriteLine($"TestLABGamutRegion0 input:\n{input.ToJsonString(nameof(input.ForwardData), nameof(CalibrationData))}");
@@ -456,7 +343,7 @@ namespace Tango.ColorLib.GradientTest.CLI
         static void TestVolumeGamutRegion0(GradientGenerator generator)
         {
             GradientConversionInput input = CreateBaseGradientConversionInput();
-            
+
             GradientInputStop gradientInputStop1 = new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Volume,
@@ -483,7 +370,7 @@ namespace Tango.ColorLib.GradientTest.CLI
                 Volume = 0
             });
             input.Stops.Add(gradientInputStop1);
-            
+
             GradientInputStop gradientInputStop2 = new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Volume,
@@ -559,7 +446,7 @@ namespace Tango.ColorLib.GradientTest.CLI
         static void TestVolumeGamutRegion1(GradientGenerator generator)
         {
             GradientConversionInput input = CreateBaseGradientConversionInput();
-           
+
             GradientInputStop gradientInputStop1 = new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Volume,
@@ -815,7 +702,7 @@ namespace Tango.ColorLib.GradientTest.CLI
                 Green = 123,
                 Blue = 95,
             });
-            
+
             input.Stops.Add(new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Lab,
@@ -824,7 +711,7 @@ namespace Tango.ColorLib.GradientTest.CLI
                 A = -10,
                 B = -10,
             });
-           
+
             GradientInputStop gradientInputStop1 = new GradientInputStop()
             {
                 ColorSpace = ColorSpace.Volume,