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 "StateMachines/Initialization/PowerOffSequence.h"

#include "drivers/Flash_Memory/FATFS/ff.h"
#include "drivers/Flash_Memory/FATFS/Control_File_System.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/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/FPGA/FPGA_SPI_Comm.h"
#include "Modules/IFS/ifs.h"
#include "Modules/IDS/ids_ex.h"
#include "Modules/Control/MillisecTask.h"
#include "modules/thread/thread_ex.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/WHS_Card/IO_Ports_TCA9555/WHS_IO.h>

extern float NumberOfRotationPerPassage;  // how many rotations per spool passage

//#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];

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;

    if(request->amount == 0x3E9) // set TCA9555 u3 or u4
    {
        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 == 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 == 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 Write_Buf[2] = {0,0};
        uint8_t Script_Slave_Add = request -> delay >> 16;
        Write_Buf[0] = request -> delay >> 8;
        Write_Buf[1] = request -> delay & 0x0000FF;

        Select_Main_Head_Mux_Channel();
        I2C_Write(I2C_ID_HEAD_CARD, Script_Slave_Add, Write_Buf, 2);

        delayms(1);

        uint8_t Read_Buf[2] = {0,0};
        I2C_Read(I2C_ID_HEAD_CARD, Script_Slave_Add + 1, Read_Buf, 2);
        response.progress = Read_Buf[1] << 8 | Read_Buf[0];
        response.has_progress = true;

    }
    else
    if(request->amount == 0xFEAD)  //functions Head Card I/O
    {
        Select_Main_Head_Mux_Channel();

        if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
        {
            HeadCard_Actuators_Control((ACTUATORS)((request -> delay & 0x100)>>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->amount == 0xFAC0) /*&& (request->delay == 0xFAC)*/) //Head Fan control
    {
        //Head_Fan_PWM_Command[0] = (request->delay & 0xFF) ;
        //Test_Head_fan_Click();

        Head_Fan_PWM_Control(0, request->delay & 0xFF);


        //response.progress = Fan_Click_Info.Product_ID;
        response.progress = Head_Fan_Tach[0];
        response.has_progress = true;

    }
    else
    if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
    {
        Head_Fan_PWM_Control(1, request->delay & 0xFF);

        response.progress = Head_Fan_Tach[1];
        response.has_progress = true;
    }
    else
    if ((request->amount & 0x0000FFF0) == 0xFAC0) //WHS Fan control
    {
        uint16_t fan_tacho = 0;

        WHS_set_fan_speed(((request->amount & 0x0000000F)-1) , request->delay & 0x000000FF);
        WHS_Read_fan_tach(((request->amount & 0x0000000F)-1),  &fan_tacho);
        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 == 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
        FRESULT iFResult = Init_Flash_File_System(true);
        if(iFResult != FR_OK)
        {
            LOG_ERROR (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
    {
        LOG_ERROR(request->delay,"CheckAcInputVoltage");
       CheckAcInputVoltage();

       response.progress = (double)Input_Voltage;
       response.has_progress = true;
    }
    else
    if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
    {
        LOG_ERROR(request->delay,"FlashInitAndLoad");
        FlashInitAndLoad();
        response.progress = (double)OK;
        response.has_progress = true;

    }
    else
    if(request->amount == 0x0CC)  //C�������� V��������� ��������
    {
        LOG_ERROR(request->delay,"ResponseDemo");
		ResponseDemo(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE0)  //fast refresh for pressure
    {
        LOG_ERROR(request->delay,"setRapidPressureRead");
        setRapidPressureRead(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xE1)  //fast refresh for pressure
    {
        LOG_ERROR(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
    {
        LOG_ERROR(request->delay,"Stoping Dispenser PID");
        IDS_Stop_Pid_Testing(request->delay);
        response.progress = (double)OK;
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB1)  //fast refresh for pressure
    {
        LOG_ERROR(request->delay,"Set loading arm center");
        Read_Dryer_ENC_Position();
        Task_sleep(500);
        Read_Dryer_ENC_Position();
        Task_sleep(500);

        response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CENTER,Read_Dryer_ENC_Position(0,0));
        response.has_progress = true;
    }
    else
    if(request->amount == 0xB2)  //fast refresh for pressure
    {
        LOG_ERROR(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
    {
        LOG_ERROR(request->amount,"keep alive test");

        keepalivetest = true;
        response.progress = keepalivetest;
        response.has_progress = true;

    }
    else     
	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
    {
        PowerOffInit();
    }
    else
    if(request->amount == 0xF1)
    {
        LOG_ERROR(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);
    //writeLine("Progress Completed!");
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);

    return;

}