aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Tango.Telemetry/Reporting
ModeNameSize
-rw-r--r--DestinationStatusSummary.cs1361logstatsplain
-rw-r--r--SourceSummary.cs1165logstatsplain
-rw-r--r--SourceTypeSummary.cs1211logstatsplain
-rw-r--r--TelemetryReport.cs3308logstatsplain
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-04 03:56:12 +0000
/*   ----  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 1200 //  seconds; 20 minutes, per Moty,  15/4/19


/*------------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;

bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;}
bool WHS_IsContainerOverflow(){return WHS_info.WHS_sensors.waste_tank_over_flow_sensor;}
bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;}
bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;}
bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;}
bool WHS_IsValveOpen(){return WHS_info.WHS_valve;}



bool WHS_IsEmptying()
{
    bool ret =  false;
    if ( WHS_info.sttMachine == WHS_emptying )
    {
        ret = true;
    }
    return ret;
}

/* --------    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;
            //Pannel_Leds(CART_2, MODE_ON);
            break;
        case waste_cartridge2:
            WHS_info.cartridge_2.autheticate = PASSED;
            //Pannel_Leds(CART_3, MODE_ON);
            break;
        default:
            WHS_info.cartridge_1.autheticate = FAILED;
            WHS_info.cartridge_2.autheticate = FAILED;
            //Pannel_Leds(CART_2, MODE_OFF);
            //Pannel_Leds(CART_3, MODE_OFF);
            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)
    if (WHS_info.active_cartridge == waste_cartridge1) WHS_info.WHS_valve = 1;
    else WHS_info.WHS_valve = 2;
    {
        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  ----------------- ");
        ret=OK;
    }
    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 = 1-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;
                    REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- ");
                }
                else
                {
                    REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
                }
            }
            else //SENSOREMPTY
            {
                if (WHS_info.sttMachine == WHS_emptying)
                {
                    WHS_info.sttMachine = WHS_empty;
                    REPORT_MSG(WHS_filling," ------------ 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)
            {
                WHS_info.sttMachine = WHS_full;
                REPORT_MSG(WHS_emptying," ------------ 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);
                if (ret != OK)
                {
                    //recreate the full event until cartridge is inserted
                    WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
                }

                // cant start a new Job
            }
            else
            {
                if (WHS_info.sttMachine == WHS_full)
                {
                    WHS_info.sttMachine = WHS_emptying;
                    REPORT_MSG(WHS_emptying," ------------ 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);
                        Pannel_Leds(CART_2, MODE_ON);
                        RdWasteCartridgeParam(waste_cartridge1);
                        SetActiveWastCartridge();
                        SetValveDirection();
                        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????
                        }
                        else
                        {
                            //WHS_info.cartridge_1.autheticate = FAILED; //='1'
                            SetCartridgeLED(waste_cartridge1, led_off);
                        }
                    }
                    else    // waste cartridge 1 take out
                    {
                        Pannel_Leds(CART_2, MODE_OFF);
                        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 .
                    {
                       Pannel_Leds(CART_3, MODE_ON);//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
                    {
                        Pannel_Leds(CART_3, MODE_OFF);
                        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:
            REPORT_MSG(WHS_emptying," ------------ 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()
{
    uint32_t parameter = 6 ;

    //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
    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);
    if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
    if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
    return ret;
}




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;
        ret = WHS_cartridge_cover_sensor;
    }
    return ret;
}

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;
        ret = WHS_waste1_presence_sensor;
    }
    return ret;
}

WHS_sensor CartridgeWaste2CallBackFunction()
{
    uint32_t parameter = 6 ;

    WHS_sensor ret = WHS_no_event;
    //ret = RdCartridgeCoverSensor();
    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor())
    {
        REPORT_MSG(parameter," ------------ find  : WHS_waste2_presence_sensor event   ----------------- ");
        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()
{
    uint32_t parameter = 6 ;

    WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();

    if (RdWasteCartridge1Sensor())
    {
        REPORT_MSG(parameter," ------------  WHS_waste1_presence_sensor event   ----------------- ");
        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgePrecense;
        Pannel_Leds( CART_2,  MODE_ON);
    }
    else
    {
        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgeNotPrecense;
        Pannel_Leds( CART_2,  MODE_OFF);
    }

    if (RdWasteCartridge2Sensor())
    {
        REPORT_MSG(parameter," ------------  WHS_waste2_presence_sensor event   ----------------- ");
        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgePrecense;
        Pannel_Leds( CART_3,  MODE_ON);
    }
    else
    {
        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgeNotPrecense;
        Pannel_Leds( CART_3,  MODE_OFF);
    }



    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)
    {
        REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 1   ----------------- ");
        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()
{
    uint8_t parameter = 5;

    bool ret = notOK;
    if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) &&
            (WHS_info.cartridge_1.autheticate == PASSED))
        {
            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  1   ----------------- ");
            WHS_info.active_cartridge = waste_cartridge1;
        }
    else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) &&
            (WHS_info.cartridge_2.autheticate == PASSED))
        {
            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  2   ----------------- ");
            WHS_info.active_cartridge = waste_cartridge2;
        }
    else
        {
            REPORT_MSG(parameter," ------------  WHS : NO active_cartridge   ----------------- ");
            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;
    WHS_info.WHS_valve = value;
    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


/*------------------------------------------------------------------------------------------------*/
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-04 03:56:12 +0000