replace all ifdef newWHS whit reading from EEPROM newWHS exist.

16 files changed, 372 insertions, 157 deletions

diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
index a1ffa2475..443ae6aa7 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
@@ -159,7 +159,6 @@ uint32_t Turn_the_Blower_On()
     }
     else //new WHS
     {
-        Trigger_WHS_init_Blower();
         Trigger_SetWHSBlowerVoltage(Default_Voltage);
     }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
index 2b6510079..7ffe70cc6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
@@ -187,7 +187,7 @@ uint32_t Data_ADC_Head = 0;
 uint32_t HeadADCPT100_SendReadDataCommand(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 {
     uint32_t Status = OK;
-    uint8_t Write_Buf[1]= 0;
+    uint8_t Write_Buf[1]= {0};
 
     uint8_t temp[3] = {0,0,0};
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
index 7bfd8612d..9d14db8e1 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -22,9 +22,8 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
-#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 #include <Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h>
-
+#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 #include "ADC_MUX/ADC_MUX.h"
 #include "modules/ids/ids_ex.h"
 
@@ -42,6 +41,7 @@ typedef enum
     Actuators_Control,
 
     /* enum for WHS :*/
+    DetectNewWHS,
     WHS_start,
     WHS_init_I2C_IO,
     WHS_init_fan,
@@ -169,6 +169,16 @@ void Trigger_InputsReading(void)
 
 }
 
+void Trigger_Check_WHS_Type_Via_EEPROM()
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+
+     I2C_ReadingMessage.messageId = DetectNewWHS;
+     if (I2C_ReadingMsgQ != NULL)
+         Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+     return;
+}
+
 void Trigger_WHS_init_IO(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
@@ -445,6 +455,10 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             }
             break;
 
+        case DetectNewWHS:
+            Check_WHS_Type_Via_EEPROM();
+            break;
+
         case WHS_init_I2C_IO:
             WHS_IO_Init();
             break;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
index 16db6132f..6e0774d75 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.h
@@ -10,7 +10,7 @@
 #define DRIVERS_I2C_COMMUNICATION_I2C_TASK_H_
 
 
-
+void Trigger_Check_WHS_Type_Via_EEPROM(void);
 void Trigger_WHS_init_IO(void);
 void Trigger_WHS_init_fan(void);
 void Trigger_WHS_init_PT100(void);
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
index b6540df04..2316b3387 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
@@ -69,8 +69,7 @@ bool D_ADS122_ReadDataCommand(uint8_t i2cbus, uint8_t i2cadd, uint32_t* p_Data_A
 
     Status |= I2C_Read(i2cbus, i2cadd, &temp, 3);
     Data_ADS122X = (temp & 0xFF0000) >> 16 | (temp & 0xFF00) | (temp & 0x0000FF) << 16;//First send the MSB so we need to reorder the bytes
-     //*p_Data_ADS122X = CalculateTemperatures(Data_ADS122X);
-#warning what to do with the data   ???????
+    *p_Data_ADS122X = Data_ADS122X;//todo
     return Status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.c
new file mode 100644
index 000000000..6cd00ea4c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.c
@@ -0,0 +1,210 @@
+/*
+ * WHS_EEPROM.c
+ *
+ *  Created on: Jun 30, 2019
+ *      Author: avi
+ */
+#include "include.h"
+#include <Drivers/I2C_Communication/I2C.h>
+#include <Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h>
+//#include "../I2C_WHS_Mux.h"
+//#include "Drivers/I2C_Communication/WHS_Card/WHS_data.h"
+#include "driverlib/i2c.h"
+
+//EEPROM M24M01-DFMN6TP
+//uint32_t I2C_WHS_EEPROM_SLAVE_ADD = 0xA0;
+
+
+//uint8_t WHS_Type = WHS_TYPE_UNKNOWN;
+
+#define MAX_ALLOWS_PAGE_WRITE 256
+#define MIN_READ_BYTE 1
+
+bool D_I2C_EEprom_Write_Byte(uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint8_t data)
+{
+    bool status = OK;
+    status = (bool)D_I2C_EEprom_Write(I2C_ID, I2C_chip_addr, address, 1, &data);
+    return status;
+}
+
+
+bool D_I2C_EEprom_Read_Byte (uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint8_t* p_data)
+{
+    bool status = OK;
+    status = (bool)D_I2C_EEprom_Read(I2C_ID, I2C_chip_addr, address, 1, p_data);
+    return status;
+
+}
+
+
+
+uint32_t D_I2C_EEprom_Write(uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint16_t size, uint8_t *p_data)
+{
+    uint32_t status= OK;
+    uint8_t Write_Buffer[size+2] ;
+    uint8_t I2C_chip_address = 0;
+    uint8_t A16 = 0;
+    uint16_t i = 0;
+
+    if (size > MAX_ALLOWS_PAGE_WRITE)
+    {
+        return status = ERROR;
+    }
+
+    A16 = ((address & 0x00010000) >> 16);
+    I2C_chip_address = (I2C_chip_addr | (A16 << 1));
+    Write_Buffer[0] = ((address & 0x0000FF00)>>8);
+    Write_Buffer[1] = (address & 0x000000FF);
+
+    for(i = 0; i < size+2; i++)
+    {
+        Write_Buffer[i+2] = *(p_data+i);
+    }
+    //status |= Select_Main_WHS_Mux_Channel();
+    status |= I2C_Write(I2C_ID, I2C_chip_address , Write_Buffer, size+2);
+return status;
+}
+
+
+uint32_t D_I2C_EEprom_Read(uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint16_t size, uint8_t *p_data)
+{
+    uint32_t status= OK;
+    uint8_t A16 = 0;
+    uint8_t I2C_chip_address = 0;
+    uint8_t Write_Buffer[2] = {0,0};
+
+
+    if (size < MIN_READ_BYTE)
+    {
+        return status = ERROR;
+    }
+
+    A16 = ((address & 0x00010000) >> 16);
+    I2C_chip_address = (I2C_chip_addr | (A16 << 1));
+    Write_Buffer[0] = ((address & 0x0000FF00)>>8);
+    Write_Buffer[1] = (address & 0x000000FF);
+
+    //status |= Select_Main_WHS_Mux_Channel();
+    status |= I2C_Write(I2C_ID, I2C_chip_address , Write_Buffer, 2);
+    status |= I2C_Read(I2C_ID, I2C_chip_address + 1, p_data, size);
+
+    return status;
+
+}
+
+/*
+uint32_t Check_WHS_Type_Via_EEPROM()
+{
+#define WHS_TYPE_ADDR 0
+
+    uint32_t status = OK;
+    uint8_t data = 0;
+
+    WHS_I2C_EEprom_Read(WHS_TYPE_ADDR, 1, &data);
+
+    if(I2CMasterErr(I2C_ID_WHS_CARD) == I2C_MASTER_ERR_NONE)
+    {
+         WHS_Type = WHS_TYPE_UNKNOWN;
+    }
+    else
+    {
+        WHS_Type = WHS_TYPE_NEW;
+    }
+
+//    //temporary
+//    #ifdef Use_Head_Card
+//        Head_Type =  HEAD_TYPE_SYLKO;
+//    #else
+//        Head_Type = HEAD_TYPE_SYLKO_WITHOUT_CARD;
+//    #endif
+
+    //TODO to test and replace #ifdef Use_Head_Card with if(Head_Type != HEAD_TYPE_SYLKO_WITHOUT_CARD)
+
+    return status;
+}
+*/
+
+/*
+uint32_t WHS_I2C_EEprom_Write_Ch()
+{
+    uint32_t status= OK;
+
+    uint8_t i = 0;
+
+
+    status |= Select_Main_WHS_Mux_Channel();
+
+    WHS_Write_Buf[0] = 0x00;
+    WHS_Write_Buf[1] = 0x00;
+
+    for(i=0;i<Max_WHS_buf_size;i++)
+    {
+        WHS_Write_Buf[i+2] = WHS_struct.Write_WHS_EEPROM.Buf[i];
+    }
+
+    status |= I2C_Write(I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS, WHS_Write_Buf, Max_WHS_buf_size+2);
+
+    return status;
+}
+
+uint32_t WHS_I2C_EEprom_Set_for_Read_Ch()
+{
+    uint32_t status= OK;
+
+    status |= Select_Main_WHS_Mux_Channel();
+
+    WHS_Write_Buf[0] = 0x00;
+    WHS_Write_Buf[1] = 0x00;
+
+    status |= I2C_Write(I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS, WHS_Write_Buf, 2);
+
+    return status;
+}
+
+uint32_t WHS_I2C_EEprom_Read_Ch()
+{
+    uint32_t status= OK;
+
+    status |= Select_Main_WHS_Mux_Channel();
+
+    status |= I2C_Read(I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS + 1, WHS_struct.Read_WHS_EEPROM.Buf, Max_WHS_buf_size);
+
+    return status;
+}
+
+uint32_t Test_WHS_EEPROM()
+{
+    uint32_t status= OK;
+    uint32_t i;
+
+    WHS_struct.Write_WHS_EEPROM.bytes.SN = 0x12345678;
+
+    WHS_struct.Write_WHS_EEPROM.bytes.Uint32_Spare[0] = 0xA123456A;
+    WHS_struct.Write_WHS_EEPROM.bytes.Uint32_Spare[1] = 0xB123456B;
+    WHS_struct.Write_WHS_EEPROM.bytes.Uint32_Spare[2] = 0xC123456C;
+    WHS_struct.Write_WHS_EEPROM.bytes.Uint32_Spare[3] = 0xD123456D;
+    WHS_struct.Write_WHS_EEPROM.bytes.Uint32_Spare[4] = 0xE123456E;
+
+    WHS_struct.Write_WHS_EEPROM.bytes.Double_Spare[0] = 0xA789012A;
+    WHS_struct.Write_WHS_EEPROM.bytes.Double_Spare[1] = 0xB789012B;
+    WHS_struct.Write_WHS_EEPROM.bytes.Double_Spare[2] = 0xC789012C;
+    WHS_struct.Write_WHS_EEPROM.bytes.Double_Spare[3] = 0xD789012D;
+    WHS_struct.Write_WHS_EEPROM.bytes.Double_Spare[4] = 0xE789012E;
+
+    status |=  WHS_I2C_EEprom_Write_Ch();
+    SysCtlDelay(5000000);//Must delay for at least 5 milli. !!!  (See data sheet )
+    status |= WHS_I2C_EEprom_Set_for_Read_Ch();
+    status |= WHS_I2C_EEprom_Read_Ch();
+
+   if(status == 0)
+   {
+       for(i=0;i<Max_WHS_buf_size;i++)
+       {
+           if(WHS_struct.Read_WHS_EEPROM.Buf[i]!=WHS_struct.Write_WHS_EEPROM.Buf[i])
+               status |= ERROR;
+       }
+   }
+
+    return status;
+}
+*/
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h
new file mode 100644
index 000000000..92414134d
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h
@@ -0,0 +1,19 @@
+/*
+ * WHS_EEPROM.h
+ *
+ *  Created on: Jun 30, 2019
+ *      Author: avi
+ */
+
+#ifndef DRIVERS_I2C_COMMUNICATION_WHS_CARD_EEPROM_D_EEPROM_H_
+#define DRIVERS_I2C_COMMUNICATION_WHS_CARD_EEPROM_D_EEPROM_H_
+
+
+uint32_t D_I2C_EEprom_Write(uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint16_t size, uint8_t *data);
+uint32_t D_I2C_EEprom_Read (uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint16_t size, uint8_t *data);
+//uint32_t Check_WHS_Type_Via_EEPROM();
+
+bool D_I2C_EEprom_Write_Byte(uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint8_t data);
+bool D_I2C_EEprom_Read_Byte (uint8_t I2C_ID, uint8_t I2C_chip_addr, uint32_t address, uint8_t* p_data);
+
+#endif /* DRIVERS_I2C_COMMUNICATION_WHS_CARD_EEPROM_D_EEPROM_H_ */
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
index 1d7a788f6..117a20913 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
@@ -5,21 +5,18 @@
  *      Author: avi
  */
 #include "include.h"
-#include <Drivers/I2C_Communication/I2C.h>
+//#include <Drivers/I2C_Communication/I2C.h>
+#include <Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h>
 #include <Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h>
 #include "../I2C_WHS_Mux.h"
 #include "Drivers/I2C_Communication/WHS_Card/WHS_data.h"
+#include "driverlib/i2c.h"
 
 //EEPROM M24M01-DFMN6TP
 //uint32_t I2C_WHS_EEPROM_SLAVE_ADD = 0xA0;
 
-//uint8_t WHS_Write_Buf[Max_WHS_buf_size +2];
 
-#ifdef Use_Whs_Card
-uint8_t WHS_Type = WHS_TYPE_NEW;
-#else
-    uint8_t WHS_Type = WHS_TYPE_UNKNOWN;
-#endif
+uint8_t WHS_Type = WHS_TYPE_UNKNOWN;
 
 #define MAX_ALLOWS_PAGE_WRITE 256
 #define MIN_READ_BYTE 1
@@ -45,27 +42,19 @@ bool WHS_I2C_EEprom_Read_Byte (uint32_t address, uint8_t* p_data)
 uint32_t WHS_I2C_EEprom_Write(uint32_t address, uint16_t size, uint8_t *p_data)
 {
     uint32_t status= OK;
-    uint8_t WHS_Write_Buffer[size+2] ;
-    uint8_t A16 = 0;
-    uint8_t I2C_chip_address = 0;
-    uint16_t i = 0;
+//    uint8_t WHS_Write_Buffer[size+2] ;
+//    uint8_t A16 = 0;
+//    uint8_t I2C_chip_address = 0;
+//    uint16_t i = 0;
 
     if (size > MAX_ALLOWS_PAGE_WRITE)
     {
         return status = ERROR;
     }
 
-    A16 = ((address & 0x00010000) >> 16);
-    I2C_chip_address = (I2CEEPROM_ADDRESS | (A16 << 1));
-    WHS_Write_Buffer[0] = ((address & 0x0000FF00)>>8);
-    WHS_Write_Buffer[1] = (address & 0x000000FF);
-
-    for(i = 0; i < size+2; i++)
-    {
-        WHS_Write_Buffer[i+2] = *(p_data+i);
-    }
     status |= Select_Main_WHS_Mux_Channel();
-    status |= I2C_Write(I2C_ID_WHS_CARD, I2C_chip_address , WHS_Write_Buffer, size+2);
+    status |= D_I2C_EEprom_Write( I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS, address, size,  p_data);
+
 return status;
 }
 
@@ -74,9 +63,9 @@ uint32_t WHS_I2C_EEprom_Read(uint32_t address, uint16_t size, uint8_t *p_data)
 {
     uint32_t status= OK;
 
-    uint8_t A16 = 0;
-    uint8_t I2C_chip_address = 0;
-    uint8_t WHS_Write_Buffer[2] = {0,0};
+//    uint8_t A16 = 0;
+//    uint8_t I2C_chip_address = 0;
+//    uint8_t WHS_Write_Buffer[2] = {0,0};
 
 
     if (size < MIN_READ_BYTE)
@@ -84,18 +73,40 @@ uint32_t WHS_I2C_EEprom_Read(uint32_t address, uint16_t size, uint8_t *p_data)
         return status = ERROR;
     }
 
-    A16 = ((address & 0x00010000) >> 16);
-    I2C_chip_address = (I2CEEPROM_ADDRESS | (A16 << 1));
-    WHS_Write_Buffer[0] = ((address & 0x0000FF00)>>8);
-    WHS_Write_Buffer[1] = (address & 0x000000FF);
-
     status |= Select_Main_WHS_Mux_Channel();
-    status |= I2C_Write(I2C_ID_WHS_CARD, I2C_chip_address , WHS_Write_Buffer, 2);
-    status |= I2C_Read(I2C_ID_WHS_CARD, I2C_chip_address + 1, p_data, size);
+    status |= D_I2C_EEprom_Read (I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS,  address,  size, p_data);
 
     return status;
 
 }
+
+uint32_t Check_WHS_Type_Via_EEPROM()
+{
+#define WHS_TYPE_ADDR 0
+
+    uint32_t status = OK;
+    uint8_t data = 0;
+
+    Select_Main_WHS_Mux_Channel();
+    status = WHS_I2C_EEprom_Write_Byte(WHS_TYPE_ADDR, &data);
+
+
+    if (status)
+    //if(I2CMasterErr(I2C_ID_WHS_CARD) == I2C_MASTER_ERR_NONE)
+    {
+         WHS_Type = WHS_TYPE_UNKNOWN;
+    }
+    else
+    {
+        WHS_Type = WHS_TYPE_NEW;
+    }
+
+
+    //TODO to test and replace #ifdef Use_Head_Card with if(Head_Type != HEAD_TYPE_SYLKO_WITHOUT_CARD)
+
+    return status;
+}
+
 /*
 uint32_t WHS_I2C_EEprom_Write_Ch()
 {
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h
index 494a1d9a0..c64f8705c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h
@@ -39,6 +39,8 @@ uint32_t Test_WHS_EEPROM();
 */
 uint32_t WHS_I2C_EEprom_Write(uint32_t address, uint16_t size, uint8_t *data);
 uint32_t WHS_I2C_EEprom_Read (uint32_t address, uint16_t size, uint8_t *data);
+uint32_t Check_WHS_Type_Via_EEPROM();
+
 bool WHS_I2C_EEprom_Write_Byte(uint32_t address, uint8_t data);
 bool WHS_I2C_EEprom_Read_Byte (uint32_t address, uint8_t* p_data);
 
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 04ab6e57d..9469f9b97 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -81,7 +81,8 @@
 #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include "Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.h"
 #include "modules/AlarmHandling/AlarmHandling.h"
-
+//#include <Drivers/I2C_Communication/I2C_Task.h>
+#include <Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h>
 
 //*****************************************************************************
 //
@@ -249,7 +250,8 @@ int main(void)
    Init_All_I2C();
    Block_Main_MUX_TCA9548A_0xE4();//unused, same i2c as head and whs cards
    Check_Head_Type_Via_EEPROM();
-   //Check_WHS_Type_Via_EEPROM();
+   //Trigger_Check_WHS_Type_Via_EEPROM();
+   Check_WHS_Type_Via_EEPROM();
 
    #ifndef EVALUATION_BOARD
    STATUS_RED_LED_ON;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 828961d17..35065cc2a 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -150,9 +150,10 @@ uint32_t HWConfigurationInit(void)
     IDS_Dispenser_Content_Init();
     //ProcessParamsInit();
     Buttons_Init();
-    WHS_init();
     if (WHS_Type == WHS_TYPE_NEW)
         newWHS_init();
+    WHS_init();
+
     ADC_MUX_Init();
     GeneralHwReady = true;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 96ce9331d..2de6b0641 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -807,7 +807,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-        if (HeaterSpikeRead[index] = 0)
+        if (HeaterSpikeRead[index] == 0)
         {
             HeaterSpikeRead[index] = readValue;
         }
@@ -993,7 +993,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
-            if (HeaterSpikeRead[index] = 0)
+            if (HeaterSpikeRead[index] == 0)
             {
                 HeaterSpikeRead[index] = readValue;
             }
@@ -1200,7 +1200,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
-            if (HeaterSpikeRead[index] = 0)
+            if (HeaterSpikeRead[index] == 0)
             {
                 HeaterSpikeRead[index] = readValue;
             }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index e6e5923c0..c21316318 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -158,7 +158,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else //
     if(request->amount == 0x3EB)
     {
-        uint16_t tempu16=0;
+        uint16_t tempu16 = 0;
         if (WHS_Type == WHS_TYPE_NEW)
         {
             if (request->delay <= 0x03FF)
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 5fcab9c13..d845a128d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -328,23 +328,30 @@ bool SetWastePump( bool power)
     if ( power == OPEN )
     {
         if (WHS_Type == WHS_TYPE_UNKNOWN)
-            Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
-        else //new WHS
-            Trigger_SetWHSPump(OPEN);
-
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- ");
+        {
+		    Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
+        }
+		else //new WHS
+        {
+		    Trigger_SetWHSPump(OPEN);
+		}
         WHS_info.WHS_pump.status = OPEN;
+        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty start PUMP -----------------", __FILE__, __LINE__, WHS_info.WHS_pump.status, RpMessage, 0, 0);
         WHS_info.WHS_pump.time = STARTCOUNT;
         ret = OPEN;
     }
     else
     {
         if (WHS_Type == WHS_TYPE_UNKNOWN)
-            Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
-        else //new WHS
-            Trigger_SetWHSPump(CLOSE);
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty stop PUMP ----------------- ");
-        WHS_info.WHS_pump.status = CLOSE;
+        {
+		    Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
+        }
+		else //new WHS
+        {
+		    Trigger_SetWHSPump(CLOSE);
+        }
+		WHS_info.WHS_pump.status = CLOSE;
+        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty stop PUMP -----------------", __FILE__, __LINE__, WHS_info.WHS_pump.status, RpMessage, 0, 0);
         WHS_info.WHS_pump.time = STOPCOUNT;
         ret = CLOSE;
     }
@@ -366,12 +373,14 @@ bool SetValveDirection()
     if (WHS_info.active_cartridge == waste_cartridge1)
     {
         WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-    }
+        ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve VALVE_DIR_WASTE_CARTRIDGE1  -----------------", __FILE__, __LINE__, WHS_info.WHS_valve, RpMessage, 0 ,0);
+}
     else
     {
         WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE2;
+        ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve VALVE_DIR_WASTE_CARTRIDGE2   -----------------", __FILE__, __LINE__, WHS_info.WHS_valve, RpMessage, 0 ,0);
     }
-    ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve   -----------------", __FILE__,__LINE__,WHS_info.WHS_valve, RpMessage, 0 ,0);
+
 
     if (WHS_Type == WHS_TYPE_UNKNOWN)
         Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
@@ -396,7 +405,6 @@ U8 CartridgeWasteFilling(bool status)
         //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
         SetWastePump(OPEN);
         //WHS_info.WHS_pump.time = 0;
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
         AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
         ret=OK;
     }
@@ -416,16 +424,16 @@ U8 CartridgeWasteFilling(bool status)
               case waste_cartridge1:
                   Pannel_Leds( CART_2,  MODE_OFF);                //set led color
                   cart2.color = colorOFF;
-                  REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge1 is used please replace it ----------------- ");
+                  ReportWithPackageFilter(WasteFilter,"------------ WHS  waste_cartridge1 is used please replace it -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                   break;
               case waste_cartridge2:
                   Pannel_Leds( CART_3,  MODE_OFF);                //set led color
                   cart3.color = colorOFF;
-                  REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge2 is used please replace it ----------------- ");
+                  ReportWithPackageFilter(WasteFilter,"------------ WHS  waste_cartridge2 is used please replace it -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                   break;
               case no_waste_cartridge:
-                  REPORT_MSG(WHS_empty," ------------ !!!!!WHS  No waste cartridge !!!!! ----------------- ");
-                  REPORT_MSG(WHS_empty," ------------ !!!! WHS  insert cartridge!!!! ----------------- ");
+                  ReportWithPackageFilter(WasteFilter,"------------ !!!!!WHS  No waste cartridge !!!!! -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                  ReportWithPackageFilter(WasteFilter,"------------ !!!! WHS  insert cartridge!!!! -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                   ret = ERROR;
                   break;
               default:
@@ -479,40 +487,20 @@ WHS_sttMachin UpdateStateMachine()
     if ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL)
     {
         WHS_info.sttMachine = WHS_empty  ;
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty  ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
     }
-    else if ((WHS_info.WHS_sensors.waste_tank_full_sensor       == SENSORFULL)          &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor      == SENSORnotEMPTY))
+    else if ((WHS_info.WHS_sensors.waste_tank_full_sensor   == SENSORFULL) &&
+             (WHS_info.WHS_sensors.waste_tank_empty_sensor  == SENSORnotEMPTY))
     {
         WHS_info.sttMachine =  WHS_full  ;
-        REPORT_MSG(WHS_full," ------------ WHS WHS_full  ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_full -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
     }
     else
     {
         WHS_info.sttMachine =  WHS_sttError  ;
-        REPORT_MSG(WHS_sttError," ------------ WHS sensor Error  ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ WHS sensor Error -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
     }
-
-/*    if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor       == SENSORnotOVERFLOW)   &&
-        ( WHS_info.WHS_sensors.waste_tank_full_sensor            == SENSORnotFULL)       &&
-        ((WHS_info.WHS_sensors.waste_tank_empty_sensor           == SENSORnotEMPTY)     ||
-         (WHS_info.WHS_sensors.waste_tank_empty_sensor           == SENSOREMPTY)))
-        WHS_info.sttMachine = WHS_empty  ;
-    else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor  == SENSORnotOVERFLOW)   &&
-             (WHS_info.WHS_sensors.waste_tank_full_sensor       == SENSORFULL)          &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor      == SENSORnotEMPTY))
-        WHS_info.sttMachine =  WHS_full  ;
-    else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor  == SENSOROVERFLOW)      &&
-             (WHS_info.WHS_sensors.waste_tank_full_sensor       == SENSORFULL)          &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor      == SENSORnotEMPTY))
-        WHS_info.sttMachine =  WHS_overflow  ;
-    else
-        {
-        WHS_info.sttMachine =  WHS_sttError  ;
-            REPORT_MSG(WHS_sttError," ------------ WHS sensor Error  ----------------- ");
-        }
-*/
-    return OK;
+    return WHS_info.sttMachine;
 }
 
 
@@ -526,20 +514,6 @@ bool initWHS_WasteTank()
 }
 
 
-/*
-WHS_sensor OverflowSensorEvent()
-{
-    WHS_sensor ret = WHS_no_event;
-    if (RdWasteTankOverFlowSensor() != WHS_info.WHS_sensors.waste_tank_over_flow_sensor)
-    {
-         WHS_info.event =  WHS_overflow_sensor;
-         ret = WHS_overflow_sensor;
-         WHS_info.WHS_sensors.waste_tank_over_flow_sensor = !(WHS_info.WHS_sensors.waste_tank_over_flow_sensor);
-    }
-    return ret;
-}
-*/
-
 WHS_sensor EmptySensorEvent()
 {
     WHS_sensor ret = WHS_no_event;
@@ -548,6 +522,7 @@ WHS_sensor EmptySensorEvent()
         WHS_info.event =  WHS_empty_sensor;
         ret = WHS_empty_sensor;
         WHS_info.WHS_sensors.waste_tank_empty_sensor = !WHS_info.WHS_sensors.waste_tank_empty_sensor;
+        ReportWithPackageFilter(WasteFilter,"------------ WHS EmptySensorEvent (status) -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
     }
     return ret;
 }
@@ -560,6 +535,7 @@ WHS_sensor FullSensorEvent()
         WHS_info.event =  WHS_full_sensor;
         ret = WHS_full_sensor;
         WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
+        ReportWithPackageFilter(WasteFilter,"------------ WHS FullSensorEvent (status) -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
     }
     return ret;
 }
@@ -578,6 +554,7 @@ WHS_sensor WasteTankCallBackFunction()
     {
         WHS_info.WHS_pump.time = 0;
         AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  false);
+        ReportWithPackageFilter(WasteFilter,"------------ WHS PUMPTIMEOUT -----------------", __FILE__, __LINE__, PUMPTIMEOUT, RpMessage, 0, 0);
         return WHS_info.event = WHS_Timeout;
     }
     if ( FullSensorEvent())
@@ -595,7 +572,6 @@ WHS_sensor WasteTankCallBackFunction()
 bool WasteTankCBFunction()
 {
 
-    uint8_t parameter = 7;
     bool ret = notOK;
     static bool pump_on_flag = CLOSE;
     //uint32_t Cartridge_Cover_device_Id = 0;
@@ -609,11 +585,11 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_empty)
                 {
                     WHS_info.sttMachine = WHS_filling;
-                    REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_filling ------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                 }
                 else
                 {
-                    REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! ------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                 }
             }
             else //SENSOREMPTY
@@ -621,7 +597,7 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_emptying)
                 {
                     WHS_info.sttMachine = WHS_empty;
-                    REPORT_MSG(WHS_filling," ------------ WHS_empty ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                     ret = CartridgeWasteFilling(OFF);
                     WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
                     WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
@@ -629,7 +605,7 @@ bool WasteTankCBFunction()
                 }
                 else
                 {
-                    REPORT_MSG(WHS_emptying," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                 }
             }
             break;
@@ -639,9 +615,9 @@ bool WasteTankCBFunction()
                 break;
             if ((WHS_info.WHS_sensors.cartridge_cover == OPEN) && (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL))
             {
-                ReportWithPackageFilter(WasteFilter,"------------ WHS_full , cartridge cover is open cant start the pump!!!! ----------------- ", __FILE__,__LINE__,(int)(WHS_emptying), RpMessage, (int)(WHS_info.WHS_sensors.cartridge_cover), 0);
-                ReportWithPackageFilter(WasteFilter,"------------ close the cartridge cover to start the pump!!!! ----------------- ", __FILE__,__LINE__,(int)(WHS_emptying), RpMessage, (int)(WHS_info.WHS_sensors.cartridge_cover), 0);
-                //pump_on_flag = OPEN;
+                ReportWithPackageFilter(WasteFilter,"------------ WHS_full , cartridge cover is open cant start the pump!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);
+                ReportWithPackageFilter(WasteFilter,"------------ WHS, close the cartridge cover to start the pump!!!! -------------"      , __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);
+
                 AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
 
                 WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;
@@ -650,7 +626,7 @@ bool WasteTankCBFunction()
             if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
             {
                 WHS_info.sttMachine = WHS_full;
-                REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- ");
+                ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_full -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
                 WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
                 WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
                 if (RdRFIDStatus (WHS_info.active_cartridge) == WasteEmpty)
@@ -668,7 +644,7 @@ bool WasteTankCBFunction()
 
                 if (ret != OK)
                 {
-                    //recreate the full event until cartridge is inserted or atontocation
+                    //recreate the full event until cartridge is inserted or authentication
                     WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
                 }
 
@@ -679,34 +655,21 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_full)
                 {
                     WHS_info.sttMachine = WHS_emptying;
-                    REPORT_MSG(WHS_emptying," ------------ WHS_emptying ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_emptying -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
                     // can start a new JOB
                 }
                 else
                 {
-                    REPORT_MSG(WHS_full," ------------ WHS FULL sensor failed !!!!!!! ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS FULL sensor failed !!!!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
                 }
             }
             break;
 
-/*       case WHS_overflow_sensor:
-            if (WHS_info.WHS_sensors.waste_tank_empty_sensor)
-            {
-
-                // 1.StopMacine
-                 WHS_info.sttMachine = WHS_overflow;
-            }
-            else
-            {
-                WHS_info.sttMachine = WHS_full;
-            }
-            break;
-*/
         case WHS_cartridge_cover_sensor:
 
             if ( WHS_info.WHS_sensors.cartridge_cover == OPEN )
             {
-                REPORT_MSG(parameter," Cartridge cover open ");//popup message :"Cartridge cover open"  //todo
+                ReportWithPackageFilter(WasteFilter,"------------ WHS, Cartridge cover open -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);//popup message :"Cartridge cover open"  //todo
                 if ( WHS_info.WHS_pump.status == OPEN)
                 {
                     CartridgeWasteFilling(CLOSE);
@@ -726,7 +689,7 @@ bool WasteTankCBFunction()
                 }
                 else
                 {
-                    REPORT_MSG(parameter,"Power down in process");//popup message :"Cartridge cover open"  //todo
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, Power down in process -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);//popup message :"Cartridge cover open"  //todo
                 }
 
 
@@ -755,7 +718,7 @@ bool WasteTankCBFunction()
                 if ( IFS_info.INK_isOK_flag )
                 {
                     IFS_info.INK_isOK_flag = false;//0
-                    REPORT_MSG(WHS_full," ------------ change INK cartridge status to color Used ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, change INK cartridge status to color Used -------------", __FILE__, __LINE__, IFS_info.INK_isOK_flag, RpMessage, 0, 0);
                     // test the Mid-tank capacity is not at Nadav sequence
                     MidTank_Pressure = Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
                     if ( MidTank_Pressure > MidTank_Pressure_EMPTY )
@@ -763,11 +726,10 @@ bool WasteTankCBFunction()
                         ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTank_Pressure_EMPTY -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                         MidTankValvesAction(Cartridge_MidTank_OFF);
                         //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-                        REPORT_MSG(WHS_full," ------------ Mid-tank not empty ----------------- ");
+                        ReportWithPackageFilter(WasteFilter,"------------ WHS, Mid-tank not empty -------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                         break;
                     }
                     IFS_info.MidTank_capacity = MidTank_Pressure;
-                    REPORT_MSG(WHS_full," ------------ Mid-tank filling in process ----------------- ");
                     ReportWithPackageFilter(WasteFilter,"------------ Mid-tank filling in process -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color  = BLINK;
@@ -797,7 +759,7 @@ bool WasteTankCBFunction()
             if (IFS_info.IFS_Ink_precense_sensor == CarteidgePrecense)
             {
                 // is power down in process??  //todo
-                if ( !PowerOffInProcessGetState() ) // not in power down proccess
+                if ( !PowerOffInProcessGetState() ) // not in power down process
                 {
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color = colorON;
@@ -806,10 +768,8 @@ bool WasteTankCBFunction()
                 else
                 {
                     //  print: "power down in process";
-                    REPORT_MSG(WHS_full," ------------ power down in process ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, Power down in process -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, IFS_info.IFS_Ink_precense_sensor, 0);
                 }
-
-
             }
             else // Cartridge is out
             {
@@ -822,14 +782,13 @@ bool WasteTankCBFunction()
                     IFS_info.Ink.time_out = 0;
                     IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
                 }
-
             }
             break;
 
         case IFS_INK_authentication_pass:
             if (!ColorMatch())
             {
-                    REPORT_MSG(WHS_full," ------------ cartridge color does not match ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, cartridge color does not match -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color  = BLINK;
                     break;
@@ -919,6 +878,7 @@ bool WasteTankCBFunction()
 
         case WHS_Timeout:
             REPORT_MSG(WHS_emptying," ------------ WHS_Timeout ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_Timeout -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
             AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
             CartridgeWasteFilling(OFF);
             break;
@@ -938,12 +898,12 @@ bool WasteTankCBFunction()
         case IFS_Timeout_Second:
 //            Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
             IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
-            REPORT_MSG(WHS_full," ------------ Change cartridge status to Fail ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ WHS, Change cartridge status to Fail -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
 
             MidTankValvesAction(Cartridge_MidTank_OFF);
             cart1.color = fastBILNK;
-            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling fail ----------------- ");
-            REPORT_MSG(WHS_full," ------------ call customer support ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ Display Mid-tank # filling fail -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
+            ReportWithPackageFilter(WasteFilter,"------------ call customer support -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
             Pannel_Leds(CART_1, MODE_ON);
             cart1.color = fastBILNK;
             IFS_TimeOutAlarm(true);
@@ -952,11 +912,11 @@ bool WasteTankCBFunction()
         case IFS_MidTankFull:
 //            Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
             IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
-            REPORT_MSG(WHS_full," ------------ Change cartridge status to Waste Empty ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ Change cartridge status to Waste Empty -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
             Pannel_Leds(CART_1, MODE_OFF);
             cart1.color = colorOFF;
             MidTankValvesAction(Cartridge_MidTank_OFF);
-            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling done ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ Display Mid-tank # filling done -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
             break;
 
 
@@ -977,7 +937,6 @@ bool WasteTankCBFunction()
 
 bool RdCartridgeCoverSensor()
 {
-    uint32_t parameter = 6 ;
 
     //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
     bool ret = notOK;
@@ -987,11 +946,11 @@ bool RdCartridgeCoverSensor()
     ret = Get_COVER_1_State(CartridgesDoor);
     if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
     {
-        Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
+        ReportWithPackageFilter(WasteFilter,"------------ RD Cartridge Cover Sensor is = OPEN(1) -------------", __FILE__, __LINE__, ret, RpMessage, 0, 0);
     }
     if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
     {
-        REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ RD Cartridge Cover Sensor is = CLOSE(0) -------------", __FILE__, __LINE__, ret, RpMessage, 0, 0);
     }
     return ret;
 }
@@ -1001,21 +960,18 @@ bool RdCartridgeCoverSensor()
 
 WHS_sensor CartridgeCoverCallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
-
     WHS_sensor ret = WHS_no_event;
    //ret = RdCartridgeCoverSensor();
     if ( WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor() )
     {
-        REPORT_MSG(parameter," ------------ find  :  WHS_cartridge_cover_sensor event   ----------------- ");
         WHS_info.event = WHS_cartridge_cover_sensor;
         WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover;
+        ReportWithPackageFilter(WasteFilter,"------------ find  :  WHS_cartridge_cover_sensor event -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.cartridge_cover, RpMessage, 0, 0);
         ret = WHS_cartridge_cover_sensor; //todo
     }
     else if (( IFS_info.INK_isOK_flag ) && ( WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN))// for Mid-tank filling
     {
-            REPORT_MSG(parameter," ------------ Mid-tank Filling  :  Close cartridge cover   ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ Mid-tank Filling  :  Close cartridge cover -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.cartridge_cover, RpMessage, 0, 0);
     }
     /*else if(WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
@@ -1087,15 +1043,13 @@ WHS_sensor CartridgeCoverCallBackFunction()
 
 WHS_sensor CartridgeWaste1CallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
     WHS_sensor ret = WHS_no_event;
     //ret = RdCartridgeCoverSensor();
     if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor())
     {
-        REPORT_MSG(parameter," ------------ find  : WHS_waste1_presence_sensor event   ----------------- ");
         WHS_info.event = WHS_waste1_presence_sensor;
         WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
+        ReportWithPackageFilter(WasteFilter,"------------ find  : WHS_waste1_presence_sensor event -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_cartridge1_precense_sensor, RpMessage, 0, 0);
         ret = WHS_waste1_presence_sensor;
     }
     return ret;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
index a255f55a0..99b96ddf3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
@@ -9,13 +9,13 @@
 #include <Drivers/I2C_Communication/WHS_Card/I2C_WHS_Mux.h>
 #include <Drivers/I2C_Communication/I2C.h>
 #include "Drivers/I2C_Communication/WHS_Card/WHS_data.h"
-#include <Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
+#include <Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h>
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 
 bool test_9555(void);
@@ -24,17 +24,21 @@ bool WHS_I2C_EEprom_Write_Ch_shai_taest(void);
 bool newWHS_init(void)
 {
     bool status = OK;
-    Main_Mux_Flag = 0;
+
+    //Main_Mux_Flag = 0;
 
 
 //    delayms(4000);
 //    status = Select_Main_WHS_Mux_Channel();
+
+    //Trigger_Check_WHS_Type_Via_EEPROM();
     Trigger_WHS_init_IO();
     Trigger_WHS_init_fan();
     Trigger_WHS_init_PT100();
     Trigger_WHS_init_Blower();
     Trigger_WHS_MAX11614_Init();
     Trigger_WHS_Rheostat_init();
+
     //status |= WHS_IO_Init();
     //status |= init_WHS_fan();
     //
diff --git a/Software/Stubs Collection/stubs/newWHS/test_valv1_valv2_pump.cs b/Software/Stubs Collection/stubs/newWHS/test_valv1_valv2_pump.cs
index c81bdaebd..c4435ab42 100644
--- a/Software/Stubs Collection/stubs/newWHS/test_valv1_valv2_pump.cs
+++ b/Software/Stubs Collection/stubs/newWHS/test_valv1_valv2_pump.cs
@@ -39,7 +39,7 @@ Thread.Sleep(5000); //Sleep for 10 milli.
 var response8 = stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3E9, 0x8700); //valv2_disable
 
 //test pump
-Thread.Sleep(5000); //Sleep for 10 milli.
+//Thread.Sleep(5000); //Sleep for 10 milli.
 stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3E9, 0x0701);// pump on
 Thread.Sleep(5000); //Sleep for 10 milli.
 stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3E9, 0x0700); // pump off