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

/************************************************************************************************************************
 * buttons.c
 * buttons behaver
 *
************************************************************************************************************************/
#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 "StateMachines/Initialization/PowerOffSequence.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"

//int MachineOnOff();
int PowerDown();
int PowerUp();
int thredJog();


/*
typedef enum
{
    OFFPB = 0,
    COUNTPB ,
    SHORTPB ,
    LONGPB  ,
    REPLONGPB //repeat long PB
}PBstat;
*/
typedef enum
{
    MSEC = 0,
    lESS200 ,
    LESS500 ,
    LESS5000 ,
    MORE5000
}timems;



//enum PBstat OnOffPBstate = OFFPB;
//enum PBstat ret
//enum PBstat threadPB = OFFPB;



button power , jog, load;
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 setJoggingEnableCondition( button *pBtn);
uint32_t joggingMachine(  button *pBtn);    //uint8_t OnOffPB,


uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t LoadStatMachine( button *pBtn);


/*
void Power_Reset();
uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode);
uint8_t Buzzer(OPERATION_MODE Buzzer_Mode);
bool Read_PWR_Button();//TODO move to GPIO folder
*/


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

    return ret;
}

int PowerUp()
{
    bool ret = OK;

    return ret;
}


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


    return ret;
}
/*
 * 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();
   /*
    *
     if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
       return 0x00;
   else
       return 0x01;
    */
}
uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    return Get_Thread_Jogging_Button();
//
//    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
//       return 0x00;
//   else
//       return 0x01;
}

uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    return Get_Thread_Load_Button();
//    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
//       return 0x00;
//   else
//       return 0x01;
}

//uint32_t    AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
//Power_Reset()// Resets the MCU

#define BUTTOMS_SAMPLE_TIME 50

uint32_t Buttons_Init(void)
{

//    power.bttn_status = 0 ;
//    power.bttn_name = "power";  //option
    power.bttn_status = release;    // 0=release 1=press
    power.Action = OFFPB ;   //off,short,long,count,replong
    power.color = BLUE;   //off, blue, blink, bithing
    power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
    power.count = 0;

    AddControlCallback( ButtonPowerCBFunction, BUTTOMS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond

//    jog.bttn_status = 0 ;
//    jog.bttn_name = "jog";  //option
    jog.bttn_status = release;    // 0=release 1=press
    jog.Action = OFFPB ;   //OFFPB,short,long,count,replong
    jog.color = colorOFF;   //colorOFF, BLUE, BLINK,
    jog.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING
    jog.count = 0;
   AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //

//   load.bttn_status = 0 ;
//    load.bttn_name = "load";  //option
   load.bttn_status = release;    // 0=release 1=press
   load.Action = OFFPB ;   //OFFPB,short,long,count,replong
   load.color = colorOFF;   //colorOFF, BLUE, BLINK,
   load.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING
   load.count = 0;

   AddControlCallback( ButtonLoadCBFunction, BUTTOMS_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;
}

uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{

    jog.bttn_status = ReadValue;
    //if (ReadValue == press)
    {
        setJoggingEnableCondition(&jog);
        joggingMachine(&jog);
    }


    return 0;
}


uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    uint8_t parameter = 2;

    if ((load.bttn_status == release) && (ReadValue == press))
    {
        REPORT_MSG(parameter," ------------ Start thread loading empty function  ----------------- ");
        load.bttn_status = press;
        LoadStatMachine(&load);

    }
    else load.bttn_status = ReadValue;

    return 0;
}

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



/* ---------------------------------------------------------
 * --- 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)
{
    uint8_t parameter = 0 ;  // why we need it!!!!


    pBtn->count += OnOffPB;
    switch( pBtn->Action )
    {
        case OFFPB: // last OnOffPBstate was OFF
            if( OnOffPB )
            {
                pBtn->Action = COUNTPB ;
                REPORT_MSG(parameter," ------------ Start count PB Power  ----------------- ");
            }
            break;
        case COUNTPB: // last OnOffPBstate was COUNTPB
            if (OnOffPB)
            {
                if( pBtn->count > 5 ) //5*50ms=250ms
                {
                    pBtn->Action =  SHORTPB ;
                    REPORT_MSG(parameter," ------------ Start count PB Power  ----------------- ");
                }
            }
            else
            {
                pBtn->Action =  OFFPB ;
                pBtn->count = 0;
            }
            break;
        case SHORTPB: // last OnOffPBstate was SHORTPB
             if (OnOffPB)
             {
                 if (pBtn->count > 100) //5000ms
                 {
                     pBtn->Action =  LONGPB ;
                     REPORT_MSG(parameter," ------------ Long PB Power  ----------------- ");
                     StateMachine(pBtn);
                     pBtn->count = 0;
                 }
             }
             else
             {
                 REPORT_MSG(parameter," ------------ Short PB Power  ----------------- ");
                 StateMachine(pBtn);
                 pBtn->count = 0;
                 pBtn->Action =  OFFPB ;
             };
             break;
        case LONGPB:
             if (OnOffPB)
             {
                 REPORT_MSG(parameter," ------------ Please release the PB  ----------------- ");
             }
             else
             {
                 pBtn->Action =  OFFPB ;
                 pBtn->count = 0;
             }
             break;
       default:
           break;
    }
    return 0;
}









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



uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
{
    uint8_t parameter = 1;
    Report(" ------------ StateMachine   state  action ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,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();// todo
                        REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                        break;
//                   case SHORTPB:   //idle ?????
//                        setMachineStatus = IDLE; // ????/
//                        break;
                    default:
                        break;
                }
               break;
            case sttOFF:
                switch (pBtn->Action)
                {
//                    case LONGPB:    //Idle?
//                          // todo
//                        break;
                    case SHORTPB:   //powerup?
                         // to do ?
                        pBtn->state = sttON;
                        pBtn->color = BLUE ;
                        Pannel_Leds(POWER_ON_OFF,MODE_ON);//AVI+
                        PowerUp(); //todo
                        REPORT_MSG(parameter," ------------ Power state is ON  ----------------- ");
                        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(); // todo
                        Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down
                        REPORT_MSG(parameter," ------------ Power state is OFF  ----------------- ");
                        break;
                    case SHORTPB:   //Wake up from idle
                        pBtn->state = sttON;
                        PowerUp();  // to do ?
                        Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+
                        REPORT_MSG(parameter," ------------ Power state is ON  ----------------- ");
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
return 0;
}





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


 /* int rdJoggingEnableCondition()
 * read if we can enabl the thraed jogging
 *
 *  return 0 or 1
 *  disable OFF(0) - the machine is working now you cannot jogging the thread.
 *  enable ON(1) - joggin thread is enable
 */



uint32_t    setJoggingEnableCondition( button *pBtn)
{
    uint8_t parameter = 3;

    if (0
//         to do : what are the conditions for enable / disable
//            1.
//            2.
//            3.
//            ...
            )
        {
            pBtn->state = sttDISABLE;
            REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttDISABLE  ----------------- ");
            pBtn->color = colorOFF;
            Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+
        //    ThreadAbortJoggingFunc();
        }

    else
    {
        pBtn->state = sttENABLE;
//        REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttENABLE  ----------------- ");
        pBtn->color = BLUE;
        Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+
        //ThreadJoggingFunc(40);
    }

return 0;
}





/*int joggingMachine()
 * 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 thread button and jogigthread
 *
 */


uint32_t joggingMachine(  button *pBtn) //uint8_t OnOffPB,
{

    uint8_t parameter = 4;

    if (sttDISABLE == pBtn->state)
    {
        // jogging is disable
        REPORT_MSG(parameter," ------------joggingMachine: Jogging is Disable   ----------------- ");
        pBtn->Action = OFFPB;
        pBtn->color =  colorOFF;
        Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+
    }
    else
    {
        if ( (pBtn->Action != OFFPB) && (pBtn->bttn_status == release))
        {
            REPORT_MSG(parameter," ------------joggingMachine:  Jogging OnOffPB == 00----------------- ");
            REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
            pBtn->Action = OFFPB;
            ThreadAbortJoggingFunc(); // to do!!!!
            pBtn->color =  BLUE;
            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
        }
        else if ((pBtn->Action == OFFPB) && (pBtn->bttn_status == press))
        {
            pBtn->Action = LONGPB;
            REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1   ----------------- ");
            REPORT_MSG(parameter," ------------joggingMachine: start Jogging    ----------------- ");
            pBtn->color =  BLINK;
            ThreadJoggingFunc(40);
        }
//        if (pBtn->bttn_status == press)ThreadJoggingFunc(40);
//        else
//        {
//            pBtn->Action = OFFPB;
//            REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
//        }
    }



//        if (OnOffPB == release)
//        {
//            REPORT_MSG(parameter," ------------joggingMachine:  Jogging OnOffPB == 00----------------- ");
//            REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
//            pBtn->Action = OFFPB;
//            ThreadAbortJoggingFunc(); // to do!!!!
//            pBtn->color =  BLUE;
//            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
//        }
//        else
//        {
//            if (pBtn->Action == OFFPB)
//            {
//                pBtn->Action = LONGPB;
//                REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1   ----------------- ");
//                REPORT_MSG(parameter," ------------joggingMachine: start Jogging    ----------------- ");
//                pBtn->color =  BLINK;
//                ThreadJoggingFunc(40);
//            }
//            else
//            {
//                REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
//            }
//
//        }
//    }
return 0;
}


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

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


uint32_t LoadStatMachine( button *pBtn)
{
    //uint8_t parameter = 5;

    //REPORT_MSG(parameter," ------------ start loading    ----------------- ");
    Report(" ------------ start loading    ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->color,0);
    switch (pBtn->state)
    {
        case sttRDY :
            switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->state = sttPRELOAD;
                    pBtn->color =  BLINK;
                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    if (ThreadLoadStateMachine( THREAD_LOAD_INIT))
                    {
                        pBtn->state = sttPRELOAD ;    // to do
                        pBtn->color =  BLUE;
                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    else
                    {
                        pBtn->state = sttDISABLE ;
                        Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
                    }
                    break;
                default :
                    break;
            }
            break;
        case sttPRELOAD:
            switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->color =  BLUE;
                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    if (ThreadLoadStateMachine( THREAD_LOAD_INITIAL_TENSION))
                    {
                        pBtn->state = sttLOADSUCSESS ;    // to do
                        pBtn->color =  BLUE;
                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    else
                    {
                        pBtn->state = sttLOADFAIL ;
                        pBtn->color = fastBILNK ;    // to do
                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                    }
                    break;
                default :
                    break;
            }
            break;
        case sttLOADING:
            break;
//        case sttLOADSUCSESS ?????
//            break;
//        case sttLOADFAIL:    ?????
//            break;

        default: //sttDISABLE
            pBtn->color =  colorOFF;
            Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
            break;
    }
    return OK;
}


void test_avi()
{

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

    //Machine_Idle_Mode = true;

}