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 <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"

int MachineOnOff();
int ch_to_power_down();
int ch_to_power_up();
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 ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonsCBFunction(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(uint8_t OnOffPB,  button *pBtn);


uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);

/*
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
*/



/*
 * read GPIO status
 * port: GPIO_PORTN_BASE
 * pin : GPIO_PIN_7
 *
 * return !GPIOstatus
 */
uint32_t ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
       return 0x00;
   else
       return 0x01;
}
uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
       return 0x00;
   else
       return 0x01;
}

uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    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 = 0;    // 0=release 1=press
    power.Action = OFFPB ;   //off,short,long,count,replong
    power.color = colorOFF;   //off, blue, blink, bithing
    power.state = sttOFF; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
    power.count = 0;

    AddControlCallback( ButtonsCBFunction, BUTTOMS_SAMPLE_TIME, ButtonsCallBackFunction, 0,0,0 ); // eFiftyMillisecond

    jog.bttn_status = 0 ;
//    power.bttn_name = "power";  //option
    jog.bttn_status = 0;    // 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 ;
//    power.bttn_name = "power";  //option
   load.bttn_status = 0;    // 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 ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    ShortLongOffPB(ReadValue,&power);
    return 0;
}

uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    setJoggingEnableCondition(&jog);
    joggingMachine(ReadValue, &jog);
    return 0;
}


uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
 //   ShortLongOffPB(ReadValue,&load);
    return 0;
}

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



//OnOffPB = getPBstatus(POWER_PB);



/*
 *
 *
 */
int Get_timer()
{
    // to go  timer
    return 0;
}

int ClearTimer()
{
    //to do clear timer
    return 0;
}
int StartTimer()
{
    // to do start timer
    return 0;
}
int StopTimer()
{
    // to do start timer
    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
 *                  )
 *
 ------------------------------------------------------------*/


//ShortLongOffPB( OnOffPB, &ret)


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 ;
            }
            break;
        case COUNTPB: // last OnOffPBstate was COUNTPB
            if (OnOffPB)
            {
                if( pBtn->count > 5 ) //250ms
                {
                    pBtn->Action =  SHORTPB ;
                }
            }
            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 ");
                     StateMachine(pBtn);
                     pBtn->count = 0;
                 }
             }
             else
             {
                 REPORT_MSG(parameter,"Short PB ");
                 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;

    switch (pBtn->state)// sttON/sttOFF/sttIDLE
        {
            case sttON:
                switch (pBtn->Action)
                {
                    case LONGPB:    //Power Down
                        pBtn->state = sttOFF;  // 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;  //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; // 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;// 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)
{
    if (0
//            1.
//            2.
//            3.
//            ...
            )
        {
            pBtn->state = sttDISABLE;
            REPORT_MSG(pBtn->state,"Jogging : sttDISABLE  ");
            ThreadAbortJoggingFunc();
        }

    else
    {
        pBtn->state = sttENABLE;
        REPORT_MSG(pBtn->state,"Jogging : sttENABLE  ");
        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(uint8_t OnOffPB,  button *pBtn)
{
    if (sttDISABLE == pBtn->state)
    {
        // jogging is disable
        pBtn->color =  colorOFF;
        Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+
    }
    else
    {
        if (!OnOffPB)
        {
            ThreadAbortJoggingFunc(); // to do!!!!
            pBtn->color =  BLUE;
            Pannel_Leds(THREAD_JOGGING,MODE_ON);//AVI+
        }
        else
        {
            pBtn->color =  BLINK;
            ThreadJoggingFunc(40);
        }
    }
return 0;
}


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

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


int LoadStatMachine( PBstat PBAction,  button *pBtn)
{

    switch (pBtn->state)
    {
        case sttRDY :
            switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                    pBtn->state = sttPRELOAD;
                    pBtn->color =  BLINK;
                    if (ThreadLoadStateMachine( THREAD_LOAD_INIT))
                        {
                            pBtn->state = sttPRELOAD ;    // to do
                            pBtn->color =  BLUE;
                        }
                    else pBtn->state = sttDISABLE ;
                    break;
                default :
                    break;
            }
            break;
        case sttPRELOAD:
            switch (pBtn->Action)
            {
                case (SHORTPB):
                case (LONGPB):
                case (REPLONGPB):
                  if (ThreadLoadStateMachine( THREAD_LOAD_INITIAL_TENSION))
                    {
                        pBtn->state = sttLOADSUCSESS ;    // to do
                        pBtn->color =  BLUE;
                    }
                    else
                    {
                        pBtn->state = sttLOADFAIL ;
                        pBtn->color = fastBILNK ;    // to do
                    }
                    break;
                default :
                    break;
            }
            break;
        case sttLOADING:
            break;
//        case sttLOADSUCSESS ?????
//            break;
//        case sttLOADFAIL:    ?????
//            break;

        default: //sttDISABLE
            pBtn->color =  colorOFF;
            break;
    }
    return OK;
}


void test_avi()
{

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

    //Machine_Idle_Mode = true;

}