From a84ca31290b18ef2a9ec4c197d86573bb13adb03 Mon Sep 17 00:00:00 2001
From: Avi Levkovich <avi@twine-s.com>
Date: Thu, 17 Dec 2020 14:35:00 +0200
Subject: Add BTSR (scripts full suport) + use NonBlocking in Shinko
 Uart3_Receive

---
 .../Common/Sys_PinOut_Config/MCU_MAIN_pinout.c     |  11 +-
 Software/Embedded_SW/Embedded/DataDef.h            |   7 +-
 .../WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.c    |  16 +-
 .../Embedded/Drivers/Uart_Comm/BTSR/BTSR.c         | 630 +++++++++++++++++++++
 .../Embedded/Drivers/Uart_Comm/BTSR/BTSR.h         |  65 +++
 .../WHS_Controller_Comm/WHS_UART/WHS_Uart.c        |   7 +-
 Software/Embedded_SW/Embedded/Main.c               |   4 +
 .../Embedded/Modules/Stubs_Handler/Progress.c      |  15 +-
 .../Embedded/Modules/Stubs_Handler/Stub_I2C.c      | 184 +++++-
 9 files changed, 898 insertions(+), 41 deletions(-)
 create mode 100644 Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
 create mode 100644 Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.h

(limited to 'Software/Embedded_SW/Embedded')

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/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 850f62181..5b163c415 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -20,7 +20,7 @@
 #define NO_INITIAL_HEATING
 #define MAX_STRING_LEN              255 //Embedded  version + filter.c
 
-#define WATCHDOG
+//#define WATCHDOG
 //#define DISPESER_TEST
 //#define FPGA_WATCHDOG_DISABLE
 
@@ -30,6 +30,8 @@
 #define BTSR_NO_PULLER_TFU
 #endif
 
+#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
@@ -139,6 +141,9 @@ typedef enum Status_Enum // don't change used for RFID
 #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..12699a1fd
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
@@ -0,0 +1,630 @@
+/*
+ * 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;
+}
+
+
+
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/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 5c2312c08..2ec2c66a7 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"
@@ -394,6 +395,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/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 284a43e41..096876cf1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -51,6 +51,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
@@ -88,7 +89,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_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 ---------------
+
+
+        uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes] = {0},i;
 
-    //response.readbytes = I2C_W_buf;
-    //response.n_readbytes = request->n_bytestwrite;
+        for(i = 0; i < request->n_bytestwrite;i++)
+        {
+            BTSR_TX_Buff[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
+        }
 
-    //-------------------------------
+        CODE_STRING = BTSR_TX_Buff[0];
 
+        if(request->i2cid == 0xFEED3ADD)//Only for commands with 3 bytes with Address 1 (0x06/0xFD)
+        {
 
-    //----------------------
+            Function_Code = BTSR_TX_Buff[4];
 
-    status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);
+            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)
+    {
+
+        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->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++)
+        response.readbytes = I2C_R32_buf;
+        response.n_readbytes = request->numberofbytestoread;
+
+        //-------------------------------
+    }
+    else
     {
-        I2C_R32_buf[i]= (uint32_t)I2C_R_buf[i] ;
+        //--------------- RS485 BTSR FEEDR ---------------
+        for(i = 0; i < request->numberofbytestoread - request->slaveaddress;i++)
+        {
+            I2C_R32_buf[i]= (uint32_t)BTSR_RX_Buff[i] ;
+        }
+
+        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;
     }
 
-    response.readbytes = I2C_R32_buf;
-    response.n_readbytes = request->numberofbytestoread;
-
-    //-------------------------------
 
     status_response(status,&response.status, &response.statusword ,&response.has_statusword);
 
-- 
cgit v1.3.1


From 39cf804612a97dfb848ac308a1b40bafc3780783 Mon Sep 17 00:00:00 2001
From: Shlomo Hecht <shlomo@twine-s.com>
Date: Thu, 17 Dec 2020 16:22:27 +0200
Subject: some small changes

---
 .../Embedded/Common/SWUpdate/FileSystem.c            | 14 +++-----------
 .../Embedded_SW/Embedded/Common/report/reportInit.c  |  5 +++--
 .../WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.c       |  2 +-
 .../Embedded/Modules/AlarmHandling/AlarmHandling.c   |  6 +++---
 .../Embedded/Modules/Heaters/Heaters_Blowers.c       | 14 ++++++++++----
 .../Embedded/Modules/Heaters/Heaters_print.c         |  2 ++
 Software/Embedded_SW/Embedded/Modules/IDS/IDS.h      |  2 ++
 .../Embedded_SW/Embedded/Modules/IDS/IDS_maint.c     | 20 ++++++++++++++++----
 .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c     |  9 ++++++---
 .../Embedded/Modules/Thread/Thread_print.c           |  6 +++++-
 .../StateMachines/Initialization/InitSequence.c      | 12 +++++++-----
 .../Embedded/StateMachines/Printing/PrintingSTM.c    |  4 ++--
 12 files changed, 60 insertions(+), 36 deletions(-)

(limited to 'Software/Embedded_SW/Embedded')

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index a59a14dcf..17c1f164b 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -566,20 +566,12 @@ uint32_t    DeleteRequestFunc(MessageContainer* requestContainer)
     //int NumOfFiles = 0;
     FRESULT Fresult = FR_OK;
 
-    if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
-    {
-        Fresult = f_unlink(request->path);
-        Semaphore_post(FFS_Sem);
-    }
-    else
-    {
-        Fresult = FR_DENIED;
-        Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
-    }
+    Fresult = f_unlink(request->path);
+    Semaphore_post(FFS_Sem);
 
     REPORT_MSG(Fresult, "File Delete");
     responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse,  requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size);
-    if (Fresult!= OK)
+    if ((Fresult!= FR_OK)&&(Fresult!= FR_NO_FILE))
     {
         //usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
         responseContainer.has_error = true;
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/Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.c
index a3ae5bba1..854153218 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.c
@@ -566,7 +566,7 @@ bool waste_seq_cont()
         WasteCounter = 0;
         waste_level_ml = avg/8;
 
-        Report("------------ Avg waste level in ml  -----------------", __FILE__, WasteAverageIndex, avg, RpMessage, (int)(waste_level_ml), 0);
+        Report("------------ Avg waste level in ml  -----------------", __FILE__, WasteAverageIndex, (int)avg, RpMessage, (int)(waste_level_ml), 0);
     }
     if (FirstInSequence == false)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index db4535e06..07ebfa747 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -638,10 +638,10 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
                 return JOB_TEMPERATURE_ALARM;
             }
         case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
-            usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId+1);
             return JOB_OUT_OF_DYE;
         case ALARM_SOURCE_TYPE__PressureAlarm:
-            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId+1);
             return JOB_PRESSURE_ALARM;
         case ALARM_SOURCE_TYPE__CurrentAlarm:
             usnprintf(AlarmReasonStr, 100, "over/under current (%d) in %d",AlarmId,AlarmItem[AlarmId].DeviceId);
@@ -653,7 +653,7 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
             usnprintf(AlarmReasonStr, 100, "Machine door %d removed during a run",AlarmItem[AlarmId].DeviceId);
             return JOB_TAMPER_ALARM;
         case ALARM_SOURCE_TYPE__HardLimitAlarm:
-            usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId);
+            usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId+1);
             return JOB_LS_ALARM;
         case ALARM_SOURCE_TYPE__DoNotPollAlarm:
             if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index 1ee5302ab..76c679d80 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -555,9 +555,15 @@ uint32_t HeadBlowersV0Init(void)
 
 void Set_Head_Blowers_Parameters(float cp,float b)
 {
-    PressureSensor_CP = cp;
-    PressureSensor_B = b;
-    Report("Head Blowers CP Coefficient", __FILE__, __LINE__, (int)(PressureSensor_CP * 1000), RpMessage, 0, 0);
-    Report("Head Blowers B Coefficient", __FILE__, __LINE__, (int)(PressureSensor_B * 1000), RpMessage, 0, 0);
+    if (cp)
+    {
+        PressureSensor_CP = cp;
+        Report("Head Blowers CP Coefficient", __FILE__, __LINE__, (int)(PressureSensor_CP * 1000), RpMessage, 0, 0);
+    }
+    if (b)
+    {
+        PressureSensor_B = b;
+        Report("Head Blowers B Coefficient", __FILE__, __LINE__, (int)(PressureSensor_B * 1000), RpMessage, 0, 0);
+    }
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index f396d78d9..db7261090 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1012,6 +1012,8 @@ void HeaterPrepareFailureCheck(void)
         HeaterPrepareFailureCheckCounter = 0;
         return;
     }
+    if (HeaterPrepareFailureCheckCounter%60 == 0)
+        ReportWithPackageFilter(HeatersFilter,"HeaterPrepareFailureCheck",__FILE__,HeaterPrepareFailureCheckCounter,GetHeatersPrepareWaiting(),RpWarning,HeaterCheckReady(), 0);
     if ((HeaterPrepareFailureCheckCounter>=300)&&(HeaterPrepareFailureCheckCounter%60 == 0))
     {
         for (i = 0; i<HEATER_TYPE_MAX_HEATERS; i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 0f8108dad..e570a27f6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -30,6 +30,8 @@ extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern bool HomingActive[MAX_SYSTEM_DISPENSERS];
 extern bool PrimingActive[MAX_SYSTEM_DISPENSERS];
 
+extern  uint32_t DispenserPreSegmentControlId;
+
 extern uint32_t LeftRockerSpeed;
 extern uint32_t RightRockerSpeed;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 400eab33e..a1aa37c07 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -540,10 +540,22 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
     if (JobIsActive())
     {
-        if (DispenserUsedInJob[DispenserId] == true)
-        {
-            return ERROR;
-        }
+#ifndef LIGHT_COLORS
+            if ((DispenserId == CLEANER_DISPENSER)&&(DispenserPreSegmentControlId != 0xFF)) //not in presegment
+            {
+                return ERROR;
+            }
+            else if ((DispenserUsedInJob[DispenserId] == true)&&(DispenserId != CLEANER_DISPENSER))
+            {
+                return ERROR;
+            }
+
+#else
+            if (DispenserUsedInJob[DispenserId] == true)
+            {
+                return ERROR;
+            }
+#endif
     }
     if (Check_Pressure_Bypass == true)
         return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index c196ea031..559ffdecc 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -966,9 +966,12 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              }
          }
 #ifndef LIGHT_COLORS
-         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
-         MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
-         CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
+         if (GetDispenserPressure(CLEANER_DISPENSER) < 0.01)
+         {
+             TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
+             MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
+             CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
+         }
          ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
 #endif
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index c3fb17460..8b72c1a30 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -629,6 +629,10 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 			//pooler dancer is right sided: data is opposite
             TranslatedReadValue = (-1*TranslatedReadValue);
         }
+#ifdef BTSR_ROTATED_WINDER_TFU
+        if (index == WINDER_MOTOR)
+                TranslatedReadValue = (-1*TranslatedReadValue);
+#endif
 #ifdef FOUR_WINDERS
         if (index == WINDER_MOTOR)
         {
@@ -653,7 +657,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             TranslatedReadValue = (-1*TranslatedReadValue);
         }*/
 #endif
-        if (index == POOLER_MOTOR)
+        if (index == WINDER_MOTOR)
         {
             //pooler dancer is right sided: data is opposite
             JobCounter++;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index d7a49dfe0..0da78dc9c 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -30,6 +30,7 @@
 #include "modules/General/process.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
+#include "StateMachines/Initialization/PowerIdle.h"
 #include "InitSequence.h"
 
 #include "drivers/I2C_Communication/DAC/Blower.h"
@@ -605,7 +606,7 @@ uint32_t InitSequenceStartHeatingCallBackFunction(uint32_t IfIndex, uint32_t Bus
 bool InitialHeating = false;
 void InitSequenceSetStartHeating(bool StartHeating)
 {
-    REPORT_MSG(StartHeating,"InitSequenceStateMachine InitialHeating set");
+    REPORT_MSG(StartHeating,"InitSequence StateMachine InitialHeating set");
     InitialHeating = StartHeating;
 }
 uint32_t InitSequenceStartHeating(void)
@@ -635,12 +636,12 @@ uint32_t InitSequenceStartHeating(void)
         {
             SetMachineState(MACHINE_STATE_NO_PROCESS_PARAMS);
 		    SetMachineStatus(MACHINE_STATE__Ready);
-	        REPORT_MSG(MachineStateDetail,"InitSequenceStateMachine no process parameters file");
+	        REPORT_MSG(MachineStateDetail,"InitSequence StateMachine no process parameters file");
         }
     }
     else
     {
-        REPORT_MSG(InitialHeating,"InitSequenceStateMachine InitialHeating is OFF");
+        REPORT_MSG(InitialHeating,"InitSequence StateMachine InitialHeating is OFF");
         SetMachineStatus(MACHINE_STATE__Ready);
         SetMachineState(MACHINE_STATE_MACHINE_READY_TO_DYE);
         InitStages++;
@@ -780,8 +781,9 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage)
         case MACHINE_STATE_BUILT_IN_TEST:
             response.state = POWER_UP_STATE__BuiltInTest;
             response.progresspercentage = 15.0;
-            response.message = "Built In Test failed";
-            Error = ERROR_CODE__POWER_UP_BUILT_IN_FAILED;
+            response.message = "Built In Test";
+            //response.message = "Built In Test failed";
+            //Error = ERROR_CODE__POWER_UP_BUILT_IN_FAILED;
             break;
         case MACHINE_STATE_INITIAL_BLOWER_ACTIVATION:
             response.state = POWER_UP_STATE__InitialBlowerActivation;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index cb0703f27..d6262119c 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -125,7 +125,7 @@ FRESULT OpenJobFile()
         {
             readbBytes = 0;
         }
-        REPORT_MSG(bBytes,"OpenJobFile");
+        Report("OpenJobFile",__FILE__,__LINE__,(int)Fresult,RpMessage,(int)bBytes,0);
     }
     return Fresult;
 }
@@ -146,6 +146,7 @@ FRESULT RewindJobFile()
 FRESULT CloseJobFile()
 {
     Fresult = f_close(JobRequestFileHandle);
+    Report("CloseJobFile",__FILE__,__LINE__,(int)Fresult,RpMessage,(int)JobRequestFileHandle,0);
 
     readbBytes = 0;
     ImmediateRead = 0;
@@ -163,7 +164,6 @@ FRESULT CloseJobFile()
         my_free(SegmentPtr);
         SegmentPtr = NULL;
     }
-    REPORT_MSG(Fresult,"CloseJobFile");
 
     return Fresult;
 }
-- 
cgit v1.3.1


From 631fd1917ab3809b4b8d7e0066c49572f76688da Mon Sep 17 00:00:00 2001
From: Shlomo Hecht <shlomo@twine-s.com>
Date: Sun, 20 Dec 2020 08:40:14 +0200
Subject: comment removed

---
 Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'Software/Embedded_SW/Embedded')

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;
-- 
cgit v1.3.1


From e6ed8903c323722e9c1529273a09aa148bc13112 Mon Sep 17 00:00:00 2001
From: Avi Levkovich <avi@twine-s.com>
Date: Sun, 20 Dec 2020 09:12:40 +0200
Subject: Update BTSR + commenet the define USE_UART4_FOR_BTSR (need changes in
 FPGA_1+ jumpers in main board )

---
 Software/Embedded_SW/Embedded/DataDef.h            |   4 +-
 .../Embedded/Drivers/Uart_Comm/BTSR/BTSR.c         | 165 ++++++++++++++++++++-
 2 files changed, 166 insertions(+), 3 deletions(-)

(limited to 'Software/Embedded_SW/Embedded')

diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 1bed505f2..001303c88 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -20,7 +20,7 @@
 #define NO_INITIAL_HEATING
 #define MAX_STRING_LEN              255 //Embedded  version + filter.c
 
-//#define WATCHDOG
+#define WATCHDOG
 //#define DISPESER_TEST
 //#define FPGA_WATCHDOG_DISABLE
 
@@ -36,7 +36,7 @@
 #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_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 //
diff --git a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
index 12699a1fd..92337080d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Uart_Comm/BTSR/BTSR.c
@@ -77,7 +77,7 @@ void U4RX()
 
 void uart4_intHandler()
 {
-    static uint8_t nop = 0;
+    //static uint8_t nop = 0;
     //Get interrupt flags
     unsigned long status = UARTIntStatus(UART4_BASE, 1);
 
@@ -626,5 +626,168 @@ uint8_t BTSR_Read_Status(uint8_t BTSR_Id, uint8_t Application, uint8_t Yarn_Type
         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;
+}
 
-- 
cgit v1.3.1


From 295cc6981e5fca0f958c7aef06ee9cf8f25a762c Mon Sep 17 00:00:00 2001
From: Shlomo Hecht <shlomo@twine-s.com>
Date: Sun, 20 Dec 2020 11:32:47 +0200
Subject: Version 1.6.0 mostly changes in flash and EEPROM

---
 .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c  |   2 +-
 Software/Embedded_SW/Embedded/DataDef.h            |   2 +-
 .../Embedded/Drivers/flash_ram/FlashProgram.c      |  34 ++-
 .../Embedded/Drivers/flash_ram/FlashProgram.h      |  32 +--
 .../Embedded/Drivers/flash_ram/MCU_E2Prom.c        |  36 +++
 .../Embedded/Drivers/flash_ram/MCU_E2Prom.h        |  12 +
 Software/Embedded_SW/Embedded/Main.c               |  19 +-
 .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 309 +--------------------
 .../Embedded/Modules/Control/MillisecTask.c        |  27 +-
 .../Modules/Diagnostics/DiagnosticsHoming.c        |  30 +-
 .../Embedded/Modules/General/GeneralHardware.c     | 124 +++------
 .../Embedded_SW/Embedded/Modules/General/process.c |  34 ++-
 .../Embedded/Modules/Heaters/Heaters_Blowers.c     |  22 +-
 .../Embedded/Modules/IDS/IDS_dispenser.c           |  21 +-
 .../Embedded_SW/Embedded/Modules/IDS/IDS_maint.c   |  18 +-
 .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c   |   2 +-
 .../Modules/Stubs_Handler/Stub_Cartridge.c         |   8 +-
 .../Embedded/Modules/Stubs_Handler/Stub_ExtFlash.c |   2 +-
 .../Embedded/Modules/Thread/Thread_init.c          |  16 --
 Software/Embedded_SW/Embedded/tm4c129xnczad.cmd    |   6 +-
 20 files changed, 259 insertions(+), 497 deletions(-)

(limited to 'Software/Embedded_SW/Embedded')

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/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 1bed505f2..348ed37f6 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -36,7 +36,7 @@
 #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_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 //
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 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 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 + 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 c1eeff837..541fff0a7 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -137,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)
 {
@@ -161,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;
@@ -270,7 +255,7 @@ int main(void)
     uint32_t Data,i;
 
    MCU_E2PromInit();
-   updateresetreasonineeprom(0);
+   MCU_E2PromUpdateResetReason(0);
 
 #endif
     #ifdef EVALUATION_BOARD
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/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/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/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
 }
-- 
cgit v1.3.1