Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<Application x:Class="Tango.MachineStudio.RML.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="pack://application:,,,/Tango.MachineStudio.Common;component/Resources/MaterialDesign.xaml" />
                <ResourceDictionary Source="pack://application:,,,/Tango.MachineStudio.Common;component/Themes/LightThemeColors.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>
/************************************************************************************************************************
 * control.c
 * Control module
 *
************************************************************************************************************************/
#include <Container.h>
#include <DataDef.h>
#include "include.h"
#include "GeneralHardware.h"
#include "thread/thread.h"
#include "ids/ids.h"
#include "control/control.h"
#include "Control/MillisecTask.h"
#include "AlarmHandling/AlarmHandling.h"
#include "heaters/heaters_ex.h"

#include "Diagnostics/Diagnostics.h"

#include "heaters/heaters_ex.h"

#include "third_party/fatfs/src/ffconf.h"
#include "third_party/fatfs/src/diskio.h"
#include "drivers/Flash_Memory/Flash_Memory.h"
#include "drivers/Flash_Memory/fatfs/ff.h"
#include "drivers/Flash_ram/FlashProgram.h"

#include "third_party/fatfs/src/ffconf.h"
#include "Common/SWUpdate/FileSystem.h"

#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationResponse.pb-c.h"
#include "PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h"
#include "PMR/Hardware/SystemResetRequest.pb-c.h"
#include "PMR/Hardware/SystemResetResponse.pb-c.h"

#include "drivers/I2C_Communication/DAC/Blower.h"
#include "drivers/Valves/Valve.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/InitSequence.h"

uint32_t EmbeddedParametersInit(void);
uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest);

bool GeneralHwReady = false;

HardwareBlower BlowerCfg;
char *SW_INFO_DIR = "0://SysInfo";

char HwConfigPath[50] = "0://SysInfo//GenHwCfg.cfg";
uint32_t HWConfigurationInit(void)
{
    FRESULT Fresult = FR_OK;
    FIL *FileHandle = 0;  //the system supports a single active file
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0,i,j,k=0;
    uint32_t status = OK;
    UploadHardwareConfigurationRequest* UploadRequest;

    GeneralHwReady = false;
    Control_WD(ENABLE,250);

    Fresult = f_mkdir(SW_INFO_DIR);
    if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
    {
        FileHandle = my_malloc(sizeof(FIL));

        Fresult = FileOpen(HwConfigPath, &Bytes, FileHandle);
        if (Fresult == FR_OK)
        {
            buffer = my_malloc (Bytes);
            if (buffer)
            {
                for (i=0;i<=(Bytes/100);i++)
                {
                    Fresult = f_read(FileHandle,&buffer[i*100],100,&j );
                    k+=j;
                }
                if (k!=Bytes)
                    LOG_ERROR(k,"File read error");
            }
           UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
           status = HWConfiguration(UploadRequest);
           if (status ==OK)
           {
               upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
               EraseFlashSection(GENHWCFG_MAP_IN_FLASH,Bytes);
               ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, Bytes, buffer);
           }
           else
           {
               SetMachineState(MACHINE_STATE_HW_CONFIG_FAILED);
           }
           free (buffer);
        }
        f_close(FileHandle);
    }
    //EmbeddedParametersInit();
    IDS_Dispenser_Content_Init();
    //ProcessParamsInit();
    GeneralHwReady = true;
    return Fresult;
}

char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg";
ConfigurationParameters EmbeddedParameters;
bool DataUpdated = false;
void LoadConfigurationParameters(ConfigurationParameters *Params)
{
    if (Params == 0)
        {
            configuration_parameters__init(&EmbeddedParameters);
            EmbeddedParameters.has_breaksensorlimit = true;
            EmbeddedParameters.breaksensorlimit = 10;
            EmbeddedParameters.has_diagnosticcollectionlimit = true;
            EmbeddedParameters.diagnosticcollectionlimit = 2;
            EmbeddedParameters.has_overheatcountlimit = true;
            EmbeddedParameters.overheatcountlimit = 3;
            EmbeddedParameters.has_underheatcountlimit = true;
            EmbeddedParameters.underheatcountlimit = 3;
            EmbeddedParameters.has_closevalvetimeout = true;
            EmbeddedParameters.closevalvetimeout = 250;
            EmbeddedParameters.has_openvalvetimeout = true;
            EmbeddedParameters.openvalvetimeout = 250;
            EmbeddedParameters.has_initialdispenserpressure = true;
            EmbeddedParameters.initialdispenserpressure = 0.08;
            EmbeddedParameters.has_initialdispensertimeout = true;
            EmbeddedParameters.initialdispensertimeout = 10000;
            EmbeddedParameters.has_initialdispensertimelag = true;
            EmbeddedParameters.initialdispensertimelag = 100;
            EmbeddedParameters.has_dispenserbuildpressurespeed = true;
            EmbeddedParameters.dispenserbuildpressurespeed=500;
            EmbeddedParameters.has_dispenserbuildpressurelimit = true;
            EmbeddedParameters.dispenserbuildpressurelimit=1.5 ;
            EmbeddedParameters.has_dispenserbuildpressuretimeout = true;
            EmbeddedParameters.dispenserbuildpressuretimeout=20000;
            EmbeddedParameters.has_dispenserbuildpressurelag = true;
            EmbeddedParameters.dispenserbuildpressurelag=50;
            EmbeddedParameters.has_acheatersloweroperationlimit = true;
            EmbeddedParameters.acheatersloweroperationlimit = 995;
            EmbeddedParameters.has_acheatersupperoperationlimit = true;
            EmbeddedParameters.acheatersupperoperationlimit = 1005;
            EmbeddedParameters.has_dcheatersloweroperationlimit = true;
            EmbeddedParameters.dcheatersloweroperationlimit = 978;
            EmbeddedParameters.has_dcheatersupperoperationlimit = true;
            EmbeddedParameters.dcheatersupperoperationlimit = 1002;
            EmbeddedParameters.has_midtankpressurecorrection = true;
            EmbeddedParameters.midtankpressurecorrection = 0.5;
            uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters));
            size_t response_size = 0;
            if (response_buffer)
            {
                response_size = configuration_parameters__pack(&EmbeddedParameters, response_buffer);
            }
            FileWrite(response_buffer,response_size,EmbeddedParametersPath);
            my_free(response_buffer);
        }
        else memcpy (&EmbeddedParameters,Params,sizeof(EmbeddedParameters));
}
uint32_t EmbeddedParametersInit(void)
{
    FRESULT Fresult = FR_OK;
    void* buffer = NULL;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params;

    Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
    if (Fresult == FR_OK)
    {
        Params = configuration_parameters__unpack(NULL, Bytes, buffer)/*(ConfigurationParameters *)buffer*/;
        LoadConfigurationParameters(Params);
        DataUpdated=true;
        free (buffer);
        configuration_parameters__free_unpacked(NULL,Params);
    }
    else
    {
        LoadConfigurationParameters(0);
    }
    IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout);
    IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag);
    IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed,   EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag);
    Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit,  EmbeddedParameters.underheatcountlimit);
    Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit);
    MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection);
    SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit);
    ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit);
    bool a1,a2,a3;
    a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true;
    a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true;
    a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true;
    AlarmHandlingSetFlags(a1,a2,a3);

    return Fresult;
}
uint32_t GenHWControlId;

uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    int   Dispenser_i;
    SafeRemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
    {
        Read_MidTank_Pressure_Sensor(Dispenser_i);
        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
            Disable_MidTank_Pressure_Reading(Dispenser_i);
    }
    return OK;
}

uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
{
    uint32_t status  = 0;
    int Motor_i, Dancer_i, Dispenser_i,PID_i;

    if (UploadRequest == NULL)
    {
        LOG_ERROR (0, "Wrong Data Allocation");
        return ERROR;
    }
    HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;

    if (JobIsActive())
    {
        return ERROR;
    }
    if (watchdogCriticalAlarm == true)
    {
        LOG_ERROR(1,"Critical Alarm cleared - Watchdog de-activated");
        watchdogCriticalAlarm = false;
    }
    EmbeddedParametersInit();

    PrintingHWConfiguration(request);
    if (request->n_winders == 1)
        status += InternalWinderConfigMessage(request->winders);
    status += MotorsInit();
 
    if (request->n_motors < NUM_OF_MOTORS)
    {
       //EraseFlashSection(GENHWCFG_MAP_IN_FLASH + 0x2000,sizeof(HardwareMotor)*request->n_motors);

        for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
        status += MotorsConfigMessage(request->motors[Motor_i]);
    }
    else
    {
        LOG_ERROR (request->n_motors, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dancers <= NUM_OF_DANCERS)
    {
        for (Dancer_i = 0; Dancer_i < request->n_dancers ; Dancer_i++)
            status += DancerConfigMessage(request->dancers[Dancer_i]);
    }
    else
    {
        LOG_ERROR (request->n_dancers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    LoadDancerConfigMessage();
    //StoreDancerConfigMessage();
    if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
    {
        IDS_DispenserControlInit();

        for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
        {
            if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
                status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
            else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                    (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)
                status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
        }
    }
    else
    {
        LOG_ERROR (request->n_pidcontrols, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dispensers <= MAX_SYSTEM_DISPENSERS)
    {
        for (Dispenser_i = 0; Dispenser_i < request->n_dispensers ; Dispenser_i++)
            status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
    }
    else
    {
        LOG_ERROR (request->n_dispensers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_breaksensors == 1)
    {
        ThreadConfigBreakSensor(request->breaksensors[0]);
    }

    if(request->blowers[0]->enabled)
    {
        BlowerCfg.enabled = true;
        BlowerCfg.voltage = request->blowers[0]->voltage;
        BlowerCfg.heatingvoltage = request->blowers[0]->heatingvoltage;
    }
    else
    {
        BlowerCfg.enabled = false;
    }
    //from now on starting blower on INIT, so that the chiller does not freeze
    /*if (BlowerCfg.enabled == true)
    {
        Turn_the_Blower_On();//Turn on with the Default_Voltage
        if (BlowerCfg.heatingvoltage)
            Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
        else
            Control_Voltage_To_Blower(BlowerCfg.voltage-500);

    }*/

/*
    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
    {
        Enable_MidTank_Pressure_Reading(Dispenser_i);
        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
    }
    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
*/
    ControlStart();
    AlarmHandlingStart();
    //ThreadInitialTestStub(request);
    GeneralHwReady = true;

    return OK;
}
uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
{
    uint32_t status  = 0;
    MessageContainer responseContainer;
    UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;

    FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath);

    UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    GeneralHwReady = false;
    Control_WD(ENABLE,250);

    status = HWConfiguration(UploadRequest);

    responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size);
    if (status!= OK)
    {
        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
        responseContainer.errormessage = "JOb Active or incorrect parameters";
    }
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
    SendChars(container_buffer, container_size);

    return OK;


}

void HWSystemResetRequest(MessageContainer* requestContainer)
{
    //uint32_t status = FAILED;

    MessageContainer responseContainer;
    SystemResetRequest* request = system_reset_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    SystemResetResponse response =   SYSTEM_RESET_RESPONSE__INIT;


    responseContainer = createContainer(MESSAGE_TYPE__SystemResetResponse, requestContainer->token, true, &response, &system_reset_response__pack, &system_reset_response__get_packed_size);

    system_reset_request__free_unpacked(request,NULL);
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    SendChars((char*)container_buffer, container_size);

    ROM_SysCtlDelay(SYS_CLK_FREQ);

    SysCtlReset();

    HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY |  NVIC_APINT_SYSRESETREQ;

}