path: root/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c

#include <Container.h>
#include <PMR/Common/MessageContainer.pb-c.h>
#include <PMR/Stubs/ProgressRequest.pb-c.h>
#include <PMR/Stubs/ProgressResponse.pb-c.h>
#include "include.h"
#include "driverlib/gpio.h"

#include "Communication/Connection.h"

#include "Drivers/USB_Communication/USBCDCD.h"
#include "drivers/Flash_Memory/FATFS/ff.h"
#include "drivers/Flash_Memory/FATFS/Control_File_System.h"
#include "drivers/Flash_ram/FlashProgram.h"
#include "drivers/adc_sampling/adc.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/ADC_Sampling/adc.h"
#include "drivers/Flash_ram/MCU_E2Prom.h"
#include "Drivers/SSI_Comm/Dancer/Dancer.h"
#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
#include "drivers/Motors/Motor.h"
#include "drivers/Valves/Valve.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include <Drivers/I2C_Communication/I2C.h>
#include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
#include "drivers/adc_sampling/adc.h"
#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
#include <Drivers/I2C_Communication/WHS_Card/WHS_data.h>
#include <Drivers/I2C_Communication/I2C_Task.h>
#include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
#include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
#include "drivers/Heater/TemperatureSensor.h"
#include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
#include "drivers/I2C_Communication/DAC/Blower.h"

#include "Modules/IFS/ifs.h"
#include "Modules/IDS/ids_ex.h"
#include "Modules/IDS/ids.h"
#include "Modules/Control/MillisecTask.h"
#include "modules/thread/thread_ex.h"
#include "modules/heaters/heaters_ex.h"
#include "modules/waste/waste_ex.h"
#include "AlarmHandling/AlarmHandling.h"

#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/PowerIdle.h"
#include "Drivers/Uart_Comm/BTSR/BTSR.h"

extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
extern void HeaterSafetyTestSetLimits(int limit);
extern uint32_t InitSequenceWHSAirFlowCalibration(void);

//#include "graphics_adapter.h"
extern uint8_t Input_Voltage;
extern uint8_t Test_Read_Buf[4];

extern uint8_t Head_Fan_PWM_Command[2];
extern uint16_t Head_Fan_Tach[2];
extern bool doorState;

bool RestartNeeded = false;
uint32_t temp1,temp2;

void Stub_ProgressRequest(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;

    ProgressRequest* request = progress_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    //writeLine("Progress Request...");

    ProgressResponse response = PROGRESS_RESPONSE__INIT;

//    uint8_t high_byte = 0;
//    uint8_t low_byte = 0;

    uint8_t addr = 0;
    uint8_t port = 0;
    uint8_t pin  = 0;
    uint8_t value= 0;
    uint32_t enable;

    uint8_t ReadBackReg[1];

    if(request->amount == 0xFEED)//BTSR Feeder
    {
        if((request->delay) >> 4 == 0)
        {
            response.progress = BTSR_Auto_Identify(request->delay & 0xF);
        }
        else
        {
            response.progress = BTSR_Set_Parmeters(request->delay & 0xF,(request->delay & 0xFF00)>>8,(request->delay & 0xFF0000)>>16);
        }
        response.has_progress = true;
    }
    else
    if(request->amount == 0xacc1e)
    {
        response.progress = IDS_Cleaning_Move_Actuators();
        response.has_progress = true;
    }
    else
    if(request->amount == 0xacc1ea)
    {
        response.progress = HeadCard_Actuators_Relocate();
        response.has_progress = true;
    }
    else
    if(request->amount == 0xC04f)
    {

        switch(request->delay)
        {
            case 0x8400:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_0_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[14].Reg0.Byte;
                break;
            case 0x8401:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_1_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[14].Reg1.Byte;
                break;
            case 0x8402:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_2_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[14].Reg2.Byte;
                break;
            case 0x8403:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_3_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[14].Reg3.Byte;
                break;
            case 0x8600:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_0_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[15].Reg0.Byte;
                break;
            case 0x8601:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_1_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[15].Reg1.Byte;
                break;
            case 0x8602:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_2_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[15].Reg2.Byte;
                break;
            case 0x8603:
                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_3_REG, &ReadBackReg[0]);
                    response.progress = ReadBackReg[0];
                    //response.progress = HeadTempSensConfig[15].Reg3.Byte;
                break;

            default:
                    if((request->delay >= HEAD_PT100_ZONE_1_0X80_0) && (request->delay <= HEAD_PT100_RESERVE_0X8E_1))
                    {
                        response.progress = TempSensorResponse[request->delay].PT100_ADC_Reading_Bits;
                    }
                break;
        }

        response.has_progress = true;
    }
    else
    if(request->amount == 0xb05)
    {
        response.progress = Test_Uart3(request->delay);//test Shinko
        response.has_progress = true;
    }
    else
    if(request->amount == 0xdace)//test_dancer_responce_RTFU
        //in order to use it unmark the define test_RTFU_dancer !!!!!!!!!!!
    {
        test_dancer_flag = true;

        if(request->delay == 0x01)
        {
            test_dancer_direction  = true;
        }
        else
        if(request->delay == 0x00)
        {
            test_dancer_direction  = false;
        }

        response.progress = 0xdace;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xb10) //S.S Head Sensor board
        {
            if(request->delay == 0x01)
            {
                response.progress = HeadCard_ActivateHeadPressureArcBlowers();
            }
            else if(request->delay == 0x00)
            {
                response.progress = HeadCard_DeActivateHeadPressureArcBlowers();
            }
            response.has_progress = true;
        }

    else
        if(request->amount == 0x3EC)
        {
            if(request->delay == 0x01)
            {
                uint16_t Vm_mv = 0;

                Trigger_WHS_MAX11614_Read_allADC();

                get_vlev1(&Vm_mv);
                response.progress = Vm_mv;
                response.has_progress = true;
            }
        }
    else
       if(request->amount == 0x3EB) //whs valves
       {
           if (WHS_Type == WHS_TYPE_NEW)
           {
               if(request->delay == 0x0101)
               {
                   Trigger_SetWHSValveWatseCartridge(OPEN);
               }
               else
               if(request->delay == 0x0100)
               {
                   Trigger_SetWHSValveWatseCartridge(CLOSE);
               }
               else
               if(request->delay == 0x0201)
               {
                   Trigger_SetWHS_VOC_Valve(OPEN);
               }
               else
               if(request->delay == 0x0200)
               {
                   Trigger_SetWHS_VOC_Valve(CLOSE);
               }
               response.progress = 0;
               response.has_progress = false;
           }
       }
    else
       if(request->amount == 0x3EE) //whs pump
       {
           if (WHS_Type == WHS_TYPE_NEW)
           {
               if(request->delay == 0x01)
               {
                   Trigger_SetWHSPump(OPEN);
               }
               else
               if(request->delay == 0x00)
               {
                   Trigger_SetWHSPump(CLOSE);
               }
           }
           response.progress = 0;
           response.has_progress = false;
       }
    else
    if(request->amount == 0x3E9) // set TCA9555 u3 or u4
    {
        if (WHS_Type == WHS_TYPE_NEW)
        {
            if (request->delay & 0x8000)        // bit15 select the chip address
            {
                addr =  I2CExp2_ADDRESS;
            }
            else
            {
                addr =  I2CExp1_ADDRESS;
            }

            if  (request->delay & 0x4000)   // bit 14 select port 0 or 1
            {
                port = D_TCA9555_PORT_1;
            }
            else
            {
                port = D_TCA9555_PORT_0;
            }

            pin = ((request->delay & 0x0F00) >> 8);  // 8..11

            if (request->delay & 0x0001)
            {
                value = 1;
            }
            else
            {
                value = 0;
            }
            response.progress = Write_WHS_9555_io_value( addr,  port,  pin,  value);
            response.has_progress = true;
        }
    }
    else
        if(request->amount == 0x3E8) //&& (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
        {
            if (WHS_Type == WHS_TYPE_NEW)
            {
                WHS_enable_control_loop( request->delay & 0x1000);//disable control loop: 0=disable 1= enable
                Trigger_SetWHSBlowerVoltage (request->delay & 0x0FFF);
                response.progress = 0;
                response.has_progress = false;
            }
        }
    else
        if (request->amount == 0x3E7) // set WHS Blower speed by Q value
        {
             if (WHS_Type == WHS_TYPE_NEW)
             {
                 WHS_Set_SetPoint_Q_value((double) request->delay);
                 response.progress = 0;
                 response.has_progress = false;
             }
        }
    else
        if (request->amount == 0x3E6) // get WHS Blower speed by Q value
        {
             if (WHS_Type == WHS_TYPE_NEW)
             {
                 response.progress = WHS_Get_Volt_Blower_Control();
                 //response.progress = 0;
                 response.has_progress = true;
             }
        }
    //   WHS_Get_Volt_Blower_Control
    else
        if(request->amount == 0x3EA)
        {
            uint16_t tempu16 = 0;
            double temp_double = 0.0;
            //uint8_t display_byte = 0;
            uint16_t A2D_data = 0;

            if (WHS_Type == WHS_TYPE_NEW)
            {
                /*display_byte = ((request->delay & 0x3000)>>12);
                switch (display_byte)
                {
                case 0:
                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x0000); //
                    SetLeftDisplayView (HeadAVERAGE);
                    SetWriteDisplayView(DrierAVERAGE);
                    SetDisplayView (AVERAGE);
                    break;
                case 1:
                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x1000); //
                    SetLeftDisplayView (HeadAVERAGE);
                    SetWriteDisplayView(HeadCURRENT);
                    break;
                case 2:
                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x2000); //
                    SetLeftDisplayView (DrierAVERAGE);
                    SetWriteDisplayView(DrierCURRENT);
                    break;
                case 3:
                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x3000); //
                    SetLeftDisplayView (HeadCURRENT);
                    SetWriteDisplayView(DrierCURRENT);
                    SetDisplayView (CURRENT);
                    break;
                }*/

                A2D_data = (request->delay & 0x0FFF);
                switch(A2D_data )// get A2D
                {
                    case 0:
                        get_orf_1(&tempu16);
                        break;
                    case 1:
                        get_orf_2(&tempu16);
                        break;
                    case 2:
                        get_orf_3(&tempu16);
                        break;
                    case 3:
                        get_vlev1(&tempu16);
                        break;
                    case 4:
                        get_vlev2(&tempu16);
                        break;
                    case 5:
                        get_gas_out(&tempu16);
                        break;
                    case 6:
                        get_cur_fan(&tempu16);
                        break;
                    case 7:
                        get_cur_vlv1(&tempu16);
                        break;
                    case 8:
                        tempu16 = 0;  //get_cur_vlv2(&tempu16);
                        break;
                    case 10:
                        temp_double = WHS_Blower_Avarege(HEAD_FLOW_METER);
                        break;
                    case 11:
                        temp_double = WHS_Blower_Avarege(NU_FLOW_METER);
                        break;
                    case 12:
                        temp_double = WHS_Blower_Avarege(DRIER_FLOW_METER);
                        break;
                    /*case 20:
                        //temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
                        break;
                    case 22:
                        //temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
                        break;

                    case 11:
                        //get_orf_2(&tempu16);
                        break;
                    case 13:
                        //get_vlev1(&tempu16);
                        break;
                    case 14:
                        //get_vlev2(&tempu16);
                        break;
                    case 15:
                        //get_gas_out(&tempu16);
                        break;
                    case 16:
                        //get_cur_fan(&tempu16);
                        break;
                    case 17:
                        //get_cur_vlv1(&tempu16);
                        break;
                    case 18:
                        //tempu16 = 0;  //get_cur_vlv2(&tempu16);
                        break;*/
                    default :
                        tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
                        break;
                }
           }
       if ((request->delay)<10)
       {
           response.progress = (double)tempu16;
       }
       else
       {
           response.progress = temp_double;
       }
       response.has_progress = true;
    }
    else //
    if(request->amount == 0x3ED)
    {
        uint16_t tempu16 = 0;
        if (WHS_Type == WHS_TYPE_NEW)
        {
            if (request->delay <= 0x03FF)
            {
                Trigger_WHS_Set_RDAC(request->delay);  // 0 -> 0x03FF
                get_gas_out(&tempu16);
            }
            else if (request->delay == 0x0FFF)
            {
                Trigger_WHS_set_Rheostat_to_CLEAN_AIR();

                //Search_Rheostat_Value_for_Air_clibration();
                get_gas_out(&tempu16);
            }
            else if (request->delay == 0x04FF)
                get_gas_out(&tempu16);
        }
        response.progress = (double)tempu16;
        response.has_progress = true;
    }
    else
    if((request->amount == 0xDE) && (request->delay < 8) && (request->delay >= 0)) // read dispenser type + LS status
    {
        response.progress = ((Dispenser_struct[request->delay].Type) << 8) + Dispenser_struct[request->delay].Status;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD) //undef AUTO_HOME_DISPENSERS
    {
        if ((request->delay >=AutoHoming_off )&&(request->delay<=AutoHoming_JobEnd_PowerOn_off ))
            IDS_Dispenser_SetAutoHoming_Config(request->delay);
        response.progress = 01;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD1) //Set_Check_Pressure_Bypass
    {
        REPORT_MSG((request->delay)?1:0,"Set_Check_Pressure_Bypass");
        response.progress = Set_Check_Pressure_Bypass(request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD2) //Set_Thread_Rockers_Bypass
    {
        REPORT_MSG((request->delay)?1:0,"Set_Thread_Rockers_Bypass");
        response.progress = Set_Thread_Rockers_Bypass(request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD3) //Set_Auto_Shutdown_Bypass
    {
        REPORT_MSG((request->delay)?1:0,"Set_Auto_Shutdown_Bypass");
        response.progress = Set_Auto_Shutdown_Bypass(request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD4) //Set_Auto_Idle_Bypass
    {
        REPORT_MSG((request->delay)?1:0,"Set_Auto_Idle_Bypass");
        response.progress = Set_Auto_Idle_Bypass(request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD5) //Set SecondFeederCorrection
    {
        REPORT_MSG(request->delay,"Set SecondFeederCorrection");
        SecondFeederCorrection = request->delay;
        response.progress = SecondFeederCorrection;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD6) //Set skip open lids
    {
        REPORT_MSG(request->delay,"Set SkipOpenLids");
        SkipOpenLids = request->delay;
        response.progress = SkipOpenLids;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD7) //Set actuators cleaning sequence
    {
        REPORT_MSG(request->delay,"Set actuators cleaning sequence");
        ActuatorsCleaningSequence = request->delay;
        response.progress = ActuatorsCleaningSequence;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD8) //Set ignore cone missing
    {
        REPORT_MSG(request->delay,"Set ignore cone missing");
        IgnoreConeMissing = request->delay;
        response.progress = IgnoreConeMissing;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xAD9) //halt
    {
        REPORT_MSG(request->delay,"halt");
        memset (0,0,100000);
        response.progress = IgnoreConeMissing;
        response.has_progress = true;
    }
    else
    if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
    {
        response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
        response.has_progress = true;
    }
    /*else
    if((request->amount == 0xAB) && (request->delay == 0xAB)) //Get pressure with flow (orifice flow meter)
    {
        response.progress = Calculate_Pitot_Pressure(true);
        response.has_progress = true;

    }
    else
        if((request->amount == 0xAB) && (request->delay == 0x0)) //measured sensor voltage without flow (orifice flow meter)
    {
        response.progress = Calculate_Pitot_Pressure(false);
        response.has_progress = true;

    }*/
    else
    if((request->amount == 0xAC) && (request->delay == 0xAC)) //VAC
    {
            response.progress = ReadVAC();
            response.has_progress = true;

    }
    else
        if(request->amount == 0x0EAD)  //Head Card I/O
        {
            uint8_t Read_Buf[1] = {0};
            uint8_t Write_Buf[2] = {0,0};
            uint8_t Script_Slave_Add = request -> delay >> 16;//Slave address 0x40 / 0x42 / 0x44 / 0x46
            Write_Buf[0] = (request -> delay & 0x00FF00) >> 8;//read/write low/high
            /*
            ------------------
            | Byte | WR | RD |
            ------------------
            | Low  | 02 | 00 |
            | High | 03 | 01 |
            ------------------
            */
            Write_Buf[1] = request -> delay & 0x0000FF;//data to write

            response.has_progress = false;

            Select_Main_Head_Mux_Channel();

            if(Write_Buf[0] == 0)//Read
            {
                //Head_Read_IO_Reg(Script_Slave_Add, LOW);

                delayms(1);
                if(Script_Slave_Add == 0x40)
                {
                    Read_Buf[0] = Head_I2C_EXP1_0x40.uchar[0];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x42)
                {
                    Read_Buf[0] = Head_I2C_EXP2_0x42.uchar[0];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x44)
                {
                    Read_Buf[0] = Head_I2C_EXP3_0x44.uchar[0];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x46)
                {
                    Read_Buf[0] = Head_I2C_EXP4_0x46.uchar[0];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
            }
            else

            if(Write_Buf[0] == 1)//Read
            {
                //Head_Read_IO_Reg(Script_Slave_Add, HIGH);

                delayms(1);
                if(Script_Slave_Add == 0x40)
                {
                    Read_Buf[0] = Head_I2C_EXP1_0x40.uchar[1];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x42)
                {
                    Read_Buf[0] = Head_I2C_EXP2_0x42.uchar[1];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x44)
                {
                    Read_Buf[0] = Head_I2C_EXP3_0x44.uchar[1];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
                else
                if(Script_Slave_Add == 0x46)//LS
                {
                    Read_Buf[0] = Head_I2C_EXP4_0x46.uchar[1];
                    response.progress = Read_Buf[0];
                    response.has_progress = true;
                }
            }
            else
            /*
            if(Write_Buf[0] == 2)//write
            {
                if(Script_Slave_Add == 0x40)
                {
                    Head_I2C_EXP1_0x40.uchar[0] = Write_Buf[1];
                }
                else
                if(Script_Slave_Add == 0x42)
                {
                    Head_I2C_EXP2_0x42.uchar[0] = Write_Buf[1];
                }
                else
                if(Script_Slave_Add == 0x46)
                {
                    Head_I2C_EXP4_0x46.uchar[0] = (Write_Buf[1] & 0x80);
                }

                //Head_Write_IO_Reg(Script_Slave_Add, LOW);
            }
            if(Write_Buf[0] == 3)//write
            {
                if(Script_Slave_Add == 0x40)
                {
                    Head_I2C_EXP1_0x40.uchar[1] = Write_Buf[1];
                }
                else
                if(Script_Slave_Add == 0x42)
                {
                    //Head_I2C_EXP2_0x42.uchar[1] = Write_Buf[1];
                    Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = (Write_Buf[1] & 0x01);//control only the magnet
                }
                else
                if(Script_Slave_Add == 0x46)
                {
                    Head_I2C_EXP3_0x44.uchar[1] = (Write_Buf[1] & 0x0C);
                }
                //Head_Write_IO_Reg(Script_Slave_Add, HIGH);
            }
            */
                if(Write_Buf[0] >=0xF0) // write
                {
                    // write , Write_Buf[0] bit number 0..15 , Write_Buf[1] 0 or 1
                    Write_Buf[1] = Write_Buf[1] & 0x01;

                    Write_Buf[0] &=0x0f;

                    if(Script_Slave_Add == 0x40)
                    {
                        if(Write_Buf[1] == 0x01)
                            Head_I2C_EXP1_0x40.ushort |= (0x01 << Write_Buf[0]);
                        else if(Write_Buf[1] == 0x00)
                            Head_I2C_EXP1_0x40.ushort &= ~(0x01 << Write_Buf[0]);
                    }
                    else
                    if(Script_Slave_Add == 0x42)
                    {
                        if(Write_Buf[1] == 0x01)
                            Head_I2C_EXP2_0x42.ushort |= (0x01 << Write_Buf[0]);
                        else if(Write_Buf[1] == 0x00)
                            Head_I2C_EXP2_0x42.ushort &= ~(0x01 << Write_Buf[0]);
                    }
                    else
                    if(Script_Slave_Add == 0x46)
                    {
                        if(Write_Buf[1] == 0x01)
                            Head_I2C_EXP4_0x46.ushort |= (0x01 << Write_Buf[0]);
                        else if(Write_Buf[1] == 0x00)
                            Head_I2C_EXP4_0x46.ushort &= ~(0x01 << Write_Buf[0]);
                    }
                }
        }
        else
    if(request->amount == 0xFEAD)  //functions Head Card I/O
    {
        Select_Main_Head_Mux_Channel();

        if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
        {
            if((request -> delay & 0x00000F) >1)
            {
                if((request -> delay & 0xFFFFFF) == 0xCAF002)//ACTUATOR-IN down without delay and without stop the actuator
                {
                    Trigger_Head_Actuators_Stub(ACTIN, true, false);
                }
                else
                if((request -> delay & 0xFFFFFF) == 0xCAF003)//ACTUATOR-IN up without delay and without stop the actuator
                {
                    Trigger_Head_Actuators_Stub(ACTIN, true, true);
                }
                else
                if((request -> delay & 0xFFFFFF) == 0xCAF008)//Stop  ACTUATOR-IN
                {
                    Trigger_Head_Actuators_Stub(ACTIN, false, true);
                }
                else
                if((request -> delay & 0xFFFFFF) == 0xCAF102)//ACTUATOR-OUT  down without delay and without stop the actuator
                {
                    Trigger_Head_Actuators_Stub(ACTOT, true, false);
                }
                else
                if((request -> delay & 0xFFFFFF) == 0xCAF103)//ACTUATOR-OUT  up without delay and without stop the actuator
                {
                    Trigger_Head_Actuators_Stub(ACTOT, true, true);
                }
                else
                if((request -> delay & 0xFFFFFF) == 0xCAF108)//Stop  ACTUATOR-OUT
                {
                    Trigger_Head_Actuators_Stub(ACTOT, false, true);
                }
            }
            else
            {
               // STUB: stubManager.Run<ProgressResponse>("ProgressRequest" ,0xFEAD, 0xCAF201);//Actuators: ID, power, Direction

                //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
                Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0xF00)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
                //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
            }
            response.has_progress = true;
        }
        else
        if((request -> delay & 0xFF0000) == 0xCA0000)//control all heaters
        {
            if(request -> delay & 0x01)
            {
                Disconnect_Mixer_and_12_Heaters_Latch();
                HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, TRUE);
                Connect_Mixer_and_12_Heaters_Latch();
            }
            else
                HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, FALSE);
        }
        else
        if(request -> delay == 0x0)//return head type
        {
            response.progress = Head_Type;
            response.has_progress = true;
        }

    }
    else
    if((request->amount == 0xFAC0) /*&& (request->delay == 0xFAC)*/) //Head Fan control
    {
        //Head_Fan_PWM_Command[0] = (request->delay & 0xFF) ;
        //Test_Head_fan_Click();
        if(request->delay <= 0xFF)
        {
            Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, request->delay & 0xFF);
            response.progress = 7864320/Head_Fan_Tach[0];
        }
        else
        {
            response.progress = 7864320/Head_Fan_Tach[0];
        }

        //response.progress = Fan_Click_Info.Product_ID;
        response.has_progress = true;

    }
    else
    if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
    {
        if(request->delay <= 0xFF)
        {
            Trigger_Head_Fan_Control(HEAD_FAN_LEFT, request->delay & 0xFF);
            response.progress = 7864320/Head_Fan_Tach[1];
        }
        else
        {
            response.progress = 7864320/Head_Fan_Tach[1];
        }
        response.has_progress = true;
    }
    else
    if ((request->amount & 0x0000FFF0) == 0xFAC0) //WHS Fan control
    {
        uint16_t fan_tacho = 0;

        if (WHS_Type == WHS_TYPE_NEW)
        {
            if(request->delay <= 0xFF)
            {
                Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-2) , request->delay & 0x000000FF);
                fan_tacho = WHS_Fan_Tach_RPM[(request->amount & 0x0000000F)-2];
            }
            else
            {
                //reading the tacho in msectask
                fan_tacho = WHS_Fan_Tach_RPM[(request->amount & 0x0000000F)-2];//WHS_Get_fan_tach( (request->amount & 0x0000000F)-2);
            }
        }
        response.progress = fan_tacho;
        response.has_progress = true;
    }
    else
    if((request->amount == 0x0A) && ((request->delay >= 0) && (request->delay < 8))) //read the midtank calibration
    {
        response.progress = Initial_Offset_A[request->delay];
        response.has_progress = true;
    }
    else
    if((request->amount == 0xB) && ((request->delay >= 0) && (request->delay < 8)))  //read the midtank calibration
    {
        response.progress = Slope_B[request->delay];
        response.has_progress = true;
    }
    else
    if((request->amount == 0x5C4E) && (request->delay == 0x5C4E)) //Screw Home Pos dir
    {
        test_Home_Pos();
    }
    else
    if((request->amount == 0x100) && (request->delay == 0x100)) //head card PT100
    {
        Test_HeadCard_PT100(TEMP_SENSE_ANALOG_DYEINGH_TEMP1);
        //response.progress = (double)Test_Read_Buf[0];
        response.progress = (double)Data_ADC_Head;
        response.has_progress = true;
    }
    else
    if((request->amount == 0x0D) && (request->delay == 0xEE)) //Dispenser EEprom
    {
        test_disp_eeprom(0x01,0xA0);
        response.progress = OK;
        response.has_progress = true;
    }
    else
    if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive
    {
#ifdef WATCHDOG
        ROM_WatchdogResetDisable(WATCHDOG0_BASE);
        uint32_t timeout = 0xFFFFFFFFU;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif
        HeatersEnd();
        FRESULT iFResult = Init_Flash_File_System(true);
        if(iFResult != FR_OK)
        {
            REPORT_MSG (iFResult, "Error during init Flash File System");
            assert(iFResult);
        }
#ifdef WATCHDOG
        ROM_WatchdogResetEnable(WATCHDOG0_BASE);
        timeout = 120000000*3;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif
    }
    /*else
    if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
    {
        response.progress = (double)Calculate_Gas_Power_Consumption();
        response.has_progress = true;

    }*/
    else
    if((request->amount == 0xDD) && (request->delay == 0xDD)) //Read Input Voltage
    {
        REPORT_MSG(request->delay,"CheckAcInputVoltage");
       CheckAcInputVoltage();

       response.progress = (double)Input_Voltage;
       response.has_progress = true;
    }
    else
    if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
    {
        REPORT_MSG(request->delay,"FlashInit");
        HeatersEnd();
        FlashInit();
        response.progress = (double)OK;
        response.has_progress = true;
        RestartNeeded = true;
    }
    else
    if((request->amount == 0x0CD) && (request->delay == 0x0CD)) //Get Gas Sensor
    {
        REPORT_MSG(request->delay,"Load embedded parameters from file and restart");
        base_flashErased = false;
        LoadConfigurationParamsFromFile(true);
        REPORT_MSG(255,"Update successful, Rebooting in 5 seconds");
        Task_sleep (eOneSecond*5);
        Power_Reset();
        response.progress = (double)OK;
        response.has_progress = true;

    }
    else
    if(request->amount == 0x0CC)  //Cartridge Validation Response Demo
    {
        REPORT_MSG(request->delay,"ResponseDemo");
		ResponseDemo(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE0)  //fast refresh for pressure
    {
        REPORT_MSG(request->delay,"setRapidPressureRead");
        setRapidPressureRead(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    /*else
    if(request->amount == 0xE1)  //fast refresh for pressure
    {
        REPORT_MSG(request->delay,"Starting Dispenser PID");
        IDS_Start_Pid_Testing(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE2)  //fast refresh for pressure
    {
        REPORT_MSG(request->delay,"Stoping Dispenser PID");
        IDS_Stop_Pid_Testing(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }*/
    else
    if(request->amount == 0xE3)  //fast refresh for pressure
    {
        Report("Set WFCF Value ",__FILE__,__LINE__,request->delay,RpWarning,(int)Get_WFCF_Time(),0);
        IDS_Dispenser_SetPreSegmentWFCFValues((double) request->delay, Get_WFCF_Time());
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE4)  //Set WFCF build to waste Time Value
    {
        Report("Set WFCF build to waste Time Value ",__FILE__,__LINE__,request->delay,RpWarning,(int)Get_WFCF(),0);
        IDS_Dispenser_SetPreSegmentWFCFValues(Get_WFCF(),(double) request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }

    else
    if(request->amount == 0xE5)  //short_cycle
    {
        Report("short_cycle ",__FILE__,__LINE__,request->delay,RpWarning,0,0);
        short_cycle = request->delay;
        response.progress = (double)short_cycle;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE6)  //HeaterSafetyTestSetLimits
    {
        Report("HeaterSafetyTestSetLimits ",__FILE__,__LINE__,request->delay,RpWarning,0,0);
        HeaterSafetyTestSetLimits(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }

    else
    if(request->amount == 0xB1)  //fast refresh for pressure
    {
        REPORT_MSG(request->delay,"Set loading arm center");
        Read_Dryer_ENC_Position();
        Task_sleep(500);
        Read_Dryer_ENC_Position();
        Task_sleep(500);

        (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CENTER,Read_Dryer_ENC_Position(0,0));

        response.progress = (double)Read_Dryer_ENC_Position(0,0);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB2)  //Set loading arm cycles
    {
        REPORT_MSG(request->delay,"Set loading arm cycles");

        response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB3)  //fast refresh for pressure
    {
        REPORT_MSG(request->amount,"keep alive test");
        keepalivetest = request->amount;
        response.progress = keepalivetest;
        response.has_progress = true;

    }
    else
    if(request->amount == 0xB4)  //IDS_Dispenser_Content_Init
    {
        REPORT_MSG(request->amount,"IDS_Dispenser_Content_Init");
        IDS_Dispenser_Content_Init();
        response.progress = 0;
        response.has_progress = true;

    }
    else
    if(request->amount == 0xB5)  //fast refresh for pressure
    {
        if (request->delay<=100)
        {
            REPORT_MSG(request->delay,"set stub_heating_limit");
            stub_heating_limit = request->delay;
        }
        response.progress = request->delay;
        response.has_progress = true;

    }
#ifdef VAC_TEST
    else
    if(request->amount == 0xB6)  //fast refresh for pressure
    {
        REPORT_MSG(request->delay,"set vac read test");
        VAC_Test = (double)request->delay;
        response.progress = request->delay;
        response.has_progress = true;

    }
#endif
    else
    if(request->amount == 0xB7)  //fast refresh for pressure
    {
        specialHeaterState = request->delay?true:false;
        REPORT_MSG(specialHeaterState,"set specialHeaterState");
        response.progress = specialHeaterState;
        response.has_progress = true;

    }
    else
    if(request->amount == 0xB8)  //fast refresh for pressure
        {
            if (request->delay == 1) {//init waste
                Waste_Init();
                REPORT_MSG(request->delay,"Waste_Init");
            }
            response.progress = request->delay;
            response.has_progress = true;
        }
    else
    if(request->amount == 0xB9)  //fast refresh for pressure
    {
        if ((request->delay == 0) || (request->delay == 1)) {
            doorState = request->delay;
            REPORT_MSG(request->delay,"door");
        }
        response.progress = request->delay;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB11)  //fast refresh for pressure
    {
        temp1 = Read_Dryer_ENC_Position();
        temp2 = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius/4;

           MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Hiz);
        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,200);
        //6 seconds per round
        Report("Arm movement test",__FILE__,request->delay,request->delay/2*2,RpWarning,(int)request->delay%2,0);

        //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, request->delay%2,request->delay/2*2,    NULL, 12000);

        response.progress = temp2;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB12)  //fast refresh for pressure
    {

        temp2 = Calculate_Arm_Distance(temp1,Read_Dryer_ENC_Position());
        Report("Arm movement test calc",__FILE__,temp2,temp1,RpWarning,Read_Dryer_ENC_Position(),0);

        response.progress = temp2;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB13)  //TryThreadLoadingRequest
    {
        TryThreadLoadingFunc(NULL);
        Report("TryThreadLoadingFunc",__FILE__,temp2,temp1,RpWarning,Read_Dryer_ENC_Position(),0);

        response.progress = 0xB13;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB14)
    {
        REPORT_MSG(request->amount,"IDS_Cleaning_Move_Actuators");
        Init_CleaningStageCounter();
        IDS_Cleaning_Move_Actuators();

        response.progress = 0xB14;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB15)
    {
        TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
        REPORT_MSG(request->amount,"Motor soft stop");
        MotorStop(MotorId,Soft_Stop);

        response.progress = 0xB15;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB16)
    {
        TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
        REPORT_MSG(request->amount,"MotorMovetoLimitSwitch");
        MotorMovetoLimitSwitch(MotorId,1 - MotorsCfg[MotorId].directionthreadwize, 50,  Motor_Id_to_LS_IdDown[MotorId], cleaningMotorCBFunction,30000);
        ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Homing", __FILE__, __LINE__, 1, RpWarning, 0, 0);

        response.progress = 0xB16;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB17)
    {
        REPORT_MSG(request->delay,"HeadBlowersOff");
        HeadBlowersOff(request->delay);

        response.progress = 0xB17;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB18)
    {
        enable = HeadBlowersOffGet();
        REPORT_MSG(enable, "HeadBlowersOffGet");

        response.progress = 0xB18;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB19)
    {
        REPORT_MSG(request->amount,"ThreadCheckArcHeadCovers");
        ThreadCheckArcHeadCovers();
        ReportWithPackageFilter(IDSFilter,"ThreadCheckArcHeadCovers", __FILE__, __LINE__, 1, RpWarning, 0, 0);

        response.progress = 0xB19;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB20)  //Set loading arm cycles
    {
        REPORT_MSG(request->delay,"Set winding calibration data");

        response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_WINDER_CALIBRATION,request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB21)  //Set loading arm cycles
    {
        REPORT_MSG(request->delay,"Set screw max speed");

        response.progress = (double)MotorSetMaxSpeed(HARDWARE_MOTOR_TYPE__MOTO_SCREW,request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB22)  //Set loading arm cycles
    {
        REPORT_MSG(request->delay,"Send persistent alarm");
        AlarmHandlingSetAlarm (EVENT_TYPE__UNINTENDED_RESET,ON);  //handle alarm detection and operation

        response.progress = (double)MotorSetMaxSpeed(HARDWARE_MOTOR_TYPE__MOTO_SCREW,request->delay);
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB23)  //Set loading arm cycles
    {
        REPORT_MSG(request->delay,"Control dryer fan tacho");
        if (request->delay>0)
            Control_Dryer_Fan(START,request->delay);//use START or STOP,  0 - 100%();
        else
            Control_Dryer_Fan(STOP,0);//use START or STOP,  0 - 100%();
        Task_sleep(1000);

        response.progress = (double)Get_Dryer_Fan_Tacho();
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB24)  //AttemptThreadJoggingFunc
    {
        REPORT_MSG(request->delay,"AttemptThreadJoggingFunc");
        AttemptThreadJoggingFunc(NULL);
        response.progress = 0xb24;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB25)  //Change jog speed
    {
        REPORT_MSG(request->delay,"Change jog speed");
        if (request->delay<100)
            JogSpeed = request->delay;
        response.progress = JogSpeed;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB26)  //Change sublimation time
    {
        REPORT_MSG(request->delay,"Change sublimation time");
        setSublimationBlowTime(request->delay);
        response.progress = JogSpeed;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xC3)  //suspend I2C task
    {
        if (request->delay == 0)
        {
            REPORT_MSG(request->delay,"Suspend I2C");
            PowerOffHeatersOff();
            Task_sleep(1000);
            Task_setPri (I2C_Task_Handle,-1);
        }
        else
        {
            REPORT_MSG(request->delay,"Resume");
            Task_setPri (I2C_Task_Handle,17);
        }
        response.progress = request->delay;
        response.has_progress = true;

    }
    else
    if(request->amount == 0xC11)
    {
        IgnoreMidTank = request->delay;
        REPORT_MSG(IgnoreMidTank, "IgnoreMidTank");

        response.progress = request->delay;
        response.has_progress = true;
    }
#ifdef MIDTANK_MITIGATION
    else
    if(request->amount == 0xC12)
    {
        MidTankMitigation = request->delay;
        REPORT_MSG(MidTankMitigation, "MidTankMitigation");

        response.progress = request->delay;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xC13)
    {
        MidTankMitigationOff = request->delay;
        REPORT_MSG(MidTankMitigationOff, "MidTankMitigationOff");

        response.progress = request->delay;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xC14)
    {
        MidTankMitigationOn = request->delay;
        REPORT_MSG(MidTankMitigationOn, "MidTankMitigationOn");

        response.progress = request->delay;
        response.has_progress = true;
    }
#endif
    else
    if(request->amount == 0xD11)
    {
        REPORT_MSG(request->delay, "stop/start blower control and blower");
        if (request->delay == 0)
        {
            WHS_enable_control_loop(false);
            Turn_the_Blower_On();//Turn on with the Default_Voltage
            Control_Voltage_To_Blower(1); //stop the blower
        }
        else
        {
            Turn_the_Blower_On();//Turn on with the Default_Voltage
            Control_Voltage_To_Blower(2400); //stop the blower
            WHS_enable_control_loop(true);
        }

        response.progress = request->delay;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xD12)
    {
        REPORT_MSG(request->delay, "stop/start blower control and blower");
        InitSequenceWHSAirFlowCalibration();

        response.progress = request->delay;
        response.has_progress = true;
    }
    else     
	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
    {
        PowerOffInit();
    }
    else
    if(request->amount == 0xF1)
    {
        REPORT_MSG(request->delay,"NumberOfRotationPerPassage");
        NumberOfRotationPerPassage = (float)(request->delay)/1000;
    }
    else
    {
        response.has_progress = true;
        int i = 0;
        for (i = 0; i < request->amount; i++)
        {
            response.progress = i;
            responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
            uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
            size_t container_size = message_container__pack(&responseContainer, container_buffer);
            free(responseContainer.data.data);
            SendChars((char*)container_buffer, container_size);
            //free(container_buffer);


            int co = 0;
            for (co = 0; co < request->delay; co++)
            {
                __delay_cycles(1000000);
            }
        }
    }
    responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size);
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    if (request)
        progress_request__free_unpacked(request,NULL);
    //writeLine("Progress Completed!");
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);
    if (RestartNeeded == true)
    {
        REPORT_MSG(255,"Update successful, Rebooting in 5 seconds");
        Task_sleep (eOneSecond*5);
        Power_Reset();
        RestartNeeded = false;
    }

    return;

}