aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/Views/ChartsView.xaml.cs
blob: bd97ed2bc0d831161495e28d0f917cbd0632b27c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
using LiveCharts;
using LiveCharts.Wpf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Tango.MachineStudio.Statistics.Views
{
    /// <summary>
    /// Interaction logic for ChartsView.xaml
    /// </summary>
    public partial class ChartsView : UserControl
    {
        public ChartsView()
        {
            InitializeComponent();
        }
        private void PieChart_DataHover(object sender, ChartPoint chartPoint)
        {
            var tooltip = ((chartPoint.ChartView as PieChart).DataTooltip as Tooltips.PieChartTooltipControl).Title;
            txtPieTitle.Text = tooltip;
        }
        private void StartDatePicker_SelectedDateChanged(object sender, SelectionChangedEventArgs e)
        {
            DatePicker datePickerObj = sender as DatePicker;
            if (datePickerObj != null && datePickerObj.SelectedDate != null && endDatePicker.SelectedDate != null)
            {
                if (datePickerObj.SelectedDate > endDatePicker.SelectedDate)
                {
                    BindingExpression start_be = datePickerObj.GetBindingExpression(DatePicker.SelectedDateProperty);
                    ValidationError validationError = new ValidationError(StartDateExpiredRule, start_be);
                    validationError.ErrorContent = "The start time must be less than or equal to end time.";
                    Validation.MarkInvalid(start_be, validationError);
                }
                else if (Validation.GetHasError(endDatePicker))
                {
                    BindingExpression end_be = endDatePicker.GetBindingExpression(DatePicker.SelectedDateProperty);
                    Validation.ClearInvalid(end_be);
                }
            }
        }

        private void EndDatePicker_SelectedDateChanged(object sender, SelectionChangedEventArgs e)
        {
            DatePicker datePickerObj = sender as DatePicker;
            if (datePickerObj.SelectedDate != null && startdatePicker.SelectedDate != null)
            {
                if (datePickerObj != null && datePickerObj.SelectedDate < startdatePicker.SelectedDate)
                {
                    BindingExpression end_be = datePickerObj.GetBindingExpression(DatePicker.SelectedDateProperty);
                    ValidationError validationError = new ValidationError(EndDateExpiredRule, end_be);
                    validationError.ErrorContent = "The end time must be greater than or equal to the start time.";
                    Validation.MarkInvalid(end_be, validationError);
                }
                else if (Validation.GetHasError(startdatePicker))
                {
                    BindingExpression start_be = startdatePicker.GetBindingExpression(DatePicker.SelectedDateProperty);
                    Validation.ClearInvalid(start_be);
                }
            }
        }
    }
}
font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/************************************************************************************************************************
 * 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 "PMR/Printing/ProcessParameters.pb-c.h"
#include "PMR/Printing/UploadProcessParametersRequest.pb-c.h"
#include "PMR/Printing/UploadProcessParametersResponse.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"
#include "StateMachines/Initialization/PowerIdle.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.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";
void *HWConfigurationLoadFromFile( uint32_t *NumOfBytes)
{
    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;

    *NumOfBytes = 0;
    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");
                    free (buffer);
                    buffer = NULL;
                }
                else
                    *NumOfBytes = Bytes;
            }
        }
        f_close(FileHandle);
        free (FileHandle);
    }

    return buffer;
}

uint32_t HWConfigurationInit(void)
{
    void* buffer1 = NULL;
    uint32_t status = OK;
    UploadHardwareConfigurationRequest* UploadRequest=0;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;

    GeneralHwReady = false;
    Control_WD(ENABLE,250);

    memcpy(&Bytes,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(Bytes));

    if ((Bytes)&&(Bytes < 4000))
    {
        buffer1 = my_malloc (Bytes);
        if (buffer1)
        {
            memcpy(buffer1, (void *)(GENHWCFG_MAP_IN_FLASH+4),Bytes);
            UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer1);
        }
    }
    //buffer = HWConfigurationLoadFromFile(&Bytes);
    //status= memcmp(buffer,buffer1,Bytes);
    //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+4);
       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,Bytes);
       //ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
    }
    else
    {
        SetMachineState(MACHINE_STATE_HW_CONFIG_FAILED);
    }
    if (buffer)
        free (buffer);

    //EmbeddedParametersInit();
    IDS_Dispenser_Content_Init();
    //ProcessParamsInit();
    GeneralHwReady = true;
    STATUS_RED_LED_OFF;
    return status;
}

char EmbeddedParametersPath[50] = "0://SysInfo//EmbParam.cfg";
ConfigurationParameters *EmbeddedParameters;
bool DataUpdated = false;
void LoadConfigurationParameters(ConfigurationParameters *Params)
{
    if (Params == 0)
        {
            EmbeddedParameters = my_malloc(sizeof(ConfigurationParameters));
            configuration_parameters__init(EmbeddedParameters);
            EmbeddedParameters->breaksensorlimit = 10;
            EmbeddedParameters->has_diagnosticcollectionlimit = true;
            EmbeddedParameters->diagnosticcollectionlimit = 1;
            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 = 1.08;
            EmbeddedParameters->has_initialdispensertimeout = true;
            EmbeddedParameters->initialdispensertimeout = 60000;
            EmbeddedParameters->has_initialdispensertimelag = true;
            EmbeddedParameters->initialdispensertimelag = 100;
            EmbeddedParameters->has_dispenserbuildpressurespeed = true;
            EmbeddedParameters->dispenserbuildpressurespeed=500;
            EmbeddedParameters->has_dispenserbuildpressurelimit = true;
            EmbeddedParameters->dispenserbuildpressurelimit=0.8 ;
            EmbeddedParameters->has_dispenserbuildpressuretimeout = true;
            EmbeddedParameters->dispenserbuildpressuretimeout=60000;
            EmbeddedParameters->has_dispenserbuildpressurelag = true;
            EmbeddedParameters->dispenserbuildpressurelag=50;
            EmbeddedParameters->has_acheatersloweroperationlimit = true;
            EmbeddedParameters->acheatersloweroperationlimit = 980;
            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.0;
            EmbeddedParameters->has_dispenserpresegmentwfcf = true;
            EmbeddedParameters->dispenserpresegmentwfcf = 80;
            EmbeddedParameters->has_startheatingoninitsequence = true;
            EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
            EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
            if (EmbeddedParameters->generalparameters)
            {
                EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms
                EmbeddedParameters->generalparameters[1] = 0.0; //CheckCurrentAlarms
                EmbeddedParameters->generalparameters[2] = 0.0; //CheckTamperAlarms
                EmbeddedParameters->generalparameters[3] = 800.0; //Winder homing time at end of job
                //EmbeddedParameters->generalparameters[4] = 1.0; //Dispenser initial pressure limit
                //EmbeddedParameters->generalparameters[5] = 1.0; //Dispenser initial pressure speed
            }
            EmbeddedParameters->has_currentalarmlowlimit = true;
            EmbeddedParameters->currentalarmlowlimit = 0.80;
            EmbeddedParameters->has_currentalarmhighlimit = true;
            EmbeddedParameters->currentalarmhighlimit= 1.07;
            EmbeddedParameters->has_ids_segmentrefilltimeout = true;
            EmbeddedParameters->ids_segmentrefilltimeout = 5000;
            EmbeddedParameters->has_ids_presegmentbuilduptime = true;
            EmbeddedParameters->ids_presegmentbuilduptime = 5000;
            EmbeddedParameters->has_ids_cleaningspeed = true;
            EmbeddedParameters->ids_cleaningspeed = 50;
            EmbeddedParameters->has_ids_cleaningstopbeforesegmenttime = true;
            EmbeddedParameters->ids_cleaningstopbeforesegmenttime = 3000;
            EmbeddedParameters->has_ids_cleaningstartspraypresegmenttime = true;
            EmbeddedParameters->ids_cleaningstartspraypresegmenttime = 1000;
            EmbeddedParameters->has_ids_leftcleaningmotorspeed = true;
            EmbeddedParameters->ids_leftcleaningmotorspeed = 30;
            EmbeddedParameters->has_ids_rightcleaningmotorspeed = true;
            EmbeddedParameters->ids_rightcleaningmotorspeed = 23;
            EmbeddedParameters->has_switchtoidletimeinseconds = true;
            EmbeddedParameters->switchtoidletimeinseconds = 3600;
            EmbeddedParameters->has_idledriertemperature = true;
            EmbeddedParameters->idledriertemperature = 80;
            EmbeddedParameters->has_idleheadtemperature = true;
            EmbeddedParameters->idleheadtemperature = 80;
            EmbeddedParameters->has_idlemixertemperature = true;
            EmbeddedParameters->idlemixertemperature = 0;
            EmbeddedParameters->has_powerofftemperaturelimit = true;
            EmbeddedParameters->powerofftemperaturelimit = 50;
            EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
            EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 1500;
            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);
                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&response_size);
                ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, response_size, response_buffer);
                my_free(response_buffer);
            }
        }
        else
        {
            EmbeddedParameters = Params;
        }
}
uint32_t EmbeddedParametersInit(void)
{
    FRESULT Fresult = FR_OK;
    void* buffer = NULL;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params;

    memcpy(&Bytes,(void *)EMBEDDED_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));

    if ((Bytes)&&(Bytes < 1000))
    {
        Params = configuration_parameters__unpack(NULL, Bytes, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4));
        LoadConfigurationParameters(Params);
        Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
    }
    else
    {
        if (LoadConfigurationParamsFromFile()!=OK)
        {
            LoadConfigurationParameters(0);
            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
        }
        else
        {
            Report("LoadConfigurationParameters from file", __FILE__,__LINE__,EmbeddedParameters->closevalvetimeout, RpMessage, Fresult, 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);
    IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters->dispenserpresegmentwfcf,  EmbeddedParameters->ids_presegment_wfcf_timebeforesegment);
    IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters->ids_cleaningspeed,EmbeddedParameters->ids_cleaningstartspraypresegmenttime ,EmbeddedParameters->ids_cleaningstopbeforesegmenttime,EmbeddedParameters->ids_leftcleaningmotorspeed,EmbeddedParameters->ids_rightcleaningmotorspeed);

    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);
    PowerOffSetTemperatureThreshold(EmbeddedParameters->powerofftemperaturelimit);

    InitSequenceSetStartHeating (EmbeddedParameters->startheatingoninitsequence);
    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);

    PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);

    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())
    {
        LOG_ERROR(1,"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)
    {
        //for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
        status += MotorsConfigMessage(request);
    }
    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]);
            if (Check_Dispenser_Type(request->dispensers[Dispenser_i]->index) == LS_STATUS_ERROR)
            {
                LOG_ERROR (Dispenser_i, "Dispenser identification failed");
                //return ERROR;
            }
        }
    }
    else
    {
        LOG_ERROR (request->n_dispensers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    Init_Dispensers_IO_Registers(&Disp_IO_Reg);
    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 = true;
        BlowerCfg.voltage = 3000;
        BlowerCfg.heatingvoltage = 3000;
    }
    //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;
    STATUS_RED_LED_OFF;
    return OK;
}
uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
{
    uint32_t status  = 0;
    uint32_t DataLen  = 0;
    MessageContainer responseContainer;
    UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;

    EraseFlashSection(GENHWCFG_MAP_IN_FLASH,requestContainer->data.len+4);
    DataLen = requestContainer->data.len;
    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, requestContainer->data.len, requestContainer->data.data);

    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);

    GeneralHwReady = true;

    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;

}
uint32_t FlashInitResults[5] = {0,0,0,0,0};
uint32_t LoadConfigurationParamsFromFile(void)
{
    FRESULT Fresult = FR_OK;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params = NULL;

    Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
    if (Fresult == FR_OK)
    {
        Params = configuration_parameters__unpack(NULL, Bytes, buffer);
        LoadConfigurationParameters(Params);
        free (buffer);
        //configuration_parameters__free_unpacked(Params,NULL);
        FlashInitResults[1] = true;
        Report("Parameters Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
    }
    return Fresult;
}
void FlashInitAndLoad(void)
{
    FRESULT Fresult = FR_OK;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0;

    ConfigurationParameters *Params = NULL;
    ProcessParameters*  ProcessParams = NULL;
    UploadProcessParametersRequest* request = NULL;

    char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg";
#ifdef WATCHDOG
        ROM_WatchdogResetDisable(WATCHDOG0_BASE);
        uint32_t timeout = 0xFFFFFFFFU;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif

    FlashInit(); //initialize flash
    Report("Flash Initialized", __FILE__,__LINE__,FLASH_SIZE, RpMessage, FLASH_RAM_BASE, 0);

    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
    if (buffer)
    {
       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
       free (buffer);
       FlashInitResults[0] = true;
    }
    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);

    StoreDancerConfigMessage();
    Report("Dancer Initialized", __FILE__,DancersCfg[0].zeropoint,DancersCfg[1].zeropoint, RpMessage, DancersCfg[2].zeropoint, 0);
    Bytes = AlarmHandlingLoadFile();
    if (Bytes>0)
    {
        Report("Alarm Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
    }
    else
    {
        Bytes = AlarmHandlingFlashLoad();
        Report("Alarm Initialized hard coded", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
    }

    Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
    if (Fresult == FR_OK)
    {
        Params = configuration_parameters__unpack(NULL, Bytes, buffer);
        LoadConfigurationParameters(Params);
        //Bytes = sizeof(EmbeddedParameters);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
        ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
        free (buffer);
        //configuration_parameters__free_unpacked(Params,NULL);
        FlashInitResults[1] = true;
        Report("Parameters Initialized from file", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
    }
    else
    {
        LoadConfigurationParameters(0);
        FlashInitResults[1] = 2;
        Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
    }

    Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer);
    if (Fresult == FR_OK)
    {
        request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
        ProcessParams = request->processparameters;
        Bytes = sizeof(ProcessParams);
        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, &ProcessParams);
        upload_process_parameters_request__free_unpacked(request,NULL);
        FlashInitResults[2] = true;
        Report("Process Initialized", __FILE__,__LINE__,Bytes, RpMessage, (int)ProcessParams->dryerzone1temp, 0);
    }
    else
        Report("Process not Initialized", __FILE__,__LINE__,0, RpMessage, 0, 0);
#ifdef WATCHDOG
        ROM_WatchdogResetEnable(WATCHDOG0_BASE);
        timeout = 120000000*3;
        ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
#endif

}