/*
 * AlarmHandlingDiagnostics.c
 *
 *  Created on: 26 june 2018
 *      Author: shlomo
 */
#include <DataDef.h>
#include "include.h"
#include <driverlib/timer.h>
#include <inc/hw_ints.h>

#include "drivers/adc_sampling/adc.h"
#include "Control/control.h"

#include <Container.h>

#include "drivers/Motors/Motor.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/SSI_Comm/Dancer/Dancer.h"
#include <Drivers/SSI_Comm/SSI_Comm.h>
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/FPGA/FPGA.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
#include "drivers/I2C_Communication/DAC/Blower.h"
#include <Drivers/I2C_Communication/I2C_Task.h>
#include "drivers/valves/valve.h"

#include "modules/ids/ids_ex.h"
#include "Modules/Control/MillisecTask.h"
#include "Modules/General/GeneralHardware.h"
#include "Modules/AlarmHandling/AlarmHandling.h"
#include "Modules/heaters/heaters_ex.h"
#include "modules/thread/thread_ex.h"
#include "modules/waste/waste_ex.h"

#include "PMR/Hardware/HardwareDancerType.pb-c.h"
#include  <PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h>
#include  <PMR/Diagnostics/StartDiagnosticsResponse.pb-c.h>
#include  <PMR/Diagnostics/StopDiagnosticsRequest.pb-c.h>
#include  <PMR/Diagnostics/StopDiagnosticsResponse.pb-c.h>
#include  <PMR/Diagnostics/Event.pb-c.h>
#include  <PMR/Diagnostics/EventType.pb-c.h>
#include  <PMR/Diagnostics/DigitalInterfaceState.pb-c.h>
#include  <PMR/Diagnostics/InterfaceIOs.pb-c.h>
#include "PMR/Diagnostics/HeaterType.pb-c.h"
#include "PMR/Diagnostics/HeaterState.pb-c.h"
#include  <PMR/debugging/DebugLogCategory.pb-c.h>

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

#include <drivers/FPGA/FPGA_Comm.h>

#include "diagnostics.h"
#include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
#include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
#include "drivers/Uart_Comm/WHS_Controller_Comm/Shinko/ACS-13AC5E3.h"
#include "Modules/IFS/ifs.h"

extern F2_CTRL_REG F2_CTRL_Reg;

char DiagnosticsToken[36+1] = {0};
bool DiagnosticsActive = false;

void SendDiagnostics(void);
uint32_t DiagnosticsStart(void);
uint32_t DiagnosticsStop(void);

uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
uint32_t Diagnostics_OneMinControlTrigger(uint32_t IfIndex, uint32_t ReadValue);


DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
#define DIAGNOSTICS_LIMIT 3
#define DIAGNOSTICS_DANCER_LIMIT 30
int DiagnosticsIndex = 0;
int DiagnosticCollectionLimit = 1;  //number of data samples to collect before sending to the host
//int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
//int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
int DiagnosticLimit =eHundredMillisecond; //frequency of data collection

int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
//DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
double dancer1angle[DIAGNOSTICS_LIMIT+1];
double dancer2angle[DIAGNOSTICS_LIMIT+1];
double dancer3angle[DIAGNOSTICS_LIMIT+1];

double feedermotorfrequency[DIAGNOSTICS_LIMIT+1];
double dryermotor[DIAGNOSTICS_LIMIT+1];
double pollermotor[DIAGNOSTICS_LIMIT+1];
double windermotor[DIAGNOSTICS_LIMIT+1];
double screwmotor[DIAGNOSTICS_LIMIT+1];
double mixertemperature[DIAGNOSTICS_LIMIT+1];
/*double headzone1temperature[DIAGNOSTICS_LIMIT+1];
double headzone2temperature[DIAGNOSTICS_LIMIT+1];
double headzone3temperature[DIAGNOSTICS_LIMIT+1];
double headzone4temperature[DIAGNOSTICS_LIMIT+1];
double headzone5temperature[DIAGNOSTICS_LIMIT+1];
double headzone6temperature[DIAGNOSTICS_LIMIT+1];
double headzone7temperature[DIAGNOSTICS_LIMIT+1];
double headzone8temperature[DIAGNOSTICS_LIMIT+1];
double headzone9temperature[DIAGNOSTICS_LIMIT+1];
double headzone10temperature[DIAGNOSTICS_LIMIT+1];
double headzone11temperature[DIAGNOSTICS_LIMIT+1];
double headzone12temperature[DIAGNOSTICS_LIMIT+1];
double dryerzone1temperature[DIAGNOSTICS_LIMIT+1];
double dryerzone2temperature[DIAGNOSTICS_LIMIT+1];
double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];*/


double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
//double dispenserinklevel[MAX_SYSTEM_DISPENSERS][1];
//double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
double HeadFlowMeter,TotalFlowMeter;
//double tempFlow = 0.0;
double DrierFlowMeter;
double AcVoltage;
double WasteLevel = 0.0;
double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
double HeadCurrent[MAX_FLAT_HEAD_HEATERS][1];
double VOC_Sensor;
double OverallTemperature;

DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
//DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
//DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];

HeaterState **heatersstates;
HeaterState  HeaterInfo[HEATER_TYPE_MAX_HEATERS];

#define NUM_OF_INTERFACE_IOS 27
DigitalInterfaceState **digitalinterfacestates;
DigitalInterfaceState DigitalOutputState[NUM_OF_INTERFACE_IOS];
/*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser4motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser5motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser6motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser7motorfrequency[DIAGNOSTICS_LIMIT+1];
double dispenser8motorfrequency[DIAGNOSTICS_LIMIT+1];
*/
Task_Handle Diagnostics_Task_Handle;
Mailbox_Handle          DiagnosticsMsgQ = NULL;

extern uint8_t Head_Fan_PWM_Command[2] ;
bool blowervolatgedisplay = false;
bool midtankDisplay = false;
double diagvoltage = 0;
/******************** Functions  ********************************************/
//**********************************************************************
typedef enum
{
    DiagnosticsTrigger,
    DiagnosticsTenMiliTrigger,
    DiagnosticsOneSecTrigger,
    DiagnosticsOneMinuteTrigger
}DiagnosticsMessages;

typedef struct DiagnosticsMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint32_t tick;
    uint8_t messageData[20];
}DiagnosticsMessageStruc;

#define MAX_DIAG_LOG 100
int diag_index=0;
uint32_t diag_size[MAX_DIAG_LOG];
uint32_t diag_time[MAX_DIAG_LOG];

Diagnostic_Mode DiagnosticMode = Diagnostic_Normal_Mode;

uint32_t Diagnostis_Time_Stamp = 0;

/******************** CODE  ********************************************/
//**********************************************************************

void DiagnosticsInit(void)
{
    int i;
    Error_Block eb;

    Error_init(&eb);

    DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb);

    DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*MAX_SYSTEM_DISPENSERS);
    DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
    //DiagnosticsMonitor.midtanksinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
    //DiagnosticsMonitor.dispensersinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
    for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
    {
        double_array__init(&DispenserFreq[i]);
        double_array__init(&DiagnosticsDispenserPressure[i]);
        //double_array__init(&DiagnosticsMidTankInkLevel[i]);
        //double_array__init(&DispenserInkLevel[i]);
    }
    heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE_MAX_HEATERS));
    for(i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        heater_state__init(&HeaterInfo[i]);
        heatersstates[i] = &HeaterInfo[i];
    }
    digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*(NUM_OF_INTERFACE_IOS));
    for (i = 0;i<NUM_OF_INTERFACE_IOS;i++ )
    {
        digital_interface_state__init(&DigitalOutputState[i]);
        DigitalOutputState[i].has_interfaceio = true;
        DigitalOutputState[i].has_value = true;
        digitalinterfacestates[i] = &DigitalOutputState[i];
    }

    return;
}
/*typedef enum
{
    Diagnostic_Minimal_Mode,
    Diagnostic_Normal_Mode,
    Diagnostic_Extended_Mode,
    Diagnostic_Extreme_Mode
}Diagnostic_Mode;
if (DiagnosticMode == Diagnostic_Minimal_Mode)
if (DiagnosticMode == Diagnostic_Normal_Mode)
if (DiagnosticMode == Diagnostic_Extended_Mode)
if (DiagnosticMode == Diagnostic_Extreme_Mode)
*/
void SetDiagnosticMode(Diagnostic_Mode Mode)
{
    DiagnosticMode = Mode;
    REPORT_MSG(Mode,"Diagnostic Mode set");
}
Diagnostic_Mode GetDiagnosticMode(void)
{
    return DiagnosticMode;
}


uint32_t GetDiagnosticCollectionLimit(void)
{
    return (DiagnosticLimit*DiagnosticCollectionLimit);
}
/*void  SetDiagnosticCollectionLimit(int limit)
{
    if ((limit)&&(limit<= DIAGNOSTICS_LIMIT))
        DiagnosticCollectionLimit = limit;
    DiagnosticLimit =eHundredMillisecond; //frequency of data collection

    REPORT_MSG(DiagnosticCollectionLimit,"Diagnostic limit set");
}*/

uint8_t HeaterCounterIndex[HEATER_TYPE_MAX_HEATERS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
double HeaterTemperature[HEATER_TYPE_MAX_HEATERS][DIAGNOSTICS_LIMIT+1];
uint8_t  DancerCounterIndex[NUM_OF_DANCERS]= {0,0,0};
double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
int8_t  DancerErrorCounterIndex[NUM_OF_DANCERS]= {0,0,0};
double DancerErrorValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
uint8_t  MotorCounterIndex[MAX_THREAD_MOTORS_NUM]= {0,0,0};
double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT+1];
uint8_t  SpeedCounterIndex= 0;
double SpeedValue[DIAGNOSTICS_DANCER_LIMIT+1];
double headblowervoltage1 = 0.0, headblowervoltage2 = 0.0;
double headblower1airflow = 0.0, headblower2airflow = 0.0;

void DiagnosticLoadMotor(int MotorId, int frequency)
{
    if (MotorId >= MAX_THREAD_MOTORS_NUM)
    {
        ReportWithPackageFilter(DiagnosticsFilter,"wrong Motor Id",__FILE__,__LINE__,(int)MotorId,RpError,(int)0,0);
        return;
    }

    MotorValue[MotorId][MotorCounterIndex[MotorId]] = frequency;
    if (MotorCounterIndex[MotorId]<DIAGNOSTICS_LIMIT )
        MotorCounterIndex[MotorId]++;
}
uint32_t DiagnosticsLoadDigitalValues(void)
{
    uint32_t index = 0;
    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR3_CTRL;
    if(F2_CTRL_Reg.ushort & CLEANER_PUMP_SSR3_CTRL)
        DigitalOutputState[index++].value = true;
    else
        DigitalOutputState[index++].value = false;

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR1_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(1);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR2_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(2);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(3);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(4);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(5);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(6);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(7);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(8);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL;
    DigitalOutputState[index++].value = GetHeaterState(9);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR13_CTRL;
    DigitalOutputState[index++].value = ReadHeadMagnetBit();


    DigitalOutputState[index].interfaceio = INTERFACE_IOS__LS_DH_LID_OPEN;
    if(Head_Type == HEAD_TYPE_ARC)
        DigitalOutputState[index++].value = FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC);
    else
        DigitalOutputState[index++].value = FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID]);

    #ifdef USE_VOC_BUZZER_ALARM
        if (WHS_Type == WHS_TYPE_NEW)
        {
            DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_BUZZER;
            DigitalOutputState[index++].value = ReadingVocEverySec; // if true WHS_IsVocPpmOverAlarmLimit is true
        }
    #endif

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_FULL;
    DigitalOutputState[index++].value = WHS_IsContainerFull();

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_WARN;
    DigitalOutputState[index++].value = WHS_IsContainerEmpty();

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR12_CTRL; /*lubricant valve*/
    DigitalOutputState[index++].value = GetLubricantState();

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART1; /*Secondary Pump Active*/
    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_1);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART2; /*Secondary Pump Active*/
    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_2);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART3; /*Secondary Pump Active*/
    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_3);

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*Waste filling middle cartridge*/
    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_middle)==CartridgeStateACTIVE)?1:0;

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*Waste filling lower cartridge*/
    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_lower)==CartridgeStateACTIVE)?1:0;

    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_TFEED_BREAK_1; /*IFS MidTank Filling*/
    DigitalOutputState[index++].value = IFS_MidTankFilling();

    return index;
}
void DiagnosticLoadTemperature(int HeaterId, int temperature)
{
    double temp = temperature;
    if (HeaterId >= HEATER_TYPE_MAX_HEATERS)
    {
        ReportWithPackageFilter(DiagnosticsFilter,"wrong Heater Id",__FILE__,__LINE__,(int)HeaterId,RpError,(int)0,0);
        return;
    }
    /*if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
    {
        return;
    }*/
    HeaterTemperature[HeaterId][HeaterCounterIndex[HeaterId]] = temp/100;
    if (HeaterCounterIndex[HeaterId]<DIAGNOSTICS_LIMIT )
        HeaterCounterIndex[HeaterId]++;
}
void DiagnosticLoadSpeedSensor(float value)
{
    SpeedValue[SpeedCounterIndex] = (double)(value);
    if (SpeedCounterIndex<DIAGNOSTICS_DANCER_LIMIT )
        SpeedCounterIndex++;
    //if (SpeedCounterIndex>=DIAGNOSTICS_DANCER_LIMIT )
    //    SpeedCounterIndex = 0;
}

void DiagnosticLoadDancer(int DancerId, uint16_t value)
{
    if (DancerId >= NUM_OF_DANCERS)
    {
        ReportWithPackageFilter(DiagnosticsFilter,"wrong Dancer Id",__FILE__,__LINE__,(int)DancerId,RpError,(int)0,0);
        return;
    }
    DancerValue[DancerId][DancerCounterIndex[DancerId]] = value;
    if (DancerCounterIndex[DancerId]<DIAGNOSTICS_DANCER_LIMIT )
        DancerCounterIndex[DancerId]++;
    //if (DancerCounterIndex[DancerId]>=DIAGNOSTICS_DANCER_LIMIT )
    //    DancerCounterIndex[DancerId] = 0;
}
void DiagnosticLoadDancerError(int DancerId, double value)
{
    if (DancerId >= NUM_OF_DANCERS)
    {
        ReportWithPackageFilter(DiagnosticsFilter,"wrong Dancer Id",__FILE__,__LINE__,(int)DancerId,RpError,(int)0,0);
        return;
    }
    DancerErrorValue[DancerId][DancerErrorCounterIndex[DancerId]] = value;
    if (DancerErrorCounterIndex[DancerId]<DIAGNOSTICS_DANCER_LIMIT )
        DancerErrorCounterIndex[DancerId]++;
    //if (DancerErrorCounterIndex[DancerId]>=DIAGNOSTICS_DANCER_LIMIT )
    //    DancerErrorCounterIndex[DancerId] = 0;

}
double Shinko_Sv = 12,Shinko_Pv = 15;
void LoadChillerState(HeaterType HeaterType,HeaterState *HeaterState)
{
    //int HeaterId = HeaterType;
    HeaterState->has_heatertype = true;
    HeaterState->heatertype = HeaterType;
    HeaterState->has_setpoint = true;
    HeaterState->setpoint = (float)(ShinkoTempDeg.Read_Setup);
    HeaterState->has_currentvalue = true;
    HeaterState->currentvalue = (float)(ShinkoTempDeg.Read_value);
    HeaterState->has_isactive = true;
    HeaterState->isactive = false;
    HeaterState->has_isrampingup = true;
    HeaterState->isrampingup = false;
    HeaterState->has_isinsetpoint = true;
    HeaterState->isinsetpoint = true;

    return;
}

#ifdef FOUR_WINDERS
    double dancer2,dancer3,dancer4;
#endif
void CopyTemperaturesToMonitor(void)
{
    DiagnosticsMonitor.mixertemperature =
            HeaterTemperature[HEATER_TYPE__MixerHeater];
    DiagnosticsMonitor.headzone1temperature =
            HeaterTemperature[HEATER_TYPE__HeaterZone1];
    DiagnosticsMonitor.headzone2temperature =
            HeaterTemperature[HEATER_TYPE__HeaterZone2];
    DiagnosticsMonitor.headzone3temperature =
            HeaterTemperature[HEATER_TYPE__HeaterZone3];
    DiagnosticsMonitor.n_mixertemperature =
            HeaterCounterIndex[HEATER_TYPE__MixerHeater];
    DiagnosticsMonitor.n_headzone1temperature =
            HeaterCounterIndex[HEATER_TYPE__HeaterZone1];
    DiagnosticsMonitor.n_headzone2temperature =
            HeaterCounterIndex[HEATER_TYPE__HeaterZone2];
    DiagnosticsMonitor.n_headzone3temperature =
            HeaterCounterIndex[HEATER_TYPE__HeaterZone3];
    if ((Head_Type == HEAD_TYPE_FLAT)
            || (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
    {
        DiagnosticsMonitor.headzone4temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone4];
        DiagnosticsMonitor.headzone5temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone5];
        DiagnosticsMonitor.headzone6temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone6];
        DiagnosticsMonitor.n_headzone4temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
        DiagnosticsMonitor.n_headzone5temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
        DiagnosticsMonitor.n_headzone6temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
    }
    if (Head_Type == HEAD_TYPE_FLAT)
    {
        DiagnosticsMonitor.headzone7temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone7];
        DiagnosticsMonitor.headzone8temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone8];
        DiagnosticsMonitor.headzone9temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone9];
        DiagnosticsMonitor.headzone10temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone10];
        DiagnosticsMonitor.headzone11temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone11];
        DiagnosticsMonitor.headzone12temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone12];
        DiagnosticsMonitor.n_headzone7temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
        DiagnosticsMonitor.n_headzone8temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
        DiagnosticsMonitor.n_headzone9temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
        DiagnosticsMonitor.n_headzone10temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
        DiagnosticsMonitor.n_headzone11temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
        DiagnosticsMonitor.n_headzone12temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
        //temporary
        DiagnosticsMonitor.headcoverheater1temperature =
                HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
        DiagnosticsMonitor.headcoverheater2temperature =
                HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
        DiagnosticsMonitor.n_headcoverheater1temperature =
                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
        DiagnosticsMonitor.n_headcoverheater2temperature =
                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
    }
    //if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
    if (Head_Type == HEAD_TYPE_ARC)
    {
        DiagnosticsMonitor.headcoverheater1temperature =
                HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
        DiagnosticsMonitor.headcoverheater2temperature =
                HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
        DiagnosticsMonitor.n_headcoverheater1temperature =
                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
        DiagnosticsMonitor.n_headcoverheater2temperature =
                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
        DiagnosticsMonitor.headzone11temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone11];
        DiagnosticsMonitor.headzone12temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone12];
        DiagnosticsMonitor.n_headzone11temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
        DiagnosticsMonitor.n_headzone12temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone12];

        DiagnosticsMonitor.n_headblower1airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
        DiagnosticsMonitor.n_headblower2airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
        headblower1airflow = PressureSensorGetPressure(HEAD_FAN_RIGHT);
        headblower2airflow = PressureSensorGetPressure(HEAD_FAN_LEFT);
        DiagnosticsMonitor.headblower1airflow = &headblower1airflow;
        DiagnosticsMonitor.headblower2airflow = &headblower2airflow;

        DiagnosticsMonitor.n_headblowervoltage1 = 1;
        DiagnosticsMonitor.n_headblowervoltage2 = 1;
        headblowervoltage1 = HeadBlowersGetRPM(HEAD_FAN_RIGHT);
        headblowervoltage2 = HeadBlowersGetRPM(HEAD_FAN_LEFT);
        DiagnosticsMonitor.headblowervoltage1 = &headblowervoltage1;
        DiagnosticsMonitor.headblowervoltage2 = &headblowervoltage2;
//#warning machine to machine test
        DiagnosticsMonitor.headzone4temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone4];
        DiagnosticsMonitor.headzone9temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone9];
        DiagnosticsMonitor.headzone10temperature =
                HeaterTemperature[HEATER_TYPE__HeaterZone10];
        DiagnosticsMonitor.n_headzone4temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
        DiagnosticsMonitor.n_headzone9temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
        DiagnosticsMonitor.n_headzone10temperature =
                HeaterCounterIndex[HEATER_TYPE__HeaterZone10];

    }
#ifdef FOUR_WINDERS
//    double dancer2,dancer3,dancer4;
    dancer2 = Control_Read_Dancer_Position(HARDWARE_DANCER_2,0);
    dancer3 = Control_Read_Dancer_Position(HARDWARE_DANCER_3,0);
    dancer4 = Control_Read_Dancer_Position(HARDWARE_DANCER_4,0);
    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
    DiagnosticsMonitor.n_headzone56heatercurrent = 1;
    DiagnosticsMonitor.n_headzone8heatercurrent = 1;
    DiagnosticsMonitor.headzone4heatercurrent = &dancer4;
    DiagnosticsMonitor.headzone56heatercurrent = &dancer3;
    DiagnosticsMonitor.headzone8heatercurrent = &dancer2;
#endif

    DiagnosticsMonitor.dryerzone1temperature =
            HeaterTemperature[HEATER_TYPE__DryerAirHeater];
    DiagnosticsMonitor.dryerzone2temperature =
            HeaterTemperature[HEATER_TYPE__DryerMainHeater];
    DiagnosticsMonitor.dryerzone3temperature =
            HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
    DiagnosticsMonitor.n_dryerzone1temperature =
            HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
    DiagnosticsMonitor.n_dryerzone2temperature =
            HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
    DiagnosticsMonitor.n_dryerzone3temperature =
            HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
}
void CopyPressuresToMonitor(int count)
{
    DiagnosticsMonitor.n_dispenser1pressure = count;
    DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
    DiagnosticsMonitor.n_dispenser2pressure = count;
    DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
    DiagnosticsMonitor.n_dispenser3pressure = count;
    DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
    DiagnosticsMonitor.n_dispenser4pressure = count;
    DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
    DiagnosticsMonitor.n_dispenser5pressure = count;
    DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
    DiagnosticsMonitor.n_dispenser6pressure = count;
    DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
    DiagnosticsMonitor.n_dispenser7pressure = count;
    DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
    DiagnosticsMonitor.n_dispenser8pressure = count;
    DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
}
void DiagnosticTenMsecCollection(void)
{
    if (DiagnosticsActive == false)
        return;
    /*if (JobIsActive()== false)
        return;*/

    DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0));
    DiagnosticLoadDancer(POOLER_DANCER,Control_Read_Dancer_Position(POOLER_DANCER, 0));
    DiagnosticLoadDancer(FEEDER_DANCER,Control_Read_Dancer_Position(FEEDER_DANCER, 0));

    DiagnosticLoadDancerError(WINDER_DANCER,ThreadGetMotorCalculatedError(WINDER_DANCER));
    DiagnosticLoadDancerError(POOLER_DANCER,ThreadGetMotorCalculatedError(POOLER_DANCER));
    DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));

    DiagnosticLoadSpeedSensor(getSensorSpeedData());
}
void DiagnosticOneMinuteCollection(void)
{
    int i;

    DiagnosticsMonitor.n_dispensersinklevel = 0;
    DiagnosticsMonitor.n_midtanksinklevel = 0;
    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
    {
        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
        //dispenserinklevel[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
        //midtankinklevel[i][0] = Get_MidTank_Pressure_Sensor(i);
        /*if (DiagnosticsMonitor.dispensersinklevel)
        {
            DiagnosticsMonitor.n_dispensersinklevel = MAX_SYSTEM_DISPENSERS;
            //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
            //double_array__init(&DiagnosticsDispenserPressure[i]);
            DispenserInkLevel[i].data = dispenserinklevel[i];
            DispenserInkLevel[i].n_data = 1;
            DiagnosticsMonitor.dispensersinklevel[i] = &DispenserInkLevel[i];
        }*/
        /*if (DiagnosticsMonitor.midtanksinklevel)
        {
            DiagnosticsMonitor.n_midtanksinklevel = MAX_SYSTEM_DISPENSERS;
            //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
            //double_array__init(&DiagnosticsDispenserPressure[i]);
            DiagnosticsMidTankInkLevel[i].data = midtankinklevel[i];
            DiagnosticsMidTankInkLevel[i].n_data = 1;
            DiagnosticsMonitor.midtanksinklevel[i] = &DiagnosticsMidTankInkLevel[i];
        }*/

    }
    DiagnosticsMonitor.n_overalltemperature = 1;
    OverallTemperature = (max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)));
    OverallTemperature = (double)OverallTemperature/100.0;
    //OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
    DiagnosticsMonitor.overalltemperature = &OverallTemperature;

    DiagnosticsMonitor.n_midtank1level = 1;
    DiagnosticsMonitor.midtank1level = MidTankpressure[0];
    DiagnosticsMonitor.n_midtank2level = 1;
    DiagnosticsMonitor.midtank2level = MidTankpressure[1];
    DiagnosticsMonitor.n_midtank3level = 1;
    DiagnosticsMonitor.midtank3level = MidTankpressure[2];
    DiagnosticsMonitor.n_midtank4level = 1;
    DiagnosticsMonitor.midtank4level = MidTankpressure[3];
    DiagnosticsMonitor.n_midtank5level = 1;
    DiagnosticsMonitor.midtank5level = MidTankpressure[4];
    DiagnosticsMonitor.n_midtank6level = 1;
    DiagnosticsMonitor.midtank6level = MidTankpressure[5];
    DiagnosticsMonitor.n_midtank7level = 1;
    DiagnosticsMonitor.midtank7level = MidTankpressure[6];
    DiagnosticsMonitor.n_midtank8level = 1;
    DiagnosticsMonitor.midtank8level = MidTankpressure[7];
    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
    {
        /*DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
        DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
        DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
        DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];*/
        Get_Head_Current(HEAD_CURRENT_MIXER,&HeadCurrent[HEAD_CURRENT_ZONE_12+1][0]);
        DiagnosticsMonitor.n_mixer1heatercurrent = 1;
        DiagnosticsMonitor.mixer1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12+1];
        if (Head_Type == HEAD_TYPE_FLAT)
        {
            for (i=0;i<HEAD_CURRENT_ZONE_12;i++)
            {
                if (Get_Head_Heater_Current_Reading_State(i) == true)
                {
                    Get_Head_Current(i,&HeadCurrent[i][0]);
                    switch(i)
                    {
                    case HEAD_CURRENT_ZONE_1:
                        DiagnosticsMonitor.n_headzone1heatercurrent = 1;
                        DiagnosticsMonitor.headzone1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_1];
                        break;
                    case HEAD_CURRENT_ZONE_2:
                        DiagnosticsMonitor.n_headzone2heatercurrent = 1;
                        DiagnosticsMonitor.headzone2heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_2];
                        break;
                    case HEAD_CURRENT_ZONE_3:
                        DiagnosticsMonitor.n_headzone3heatercurrent = 1;
                        DiagnosticsMonitor.headzone3heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_3];
                        break;
                    case HEAD_CURRENT_ZONE_4:
                        DiagnosticsMonitor.n_headzone4heatercurrent = 1;
                        DiagnosticsMonitor.headzone4heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_4];
                        break;
                    case HEAD_CURRENT_ZONE_5:
                        DiagnosticsMonitor.n_headzone56heatercurrent = 1;
                        DiagnosticsMonitor.headzone56heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_5];
                        break;
/*                    case HEAD_CURRENT_ZONE_6:
                        DiagnosticsMonitor.n_headzone6heatercurrent = 1;
                        DiagnosticsMonitor.headzone6heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_6];
                        break;*/
                    case HEAD_CURRENT_ZONE_7:
                        DiagnosticsMonitor.n_headzone7heatercurrent = 1;
                        DiagnosticsMonitor.headzone7heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_7];
                        break;
                    case HEAD_CURRENT_ZONE_8:
                        DiagnosticsMonitor.n_headzone8heatercurrent = 1;
                        DiagnosticsMonitor.headzone8heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_8];
                        break;
                    case HEAD_CURRENT_ZONE_9:
                        DiagnosticsMonitor.n_headzone9heatercurrent = 1;
                        DiagnosticsMonitor.headzone9heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_9];
                        break;
                    case HEAD_CURRENT_ZONE_10:
                        DiagnosticsMonitor.n_headzone10heatercurrent = 1;
                        DiagnosticsMonitor.headzone10heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_10];
                        break;
                    case HEAD_CURRENT_ZONE_11:
                        DiagnosticsMonitor.n_headzone11heatercurrent = 1;
                        DiagnosticsMonitor.headzone11heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_11];
                        break;
                    case HEAD_CURRENT_ZONE_12:
                        DiagnosticsMonitor.n_headzone12heatercurrent = 1;
                        DiagnosticsMonitor.headzone12heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12];
                        break;
                    default:
                        break;
                    }
                }
            }
        }
        else //arc head
        {
            i = 0;
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_1) == true)
            {
                Get_Head_Current(HEAD_CURRENT_ZONE_1,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone1heatercurrent = 1;
                DiagnosticsMonitor.headzone1heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_2) == true)
            {
                Get_Head_Current(HEAD_CURRENT_ZONE_2,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone2heatercurrent = 1;
                DiagnosticsMonitor.headzone2heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_3) == true)
            {
                Get_Head_Current(HEAD_CURRENT_ZONE_3,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone3heatercurrent = 1;
                DiagnosticsMonitor.headzone3heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_4) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTIN_1,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headcoverheater1current= 1;
                DiagnosticsMonitor.headcoverheater1current = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_5) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTOT_1,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headcoverheater2current = 1;
                DiagnosticsMonitor.headcoverheater2current = HeadCurrent[i];
                i++;
            }
            /*if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTIN_2,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone7heatercurrent = 1;
                DiagnosticsMonitor.headzone7heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTIN_3,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone8heatercurrent = 1;
                DiagnosticsMonitor.headzone8heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTIN_4,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone9heatercurrent = 1;
                DiagnosticsMonitor.headzone9heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_2) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTOT_2,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone10heatercurrent = 1;
                DiagnosticsMonitor.headzone10heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_3) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTOT_3,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone11heatercurrent = 1;
                DiagnosticsMonitor.headzone11heatercurrent = HeadCurrent[i];
                i++;
            }
            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_4) == true)
            {
                Get_Head_Current(HEAD_CURRENT_HTOT_4,&HeadCurrent[i][0]);
                DiagnosticsMonitor.n_headzone12heatercurrent = 1;
                DiagnosticsMonitor.headzone12heatercurrent = HeadCurrent[i];
                i++;
            }*/
        }

    }
    else
    {
        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
        {
            if (Get_Heater_Current_Reading_State(i) == true)
            {
                HeatersCurrent[i][0] = Get_Heaters_Current(i);
                switch(i)
                {
                case HEATER_DRYER_CURRENT_1:
                    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
                    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
                    break;
                case HEATER_DRYER_CURRENT_2:
                    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
                    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
                    break;
                case HEATER_MIXCHIP_CURRENT:
                    DiagnosticsMonitor.n_mixer1heatercurrent = 1;
                    DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
                    break;
                case HEATER_HEAD_CURRENT_ZONE_1:
                    DiagnosticsMonitor.n_headzone1heatercurrent = 1;
                    DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
                    break;
                case HEATER_HEAD_CURRENT_ZONE_2:
                    DiagnosticsMonitor.n_headzone2heatercurrent = 1;
                    DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
                    break;
                case HEATER_HEAD_CURRENT_ZONE_3:
                    DiagnosticsMonitor.n_headzone3heatercurrent = 1;
                    DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
                    break;
                case HEATER_HEAD_CURRENT_ZONE_4:
                    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
                    DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
                    break;
                case HEATER_HEAD_CURRENT_ZONE_5_6:
                    DiagnosticsMonitor.n_headzone56heatercurrent = 1;
                    DiagnosticsMonitor.headzone56heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
                    break;
                default:
                    break;
                }
            }
        }

    }
    DiagnosticsMonitor.n_blowervoltage = 1;
    diagvoltage = getBlowerState();
    DiagnosticsMonitor.blowervoltage = &diagvoltage;

    DrierFlowMeter = GetWHSAirFlow(DRIER_FLOW_METER);
    DiagnosticsMonitor.n_dryerairflow = 1;
    DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;

    HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
    /*if (fabs(tempFlow - HeadFlowMeter)>0.05)
    {
        Report("Head flow change 1m",__FILE__,(int)diagvoltage,(int)(tempFlow*1000),RpWarning,(int)(HeadFlowMeter*1000),0);
        tempFlow = HeadFlowMeter;
    }*/
    DiagnosticsMonitor.n_headairflow = 1;
    DiagnosticsMonitor.headairflow = &HeadFlowMeter;

}
void DiaglosticChangeBlowerData()
{
    DiagnosticsMonitor.n_blowervoltage = 1;
    diagvoltage = getBlowerState();
    DiagnosticsMonitor.blowervoltage = &diagvoltage;
}


void DiagnosticOneSecCollection(void)
{
    int i;
    memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));

    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
    {
        AcVoltage = ReadVAC();
        //DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
        //DiagnosticsMonitor.n_whsblower2voltage = 1;
        DiagnosticsMonitor.incomingvoltage = &AcVoltage;
        DiagnosticsMonitor.n_incomingvoltage = 1;
    }
    if (WHS_Type == WHS_TYPE_NEW) //rapid/pp machines
    {
        DrierFlowMeter = GetWHSAirFlow(DRIER_FLOW_METER);
        DiagnosticsMonitor.n_dryerairflow = 1;
        DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;

        HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
        DiagnosticsMonitor.n_headairflow = 1;
        DiagnosticsMonitor.headairflow = &HeadFlowMeter;

        TotalFlowMeter = GetWHSAirFlow(NU_FLOW_METER);
        DiagnosticsMonitor.n_totalwhsflow = 1;
        DiagnosticsMonitor.totalwhsflow = &TotalFlowMeter;

        /*if (fabs(tempFlow - HeadFlowMeter)>0.25)
        {
            Report("Head flow change 1s",__FILE__,(int)diagvoltage,(int)(tempFlow*1000),RpWarning,(int)(HeadFlowMeter*1000),0);
            tempFlow = HeadFlowMeter;
        }*/
        WasteLevel = GetWHSWasteTankLevelMiliLiter()/1000;//change from ml to litter
        static double InitCounter = 85.0;
        if (GetMachineState()<=MACHINE_STATE_WAIT_FOR_COOLER)
        {
            InitCounter-=1.0;
            if(InitCounter<0)InitCounter = 0;
        }
        else
        {
            InitCounter =  ShinkoTempDeg.Read_value;
        }
        DiagnosticsMonitor.chillertemperature = &InitCounter;
        DiagnosticsMonitor.n_chillertemperature = 1;
        DiagnosticsMonitor.n_wastelevel = 1;
        DiagnosticsMonitor.wastelevel = &WasteLevel;
   }
    HeatersCurrent[HEATER_DRYER_CURRENT_1][0] = Get_Heaters_Current(HEATER_DRYER_CURRENT_1);
    HeatersCurrent[HEATER_DRYER_CURRENT_2][0] = Get_Heaters_Current(HEATER_DRYER_CURRENT_2);
    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];

    if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
    {
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
    }
    if (Head_Type == HEAD_TYPE_FLAT)
    {
        DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));

        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
    }
    if (Head_Type == HEAD_TYPE_ARC)
    {
        DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
        
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
        //DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
        //DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
#warning MACHINE TO MACHINE TEST
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));

    }
    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
    {
        dispensermotorfrequency[i][0] = IdsGetMotorSpeed(i);
        if (DiagnosticMode < Diagnostic_Extended_Mode)
            dispenserspressure[i][0] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
    }
    //if (DiagnosticMode < Diagnostic_Extended_Mode)
    CopyTemperaturesToMonitor();

    if (DiagnosticMode < Diagnostic_Extended_Mode)
    {
        CopyPressuresToMonitor(1);
    }

}
void Diagnostic100msecCollection(void)
{
    int i;
    if (DiagnosticsActive == false)
        return;

    //DiagnosticLoadSpeedSensor(getSensorSpeedData());
    if (DiagnosticMode != Diagnostic_Extreme_Mode)
        DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport

    if (DiagnosticMode >= Diagnostic_Extended_Mode)
    {
        //if (JobIsActive())
        {
#ifdef FOUR_WINDERS
            DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (WINDER_2_MOTOR));
            DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (WINDER_3_MOTOR));
            DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (WINDER_4_MOTOR));
            DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
            DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
#else
            DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
            DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
            DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
            DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
            DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
#endif
        }
        for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
        {
            dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
        }
    }

   /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
     dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
     dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
     dispenser4motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4);
     dispenser5motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5);
     dispenser6motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6);
     dispenser7motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7);
     dispenser8motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8);
*/
    if (DiagnosticsIndex < DIAGNOSTICS_LIMIT)
        DiagnosticsIndex++;
    if (DiagnosticsIndex >= DiagnosticCollectionLimit)
        SendDiagnostics();

}
void DiagnosticsReset(void)
{
    memset(DancerCounterIndex,0,sizeof(DancerCounterIndex));
    memset(MotorCounterIndex,0,sizeof(MotorCounterIndex));
    memset(DancerErrorCounterIndex,0,sizeof(DancerErrorCounterIndex));
    SpeedCounterIndex = 0;
    DiagnosticsIndex = 0;
    DiagnosticsMonitor.n_dancer1angle =  0;
    DiagnosticsMonitor.n_dancer2angle =  0;
    DiagnosticsMonitor.n_dancer3angle =  0;
    DiagnosticsMonitor.n_windertension =  0;
    DiagnosticsMonitor.n_pullertension =  0;
    DiagnosticsMonitor.n_feedertension =  0;

}
int j=0;
MessageContainer diagnosticsresponseContainer;
uint8_t diagnostics_response_buffer[5500];
uint8_t *diagnostics_response_ptr = diagnostics_response_buffer;
char * diagnosticscontainer_buffer=0;
int LargeMessagesD = 0;


void SendDiagnostics(void)
{
    //MessageContainer responseContainer;
    StartDiagnosticsResponse response = START_DIAGNOSTICS_RESPONSE__INIT;
    //int i;
    int chillerHeaterId = 0;

    if (DiagnosticsActive == false)
    {
        DiagnosticsReset();
        return;
    }
    if (SuspendLargeMessages == true)
    {
        LargeMessagesD++;
        DiagnosticsReset();
        return;
    }


    //if (JobIsActive())
    {
        DiagnosticsMonitor.n_dispenser1motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser2motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser3motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser4motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser5motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser6motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser7motorfrequency = 1;
        DiagnosticsMonitor.n_dispenser8motorfrequency = 1;
        DiagnosticsMonitor.dispenser1motorfrequency =   dispensermotorfrequency[0];
        DiagnosticsMonitor.dispenser2motorfrequency =   dispensermotorfrequency[1];
        DiagnosticsMonitor.dispenser3motorfrequency =   dispensermotorfrequency[2];
        DiagnosticsMonitor.dispenser4motorfrequency =   dispensermotorfrequency[3];
        DiagnosticsMonitor.dispenser5motorfrequency =   dispensermotorfrequency[4];
        DiagnosticsMonitor.dispenser6motorfrequency =   dispensermotorfrequency[5];
        DiagnosticsMonitor.dispenser7motorfrequency =   dispensermotorfrequency[6];
        DiagnosticsMonitor.dispenser8motorfrequency =   dispensermotorfrequency[7];
    }
/*
    DiagnosticsMonitor.n_dancer1angle =  DiagnosticsIndex;
    DiagnosticsMonitor.n_dancer2angle =  DiagnosticsIndex;
    DiagnosticsMonitor.n_dancer3angle =  DiagnosticsIndex;
    DiagnosticsMonitor.dancer1angle = dancer1angle;
    DiagnosticsMonitor.dancer2angle = dancer2angle;
    DiagnosticsMonitor.dancer3angle = dancer3angle;
*/
//    if ((JobIsActive())&&(DiagnosticMode >= Diagnostic_Extended_Mode))
    if (DiagnosticMode >= Diagnostic_Extended_Mode)
    {
        DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
        DiagnosticsMonitor.n_dancer2angle =  DancerCounterIndex[1];
        DiagnosticsMonitor.n_dancer3angle =  DancerCounterIndex[2];
        DiagnosticsMonitor.dancer1angle = DancerValue[0];
        DiagnosticsMonitor.dancer2angle = DancerValue[1];
        DiagnosticsMonitor.dancer3angle = DancerValue[2];
        DiagnosticsMonitor.n_windertension =  DancerErrorCounterIndex[0];
        DiagnosticsMonitor.n_pullertension =  DancerErrorCounterIndex[1];
        DiagnosticsMonitor.n_feedertension =  DancerErrorCounterIndex[2];
        DiagnosticsMonitor.windertension = DancerErrorValue[0];
        DiagnosticsMonitor.pullertension = DancerErrorValue[1];
        DiagnosticsMonitor.feedertension = DancerErrorValue[2];
        //DiagnosticsMonitor.n_threadspeed = SpeedCounterIndex;
        //DiagnosticsMonitor.threadspeed = SpeedValue;


        DiagnosticsMonitor.feedermotorfrequency = MotorValue[FEEDER_MOTOR];
        DiagnosticsMonitor.dryermotor = MotorValue[DRYER_MOTOR];
        DiagnosticsMonitor.pollermotor = MotorValue[POOLER_MOTOR];
        DiagnosticsMonitor.windermotor = MotorValue[WINDER_MOTOR];
        DiagnosticsMonitor.screwmotor = MotorValue[SCREW_MOTOR];
        DiagnosticsMonitor.n_feedermotorfrequency =  MotorCounterIndex[FEEDER_MOTOR];
        DiagnosticsMonitor.n_dryermotor =  MotorCounterIndex[DRYER_MOTOR];
        DiagnosticsMonitor.n_pollermotor =  MotorCounterIndex[POOLER_MOTOR];
        DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
        DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
    }
    int i,temp;
    DiagnosticsMonitor.n_dispensersmotorsfrequency = 0;
    /**/
	//if (JobIsActive())
    {
        j++;
        DiagnosticsMonitor.n_dispensersmotorsfrequency = MAX_SYSTEM_DISPENSERS;
        if (DiagnosticsMonitor.dispensersmotorsfrequency)
        {
            for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
            {
                //double_array__init(&DispenserFreq[i]);
                //DispenserFreq[i] = dispensermotorfrequency[i];
                DispenserFreq[i].data = dispensermotorfrequency[i];
                DispenserFreq[i].n_data = 1;
                DiagnosticsMonitor.dispensersmotorsfrequency[i] = &DispenserFreq[i];
            }
        }
    }
    /**/
    if (DiagnosticMode < Diagnostic_Extended_Mode)
        temp = 1;
    else
        temp = DiagnosticsIndex;
    DiagnosticsMonitor.n_dispenserspressure = 0;
    /**/
	DiagnosticsMonitor.n_dispenserspressure = MAX_SYSTEM_DISPENSERS;
    if (DiagnosticsMonitor.dispenserspressure)
    {
        for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
        {
            //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
            //double_array__init(&DiagnosticsDispenserPressure[i]);
            DiagnosticsDispenserPressure[i].data = dispenserspressure[i];
            DiagnosticsDispenserPressure[i].n_data = temp;
            DiagnosticsMonitor.dispenserspressure[i] = &DiagnosticsDispenserPressure[i];
        }
    }
    /**/
    DiagnosticsMonitor.n_dispenserslinearpositions = 0;
    DiagnosticsMonitor.n_dispensersangularencoders = 0;

    /*if (DiagnosticMode >= Diagnostic_Extended_Mode)
    {
        CopyTemperaturesToMonitor();
    }*/
    if (DiagnosticMode >= Diagnostic_Extended_Mode)
    {
        CopyPressuresToMonitor(temp);
    }

    DiagnosticsMonitor.n_midtank1level = 1;
    DiagnosticsMonitor.midtank1level = MidTankpressure[0];
    DiagnosticsMonitor.n_midtank2level = 1;
    DiagnosticsMonitor.midtank2level = MidTankpressure[1];
    DiagnosticsMonitor.n_midtank3level = 1;
    DiagnosticsMonitor.midtank3level = MidTankpressure[2];
    DiagnosticsMonitor.n_midtank4level = 1;
    DiagnosticsMonitor.midtank4level = MidTankpressure[3];
    DiagnosticsMonitor.n_midtank5level = 1;
    DiagnosticsMonitor.midtank5level = MidTankpressure[4];
    DiagnosticsMonitor.n_midtank6level = 1;
    DiagnosticsMonitor.midtank6level = MidTankpressure[5];
    DiagnosticsMonitor.n_midtank7level = 1;
    DiagnosticsMonitor.midtank7level = MidTankpressure[6];
    DiagnosticsMonitor.n_midtank8level = 1;
    DiagnosticsMonitor.midtank8level = MidTankpressure[7];

/*    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
    DiagnosticsMonitor.n_mixer1heatercurrent = 1;
    DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
    DiagnosticsMonitor.n_headzone1heatercurrent = 1;
    DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
    DiagnosticsMonitor.n_headzone2heatercurrent = 1;
    DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
    DiagnosticsMonitor.n_headzone3heatercurrent = 1;
    DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
    DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
    DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
    DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
*/
    VOC_Sensor = (double) Get_latest_Gas_Sensor_PPM();//(double) getGasReading();

    DiagnosticsMonitor.n_gassensor = 1;
    DiagnosticsMonitor.gassensor = &VOC_Sensor;

    response.monitors = &DiagnosticsMonitor;
    //response.digitalpins = DigitalPinArray;
    response.n_componentsstates = 0;

    response.n_digitalinterfacestates = DiagnosticsLoadDigitalValues();
    response.digitalinterfacestates = digitalinterfacestates;

    response.n_heatersstates = 0;
    i = 0;
    LoadHeaterState(HEATER_TYPE__DryerAirHeater,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__DryerMainHeater,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__DryerSecondaryHeater,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__MixerHeater,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__HeaterZone1,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__HeaterZone2,&HeaterInfo[i++]);
    LoadHeaterState(HEATER_TYPE__HeaterZone3,&HeaterInfo[i++]);

    if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
    {
        LoadHeaterState(HEATER_TYPE__HeaterZone4,&HeaterInfo[i++]);    
    }
	LoadHeaterState(HEATER_TYPE__HeaterZone5,&HeaterInfo[i++]);
	//LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);
	 if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
    {
        LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);  
    }
	if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_ARC))
	{
        LoadHeaterState(HEATER_TYPE__HeaterZone7,&HeaterInfo[i++]);
		//LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
	}
    if (Head_Type == HEAD_TYPE_FLAT)
    {		
        LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
		LoadHeaterState(HEATER_TYPE__HeaterZone9,&HeaterInfo[i++]);
        LoadHeaterState(HEATER_TYPE__HeaterZone10,&HeaterInfo[i++]);
        LoadHeaterState(HEATER_TYPE__HeaterZone11,&HeaterInfo[i++]);
        LoadHeaterState(HEATER_TYPE__HeaterZone12,&HeaterInfo[i++]);
    }
    if (Head_Type == HEAD_TYPE_ARC)
    //if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
    {
        LoadHeaterState(HEATER_TYPE__HeadCoverHeater1,&HeaterInfo[i++]);
        LoadHeaterState(HEATER_TYPE__HeadCoverHeater2,&HeaterInfo[i++]);
    }
    if(WHS_Type == WHS_TYPE_NEW)
    {
        chillerHeaterId = (Head_Type == HEAD_TYPE_ARC)?HEATER_TYPE__HeaterZone12:HEATER_TYPE__HeadCoverHeater1;
        LoadChillerState(chillerHeaterId,&HeaterInfo[i++]);
    }
    response.n_heatersstates = i;
    response.heatersstates = heatersstates;

    response.has_elapsedmilli = true;
    if (Diagnostis_Time_Stamp == 0)
    {
        response.elapsedmilli = 0;
    }
    else
        response.elapsedmilli = msec_millisecondCounter-Diagnostis_Time_Stamp;
    Diagnostis_Time_Stamp = msec_millisecondCounter;


//    diagnosticsresponseContainer = createContainer(MESSAGE_TYPE__StartDiagnosticsResponse,  DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size);
    diagnosticsresponseContainer = createAllocatedContainer(MESSAGE_TYPE__StartDiagnosticsResponse,  DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size,diagnostics_response_ptr);
    diagnosticsresponseContainer.has_continuous = true;
    diagnosticsresponseContainer.continuous = true;

    if (diagnosticsresponseContainer.data.data)
    {
        if (diagnosticscontainer_buffer == 0) //send new diagnostics packet only if the previous one was sent and released
        {
            diagnosticscontainer_buffer = my_malloc(message_container__get_packed_size(&diagnosticsresponseContainer));
            if (diagnosticscontainer_buffer)
            {
                size_t container_size = message_container__pack(&diagnosticsresponseContainer, diagnosticscontainer_buffer);
                //        if (SendChars(diagnosticscontainer_buffer, container_size)== false) //comm tx mailbox full
                if (SendCharsWithType(diagnosticscontainer_buffer, container_size,MESSAGE_TYPE__StartDiagnosticsResponse) == false) //comm tx mailbox full
                {
                    DiagnosticsStop();
                    my_free(diagnosticscontainer_buffer);
                }
	            /*else
	            {
	                Report("Diagnostic Messgage",__FILE__,__LINE__,container_size,RpWarning,msec_millisecondCounter,  msec_millisecondCounter);
	            }*/
                //diag_size[diag_index] = container_size;
                //diag_time[diag_index] = msec_millisecondCounter;
                //if (diag_index++>=MAX_DIAG_LOG)
                //    diag_index = 0;
            }
            else
            {
                ReportWithPackageFilter(DiagnosticsFilter,"my_malloc failed, DiagnosticsStop ",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
                DiagnosticsStop();
                //CommunicationMailboxFlush();
            }
        }
        else
        {
            ReportWithPackageFilter(DiagnosticsFilter,"previous packet not sent",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
        }
        //my_free(diagnosticsresponseContainer.data.data);
    }
    else
    {
        ReportWithPackageFilter(DiagnosticsFilter,"my_malloc failed, DiagnosticsStop ",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
        DiagnosticsStop();
    }
    DiagnosticsReset();
}
uint32_t DiagnosticsControlId = 0xff;
uint32_t Diagnostics10MSControlId = 0xff;
uint32_t Diagnostics1SecControlId = 0xff;
uint32_t Diagnostics1MinControlId = 0xFF;
bool DiagnosticRequestAccepted = false;
uint32_t DiagnosticsStart(void)
{

    if ( DiagnosticsActive == false)
    {
        if (DiagnosticRequestAccepted == true)
        {
            DiagnosticsActive = true;
            if (DiagnosticsControlId == 0xFF)
                DiagnosticsControlId = AddControlCallback(NULL,Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
            else
                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)DiagnosticLimit,RpWarning,(int)DiagnosticsControlId,0);
            if (Diagnostics10MSControlId == 0xFF)
                Diagnostics10MSControlId = AddControlCallback(NULL,Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
            else
                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)DiagnosticFastLimit,RpWarning,(int)Diagnostics10MSControlId,0);
            if (Diagnostics1SecControlId == 0xFF)
                Diagnostics1SecControlId = AddControlCallback(NULL,Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
            else
                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)eOneSecond,RpWarning,(int)Diagnostics1SecControlId,0);
            if (Diagnostics1MinControlId == 0xFF)
                Diagnostics1MinControlId = AddControlCallback(NULL,Diagnostics_OneMinControlTrigger,eOneMinute,TemplateDataReadCBFunction,0,0,0);
            else
                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)eOneMinute,RpWarning,(int)Diagnostics1MinControlId,0);
       }

    }
    return OK;
}
uint32_t DiagnosticsStop(void)
{
    if ( DiagnosticsActive == true)
    {
        DiagnosticsActive = false;
        if (DiagnosticsControlId != 0xFF)
            RemoveControlCallback(DiagnosticsControlId,Diagnostics_ControlTrigger);
        if (Diagnostics10MSControlId != 0xFF)
            RemoveControlCallback(Diagnostics10MSControlId,Diagnostics_TenMiliControlTrigger);
        if (Diagnostics1SecControlId != 0xFF)
            RemoveControlCallback(Diagnostics1SecControlId,Diagnostics_OneSecControlTrigger);
        if (Diagnostics1MinControlId != 0xFF)
            RemoveControlCallback(Diagnostics1MinControlId,Diagnostics_OneMinControlTrigger);

        DiagnosticsControlId = 0xFF;
        Diagnostics10MSControlId = 0xFF;
        Diagnostics1SecControlId = 0xFF;
        Diagnostics1MinControlId = 0xFF;
        Diagnostis_Time_Stamp = 0;

    }
    return OK;
}
uint32_t StartDiagnosticsRequestFunc(MessageContainer* requestContainer)
{
    uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;

//    ReportInitParams InitParams;
    //ControlStart();
    DiagnosticRequestAccepted = true;
    DiagnosticsStart();

    StartDiagnosticsRequest* request = start_diagnostics_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    ustrncpy (DiagnosticsToken, requestContainer->token,36);
    start_diagnostics_request__free_unpacked(request,NULL);
    return status;
}
uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    StopDiagnosticsRequest* request = stop_diagnostics_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StopDiagnosticsResponse response = STOP_DIAGNOSTICS_RESPONSE__INIT;

    DiagnosticsStop();

    DiagnosticRequestAccepted = false;

    responseContainer = createContainer(MESSAGE_TYPE__StopDiagnosticsResponse,  requestContainer->token, false, &response, &stop_diagnostics_response__pack, &stop_diagnostics_response__get_packed_size);
    responseContainer.continuous = false;
    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);
    SendChars(container_buffer, container_size);

return OK;
}
uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    DiagnosticsMessageStruc Message;

    //send message to the Millisec task
    Message.messageId = DiagnosticsTrigger;
    Message.msglen = sizeof(DiagnosticsMessageStruc);
    if (DiagnosticsMsgQ != NULL)
        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}

uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    DiagnosticsMessageStruc Message;

    if (DiagnosticMode == Diagnostic_Extreme_Mode)
    {
        Message.messageId = DiagnosticsTenMiliTrigger;
        Message.msglen = sizeof(DiagnosticsMessageStruc);
        if (DiagnosticsMsgQ != NULL)
            Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
    }
    return OK;
}

uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    DiagnosticsMessageStruc Message;

    Message.messageId = DiagnosticsOneSecTrigger;
    Message.msglen = sizeof(DiagnosticsMessageStruc);
    if (DiagnosticsMsgQ != NULL)
        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}
uint32_t Diagnostics_OneMinControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    DiagnosticsMessageStruc Message;

    Message.messageId = DiagnosticsOneMinuteTrigger;
    Message.msglen = sizeof(DiagnosticsMessageStruc);
    if (DiagnosticsMsgQ != NULL)
        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}
/******************************************************************************
 *  ======== messageTsk ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this message task is created statically in system initialization,
 ******************************************************************************/
void DiagnosticsTask(UArg arg0, UArg arg1)
{
    DiagnosticsMessageStruc Message;
    //char str[60];
    //uint16_t length;
    //Clock_setTimeout(HostKAClock, 1000);
    //Clock_start(HostKAClock);
    DiagnosticsInit();
    Diagnostics_Task_Handle = Task_self();
    while(1)
    {
        Mailbox_pend(DiagnosticsMsgQ , &Message, BIOS_WAIT_FOREVER);
        switch (Message.messageId)
        {
            case DiagnosticsTrigger:
                Diagnostic100msecCollection();
                break;
            case DiagnosticsTenMiliTrigger:
                if (DiagnosticMode >= Diagnostic_Extreme_Mode)
                    DiagnosticTenMsecCollection();
                break;
            case DiagnosticsOneSecTrigger:
                DiagnosticOneSecCollection();
                if (DiagnosticMode >= Diagnostic_Extreme_Mode)
                    DiagnosticOneMinuteCollection();
                break;
            case DiagnosticsOneMinuteTrigger:
                DiagnosticOneMinuteCollection();
                break;
            default:
                break;
        }
    }
}