/* ---- WHS */ #include #include #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 #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_IsContainerEmpty(){return WHS_info.WHS_sensors.waste_tank_empty_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 } // close that line for only ITMA !!! SetWastePump(OPEN); ToDo //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 !!! switch (WHS_info.active_cartridge) { case waste_cartridge1: Pannel_Leds( CART_2, MODE_OFF); //set led color REPORT_MSG(WHS_empty," ------------ WHS waste_cartridge1 is used please replace it ----------------- "); break; case waste_cartridge2: Pannel_Leds( CART_3, MODE_OFF); //set led color REPORT_MSG(WHS_empty," ------------ WHS waste_cartridge2 is used please replace it ----------------- "); break; case no_waste_cartridge: break; default: break; } //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 /*------------------------------------------------------------------------------------------------*/