path: root/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c

/*
 * FPGA_GPIO.c
 *
 *  Created on: May 30, 2018
 *      Author: avi
 */

#include <stdint.h>
#include <stdbool.h>
#include <drivers/FPGA/FPGA_Comm.h>
#include <DataDef.h>
#include "modules/control/millisecTask.h"
#include "modules/thread/thread.h"
#include "FPGA_GPIO.h"
#include "drivers/FPGA/FPGA.h"
#include "StateMachines/Printing/PrintingSTM.h"
#include <drivers/FPGA/FPGA_SPI_Comm.h>

#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
#include <Drivers/I2C_Communication/I2C_Task.h>
#include <Utilities/utils.h>
#include <Utilities/delay.h>

FPGA_GPI FPGA_Gpi;

extern F2_CTRL_REG F2_CTRL_Reg;

bool FPGA_Gpi_Buf[MAX_GPI] = {0};

extern bool Machine_Idle_Mode;

extern F3_GPO_01_REG F3_GPO_01_Reg;

void Read_FPGA_GPI_Rgisters()
{
    uint32_t i;
    unsigned char index_buf;
    unsigned shift;
    unsigned char Size = sizeof(unsigned short) * 8; // register from the FPGA is 16 bit

    FPGA_Gpi.Reg.GPI_LS1_D = F1_GPI_LS1_D;
    FPGA_Gpi.Reg.GPI_LS2_D = F1_GPI_LS2_D;
    FPGA_Gpi.Reg.GPI_LS3_D = F1_GPI_LS3_D;


    FPGA_Gpi.Reg.LS_01 = F2_LS_01_Direct;  //LS_DISPENSER_1_2
    FPGA_Gpi.Reg.LS_02 = F2_LS_02_Direct;  //LS_DISPENSER_3_4
    FPGA_Gpi.Reg.LS_03 = F2_LS_03_Direct;  //LS_DISPENSER_5_6
    FPGA_Gpi.Reg.LS_04 = F2_LS_04_Direct;  //LS_DISPENSER_7_8

    FPGA_Gpi.Reg.GPI_EXTWINDER = F1_GPI_EXTWINDER_D;

   for(i=0;i<MAX_GPI;i++)
   {
       index_buf = i / Size;
       shift  = i % Size;

       FPGA_Gpi_Buf[i] = (FPGA_Gpi.Buf[index_buf] & (0x01 << shift)) >> shift;
   }
}



/* example to read the Limit switch :

if(FPGA_Gpi_Buf[GPI_LS_RLOADRAM_UP] == LIMIT)
{
      // stop motor
}
*/

void test_fpga_gpi()
{
    int nop = 0;

while(1)
{
    Read_FPGA_GPI_Rgisters();

    if(     //FPGA_Gpi_Buf[GPI_LS_LPIVOT_UP]       |
//            FPGA_Gpi_Buf[GPI_LS_LPIVOT_DOWN]     |
//            FPGA_Gpi_Buf[GPI_LS_LLOADMOTOR_UP]   |
//            FPGA_Gpi_Buf[GPI_LS_LLOADMOTOR_DOWN] |
//            FPGA_Gpi_Buf[GPI_LS_LDANCER1_UP]     |
//            FPGA_Gpi_Buf[GPI_LS_LDANCER1_DOWN]   |
//
//            FPGA_Gpi_Buf[GPI_LS_RDANCER_LONG]    |
//            FPGA_Gpi_Buf[GPI_LS_RLOADMOTOR_UP]   |
//            FPGA_Gpi_Buf[GPI_LS_RLOADMOTOR_DOWN] |
//            FPGA_Gpi_Buf[GPI_LS_RDANCER_UP]      |
//            FPGA_Gpi_Buf[GPI_LS_RDANCER_DOWN]    |
//
//            FPGA_Gpi_Buf[GPI_LS_SCREW_RIGHT]     |
            //FPGA_Gpi_Buf[GPI_LS_SCREW_LEFT]    //  |
//            FPGA_Gpi_Buf[GPI_F1_GPI_TFEED_BREAK_2]
//                          == LIMIT)

        FPGA_Gpi_Buf[GPI_LS_DISPENSER_DOWN_7]
                      == LIMIT)

//        GPI_LS_DISPENSER_DOWN_7,     //98
//        GPI_LS_DISPENSER_75_7,       //99
//        GPI_LS_DISPENSER_25_7,       //100
//        GPI_LS_DISPENSER_UP_7,       //101
    {
        nop += 1;
    }
    else
    {
        nop += 2;
    }

}

}

LS_LEFT LS_Left;
LS_RIGHT_SCREW_SPOOL Ls_Right_Screw_Spool;
LS_DISPENSER_1_2 LS_Dispenser_1_2;
LS_DISPENSER_3_4 LS_Dispenser_3_4;
LS_DISPENSER_5_6 LS_Dispenser_5_6;
LS_DISPENSER_7_8 LS_Dispenser_7_8;
LS_DRYER_DH Ls_Dryer_Dh;
F3_LS_01 LS_Spare;

void FPGA_Read_LS_Safty_Ind_Reg()//MillisecLoop
{
   // uint8_t temp[8] = {0,0,0,0,0,0,0,0},i;
#ifndef EVALUATION_BOARD

    LS_Left.ushort              = F1_GPI_LS2_D;
    Ls_Right_Screw_Spool.ushort = F1_GPI_LS3_D;
    LS_Dispenser_1_2.ushort = F2_LS_01_Direct;
    LS_Dispenser_3_4.ushort = F2_LS_02_Direct;
    LS_Dispenser_5_6.ushort = F2_LS_03_Direct;
    LS_Dispenser_7_8.ushort = F2_LS_04_Direct;
    Ls_Dryer_Dh.ushort = F1_GPI_LS1_D; //F1_LS_01_Direct
    LS_Spare.ushort = F3_LS_01_Direct;

/*
    temp[0] = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_1 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_1 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_75_1 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_1;
    temp[1] = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_2 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_2 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_75_2 + LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_2;
    temp[2] = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_3 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_3 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_75_3 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_3;
    temp[3] = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_4 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_4 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_75_4 + LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_4;
    temp[4] = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_5 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_5 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_75_5 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_5;
    temp[5] = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_6 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_6 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_75_6 + LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_6;
    temp[6] = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_7 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_7 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_75_7 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_7;
    temp[7] = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_8 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_8 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_75_8 + LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_8;

    for(i=0;i<8;i++)
    {
        if((temp[i] < 3) && ( Dispenser_struct[i].LS_Polarity == DEFAULT_POLARITY))
            Dispenser_struct[i].Status = LS_STATUS_ERROR;
        else
        if((temp[i] > 1) && ( Dispenser_struct[i].LS_Polarity == INVERSION_POLARITY))
            Dispenser_struct[i].Status = LS_STATUS_ERROR;
        else
            Dispenser_struct[i].Status = LS_STATUS_OK;
    }
*/
#endif
}

bool Check_Disp_Safety_Stop_Indication(uint8_t Dispenser_ID)//0..7
{
    bool Safety_Indication = OK;

    assert(Dispenser_ID < MAX_DISPENSER_NUM);

#ifndef EVALUATION_BOARD
    switch(Dispenser_ID)
    {
    case 0:
            Safety_Indication = LS_Dispenser_1_2.bits.F2_DISP_SAFETY_STOP_IND_1;
        break;
    case 1:
            Safety_Indication = LS_Dispenser_1_2.bits.F2_DISP_SAFETY_STOP_IND_2;
        break;
    case 2:
            Safety_Indication = LS_Dispenser_3_4.bits.F2_DISP_SAFETY_STOP_IND_3;
        break;
    case 3:
            Safety_Indication = LS_Dispenser_3_4.bits.F2_DISP_SAFETY_STOP_IND_4;
        break;
    case 4:
            Safety_Indication = LS_Dispenser_5_6.bits.F2_DISP_SAFETY_STOP_IND_5;
        break;
    case 5:
            Safety_Indication = LS_Dispenser_5_6.bits.F2_DISP_SAFETY_STOP_IND_6;
        break;
    case 6:
            Safety_Indication = LS_Dispenser_7_8.bits.F2_DISP_SAFETY_STOP_IND_7;
        break;
    case 7:
            Safety_Indication = LS_Dispenser_7_8.bits.F2_DISP_SAFETY_STOP_IND_8;
        break;
    default:
        break;
    }
#endif

    return Safety_Indication;
}

bool FPGA_Read_limit_Switches(FPGA_GPI_ENUM Limit_Switch)
{
    bool LM_Status = NO_LIMIT;

    switch(Limit_Switch)
    {
        case GPI_LS_LPIVOT_UP:
            LM_Status = LS_Left.bits.F1_LS_LPIVOT_UP;
            //LS_Left.bits.F1_LS_LPIVOT_UP = NO_LIMIT;
            break;
        case GPI_LS_LPIVOT_DOWN:
            LM_Status = LS_Left.bits.F1_LS_LPIVOT_DOWN;
            //LS_Left.bits.F1_LS_LPIVOT_DOWN = NO_LIMIT;
            break;
        case GPI_LS_LLOADMOTOR_UP:
            LM_Status = LS_Left.bits.F1_LS_LLOADMOTOR_UP;
            //LS_Left.bits.F1_LS_LLOADMOTOR_UP = NO_LIMIT;
            break;
        case GPI_LS_LLOADMOTOR_DOWN:
            LM_Status = LS_Left.bits.F1_LS_LLOADMOTOR_DOWN;
            //LS_Left.bits.F1_LS_LLOADMOTOR_DOWN = NO_LIMIT;
            break;
        case GPI_LS_LDANCER1_UP:
            LM_Status = LS_Left.bits.F1_LS_LDANCER1_UP;
            //LS_Left.bits.F1_LS_LDANCER1_UP = NO_LIMIT;
            break;
        case GPI_LS_LDANCER1_DOWN:
            LM_Status = LS_Left.bits.F1_LS_LDANCER1_DOWN;
            //LS_Left.bits.F1_LS_LDANCER1_DOWN = NO_LIMIT;
            break;
        case GPI_LS_RDANCER_LONG:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_LONG;
            //Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_LONG = NO_LIMIT;
            break;
        case GPI_LS_RLOADMOTOR_UP:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_RLOADMOTOR_UP;
            //Ls_Right_Screw_Spool.bits.F1_LS_RLOADMOTOR_UP = NO_LIMIT;
            break;
        case GPI_LS_RLOADMOTOR_DOWN:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_RLOADMOTOR_DOWN;
            //Ls_Right_Screw_Spool.bits.F1_LS_RLOADMOTOR_DOWN = NO_LIMIT;
            break;
        case GPI_LS_RDANCER_UP:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_UP;
            //Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_UP = NO_LIMIT;
            break;
        case GPI_LS_RDANCER_DOWN:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_DOWN;
            //Ls_Right_Screw_Spool.bits.F1_LS_RDANCER_DOWN = NO_LIMIT;
            break;

        case GPI_LS_SCREW_RIGHT:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_SCREW_RIGHT;
            //Ls_Right_Screw_Spool.bits.F1_LS_SCREW_RIGHT = NO_LIMIT;
            break;
        case GPI_LS_SCREW_LEFT:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_LS_SCREW_LEFT;
            //Ls_Right_Screw_Spool.bits.F1_LS_SCREW_LEFT = NO_LIMIT;
            break;
        case GPI_SW_SPOOL_EXISTS:
            LM_Status = Ls_Right_Screw_Spool.bits.F1_SW_SPOOL_EXISTS;
            //Ls_Right_Screw_Spool.bits.F1_SW_SPOOL_EXISTS = NO_LIMIT;
            break;
/**/
        case GPI_LS_DISPENSER_50_1:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_1 ^ Dispenser_struct[0].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_1 = NO_LIMIT;
            break;
        case GPI_LS_DISPENSER_DOWN_1:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_1 ^ Dispenser_struct[0].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_1 = NO_LIMIT;
            break;
        case GPI_LS_DISPENSER_25_1:
            //LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_1 ^ Dispenser_struct[0].LS_Type;
            LM_Status = ((~Dispenser_struct[0].LS_Polarity) & LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_1) | ((Dispenser_struct[0].LS_Polarity) & (~LS_Dispenser_1_2.bits.F2_LS_DISPENSER_75_1));//new dispenser use 75 old use 25
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_1 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_1:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_1 ^ Dispenser_struct[0].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_1 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_50_2:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_2 ^ Dispenser_struct[1].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_50_2 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_2:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_2 ^ Dispenser_struct[1].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_DOWN_2 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_25_2:
            //LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_2 ^ Dispenser_struct[1].LS_Type;
            LM_Status = ((~Dispenser_struct[1].LS_Polarity) & LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_2) | ((Dispenser_struct[1].LS_Polarity) & (~LS_Dispenser_1_2.bits.F2_LS_DISPENSER_75_2));//new dispenser use 75 old use 25
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_25_2 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_2:
            LM_Status = LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_2 ^ Dispenser_struct[1].LS_Polarity;
            //LS_Dispenser_1_2.bits.F2_LS_DISPENSER_UP_2 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_50_3:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_3 ^ Dispenser_struct[2].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_3 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_3:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_3 ^ Dispenser_struct[2].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_3 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_25_3:
            //LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_3 ^ Dispenser_struct[2].LS_Type;
            LM_Status = ((~Dispenser_struct[2].LS_Polarity) & LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_3) | ((Dispenser_struct[2].LS_Polarity) & (~LS_Dispenser_3_4.bits.F2_LS_DISPENSER_75_3));//new dispenser use 75 old use 25
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_3 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_3:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_3 ^ Dispenser_struct[2].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_3 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_50_4:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_4 ^ Dispenser_struct[3].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_50_4 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_4:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_4 ^ Dispenser_struct[3].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_DOWN_4 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_25_4:
            //LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_4 ^ Dispenser_struct[3].LS_Type;
            LM_Status = ((~Dispenser_struct[3].LS_Polarity) & LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_4) | ((Dispenser_struct[3].LS_Polarity) & (~LS_Dispenser_3_4.bits.F2_LS_DISPENSER_75_4));//new dispenser use 75 old use 25
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_25_4 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_4:
            LM_Status = LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_4 ^ Dispenser_struct[3].LS_Polarity;
            //LS_Dispenser_3_4.bits.F2_LS_DISPENSER_UP_4 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_50_5:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_5 ^ Dispenser_struct[4].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_5 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_5:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_5 ^ Dispenser_struct[4].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_5 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_25_5:
            //LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_5 ^ Dispenser_struct[4].LS_Type;
            LM_Status = ((~Dispenser_struct[4].LS_Polarity) & LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_5) | ((Dispenser_struct[4].LS_Polarity) & (~LS_Dispenser_5_6.bits.F2_LS_DISPENSER_75_5));//new dispenser use 75 old use 25
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_5 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_5:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_5 ^ Dispenser_struct[4].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_5 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_50_6:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_6 ^ Dispenser_struct[5].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_50_6 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_6:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_6 ^ Dispenser_struct[5].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_DOWN_6 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_25_6:
            //LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_6 ^ Dispenser_struct[5].LS_Type;
            LM_Status = ((~Dispenser_struct[5].LS_Polarity) & LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_6) | ((Dispenser_struct[5].LS_Polarity) & (~LS_Dispenser_5_6.bits.F2_LS_DISPENSER_75_6));//new dispenser use 75 old use 25
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_25_6 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_6:
            LM_Status = LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_6 ^ Dispenser_struct[5].LS_Polarity;
            //LS_Dispenser_5_6.bits.F2_LS_DISPENSER_UP_6 = NO_LIMIT;
               break;
        case GPI_LS_DISPENSER_50_7:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_7 ^ Dispenser_struct[6].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_7 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_7:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_7 ^ Dispenser_struct[6].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_7 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_25_7:
            //LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_7 ^ Dispenser_struct[6].LS_Type;
            LM_Status = ((~Dispenser_struct[6].LS_Polarity) & LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_7) | ((Dispenser_struct[6].LS_Polarity) & (~LS_Dispenser_7_8.bits.F2_LS_DISPENSER_75_7));//new dispenser use 75 old use 25
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_7 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_7:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_7 ^ Dispenser_struct[6].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_7 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_50_8:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_8 ^ Dispenser_struct[7].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_50_8 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_DOWN_8:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_8 ^ Dispenser_struct[7].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_DOWN_8 = NO_LIMIT;
                    break;
        case GPI_LS_DISPENSER_25_8:
            //LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_8 ^ Dispenser_struct[7].LS_Type;
            LM_Status = ((~Dispenser_struct[7].LS_Polarity) & LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_8) | ((Dispenser_struct[7].LS_Polarity) & (~LS_Dispenser_7_8.bits.F2_LS_DISPENSER_75_8));//new dispenser use 75 old use 25
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_25_8 = NO_LIMIT;
                break;
        case GPI_LS_DISPENSER_UP_8:
            LM_Status = LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_8 ^ Dispenser_struct[7].LS_Polarity;
            //LS_Dispenser_7_8.bits.F2_LS_DISPENSER_UP_8 = NO_LIMIT;
                break;/**/
        case GPI_LS_DRYER_LID_OPEN:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DRYER_LID_OPEN;
                break;
        case GPI_LS_DRYER_LID_CLOSED:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DRYER_LID_CLOSED;
                break;
        case GPI_LS_DH_LID_OPEN:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DH_LID_OPEN;
                break;
        case GPI_LS_DH_LID_CLOSED:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DH_LID_CLOSED;
                break;
        case GPI_LS_DH_LID_CLEANING:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DH_LID_CLEANING;
                break;
        case GPI_LS_DH_CLEAN_UP:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DH_CLEAN_UP;
                break;
        case GPI_LS_DH_CLEAN_RIGHT:
            LM_Status = !(Ls_Dryer_Dh.bits.F1_LS_DH_CLEAN_RIGHT);
                break;
        case GPI_LS_DH_CLEAN_LEFT:
            LM_Status = !(Ls_Dryer_Dh.bits.F1_LS_DH_CLEAN_LEFT);
                break;
        case GPI_LS_DH_CLEAN_DOWN:
            LM_Status = Ls_Dryer_Dh.bits.F1_LS_DH_CLEAN_DOWN;
                break;
        case GPI_LS_LSPARE1:
            LM_Status = LS_Left.bits.F1_LS_LSPARE1;
                break;
        case GPI_LS_LSPARE2:
            LM_Status = LS_Left.bits.F1_LS_LSPARE2;
                break;
        case GPI_LS_SPARE2_2:
            LM_Status = LS_Spare.bits.F3_LS_SPARE2_2;
            break;
        case GPI_LS_SPARE1_2:
            LM_Status = LS_Spare.bits.F3_LS_SPARE1_2;
            break;
        case I2C_HEADCARD_COVER_LS_FRONT:
        case I2C_HEADCARD_ARC_LS_ACTUATOR:
            if (Head_Type == HEAD_TYPE_ARC)
                LM_Status = Head_I2C_EXP4_0x46.bits.INPUT_LS_FRONT_ARC_ACT;
            else
                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_FRONT_ARC_ACT);
            break;
        case I2C_HEADCARD_COVER_LS_REAR:
        case I2C_HEADCARD_COVER_LS_ARC:
            if(Head_Type == HEAD_TYPE_ARC)
                LM_Status = Head_I2C_EXP4_0x46.bits.INPUT_LS_REAR_ARC_COVER;
            else
                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_REAR_ARC_COVER);
                break;
        case I2C_HEADCARD_COVER_LS_UPPER:
                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_UP);
                break;
        case I2C_HEADCARD_COVER_LS_TUNNEL_ARC:
            if(Head_Type == HEAD_TYPE_ARC)
                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_ARC_TUNNEL_COVER);
                break;
        default :
            LM_Status = NO_LIMIT;
            break;
    }

    return LM_Status;
}


//-----------------------------------------------------------------------------------------------

uint32_t ActivateCleanerPump()
{
        F2_CTRL_Reg.ushort |= CLEANER_PUMP_SSR3_CTRL;
        F2_CTRL = F2_CTRL_Reg.ushort;
        return OK;
}

uint32_t DeActivateCleanerPump()
{
#ifndef EVALUATION_BOARD
    F2_CTRL_Reg.ushort &= ~CLEANER_PUMP_SSR3_CTRL;
    F2_CTRL = F2_CTRL_Reg.ushort;
#endif
    return OK;
}
//----------------------------------
void Power_Off()//Power Down
{
    utilsStoreLocalTime();
#ifdef WATCHDOG
    ROM_WatchdogResetDisable(WATCHDOG0_BASE);
#endif
#ifndef EVALUATION_BOARD
    F2_CTRL_Reg.ushort |= PDOWN_RL1_CTRL;
    F2_CTRL = F2_CTRL_Reg.ushort;
#endif
}

void Power_Reset()// Resets the MCU
{
    utilsStoreLocalTime();
#ifndef EVALUATION_BOARD
    F3_SW_RESET_reg  &= ~BIT0;
    SysCtlDelay(1000);
    F3_SW_RESET_reg  |=  BIT0;
#endif
    SysCtlReset();
}

//--------------------------------------

uint32_t ActivateChiller() //WHS Cooler / WHS DX Cooler
{
#ifndef EVALUATION_BOARD
        F2_CTRL_Reg.ushort |= CHILLER_SSR9_CTRL;
        F2_CTRL = F2_CTRL_Reg.ushort;
#endif
        return OK;
}

uint32_t DeActivateChiller() //WHS Cooler / WHS DX Cooler
{
#ifndef EVALUATION_BOARD
        F2_CTRL_Reg.ushort &= ~CHILLER_SSR9_CTRL;
        F2_CTRL = F2_CTRL_Reg.ushort;
#endif
        return OK;
}

MOT_SW1 F1_Mot_Dr_SW1;

uint32_t ActivateCoolerPump() //WHS  - Pump the waste accumulated in cooler to the waste tank
{

#ifndef EVALUATION_BOARD
        F1_Mot_Dr_SW1.bits.GPO_DH_MAGNET = ON; //TBD verify polarity
        F1_Moto_Driver_SW1 = F1_Mot_Dr_SW1.ushort;
#endif
        return OK;
}

uint32_t DeActivateCoolerPump() //WHS  - Pump the waste accumulated in cooler to the waste tank
{
#ifndef EVALUATION_BOARD
        F1_Mot_Dr_SW1.bits.GPO_DH_MAGNET = OFF; //TBD verify polarity
        F1_Moto_Driver_SW1 = F1_Mot_Dr_SW1.ushort;
#endif
        return OK;
}
uint32_t MagnetControlId = 0xFF;
uint32_t MagnetCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{

    if(Head_Type == HEAD_TYPE_FLAT)
        Trigger_Head_Magnet(DISABLE_MAGNET);
        //HeadCard_HeadMagnet_Disable();
#ifndef FOUR_WINDERS
    else
        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,Hard_Hiz );
#endif
    if (SafeRemoveControlCallback(MagnetControlId, MagnetCallBackFunction )==OK)
        MagnetControlId = 0xFF;
    else
        Report("Remove control callback failed",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
    Report("MagnetCallBackFunction",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
    return OK;
}
//double BlowerSetPoint;
uint32_t ActivateHeadMagnet()
{
    Report("ActivateHeadMagnet - Close the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_OPEN,0);
    //WHS_Start_Blower_Control_Closed_Loop(BlowerSetPoint);
    //Task_sleep(500);
    if(Head_Type == HEAD_TYPE_FLAT)
        //HeadCard_ActivateHeadMagnet();
        Trigger_Head_Magnet(CLOSE_MAGNET);
    else
    {
#ifndef EVALUATION_BOARD
        F2_CTRL_Reg.ushort &= ~SPARE_SSR13_CTRL;
        F2_CTRL = F2_CTRL_Reg.ushort;
#endif
    }
#ifndef FOUR_WINDERS
    if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
    {
        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
            MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_OPEN );
        else
            MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_CLOSE );
    }
#endif
    MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
    return OK;
}
/*
uint32_t HeadCard_ActivateHeadMagnet();
uint32_t HeadCard_DeActivateHeadMagnet();
uint32_t HeadCard_HeadMagnet_Disable();
*/
uint32_t DeActivateHeadMagnet()
{
    //BlowerSetPoint = WHS_Get_Blower_Control_Closed_Loop_SetPoint();

    //WHS_Start_Blower_Control_Closed_Loop(0.0);

    if(Head_Type == HEAD_TYPE_FLAT)
    {
        Trigger_Head_Magnet(OPEN_MAGNET);
        //HeadCard_DeActivateHeadMagnet();
    }
    else
    {
#ifndef EVALUATION_BOARD
        F2_CTRL_Reg.ushort |= SPARE_SSR13_CTRL;
        F2_CTRL = F2_CTRL_Reg.ushort;
#endif
    }
    Report("DeActivateHeadMagnet - open the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_CLOSE,0);
#ifndef FOUR_WINDERS
    if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
    {
        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM].DriverType == CombinrdMotDriver)
            MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_CLOSE );
        else
            MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_OPEN );
        //MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_OPEN, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
    }
#endif
    //MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
    Task_sleep(500);
    return OK;
}

uint32_t ReadHeadMagnetBit()
{
#ifndef EVALUATION_BOARD
        return (F2_CTRL & BIT0);//SSR13 is not in the WD therefore it it possible to read the bit
#else
        return 0;
#endif
}

uint32_t DeActivateAllSSR()
{
        F2_CTRL_Reg.ushort = 0;
        F2_CTRL = F2_CTRL_Reg.ushort;
        //TODO add SSR10 - 11
        return OK;
}

bool FPGA_WD_Occurred = false;
uint32_t FPGA_WD_Counter = 0;
bool Is_FPGA_WD_Occurred()
{
    if( ((F1_Moto_Driver_NSTBYRST1 & 0x7FF) != 0x7FF) ||
        (F1_Moto_Driver_NSTBYRST2 & 0x3F != 0x3F) ||
        (F2_Moto_Driver_NSTBYRST1 & 0xFF != 0xFF) ||
        (F3_Moto_Driver_NSTBYRST1 &0x1F != 0x1F) )
    {
        LOG_ERROR (FPGA_WD_Counter, "FPGA WD Occurred");
        FPGA_WD_Counter = FPGA_WD_Counter+1;
        FPGA_WD_Occurred = true;

           //To recover:
/*               //1. Disable all FPGA's WD:
               Control_WD(DISABLE,0);
               //2. Enqable all FPGA's WD:
               Control_WD(ENABLE,250);
               //3. Call FPGA_SetMotorsInit:
               //FPGA_SetMotorsInit();
               //4. Init Motor's Drivers:
               //Init_Motors_Drivers_After_FPGA_WD();
               Motor_ReconfigAllMotors();

               //OR
               //Reset MCU (will reset also the FPGA):
               //Power_Reset();
*/
        return true;
    }
    else
        return false;

}
uint32_t msec_millisecondCounter_save = 0;
uint32_t Control_WD(bool IsEnable, unsigned char SetTimer_Steps100mSec) // Control_WD(ENABLE, 30);//Enable the watchdog for 3 seconds
/*
 * To enable the watchdog write '1' to bit No. 14 (value 0x40).
 * To set the watchdog time, write to lower 8 bits of the register number of times to count with a step of 0.1 seconds.
 * For example, for 3 seconds write the number 30 (0x1E).
 * If you will write the 0x4000 the watchdog will be enabled and activated immediately, the control register will be resetted.
 * If you will write the 0x40xx, where 0xFF >= xx > 0, the watchdog will be enabled, will start count the specified time,
 * the control register will take the value it had before to be resetted.
 */
{
    uint32_t status = OK;

    static bool En_WD_First_Time = true;
    uint32_t i = 0;

#ifndef EVALUATION_BOARD

    #ifdef  FPGA_WATCHDOG_DISABLE
        IsEnable = DISABLE;
    #endif

    short WD_Enable = 0x4000 | SetTimer_Steps100mSec;

    if (msec_millisecondCounter_save)
    {
        if ((msec_millisecondCounter-msec_millisecondCounter_save)>300)
        {
            LOG_ERROR((msec_millisecondCounter-msec_millisecondCounter_save),"Control WD too long");
        }
    }
    msec_millisecondCounter_save = msec_millisecondCounter;
    if (IsEnable == DISABLE)
    {
        F1_Watchdog_reg = 0xFF;//changed from 0 to 0xFF because if the WD expired 0 won't disable the WD must set  (0 <) number (< 0x4000)
        F2_Watchdog_reg = 0xFF;
        F3_Watchdog_reg = 0xFF;
    }
    else
    {
        if(En_WD_First_Time == false)
            status |= Is_FPGA_WD_Occurred();

        F1_Watchdog_reg = WD_Enable; // Enable the watchdog F3_GPO_01_bus BIT4 DYEINGH_SSR11_CTRL HeadHeaterZ6
        F2_Watchdog_reg = WD_Enable; // Enable the watchdog F2_CTRL + reset dispensers motor drivers
        F3_Watchdog_reg = WD_Enable; // Enable the watchdog F1_gpo_01 BIT2 DYEINGH_SSR10_CTRL HeadHeaterZ5

        if(En_WD_First_Time == true)
        {
            for(i=0;i<NUM_OF_MOTORS;i++)
            {
                MotorDriverRequest[i].Stop = Hard_Hiz;
                FPGA_SetMotStop((HardwareMotorType)i);
            }
            En_WD_First_Time = false;
        }
    }
#endif
    return status;
}

uint32_t ReadBreakSensor()
{
    uint32_t Status = WARNING;

    uint32_t BearkSensorsMask = GPI_TFEED_BREAK_1 /*| GPI_TFEED_BREAK_2*/;

    uint16_t temp = F1_GPI_EXTWINDER_D;

    if((temp & BearkSensorsMask) == BearkSensorsMask )  //  (1 - Broken, 0 - Running) TODO: Verify the polarity
    {
        Status = ERROR;
    }
    else
    {
        Status = OK;
    }
    return Status;
}


//------------------------- WHS ----------------------


F2_GPI_REG F2_GPI_Reg;
F3_GPI_01 F3_GPI_01_Reg;

void WHS_Read_GPI_Registers()//every Fifty_msTick
{

#ifndef EVALUATION_BOARD
    F2_GPI_Reg.ushort = F2_GPI_REGISTER1_Direct;
    F3_GPI_01_Reg.ushort = F3_GPI_01_D;
#endif
}

bool WHS_GPI_CHILLER_FAULT()
{
#ifndef EVALUATION_BOARD
    return F2_GPI_Reg.bits.F2_GPI_CHILLER_FAULT;
#else
    return false;
#endif

}

bool WHS_GPI_WASTE_OVERFULL()//waste tank overflow
{
//#warning NA need to check the DISP_SAFETY_STOP_IND of all the connected dispensers done
#ifndef EVALUATION_BOARD
    return F2_GPI_Reg.bits.F2_WASTE_OVERFULL_NO;
#else
    return false;
#endif
}

bool WHS_GPI_SW_FILTER_PRES()
{
#ifndef EVALUATION_BOARD
    return F3_GPI_01_Reg.bits.F3_GPI_SW_FILTER_PRES;
#else
    return false;
#endif
}

bool WHS_GPI_WCONTAINER_FULL()//waste tank full
{
#ifndef EVALUATION_BOARD
    return F3_GPI_01_Reg.bits.F3_GPI_WCONTAINER_FULL;
#else
    return false;
#endif
}

bool WHS_GPI_WCONTAINER_WARN()//waste tank empty
{
#ifndef EVALUATION_BOARD
    return F3_GPI_01_Reg.bits.F3_GPI_WCONTAINER_WARN;
#else
    return false;
#endif
}

bool WHS_GPI_WASTE_FLOW_SWITCH()// DRyer air - Read the airflow safety
{
#ifndef EVALUATION_BOARD
        return F2_GPI_Reg.bits.F2_WASTE_FLOW_SW_NO;
#else
    return false;
#endif
}

uint8_t GPO_Waste_Pressure_Software_Stop(uint8_t TrueToStop)
{
    //GPO_SPARE1_1 (New BP: DISP_SAFETY_STOP_INPUT)  Connected to WASTE_PRESS_SW and Stop from MCU
    uint8_t Status = OK;

#ifndef EVALUATION_BOARD
    switch(TrueToStop)
    {
    case true:
            F3_GPO_02_bus |= STOP ;
        break;
    case false:
            F3_GPO_02_bus &= ~(STOP);
        break;
    default:
        Status = ERROR;
        break;
    }
#endif

    return Status;
}
//--------------------------------------
bool Get_COVER_1_State(COVERS_ENUM CoverId)
{
    assert (CoverId<Max_Doors);

#ifndef EVALUATION_BOARD
    switch (CoverId)
    {
        case FrontDoor1_EC:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW1;
            //break;
        case FrontDoor2_PPC:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW2;
            //break;
        case FrontDoor3_DH_DRYER:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW3;
            //break;
        case FrontDoor4_MIDTANKS:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW4;
            //break;
        case CartridgesDoor:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW5;
            //break;
        case RearDoor:
            return F3_GPI_01_Reg.bits.F3_GPI_PANSW6;
            //break;
        case DryerDoor:
            return LS_Left.bits.F1_DR_DOOR_SW_NO;
            //break;
        default:
            return false;
    }
#else
    return OK;
#endif
}

extern F1_GPO_REG F1_GPO_Reg; // must be global to keep all other bits
bool SecondaryPumpActive = false;
void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ??
{


    switch(Pump_Id)
    {
        // Waste Pump Control
        case WASTECH_PUMP2:
            if (WHS_Type == WHS_TYPE_UNKNOWN)
            {
                if (Direction == true)
                    ActivateCoolerPump();
                else
                    DeActivateCoolerPump();
                //F1_GPO_Reg.bits.F1_GPO_WASTECH_PUMP2 = Direction;
                SecondaryPumpActive = Direction;
            }
            break;
        case WHS_WTANKPUMP2:
#ifndef EVALUATION_BOARD
                F1_GPO_Reg.bits.F1_GPO_WHS_WTANKPUMP2 = Direction;
#endif
                break;

        default:
            break;
    }

#ifndef EVALUATION_BOARD
    F1_gpo_01 = F1_GPO_Reg.ushort;
#endif
}
uint32_t SecondaryPumpControlId;

uint32_t SecondaryPumpCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
{
    Pumps_Control(WASTECH_PUMP2, CLOSE);
    if (SafeRemoveControlCallback(SecondaryPumpControlId, SecondaryPumpCallBackFunction )==OK)
        SecondaryPumpControlId = 0xFF;
    else
        Report("Remove control callback failed",__FILE__,__LINE__,(int)SecondaryPumpControlId,RpWarning,(int)SecondaryPumpCallBackFunction,0);

    return OK;
}

void PumpActivation(uint32_t seconds)
{
    Pumps_Control(WASTECH_PUMP2, OPEN);
    SecondaryPumpControlId = AddControlCallback(NULL, SecondaryPumpCallBackFunction, seconds*1000/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
}
/*
uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode)
{
    uint8_t Status = OK;

    switch(LED_Mode)
    {
    case MODE_ON:
            F3_GPO_01_bus |= (0x01 << Button);
        break;
    case MODE_OFF:
            F3_GPO_01_bus &= ~(0x01 << Button);
        break;
    default:
        Status = ERROR;
        break;
    }

    return Status;
}
*/
uint8_t Buzzer(OPERATION_MODE Buzzer_Mode)
{
    uint8_t Status = OK;

#ifndef EVALUATION_BOARD
    switch(Buzzer_Mode)
    {
    case MODE_ON:
            //F3_GPO_01_bus |= BIT5;
            F3_GPO_01_Reg.bits.F3_GPO_BUZZER = ON;
        break;
    case MODE_OFF:
            //F3_GPO_01_bus &= ~BIT5;
            F3_GPO_01_Reg.bits.F3_GPO_BUZZER = OFF;
        break;
    default:
        Status = ERROR;
        break;
    }

    F3_GPO_01_bus = F3_GPO_01_Reg.ushort;
#endif
    return Status;
}


F3_GPI_02 F3_GPI_02_Reg;

void Read_Buttons_Reg()
{
#ifndef EVALUATION_BOARD
    F3_GPI_02_Reg.ushort = F3_GPI_02_Direct;
#endif
}

bool Get_Thread_Jogging_Button()
{
    bool IsThreadJoggingPressed = false;

#ifndef EVALUATION_BOARD
    if(F3_GPI_02_Reg.bits.Thread_Jogging_Switch == false)
        IsThreadJoggingPressed = true;
#endif

        return IsThreadJoggingPressed;
}

bool Get_Thread_Load_Button()
{
    bool IsThreadLoadPressed = false;

#ifndef EVALUATION_BOARD
    if(F3_GPI_02_Reg.bits.Thread_Load_Switch == false)
        IsThreadLoadPressed = true;
#endif

        return IsThreadLoadPressed;
}

bool Read_PWR_Button()//TODO move to GPIO folder

{
    bool IsPowerPressed = false;

    if(ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_6))
        IsPowerPressed = true;

        return IsPowerPressed;
}
/*
uint8_t Cartridges_LEDS(CARTREGE Cartridge, OPERATION_MODE LED_Mode) // CART1_LAMP, CART2_LAMP,CART3_LAMP
{
    uint8_t Status = OK;

    switch(LED_Mode)
    {
    case MODE_ON:
            F3_GPO_02_bus |= (0x01 << Cartridge);
        break;
    case MODE_OFF:
            F3_GPO_02_bus &= ~(0x01 << Cartridge);
        break;
    default:
        Status = ERROR;
        break;
    }

    return Status;
}
*/
uint8_t Last_Mode[7] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};//Leds
uint8_t Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode)
{
    uint8_t Status = OK;
    bool Flag = true;

    short Low_Reg;
    short High_Reg;

    switch(LED_Mode)
    {
    case MODE_ON:
            Low_Reg = 1;
            High_Reg = MAX_PWM_Command +1;
        break;
    case MODE_OFF:
            Low_Reg = MAX_PWM_Command +1;
            High_Reg = 1;
        break;
    //case MODE_SLOW_BLINKING://Done in ControlActivityLed
    //case MODE_FAST_BLINKING://Done in ControlActivityLed
    //case MODE_BREATHING://Done in Machine_Idle_Breathing_Led on idle mode (only for POWER)
    default:
        Flag = false;
        break;
    }

    if(Flag == true)
    {
#ifndef EVALUATION_BOARD
        switch(Pannel_Led_Id)
        {
        case POWER_ON_OFF:
            if(Last_Mode[POWER_ON_OFF] != LED_Mode)
            {
                F3_low_var_LED1 = Low_Reg;
                F3_high_var_LED1 = High_Reg;
                Machine_Idle_Mode = false;
                Last_Mode[POWER_ON_OFF] = LED_Mode;
            }
            break;
        case THREAD_JOGGING:
            if(Last_Mode[THREAD_JOGGING] != LED_Mode)
            {
                F3_low_var_LED3 = Low_Reg;
                F3_high_var_LED3 = High_Reg;
                Last_Mode[THREAD_JOGGING] = LED_Mode;
            }
            break;
        case THREAD_LOAD:
            if(Last_Mode[THREAD_LOAD] != LED_Mode)
            {
                F3_low_var_LED2 = Low_Reg;
                F3_high_var_LED2 = High_Reg;
                Last_Mode[THREAD_LOAD] = LED_Mode;
            }
            break;
        case CART_1:
            if(Last_Mode[CART_1] != LED_Mode)
            {
                F3_LOw_Cart_Led1 = Low_Reg;
                F3_High_Cart_Led1 = High_Reg;
                Last_Mode[CART_1] = LED_Mode;
            }
            break;
        case CART_2:
            if(Last_Mode[CART_2] != LED_Mode)
            {
                F3_LOw_Cart_Led2 = Low_Reg;
                F3_High_Cart_Led2 = High_Reg;
                Last_Mode[CART_2] = LED_Mode;
            }
            break;
        case CART_3:
            if(Last_Mode[CART_3] != LED_Mode)
            {
                F3_LOw_Cart_Led3 = Low_Reg;
                F3_High_Cart_Led3 = High_Reg;
                Last_Mode[CART_3] = LED_Mode;
            }
            break;
        default:
            Status = ERROR;
            break;
        }
#endif
    }
    return Status;
}

uint8_t Init_Machine_Leds()
{
    uint8_t Status = OK;
#ifndef EVALUATION_BOARD

    F3_Prescaler1_reg5 = 0x03; // PWM LED Prescaler default in FPGA just to verify

    Status |= Pannel_Leds(POWER_ON_OFF,MODE_ON);

    Status |= Pannel_Leds(THREAD_JOGGING,MODE_OFF);
    Status |= Pannel_Leds(THREAD_LOAD,MODE_OFF);

    Status |= Pannel_Leds(CART_1,MODE_OFF);
    Status |= Pannel_Leds(CART_2,MODE_OFF);
    Status |= Pannel_Leds(CART_3,MODE_OFF);
#endif
    return Status;
}

bool Is_AnyCartridge_presence()
{
    bool IsAnyCartPresent = true;
    uint16_t cartridgesPresence = BIT5 | BIT6 | BIT7;

    #ifndef EVALUATION_BOARD
        if(F3_CARTx_PRES_02_Direct & (cartridgesPresence)==cartridgesPresence)
            IsAnyCartPresent = false;
    #endif

    return IsAnyCartPresent;
}

bool Is_Cartridge_Present(PANEL_BUTTON_OR_CRAT_ID Cartridge)
{
    bool IsCartPresent = true;
#ifndef EVALUATION_BOARD

        if((Cartridge == CART_1) && (F3_CARTx_PRES_02_Direct & BIT7))
            IsCartPresent = false;
        else
        if((Cartridge == CART_2) && (F3_CARTx_PRES_02_Direct & BIT6))
            IsCartPresent = false;
        else
        if((Cartridge == CART_3) && (F3_CARTx_PRES_02_Direct & BIT5))
            IsCartPresent = false;
#endif
        return IsCartPresent;
}
bool DryerFanStopped = STOP;
bool IsDryerStopped (void)
{
    return DryerFanStopped;
}
uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)//use START or STOP,  0 - 100%
{
    uint32_t status = OK;

    F1_GPO_Reg.bits.DRYER_FAN_ON = StartStop;//0 - to turn on Blower
    F1_GPO_Reg.bits.DRYER_FAN_DIRECT = CCW;//Set Direction - TODO: Verify the correct direction
    F1_GPO_Reg.bits.DRYER_FAN_TORQUE_PWM = HIGH;//Torqer High
#ifndef EVALUATION_BOARD

    F1_gpo_01 = F1_GPO_Reg.ushort;
#endif
    if(StartStop == START)
        Control_Dryer_Fan_PWM(PWM_Command_Precent);// 0 - 100%

    DryerFanStopped = StartStop;
    return status;
}

bool Safety_Incident_Report()//TODO move to GPIO folder
{
    bool IsSafetyIncidentOccurred = No_Safety_Event;

    if(ROM_GPIOPinRead(GPIO_PORTR_BASE, GPIO_PIN_2)==0) //EPB_S1 (GPI_PS1_DC_OK)
        IsSafetyIncidentOccurred = Safety_Event_Occurred;

        return IsSafetyIncidentOccurred;
}

/*
bool Dryer_Door_Switch()//move to Get_COVER_1_State
{
    if(LS_Left.bits.F1_DR_DOOR_SW_NO)
        return OPEN;

    return CLOSE;
}
*/

char Read_HW_Version(unsigned char *Brd_ID, unsigned char *Assy_ID)
{
    //TODO Move in GPIO Initialisation

    // -----------  Set HW Version GPIO as Input -----------
    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1);
    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7);
    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5);

    //Set HW Version GPIO to Pull UP
    GPIOPadConfigSet(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU );
    GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );
    GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5,              GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );
    // ------------------------------------------------------

    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3) == GPIO_PIN_3)
        *Brd_ID |= 0x08;
    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_2) == GPIO_PIN_2)
        *Brd_ID |= 0x04;
    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_5) == GPIO_PIN_5)
        *Brd_ID |= 0x02;
    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_4) == GPIO_PIN_4)
        *Brd_ID |= 0x01;

    if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_3) == GPIO_PIN_3)//ASSY_ID3
        *Assy_ID |= 0x08;
    if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_5) == GPIO_PIN_5)//ASSY_ID2
        *Assy_ID |= 0x04;
    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_1) == GPIO_PIN_1)//ASSY_ID1
        *Assy_ID |= 0x02;
    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_7) == GPIO_PIN_7)//ASSY_ID0
        *Assy_ID |= 0x01;

    return PASSED;
}