add WHS files.

3 files changed, 1427 insertions, 0 deletions

diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 5136c4521..2d3bd336e 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -65,6 +65,8 @@
 #include "drivers/Flash_Memory/FATFS/ff.h"
 #include "drivers/Flash_Memory/FATFS/Control_File_System.h"
 
+#include "Modules/General/buttons.h"
+#include "Modules/Waste/Waste.h"
 //#define WATCHDOG
 //*****************************************************************************
 //
@@ -193,6 +195,9 @@ int main(void)
     ControlStart();
     Heaters_Init();
     MotorsInit();
+//Shai    WHS_HW_test(); // for WHS sensor test
+    WHS_init();
+    Buttons_Init();
     //IDS_ModuleInit();
     Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index e69de29bb..66428039f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
@@ -0,0 +1,104 @@
+#ifndef WASTE_H
+#define WASTE_H
+
+
+#define temp_funcion  0
+#define notOK 1
+
+
+/*
+#define SENSORFULL 1
+#define SENSOROVERFLOW 1
+#define SENSOREMPTY 0
+
+
+#define SENSORnotFULL 0
+#define SENSORnotOVERFLOW 0
+#define SENSORnotEMPTY 1
+*/
+#define PUMPON 1
+#define PUMPOFF 0
+
+#define PRECENSE 1
+#define NOTPRECENSE 0
+
+typedef unsigned char U8;
+
+typedef enum
+{
+    WHS_CarteidgeNotPrecense = 0,
+    WHS_CarteidgePrecense
+} WHS_CarteidgPrecenseSensorStatus;
+
+typedef enum
+{
+    WHS_CartridgeCoverCLOSE = 0,
+    WHS_CartridgeCoverOPEN
+} WHS_CarteidgeCoverSensorStatus;
+
+typedef enum
+{
+    SENSORnotFULL = 0,
+    SENSORFULL
+} WHS_FullSensorStatus;
+
+typedef enum
+{
+    SENSOREMPTY = 0,
+    SENSORnotEMPTY
+} WHS_EmptySensorStatus;
+
+typedef enum
+{
+    WHS_empty = 0,
+    WHS_filling,
+    WHS_emptying,
+    WHS_full,
+    WHS_overflow,
+    WHS_sttError
+} WHS_sttMachin;
+
+typedef enum
+{
+    WHS_no_event = 0,
+    WHS_overflow_sensor,
+    WHS_full_sensor,
+    WHS_empty_sensor,
+    WHS_waste1_presence_sensor,
+    WHS_waste2_presence_sensor,
+    WHS_filter_sensor,
+    WHS_cartridge_cover_sensor,
+    WHS_Timeout
+} WHS_sensor;
+
+typedef enum
+{
+    WasteEmpty = 0,
+    WasteFilling,
+    WasteFail,
+    WasteFull
+} cartridge_status;
+
+typedef enum
+{
+    led_on = 0,
+    led_off,
+    led_blink,
+    led_panic
+} led_status;
+
+typedef enum
+{
+    waste_cartridge1 = 0,
+    waste_cartridge2,
+    no_waste_cartridge
+} cartridge_name;
+
+
+U8 WHS_init(void);
+U8 WHS_HW_test(void);
+
+
+
+#endif
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index e69de29bb..689a2bc95 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -0,0 +1,1318 @@
+/*   ----  WHS      */
+#include <Container.h>
+#include <DataDef.h>
+#include "include.h"
+#include "Modules/Control/control.h" //  use for FPGA IO
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
+#include "drivers/Valves/Valve.h"
+#include "Common/report/report.h"
+#include "Modules/Waste/Waste.h"
+
+#include  <PMR/Diagnostics/EventType.pb-c.h>
+#include "Modules/AlarmHandling/AlarmHandling.h"
+
+
+#define WasteTankCallBackTime           eOneSecond
+#define CartridgeCoverCallBackTime      eOneSecond
+#define CartridgeCoverCallBackFastTime  eTenMillisecond
+#define CartridgeWaste1CallBackTime     eOneSecond
+#define CartridgeWaste2CallBackTime     eOneSecond
+#define STARTCOUNT  1
+#define STOPCOUNT   0
+#define PumpTimeout 60 //  minutes
+
+
+/*------------Waste Tank function-----------------------*/
+bool initWHS_WasteTank();
+bool InitWasteCartStatus();
+
+bool CartridgeCoverCBFunction();
+U8 CartridgeCoverCallBackFunction();
+WHS_sensor CartridgeWaste1CallBackFunction();
+WHS_sensor CartridgeWaste2CallBackFunction();
+WHS_sensor WasteTankCallBackFunction();
+U8 CartridgeWasteFilling(bool status);
+bool WasteTankCBFunction();
+
+U8 CartridgePrecenceCBFunction();
+U8 SetCartridgeLED(cartridge_name name,led_status led);
+
+bool SetWastePump( bool power);
+bool SetValveDirection();
+bool RdCartridgeCoverSensor();
+bool RdWasteCartridge1Sensor();
+bool RdWasteCartridge2Sensor();
+bool RdWasteTankFilterSensor();
+bool RdWasteTankOverFlowSensor();
+bool RdWasteTankFullSensor();
+bool RdWasteTankEmptySensor();
+bool RdWasteCartridgeParam(cartridge_name cart_name);
+bool CartridgeAuthentication(cartridge_name cart_name);
+bool SetActiveWastCartridge();
+
+
+
+
+struct waste_cartridge_params
+{
+    uint32_t serial_number;
+    cartridge_status status;  /*WasteEmpty, WasteFilling, WasteFail, WasteFull*/
+    bool autheticate;
+};
+
+struct pump_params
+{
+    bool status;
+    uint32_t time;
+};
+
+
+struct WHS_sensors_status
+{
+    WHS_CarteidgeCoverSensorStatus cartridge_cover;                       /*open(1)          ,close(0)           */
+    WHS_CarteidgPrecenseSensorStatus waste_cartridge1_precense_sensor;      /*presence(1)      ,not_precense(0)    */
+    bool waste_cartridge1_precense_sensor_flag; /* 1=event          0=no enent */
+    WHS_CarteidgPrecenseSensorStatus waste_cartridge2_precense_sensor;      /*presence(1)      ,not_precense(0)    */
+    bool waste_cartridge2_precense_sensor_flag; /* 1=event           0=no enent */
+    bool waste_tank_filter_sensor;              /*presence(1)      ,not_precense(0)    */
+    WHS_EmptySensorStatus waste_tank_empty_sensor; /*enpty(1)         ,not_empty(0)       */
+    WHS_FullSensorStatus waste_tank_full_sensor;   /*full(1)          ,not_full(0)        */
+    bool waste_tank_over_flow_sensor;           /*over_flow(1)     ,not_over_flow(0)   */
+};
+
+
+
+struct WHS_information
+{
+    WHS_sttMachin sttMachine;
+    struct waste_cartridge_params cartridge_1, cartridge_2;
+    struct WHS_sensors_status WHS_sensors;
+    struct pump_params WHS_pump;
+    bool WHS_valve;
+    WHS_sensor event;
+    cartridge_name active_cartridge;
+    uint32_t Cartridge_Waste1_device_Id;
+    uint32_t Cartridge_Waste2_device_Id;
+    uint32_t Cartridge_Cover_device_Id;
+};
+
+struct WHS_information WHS_info;
+
+
+
+
+/* --------    cartridge function  ----*/
+
+
+bool RdWasteCartridgeParam(cartridge_name cart_name)
+{
+    /*
+    read all parameters from RFid cartridge:
+    serial number, cartridge_status...
+    waste_cartridge 1 or 1
+    update waste_cartridge struct
+    */
+    if (cart_name == waste_cartridge1)
+    {
+        WHS_info.cartridge_1.serial_number = temp_funcion; //to do
+        WHS_info.cartridge_1.status = temp_funcion; // to do
+    }
+    else
+    {
+        WHS_info.cartridge_2.serial_number = temp_funcion;
+        WHS_info.cartridge_2.status = temp_funcion;
+    }
+    return OK;
+}
+
+bool CartridgeAuthentication(cartridge_name cart_name)
+{
+    bool ret = notOK;
+    // TBD;
+    switch (cart_name)
+    {
+        case waste_cartridge1:
+            WHS_info.cartridge_1.autheticate = PASSED;
+            break;
+        case waste_cartridge2:
+            WHS_info.cartridge_2.autheticate = PASSED;
+            break;
+        default:
+            WHS_info.cartridge_1.autheticate = FAILED;
+            WHS_info.cartridge_2.autheticate = FAILED;
+            break;
+    }
+    ret = OK;
+    return ret;
+}
+
+/*
+bool check_RFID_authentication()
+{
+    bool ret = notOK;
+ //   rd_waste_cartridge_param();
+    if ( 1 )
+        ret = OK;
+    return ret;
+}
+
+
+U8 Wr_cartridge_RFid(cartridge_name cartridge, cartridge_status status)
+{
+    bool ret = notOK;
+    // TBD;
+    ret = OK;
+    return ret;
+}
+
+U8 set_cartridge_2(U8 cartridge_status)
+{
+    bool ret = notOK;
+    WHS_info.cartridge_2.status = temp_funcion;
+    return ret;
+}
+*/
+
+/* ------------------------------*/
+
+
+bool SetWastePump( bool power)
+{
+    /*
+    set the waste pump on/off
+    off - :
+        1. when waste tank is empty
+        2. when empting is time out
+        3. cartrigde cover is open
+        4. when waste1 is not precense AND valve3way==1
+        5. when waste2 is not precense AND valve3way==2
+        6. when autentication with waste cartige is disable
+    on :
+        1. when waste_tank_full
+
+        void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? WHS_WTANKPUMP2 or WASTECH_PUMP2
+    */
+    bool ret = notOK;
+    if ( power == OPEN )
+    {
+        Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
+        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- ");
+        WHS_info.WHS_pump.status = OPEN;
+        WHS_info.WHS_pump.time = STARTCOUNT;
+        ret = OPEN;
+    }
+    else
+    {
+        Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_off();
+        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty stop PUMP ----------------- ");
+        WHS_info.WHS_pump.status = CLOSE;
+        WHS_info.WHS_pump.time = STOPCOUNT;
+        ret = CLOSE;
+    }
+    return ret;
+}
+
+
+
+
+bool SetValveDirection()
+{
+    /*
+     * waste_cartridge = 1- OPEN, 0 - CLOSE
+     *   VALVE_WASTE_TANK
+     *
+     * */
+    bool ret = notOK;
+    if (WHS_info.WHS_valve != no_waste_cartridge)
+    {
+        Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
+        ret = OK;
+    }
+    return ret;
+}
+
+
+/*--------------------------    function for  WHS  -------------------------------   */
+
+U8 CartridgeWasteFilling(bool status)
+{
+    bool ret = notOK;
+
+    if ((status == ON) && (WHS_info.active_cartridge != no_waste_cartridge))
+    {
+
+       //if (WHS_info.active_cartridge != no_waste_cartridge) //
+        {
+            Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction
+            //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
+            //write RFID status
+        }
+        SetWastePump(OPEN);
+        //WHS_info.WHS_pump.time = 0;
+        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
+    }
+    else // stop Waste cartridge filling
+    {
+        SetWastePump(CLOSE);
+        Valve_Set(VALVE_WASTE_TANK, waste_cartridge2);  //set the valve direction set to low POWER !!!
+        Pannel_Leds( CART_2,  MODE_OFF);                //set led color
+        Pannel_Leds( CART_3,  MODE_OFF);                //set led color
+
+        //write RFID status
+    }
+    return ret;
+}
+
+/* ------read waste tank sensors -----------  */
+bool RdWasteTankEmptySensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_tank_empty_sensor = WHS_GPI_WCONTAINER_WARN();
+    //ret = WHS_info.WHS_sensors.waste_tank_empty_sensor;
+     ret = WHS_GPI_WCONTAINER_WARN();
+     return ret;
+}
+
+bool RdWasteTankFullSensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_tank_full_sensor =  WHS_GPI_WCONTAINER_FULL();
+    //ret = WHS_info.WHS_sensors.waste_tank_full_sensor;
+    ret = WHS_GPI_WCONTAINER_FULL();
+    return ret;
+}
+
+bool RdWasteTankOverFlowSensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_tank_over_flow_sensor =  WHS_GPI_WASTE_OVERFULL();
+    //ret = WHS_info.WHS_sensors.waste_tank_over_flow_sensor;
+    ret = WHS_GPI_WASTE_OVERFULL();
+    return ret;
+}
+
+/*-------------*/
+
+
+WHS_sttMachin UpdateStateMachine()
+{
+    //WHS_sttMachin ret = WHS_sttError  ;
+
+    if ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL)
+    {
+        WHS_info.sttMachine = WHS_empty  ;
+        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty  ----------------- ");
+    }
+    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  ----------------- ");
+    }
+    else
+    {
+        WHS_info.sttMachine =  WHS_sttError  ;
+        REPORT_MSG(WHS_sttError," ------------ WHS sensor Error  ----------------- ");
+    }
+
+/*    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;
+}
+
+
+bool initWHS_WasteTank()
+{
+    WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
+    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;//RdWasteTankFullSensor();
+    UpdateStateMachine();
+    AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
+    return OK;
+}
+
+
+/*
+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;
+    if (RdWasteTankEmptySensor() != WHS_info.WHS_sensors.waste_tank_empty_sensor)
+    {
+        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;
+    }
+    return ret;
+}
+
+WHS_sensor FullSensorEvent()
+{
+    WHS_sensor ret = WHS_no_event;
+    if ( RdWasteTankFullSensor() != WHS_info.WHS_sensors.waste_tank_full_sensor )
+    {
+        WHS_info.event =  WHS_full_sensor;
+        ret = WHS_full_sensor;
+        WHS_info.WHS_sensors.waste_tank_full_sensor = !WHS_info.WHS_sensors.waste_tank_full_sensor;
+    }
+    return ret;
+}
+
+WHS_sensor WasteTankCallBackFunction()
+{
+    /* detect waste tank sensor event */
+    WHS_sensor ret = WHS_no_event;
+/*    if ( OverflowSensorEvent())
+        {
+         return WHS_info.event;
+        }
+    else */
+    if (WHS_info.WHS_pump.time) WHS_info.WHS_pump.time += 1;
+    if (WHS_info.WHS_pump.time == PumpTimeout)
+    {
+        WHS_info.WHS_pump.time = 0;
+        AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  false);
+        return WHS_info.event = WHS_Timeout;
+    }
+    if ( FullSensorEvent())
+         {
+             return WHS_info.event;
+         }
+    else if ( EmptySensorEvent())
+         {
+            return WHS_info.event;
+         }
+
+    return ret;
+}
+
+/*
+bool start_WHS_machin()
+{
+    AddControlCallback( WasteTankCBFunction,  eTenMillisecond, WasteTankCallBackFunction, 0,0,0 );// eOneMinute
+    return OK;
+}
+ */
+
+bool WasteTankCBFunction()
+{
+    bool ret = notOK;
+    static bool pump_on_flag = CLOSE;
+    //uint32_t Cartridge_Cover_device_Id = 0;
+
+
+    switch (WHS_info.event)
+    {
+       case WHS_empty_sensor:
+            if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)
+            {
+                if (WHS_info.sttMachine == WHS_empty)
+                    WHS_info.sttMachine = WHS_filling;
+                else
+                {
+                    REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                }
+            }
+            else //SENSOREMPTY
+            {
+                if (WHS_info.sttMachine == WHS_emptying)
+                {
+                    WHS_info.sttMachine = WHS_empty;
+                    ret = CartridgeWasteFilling(OFF);
+                    WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
+                   WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
+                    //SafeRemoveControlCallback(Cartridge_Cover_device_Id, CartridgeCoverCBFunction );
+                }
+                else
+                {
+                    REPORT_MSG(WHS_emptying," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                }
+            }
+            break;
+        case WHS_full_sensor:
+            if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
+            {
+                if (WHS_info.sttMachine == WHS_filling)
+                {
+                    WHS_info.sttMachine = WHS_full;
+                    WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
+                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
+                    ret = CartridgeWasteFilling(ON);
+                    // cant start a new Job
+                }
+                else
+                {
+                    REPORT_MSG(WHS_filling," ------------ WHS FULL sensor failed !!!!!!! ----------------- ");
+                }
+            }
+            else
+            {
+                if (WHS_info.sttMachine == WHS_full)
+                {
+                    WHS_info.sttMachine = WHS_emptying;
+                    // can start a new JOB
+                }
+                else
+                {
+                    REPORT_MSG(WHS_full," ------------ WHS FULL sensor failed !!!!!!! ----------------- ");
+                }
+            }
+            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 )
+            {
+                if ( WHS_info.WHS_pump.status == OPEN)
+                {
+                    CartridgeWasteFilling(CLOSE);
+                    pump_on_flag = OPEN;
+                }
+                WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
+                WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
+
+
+
+                //if (WHS_info.WHS_pump == ON)
+                //{
+                //    SetWastePump(OFF); //pump OFF
+                //}
+                // prevent NEW Job
+                // Display "Close cartridge cover"
+                // pop up message in GUI
+            }
+            else // CLOSE
+            {
+                //if (WHS_info.sttMachine == WHS_full) CartridgeWasteFilling(OPEN);
+                SetActiveWastCartridge();
+                if (pump_on_flag == OPEN )
+                {
+                    CartridgeWasteFilling(OPEN);
+                    pump_on_flag = CLOSE;
+                }
+                WHS_info.Cartridge_Waste1_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste1_device_Id, WasteTankCBFunction );
+                WHS_info.Cartridge_Waste2_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste2_device_Id, WasteTankCBFunction );
+            }
+            break;
+        case WHS_waste1_presence_sensor :
+                    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge 1 is inserted .
+                    {
+                        SetCartridgeLED(waste_cartridge1, led_on);
+                        RdWasteCartridgeParam(waste_cartridge1);
+                        if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication
+                        {
+                            //WHS_info.cartridge_1.autheticate = PASSED; //='0'
+                            //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping????
+                            //???SetValveDirection();    // or we should do it only before pumping????
+                        }
+                        else
+                        {
+                            //WHS_info.cartridge_1.autheticate = FAILED; //='1'
+                            SetCartridgeLED(waste_cartridge1, led_off);
+                        }
+                    }
+                    else    // waste cartridge 1 take out
+                    {
+                        WHS_info.cartridge_1.autheticate = FAILED;
+                        //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
+                        //???{
+                        //???WHS_info.WHS_valve = waste_cartridge;
+                        //???SetValveDirection();
+                        //???}
+                        //???else
+                        //???{
+                        //???
+                        //???}
+                        //???        RdWasteCartridgeParam(waste_cartridge2);
+                        //???WHS_info.WHS_valve = waste_cartridge1;
+                    }
+                    //SetActiveWastCartridge();
+                    break;
+        case WHS_waste2_presence_sensor :
+                    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge  is inserted .
+                    {
+                       SetCartridgeLED(waste_cartridge2, led_on);
+                       RdWasteCartridgeParam(waste_cartridge2);
+                       if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication
+                       {
+                           //WHS_info.cartridge_2.autheticate = PASSED; //='0'
+                           //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping????
+                           //???SetValveDirection();    // or we should do it only before pumping????
+                       }
+                       else
+                       {
+                           //WHS_info.cartridge_2.autheticate = FAILED; //='1'
+                           SetCartridgeLED(waste_cartridge2, led_off);
+                       }
+                    }
+                    else    // waste cartridge 2 take out
+                    {
+                        WHS_info.cartridge_2.autheticate = FAILED;
+                        /*
+                          if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
+                          {
+                            WHS_info.WHS_valve = waste_cartridge;
+                            SetValveDirection();
+                            }
+                       else
+                        {
+
+                        }
+                        RdWasteCartridgeParam(waste_cartridge2);
+                       WHS_info.WHS_valve = waste_cartridge1;
+                       */
+                    }
+                    //SetActiveWastCartridge();
+                    break;
+        case WHS_Timeout:
+            AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
+            CartridgeWasteFilling(OFF);
+            break;
+        case WHS_no_event:
+            break;
+        default: //error state
+            break;
+    }
+    WHS_info.event = WHS_no_event;
+    return ret;
+}
+
+
+/*------------------------------- Cartridge  Cover       -----------------------------------------*/
+
+bool RdCartridgeCoverSensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+   // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor);
+   // ret = WHS_info.WHS_sensors.cartridge_cover;
+    ret = Get_COVER_1_State(CartridgesDoor);
+    return ret;
+}
+
+
+
+
+WHS_sensor CartridgeCoverCallBackFunction()
+{
+    WHS_sensor ret = WHS_no_event;
+   //ret = RdCartridgeCoverSensor();
+    if (WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor())
+    {
+        WHS_info.event = WHS_cartridge_cover_sensor;
+        WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover;
+        ret = WHS_cartridge_cover_sensor;
+    }
+    return ret;
+}
+
+WHS_sensor CartridgeWaste1CallBackFunction()
+{
+    WHS_sensor ret = WHS_no_event;
+    //ret = RdCartridgeCoverSensor();
+    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor())
+    {
+        WHS_info.event = WHS_waste1_presence_sensor;
+        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
+        ret = WHS_waste1_presence_sensor;
+    }
+    return ret;
+}
+
+WHS_sensor CartridgeWaste2CallBackFunction()
+{
+    WHS_sensor ret = WHS_no_event;
+    //ret = RdCartridgeCoverSensor();
+    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor())
+    {
+        WHS_info.event = WHS_waste2_presence_sensor;
+        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
+        ret = WHS_waste2_presence_sensor;
+    }
+    return ret;
+}
+
+/*------------------------------- Cartridge  Waste       -----------------------------------------*/
+bool InitWasteCartStatus()
+{
+    WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();
+    WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = RdWasteCartridge1Sensor();
+    WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = RdWasteCartridge2Sensor();
+    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge1);
+    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge2);
+    SetActiveWastCartridge();
+
+    if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
+    {
+        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
+        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
+    }
+    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
+
+    return OK;
+}
+
+bool RdWasteCartridge1Sensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = Is_Cartridge_Present(CART_2);
+    //ret = WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
+    ret = Is_Cartridge_Present(CART_2);
+    return ret;
+}
+
+bool RdWasteCartridge2Sensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    //WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = Is_Cartridge_Present(CART_3);
+    //ret = WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
+    ret = Is_Cartridge_Present(CART_3);
+    return ret;
+}
+
+bool SetActiveWastCartridge()
+{
+    bool ret = notOK;
+    if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) &&
+            (WHS_info.cartridge_1.autheticate == PASSED))    WHS_info.active_cartridge = waste_cartridge1;
+    else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) &&
+            (WHS_info.cartridge_2.autheticate == PASSED))    WHS_info.active_cartridge = waste_cartridge2;
+    else WHS_info.active_cartridge = no_waste_cartridge;
+    return ret;
+
+}
+
+/*
+U8 RdWastePrecenseSensor(cartridge_name name)
+{
+
+  //  we have 2 waste_cartridge (waste_cartridge1 and waste_cartridge2)
+  //  bool Is_Cartridge_Present(PANEL_BUTTON_OR_CRAT_ID Cartridge); //use CART_2 or CART_3
+
+    WHS_Read_GPI_Registers();
+    switch (name)
+    {
+        case waste_cartridge1:
+            if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != Is_Cartridge_Present(CART_2))
+                {
+                    WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
+                    WHS_info.event = WHS_waste1_presence_sensor;
+                }
+            break;
+        case waste_cartridge2:
+            if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != Is_Cartridge_Present(CART_3))
+                {
+                    WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
+                    WHS_info.event = WHS_waste2_presence_sensor;
+                }
+            break;
+        default :
+            break;
+    }
+    return OK;
+}
+*/
+/*
+U8 cartridge_handeling()
+{
+    AddControlCallback( CartridgePrecenceCBFunction, eOneMinute, CartridgePrecenceCallBackFunction, 0,0,0 ); //
+    return OK;
+}
+*/
+
+U8 SetCartridgeLED(cartridge_name name,led_status led)
+{
+    bool ret = notOK;
+    return ret;
+}
+
+/*
+U8 CartridgePrecenceCBFunction()
+{
+  if ( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor_flag ) // if we have changes at cartridge1:
+  {
+      if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor) // if new cartridge is presence:
+      {
+          if (rd_waste_cartridge_param()== OK) //read parameter from RFID
+          SetCartridgeLED(waste_cartridge1,led_on);   //change led status to ON
+      }
+      else // if the cartridge is removed
+      {
+          SetCartridgeLED(waste_cartridge1, led_off);   //change led status to OFF
+      }
+      WHS_info.WHS_sensors.waste_cartridge1_precense_sensor_flag = 0; //remove the flag
+
+  }
+  else if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor_flag )
+       {
+          if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor)
+          {
+
+          }
+          else
+          {
+
+          }
+       }
+  return OK;
+}*/
+/*
+U8 CartridgePrecenceCallBackFunction()
+{
+    bool ret = notOK;
+    return ret;
+}
+*/
+
+
+
+
+
+
+
+
+bool CartridgeCoverCBFunction()
+{
+    bool ret = notOK;
+    if (WHS_info.WHS_sensors.cartridge_cover == OPEN)
+    {
+        //if (WHS_info.WHS_pump == ON)
+        //{
+            SetWastePump(OFF); //pump OFF
+        //}
+        // prevent NEW Job
+        // Display "Close cartridge cover"
+        // pop up message in GUI
+    }
+    else
+    {
+        // can do a NEW Job
+        // remove message "Close cartridge cover"
+        // remove pop up message in GUI
+    }
+    WHS_info.event = WHS_no_event;
+    return ret;
+}
+
+
+/*------------------------------------------------------------------------------------------------*/
+
+
+
+U8 WHS_init(void)
+{
+    InitWasteCartStatus();
+    initWHS_WasteTank();
+    SetWastePump(CLOSE);
+    return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*----------------------------------    HW Test   --------------------------------------------------------------*/
+
+
+
+bool RdWasteTankFilterSensor()
+{
+    bool ret = notOK;
+    WHS_Read_GPI_Registers();
+    WHS_info.WHS_sensors.waste_tank_filter_sensor = WHS_GPI_SW_FILTER_PRES();
+    ret = WHS_info.WHS_sensors.waste_tank_filter_sensor;
+    return ret;
+}
+
+
+U8 RdCartridgeDoor()
+{
+    bool ret = notOK;
+    ret = RdCartridgeCoverSensor();
+    return ret;
+}
+U8 RdWaste1()
+{
+    bool ret = notOK;
+    ret = RdWasteCartridge1Sensor();
+    return ret;
+}
+U8 RdWaste2()
+{
+    bool ret = notOK;
+    ret = RdWasteCartridge2Sensor();
+    return ret;
+}
+U8 SetValve(bool value)
+{
+    bool ret = notOK;
+    ret = SetValveDirection( );
+    return ret;
+}
+
+U8 SetPump(bool value)
+{
+    bool ret = notOK;
+    ret = SetWastePump(value);
+    return ret;
+}
+
+U8 RdFilter()
+{
+    bool ret = notOK;
+    ret = RdWasteTankFilterSensor();
+    return ret;
+}
+U8 RdEmpty()
+{
+    bool ret = notOK;
+    ret = RdWasteTankEmptySensor();
+    return ret;
+}
+U8 RdFull()
+{
+    bool ret = notOK;
+    ret = RdWasteTankFullSensor();
+    return ret;
+}
+U8 RdOverFlow()
+{
+    bool ret = notOK;
+    RdWasteTankOverFlowSensor();
+    return ret;
+}
+
+
+
+U8 WHS_HW_test()
+{
+    bool ret = notOK;
+/*    ret = RdCartridgeDoor();
+    while (ret == RdCartridgeDoor());
+*/
+/* ---  connect JO271 cable ---*/
+    ret = RdWaste1();
+    while (ret == RdWaste1());// blue = waste1
+    ret = RdWaste2();
+    while (ret == RdWaste2());// yellow = waste2
+
+    /* ---  connect JO71 JO72 JO121  cable ---*/
+
+    ret = SetValve(1); //red LED On
+    ret = SetValve(0); //red LED Off
+
+
+    ret = SetPump(1);  // led green (backplan) On
+    ret = SetPump(0);  // led green (backplan) Off
+
+    ret = RdFilter();
+    while (ret == RdFilter());
+    ret = RdEmpty();
+    while (ret == RdEmpty());
+    ret = RdFull();
+    while (ret == RdFull());
+//    ret = RdOverFlow();
+//    while (ret == RdOverFlow());
+    return ret;
+}
+
+
+
+
+
+
+
+
+/*------------------------------------------------------------------------------------------------*/
+
+/*
+//U8 WasteCartridgeCallBackFunction();
+//U8 WasteCartridgeCBFunction();
+
+bool start_WHS_machin();
+U8 CartridgePrecenceCallBackFunction();
+uint32_t EmptyWasteTankFullCBFunction();
+U8 cartridge_handeling();
+
+U8 RdWastePrecenseSensor(cartridge_name name);
+
+U8 rd_waste_cartridge_param();
+U8 set_cartridge_1(U8 cartridge_status);
+U8 set_cartridge_2(U8 cartridge_status);
+U8 check_sensors_before_start_emptying();
+bool check_RFID_authentication();
+
+uint32_t waste_tank_init(void);
+uint32_t EmptyWasteTankCBFunction();
+
+
+
+U8 WasteCartridgeCallBackFunction()
+{
+    bool ret = notOK;
+
+    ret = RdWastePrecenseSensor(waste_cartridge1);
+    ret = RdWastePrecenseSensor(waste_cartridge2);
+    return ret;
+}
+
+
+U8 Wr_cartridge_RFid(cartridge_name cartridge, cartridge_status status);
+WHS_sttMachin UpdateStateMachine();
+
+*/
+
+//  uint32_t updateWasteTankStruct();
+//uint32_t WasteTankFullCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
+
+/*--- functipons not in use ----*/
+
+/*
+U8 check_sensors_before_start_emptying() ????????????????????
+{
+    bool ret = notOK;
+
+    if ((WHS_info.WHS_sensors.cartridge_cover == CLOSE) &&
+        (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == precense) ||
+         (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == precense)) &&
+        (WHS_info.WHS_sensors.waste_tank_filter_sensor == 1 ))
+    {
+        ret = OK;
+    }
+    return ret;
+}
+
+
+
+
+uint32_t updateWasteTankStruct() //----------what is the timing??????-----------------
+{
+//    bool waste_number =1;
+
+    rd_waste_precense_sensor( );
+    RdWasteTankFilterSensor();
+    rd_whs_cartridge_cover();
+
+//    rd_waste_tank_RdWasteTankEmptySensor_sensor();
+//    RdWasteTankFullSensor();
+//    rd_waste_tank_over_flow_sensor();
+    return OK;
+}
+
+
+
+
+uint32_t WasteTankFullCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    if ( RdWasteTankFullSensor() != WHS_info.WHS_sensors.waste_tank_full_sensor )
+    {
+        WHS_info.event =  WHS_full_sensor;
+        WHS_info.WHS_sensors.waste_tank_full_sensor = !WHS_info.WHS_sensors.waste_tank_full_sensor;
+    }
+    return OK;
+}
+
+
+uint32_t WasteTankEmptyCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    if (RdWasteTankEmptySensor() != WHS_info.WHS_sensors.waste_tank_empty_sensor)
+    {
+        WHS_info.event =  WHS_empty_sensor;
+        WHS_info.WHS_sensors.waste_tank_empty_sensor = !WHS_info.WHS_sensors.waste_tank_empty_sensor;
+    }
+    return OK;
+}
+
+uint32_t WasteTankOverflowCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    if (rd_waste_tank_over_flow_sensor() != WHS_info.WHS_sensors.waste_tank_over_flow_sensor)
+    {
+         WHS_info.event =  WHS_overflow_sensor;
+         WHS_info.WHS_sensors.waste_tank_over_flow_sensor = !(WHS_info.WHS_sensors.waste_tank_over_flow_sensor);
+    }
+    return OK;
+}
+
+
+U8 CartridgeCoverCallBackFunction()
+{
+    bool ret = notOK;
+    return ret;
+}
+
+
+U8 CartridgeCoverCBFunction()
+{
+    bool ret = notOK;
+    return ret;
+}
+
+
+
+
+uint32_t WHS_machin()
+{
+    switch( WHS_info.sttMachine )
+        {
+            case WHS_empty: // last OnOffPBstate was OFF
+
+               break;
+            case WHS_filling : // last OnOffPBstate was COUNTPB
+
+                break;
+            case WHS_emptying: // last OnOffPBstate was SHORTPB
+
+                 break;
+            case WHS_full:
+
+                 break;
+            case WHS_overflow:
+
+                 break;
+          default:              // WHS_sttError
+               break;
+        }
+    return OK;
+}
+
+
+
+
+uint32_t EmptyWasteTankCBFunction()
+{
+    bool ret = notOK;
+//--------try state machine-------
+    if (WHS_info.event == WHS_no_event)
+        return OK;
+    else
+    {
+//        WHS_info.sttMachine = UpdateStateMachine();
+//        WHS_info.event = WHS_no_event;
+        switch (WHS_info.event)
+        {
+           case WHS_empty_sensor:
+                if (WHS_info.WHS_sensors.waste_tank_empty_sensor)
+                {
+
+                }
+                else
+                {
+                    ret = CartridgeWasteFilling(OFF);
+                }
+                break;
+            case WHS_full_sensor:
+                if (WHS_info.WHS_sensors.waste_tank_full_sensor)
+                {
+                    ret = CartridgeWasteFilling(ON);
+                    // cant start a new Job
+                }
+                else
+                {
+                    // can start a new JOB
+                    WHS_info.sttMachine = WHS_empty;
+                }
+                break;
+            case WHS_overflow_sensor:
+                if (WHS_info.WHS_sensors.waste_tank_empty_sensor)
+                {
+
+                    // 1.StopMacine
+                    // 2.
+
+                    WHS_info.sttMachine = WHS_overflow;
+                }
+                else
+                {
+                    WHS_info.sttMachine = WHS_full;
+                }
+            break;
+            default: //error state
+                break;
+        }
+        WHS_info.event = WHS_no_event;;
+    }
+    return ret;
+}
+
+
+
+uint32_t start_WHS_machin()
+{
+    switch( WHS_info.sttMachine )
+        {
+            case WHS_empty: // last OnOffPBstate was OFF
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+               break;
+            case WHS_filling : // last OnOffPBstate was COUNTPB
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+                break;
+            case WHS_emptying: // last OnOffPBstate was SHORTPB
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                 break;
+            case WHS_full:
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
+                 break;
+            case WHS_overflow:
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
+                 break;
+          default:              // WHS_sttError
+               break;
+        }
+    return OK;
+}
+
+*/
+
+//U8 WasteCartridgeCBFunction()
+//{
+//    bool ret = notOK;
+//    switch (WHS_info.event)
+//    {
+//        /*case WHS_waste1_presence_sensor :
+//            if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor  ) // waste cartridge 1 is inserted .
+//            {
+//                SetCartridgeLED(waste_cartridge1, led_on);
+//                RdWasteCartridgeParam(waste_cartridge1);
+//                if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication
+//                {
+//                    //WHS_info.cartridge_1.autheticate = PASSED; //='0'
+//                    //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping????
+//                    //???SetValveDirection();    // or we should do it only before pumping????
+//                }
+//                else
+//                {
+//                    //WHS_info.cartridge_1.autheticate = FAILED; //='1'
+//                    SetCartridgeLED(waste_cartridge1, led_off);
+//                }
+//            }
+//            else    // waste cartridge 1 take out
+//            {
+//                WHS_info.cartridge_1.autheticate = FAILED;
+//                //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
+//                //???{
+//                //???WHS_info.WHS_valve = waste_cartridge;
+//                //???SetValveDirection();
+//                //???}
+//                //???else
+//                //???{
+//                //???
+//                //???}
+//                //???        RdWasteCartridgeParam(waste_cartridge2);
+//                //???WHS_info.WHS_valve = waste_cartridge1;
+//            }
+//
+//            break;
+//        case WHS_waste2_presence_sensor :
+//            if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor  ) // waste cartridge  is inserted .
+//            {
+//               SetCartridgeLED(waste_cartridge2, led_on);
+//               RdWasteCartridgeParam(waste_cartridge2);
+//               if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication
+//               {
+//                   //WHS_info.cartridge_2.autheticate = PASSED; //='0'
+//                   //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping????
+//                   //???SetValveDirection();    // or we should do it only before pumping????
+//               }
+//               else
+//               {
+//                   //WHS_info.cartridge_2.autheticate = FAILED; //='1'
+//                   SetCartridgeLED(waste_cartridge2, led_off);
+//               }
+//            }
+//            else    // waste cartridge 2 take out
+//            {
+//                WHS_info.cartridge_2.autheticate = FAILED;
+//
+//                  if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
+//                  {
+//                    WHS_info.WHS_valve = waste_cartridge;
+//                    SetValveDirection();
+//                    }
+//               else
+//                {
+//
+//                }
+//                RdWasteCartridgeParam(waste_cartridge2);
+//               WHS_info.WHS_valve = waste_cartridge1;
+//
+//            }
+//            break;*/
+//        default:
+//            break;
+//    }
+//
+//    WHS_info.event = WHS_no_event;
+//
+//     return ret;
+//}
+
+
+//IDS_Dispenser_Build_Pressure_Callback
+
+
+/*------------------------------------------------------------------------------------------------*/
+
+
+
+