path: root/Software/Embedded_SW/Embedded/Modules/General/buttons.c

/************************************************************************************************************************
 * buttons.c
 * buttons behaver
 *
************************************************************************************************************************/

/**
 * @file buttons.c
 *
 * @brief  buttons behaver
 * @date   23.10.2019
 * @author Shai
 */


#include <Container.h>
#include <DataDef.h>
#include "include.h"

#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
#include "DataDef.h"  //  use for FPGA IO
#include "Modules/Control/control.h" //  use for FPGA IO
#include "Modules/General/buttons.h"
#include "StateMachines/Printing/PrintingSTM.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"

#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <driverlib/gpio.h>
#include "Common/report/report.h"
#include "Modules/Thread/Thread_ex.h"

#include "Modules/General/buttons.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/PowerIdle.h"

int PowerDown();
int PowerUp();
int thredJog();

#define BUTTONS_SAMPLE_TIME (eHundredMillisecond)
#define SECOND1 (1000/BUTTONS_SAMPLE_TIME)
#define SECOND2 (2000/BUTTONS_SAMPLE_TIME)
#define SECOND5 (5000/BUTTONS_SAMPLE_TIME)

button power, jog, load, cart1, cart2, cart3;
uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn);
uint32_t StateMachine( button *pBtn);


uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint8_t  thraedJogging(uint8_t off);


uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);
//uint32_t LoadStatMachine( button *pBtn);
//uint32_t LoadLongPress( button *pBtn);
bool get_pbAction ( button *pBtn, PB_Status ReadValue);

int JogSpeed = 40;
#define LOADLONGPRESS 3

int PowerDown()
{
    bool ret = !OK;
    ret = PowerOffInit();

    return ret;
}

int PowerUp()
{
    bool ret = OK;

    PowerIdleOutOfIdleState();

    return ret;
}

bool SetPowerMachineState(PBmachineState state)
{
    bool ret = OK;
    switch ( state )
    {
        case sttOFF:
        case sttON:
        case sttIDLE:
            power.state = state;
           break;
        case sttDISABLE:
        case sttENABLE:
        case sttJOGGING:
            jog.state = state;
            break;
        case sttRDY:
        case sttPRELOAD:
        case sttLOADING:
        case sttLOADSUCSESS:
        case sttLOADFAIL:
            load.state = state;
            break;
        default:
              break;
    }


    return ret;
}

/**
 * @file buttons.c
 *
 * @brief  detect push buttons actions
 *    OFFPB = 0, //notCOUNT
 *     COUNTPB ,
 *     SHORTPB ,
 *     LONGPB  ,
 *     REPLONGPB //repeat long PB
 * @return OK
 */
bool get_pbAction (button *pBtn, PB_Status ReadValue )
{
    pBtn->bttn_status = ReadValue;
    switch (pBtn->Action)
    {
        case OFFPB:
            if (ReadValue == PRESS)
            {
                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: OFFPB -> COUNTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                pBtn->count = 1 ;
                pBtn->Action = COUNTPB;
            }
            else
            {
                pBtn->count = 0 ;
                pBtn->Action = OFFPB;
            }
            break;
        case COUNTPB:
            if (ReadValue == PRESS)
            {
                pBtn->count += 1 ;
                if (pBtn->count > SECOND5)
                {
                    pBtn->Action = LONGPB;
                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> LONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                }
            }
            else
            {
                if (pBtn->count > SECOND1)
                {
                    pBtn->Action = SHORTPB;
                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> SHORTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                }
                else
                {
                    pBtn->Action = OFFPB;
                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                }
                pBtn->count = 0 ;
            }
            break;
        case SHORTPB:
            if (ReadValue == PRESS)
            {
                pBtn->count += 1 ;
                if (pBtn->count > SECOND5)
                {
                    pBtn->Action = LONGPB;
                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> LONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                }
            }
            else
            {
                pBtn->Action = OFFPB;
                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                pBtn->count = 0 ;
            }
            //pBtn->Action = OFFPB;
            //ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: SHORTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            break ;
        case LONGPB:
            if (ReadValue == RELEASE)
            {
                pBtn->count = 0 ;
                pBtn->Action = OFFPB;
                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: LONGPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            }
            else
            {
                pBtn->Action = REPLONGPB;
                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: LONGPB -> REPLONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            }
            break ;
        case REPLONGPB:
            if (ReadValue == RELEASE)
            {
                pBtn->count = 0 ;
                pBtn->Action = OFFPB;
                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: REPLONGPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            }
            break ;
        default:
            break;
    }
    return OK;
}


/*
 * read GPIO status
 * port: GPIO_PORTN_BASE
 * pin : GPIO_PIN_7
 *
 * return !GPIOstatus
 */
uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
   return Read_PWR_Button();
}

uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    if (jog.state != sttDISABLE)
    {
        ReadValue = Get_Thread_Jogging_Button();
        get_pbAction (  &jog, ReadValue );
    }
    return ReadValue;
}

uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    ReadValue = Get_Thread_Load_Button();
    get_pbAction (  &load, ReadValue );

    return OK;
}


uint32_t Buttons_Init(void)
{
    strcpy(power.bttn_name, "power");
    power.bttn_status = RELEASE;    // 0=RELEASE 1=PRESS
    power.Action = OFFPB ;   //off,short,long,count,replong
    power.color = colorON;   //off, blue, blink, bithing
    power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
    power.count = 0;

    Task_sleep(15);
    AddControlCallback("ButtonPowerCB", ButtonPowerCBFunction, BUTTONS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond

    strcpy(jog.bttn_name, "jog");
    jog.bttn_status = RELEASE;    // 0=RELEASE 1=PRESS
    jog.Action = OFFPB ;   //OFFPB,short,long,count,replong
    jog.color = colorON;   //colorOFF, BLUE, BLINK,
    Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
    jog.state = sttENABLE; // sttDISABLE, sttENABLE, sttJOGGING
    jog.count = 0;

    Task_sleep(15);
    AddControlCallback("ButtonJogCB", ButtonJogCBFunction, BUTTONS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //

    strcpy(load.bttn_name, "load");
    load.bttn_status = RELEASE;    // 0=RELEASE 1=PRESS
    load.Action = OFFPB ;   //OFFPB,short,long,count,replong
    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
    load.color = colorON;   //colorOFF, BLUE, BLINK,
    load.state = sttRDY; //
    load.count = 0;

    Task_sleep(15);
    AddControlCallback("ButtonLoadCB", ButtonLoadCBFunction, BUTTONS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
return OK;
}


//read the buttons data here and handle
uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    ShortLongOffPB(ReadValue,&power);
    return 0;
}


/*ButtonJogCBFunction()
 * state machine for thread jogging button:
 * 1. OFF - when the machine is working
 * 2. blue - when the machin is not workig so we can jog thread
 * 3. blink - when pushing the JOG button
 *            when pushing the JOG more the 5 second
 *
 */
uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    switch (jog.state)
    {
        case sttDISABLE:
           if (JobIsActive() == false)
           {
               ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: jog.state=sttDISABLE , JobIsActive() == false-----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
               jog.color =  colorON;
               Pannel_Leds(THREAD_JOGGING, MODE_ON);
               jog.state = sttENABLE;
           }
           break;
        case sttENABLE:
            if (JobIsActive() == true)
            {
                 ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                 jog.Action = OFFPB;
                 jog.color =  colorOFF;
                 Pannel_Leds(THREAD_JOGGING,MODE_OFF);
                 jog.state = sttDISABLE;
            }
            else
            {
                if (jog.Action == COUNTPB)
                {
                    ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                    jog.color =  colorON;
                    jog.color =  BLINK;
                    ThreadJoggingFunc(JogSpeed);
                    jog.state = sttJOGGING;
                }
            }

//            if (jog.Action == COUNTPB)
//            {
//                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
//                jog.color =  colorON;
//                jog.color =  BLINK;
//                ThreadJoggingFunc(40);
//                jog.state = sttJOGGING;
//            }
//            else
//            {
//                if (JobIsActive() == true)
//                {
//                     ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
//                     jog.Action = OFFPB;
//                     jog.color =  colorOFF;
//                     Pannel_Leds(THREAD_JOGGING,MODE_OFF);
//                     jog.state = sttDISABLE;
//                }
//            }
            break;
        case sttJOGGING:
            if (jog.Action == OFFPB) //PB is OFF
            {
                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action SHORTPB, sttJOGGING -> sttENABLE,  stop JOGGING----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                ThreadAbortJoggingFunc(); 
                jog.color =  colorON;
                Pannel_Leds(THREAD_JOGGING, MODE_ON);
                jog.state = sttENABLE;
            }
            else if (jog.Action == LONGPB)
            {
                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action LONGPB,  sttJOGGING -> sttLONG_JOGGING-----------------", __FILE__,__LINE__, jog.state, RpMessage, jog.Action, 0);
                jog.state = sttLONG_JOGGING;
            }
            break;
        case sttLONG_JOGGING:
             if (jog.Action == COUNTPB)
             {
                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttLONG_JOGGING action COUNTPB,  sttLONG_JOGGING -> sttENABLE, stop JOGGING-----------------", __FILE__,__LINE__, jog.state, RpMessage, jog.Action, 0);
                ThreadAbortJoggingFunc();
                jog.color =  colorON;
                Pannel_Leds(THREAD_JOGGING, MODE_ON);
                jog.state = sttENABLE;
             }
             if (JobIsActive() == false) // added because sometimes the jog stops because of another reason and the button s stucked blinking
             {
                 jog.color =  colorON;
                 Pannel_Leds(THREAD_JOGGING, MODE_ON);
                 jog.state = sttENABLE;
             }
            break;
        default:
            break;
    }
    return OK;
}




uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
   switch (load.Action)
   {
       case SHORTPB:
           ReportWithPackageFilter(GeneralFilter,"------------ thread loading SHORTPB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
           if (ThreadLoadingActive() == true)
               ThreadLoadButton(0);  //fix failures and continue of planned stop
           break;
       case LONGPB:
           ReportWithPackageFilter(GeneralFilter,"------------ thread loading LONGPB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
           if (ThreadLoadingActive() == false)
		   {
               ReportWithPackageFilter(GeneralFilter,"------------ NOT starting loading from button  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
               //ThreadLoadButton(0); //INIT CHANGE HERE FOR 1.4.6.44
		   }
           else
               Thread_Load_End(); //END
           break;
       case REPLONGPB:
           ReportWithPackageFilter(GeneralFilter,"------------ thread loading REPLONGPB please release the PB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
           break;
       default:
           if (ThreadLoadingActive() == false)
           {
               if (JobIsActive())
               {
                   load.color =  colorOFF;
                   Pannel_Leds(THREAD_LOAD, MODE_OFF);
               }
               else
               {
                   load.color =  colorON;
                   Pannel_Leds(THREAD_LOAD, MODE_ON);
               }
           }
           break;
   }
return OK;
}

/*---------------------------------------------------------------------------------*/



/* ---------------------------------------------------------
 * --- ShortLongOffPB(int OnOffPB, enum PBstat *ret) ----
 * input:   OnOffPB status(0(pressed) or 1(relesed)
 *
 * output:  offPB, countPB, shortPB, longPB, replongPB
 *
 * that func get :
 *  OnOffPB status (
 *                  0=release,
 *                  1=pressed
 *                  )
 *
 ------------------------------------------------------------*/




uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn)
{

    pBtn->count += OnOffPB;
    switch( pBtn->Action )
    {
        case OFFPB: // last OnOffPBstate was OFF
            if( OnOffPB )
            {
                pBtn->Action = COUNTPB ;
                ReportWithPackageFilter(GeneralFilter,"------------ Start count PB Power  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            }
            break;
        case COUNTPB: // last OnOffPBstate was COUNTPB
            if (OnOffPB)
            {
                if( pBtn->count > SECOND1 )
                {
                    pBtn->Action =  SHORTPB ;
                    ReportWithPackageFilter(GeneralFilter,"------------ 1 seconds count PB Power  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                }
            }
            else
            {
                pBtn->Action =  OFFPB ;
                pBtn->count = 0;
            }
            break;
        case SHORTPB: // last OnOffPBstate was SHORTPB
             if (OnOffPB)
             {
                 if (pBtn->count > SECOND5)
                 {
                     pBtn->Action =  LONGPB ;
                     ReportWithPackageFilter(GeneralFilter,"------------ Long PB Power  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                     StateMachine(pBtn);
                     pBtn->count = 0;
                 }
             }
             else
             {
                 ReportWithPackageFilter(GeneralFilter,"------------ Short PB Power  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                 StateMachine(pBtn);
                 pBtn->count = 0;
                 pBtn->Action =  OFFPB ;
             };
             break;
        case LONGPB:
             if (OnOffPB)
             {
                 ReportWithPackageFilter(GeneralFilter,"------------ Please release the PB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             }
             else
             {
                 pBtn->Action =  OFFPB ;
                 pBtn->count = 0;
             }
             break;
       default:
           break;
    }
    return OK;
}









/* --- StateMachine(enum PBstat PBAction) ----
 * input:
 *
 * output:  offPB, countPB, shortPB, longPB, replong
 *
 *
 */



uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
{

    ReportWithPackageFilter(GeneralFilter,"------------ StateMachine   state  action  -----------------", __FILE__,__LINE__,pBtn->state, RpMessage, pBtn->Action, 0);

    switch (pBtn->state)// sttON/sttOFF/sttIDLE
        {
            case sttON:
                switch (pBtn->Action)
                {
                    case LONGPB:    //Power Down
                        pBtn->state = sttOFF;
                        pBtn->color =  colorOFF;
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
                        PowerDown();
                        ReportWithPackageFilter(GeneralFilter,"------------ Power state is OFF  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                        break;
//                   case SHORTPB:   //idle ?????
//                        setMachineStatus = IDLE; // ????/
//                        break;
                    default:
                        break;
                }
               break;
            case sttOFF:
                switch (pBtn->Action)
                {
//                    case LONGPB:    //Idle?

//                        break;
                    case SHORTPB:   //powerup?
                         // to do ?
                        pBtn->state = sttON;
                        pBtn->color = colorON ;
                        Pannel_Leds(POWER_ON_OFF,MODE_ON);//AVI+
                        PowerUp();
                        ReportWithPackageFilter(GeneralFilter,"------------ Power state is ON  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                        break;
                    default:
                        break;
                }
               break;
            case sttIDLE:
                switch (pBtn->Action)
                {
                    case LONGPB:    //Power off from idle
                        pBtn->state = sttOFF;
                        pBtn->color =  colorOFF;
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+
                        PowerDown();
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down
                        ReportWithPackageFilter(GeneralFilter,"------------ Power state is OFF  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                        break;
                    case SHORTPB:   //Wake up from idle
                        pBtn->state = sttON;
                        PowerUp();  // to do ?
                        Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+
                        ReportWithPackageFilter(GeneralFilter,"------------ Power state is ON -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
return OK;
}


/*------------------------------------------------------------------------------*/

/*------     THREAD LOAD/UNLOAD        ----------*/


/*uint32_t LoadStatMachine( button *pBtn)
{

    ReportWithPackageFilter(GeneralFilter,"------------ (state) (color) -----------------", __FILE__,__LINE__,pBtn->state, RpMessage, pBtn->color, 0);
    switch (pBtn->state)
    {
        case sttRDY :
            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttRDY -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            switch (pBtn->Action)
            {
                case (SHORTPB):
                //case (LONGPB):
                case (REPLONGPB):
                    pBtn->state = sttPRELOAD;
//                    pBtn->color =  BLINK;
                    if (ThreadLoadButton( THREAD_LOAD_INIT)== OK)
                    {
                        pBtn->state = sttPRELOAD ;    // to do
//                        pBtn->color =  colorON;
//                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
//                    else
//                    {
//                       // pBtn->state = sttDISABLE ;
//                        Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
//                    }
                    break;
                case (LONGPB):
                    Thread_Load_End();
                        break;
                default :
                    break;
            }
            break;
        case sttPRELOAD:
            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttPRELOAD -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            /`*switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->color =  BLUE;
                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*`/
                    if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION)== OK)
                    {
                        pBtn->state = sttRDY ;    // to do
//                        pBtn->color =  colorON;
//                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    else
                    {
                        //pBtn->state = sttLOADFAIL ;
//                        pBtn->color = fastBILNK ;    // to do
                    }
                    /`*break;
                default :
                    break;
            }*`/
            break;
        case sttLOADING:
            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttLOADING -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
//            pBtn->color =  fastBILNK;
//            Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
            if (ThreadLoadButton( THREAD_LOAD_END)== OK)
            {
                pBtn->state = sttRDY ;    // to do
//                pBtn->color =  colorON;
//                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
            }
            else
            {
                pBtn->state = sttRDY ;    // to do
                //pBtn->state = sttLOADFAIL ;
//                pBtn->color = fastBILNK ;    // to do
            }
            break;
//        case sttLOADSUCSESS ?????
//            break;
//        case sttLOADFAIL:    ?????
//            break;

        default: //sttDISABLE
            ReportWithPackageFilter(GeneralFilter,"------------ load.state = default -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            pBtn->state = sttRDY ;    // to do
            pBtn->color =  BREATHING;
            Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
            break;
    }
    return OK;
}*/

void test_avi()
{

    power.color = BLINK;
    //power.color = fastBILNK

    //Machine_Idle_Mode = true;

}

/*uint32_t LoadLongPress( button *pBtn)
{
    ReportWithPackageFilter(GeneralFilter,"------------ load.state = LoadLongPress -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
    Thread_Load_End();
/`*    switch (pBtn->state)
    {
        case sttRDY :
            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttRDY -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            if (ThreadLoadButton( THREAD_LOAD_INIT)== OK)
            {
                pBtn->state = sttPRELOAD ;    // to do
                pBtn->color =  colorON;
                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
            }
            else
            {
               // pBtn->state = sttDISABLE ;
                Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
            }
            break;
        default:
            Thread_Load_End();
    }*`/
    return OK;
}*/