input.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

    #define     INPUT_C
    #include    "input.h"


// ////////////////////////////////////////////////////////////////////////////
// Local Defines
// ////////////////////////////////////////////////////////////////////////////

#define BTSM_START          0x00 // Waiting for a released button.
#define BTSM_IDLE           0x01 // Button is idle.
#define BTSM_PRESSED_FIRST  0x02 // Button pressed first, waiting for release.
#define BTSM_RELEASED_FIRST 0x04 // Button released the first time.
#define BTSM_PRESSED_SECOND 0x08 // Button pressed second, waiting for release.
#define BTSM_DOUBLE_MASK    0x10 // Double push recognized.
#define BTSM_PUSH_MASK      0x20 
#define BTSM_PUSH_TEST_MASK 0x22
#define BTSM_LONG_PUSH_MASK 0x40


// ////////////////////////////////////////////////////////////////////////////
// Local Variables
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8BtnDebounce[BTN_COUNT];
static BYTE _u8BtnSM[BTN_COUNT];
static BYTE _u8PwrSM;
static WORD _u16PwrTimer;
static WORD _u16BtnTimer[BTN_COUNT];

static WORD _u16Enc;
static SHORT _s16EncVal;
static BYTE _u8EncFlags;
static SHORT _s16EncMin;
static SHORT _s16EncMax;
static SHORT _s16EncLastVal;
static SHORT _u16EncMaxInc;

static BOOL _bEncTurning;
static WORD _u16EncIncrement;
static BOOL _bEncDirection;
static BOOL _bEncTrigger;
static BYTE _u8EncPause;

// ////////////////////////////////////////////////////////////////////////////
// Local function prototypes
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bCheckPush(eButtonID eBtn);
static void initTimer(void);


// ////////////////////////////////////////////////////////////////////////////
// Function implementations
// ////////////////////////////////////////////////////////////////////////////

void InputInit(void)
{
    int i = 0;

    PORTE = 0xFF;           // 8 buttons.
    TRISE = 0xFF;

    PORTB |= 0x30;
    TRISB |= 0x30;

    PORTD = 0xFF;           // Rotary encoder.
    TRISD = 0xFF;

    // Enable pullups!
    INTCON2bits.RBPU = 0;   // For PORTB
    LATAbits.REPU = 1;      // For PORTE
    LATAbits.RDPU = 1;      // For PORTD

    // Initialize the state machines:
    for (i = 0; i < BTN_COUNT; i++)
    {
        _u8BtnDebounce[i] = 0xFF;
        _u8BtnSM[i] = BTSM_START;
        _u16BtnTimer[i] = 0;
    }
    _u8PwrSM = BTSM_START;

    _u16Enc = 0x0F;
    _bEncTurning = FALSE;
    _u16EncIncrement = 1;
    _u8EncPause = 0;
    _bEncTrigger = FALSE;

    initTimer();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputMain(void)
{
    // Reading from all the input devices and shift them into the state 
    //registers.
    BYTE i = 0;
    for (i = 0; i < BTN_COUNT; i++)
    {
        _u8BtnDebounce[i] = _u8BtnDebounce[i] << 1;
    }
    
    _u8BtnDebounce[PWR_BTN] |= PORTEbits.RE0;
    _u8BtnDebounce[SEL_BTN] |= PORTEbits.RE1;
    _u8BtnDebounce[ACC_BTN] |= PORTEbits.RE2;
    _u8BtnDebounce[FL_BTN] |= PORTEbits.RE3;
    _u8BtnDebounce[F1_BTN] |= PORTEbits.RE4;
    _u8BtnDebounce[F2_BTN] |= PORTEbits.RE5;
    _u8BtnDebounce[F3_BTN] |= PORTBbits.RB4;
    _u8BtnDebounce[F4_BTN] |= PORTBbits.RB5;
    _u8BtnDebounce[ENC_BTN] |= PORTDbits.RD0;


    // The button state machines:
    for (i = 0; i < BTN_COUNT; i++)
    {
        // The power button always will be checked for a long push separately 
        // because that's the signal for eWicht to turn off.
        if (i == PWR_BTN)
        {
            if ((_u8PwrSM == BTSM_START) && (_u8BtnDebounce[PWR_BTN] == 0xFF))
            {
                // After reseting the state machine the SM waits for a released
                // button (Release = 80 ms an inactive button).
                _u8PwrSM = BTSM_IDLE;
            }

            switch (_u8PwrSM)
            {
                case BTSM_IDLE:
                    // Waiting for a pushed button (pushed = 80 ms active).
                    if (_u8BtnDebounce[PWR_BTN] == 0x00)
                    {
                        // Push detected!
                        _u8PwrSM = BTSM_PRESSED_FIRST;
                        // Measure the push time to detect a long push:
                        _u16PwrTimer = BTN_LONG_PUSH_TIME;
                    }
                    break;          

                case BTSM_PRESSED_FIRST:
                    if (_u8BtnDebounce[PWR_BTN] == 0xFF)
                    {
                        // Not long enough pushed for a long pushed, reset the
                        // state machine and start again.
                        _u8PwrSM = BTSM_START;
                    }
                    else if ( _u16PwrTimer == 0 )
                    {
                        // Long push detected!
                        _u8PwrSM = BTSM_LONG_PUSH_MASK;
                    }
                    else
                    {
                        // Waiting...
                        _u16PwrTimer--;
                    }
                    break;
            }
        }

        if ((_u8BtnSM[i] == BTSM_START) && (_u8BtnDebounce[i] == 0xFF))
        {
            // After reseting the state machine the SM waits for a released
            // button (Release = 80 ms an inactive button).
            _u8BtnSM[i] = BTSM_IDLE;
        }
        else
        {
            switch(_u8BtnSM[i] & 0x0F)
            {
                case BTSM_IDLE:
                    // Waiting for a pushed button (pushed = 80 ms active).
                    if (_u8BtnDebounce[i] == 0x00)
                    {
                        // Push detected!
                        _u8BtnSM[i] = BTSM_PRESSED_FIRST;
                        // Wait for releasing the button (longer pushes
                        // lead to the set of the flag BTSM_LONG_PUSH_MASK).
                        _u16BtnTimer[i] = BTN_LONG_PUSH_TIME;
                    }
                    break;

                case BTSM_PRESSED_FIRST:
                    // First button push is recognized, waiting for a button
                    // release now (Release = 80 ms an inactive button).
                    if (_u8BtnDebounce[i] == 0xFF)
                    {
                        // Set the flag for a detected single push and enter
                        // the next state.
                        _u8BtnSM[i] = BTSM_RELEASED_FIRST | BTSM_PUSH_MASK;
                        // Wait some time for a second push:
                        _u16BtnTimer[i] = BTN_DOUBLE_PUSH_TIME;
                    }
                    else if (_u16BtnTimer[i] == 0)
                    {
                        // Time for a long push has elapsed, set the flag for a
                        // long push. This flag is set independently of the 
                        // button state machine. 
                        _u8BtnSM[i] = BTSM_LONG_PUSH_MASK;
                    }
                    else
                    {
                        // Decrease the timer until zero.
                        _u16BtnTimer[i]--;
                    }
                    break;

                case BTSM_RELEASED_FIRST:
                    if (_u8BtnDebounce[i] == 0x00)
                    {
                        // The second push was detected. Enter the next state 
                        // but without affecting the flags which may be set
                        // like the single and long push flags.
                        _u8BtnSM[i] &= ~BTSM_RELEASED_FIRST;
                        _u8BtnSM[i] |= BTSM_PRESSED_SECOND;
                    }
                    else if (_u16BtnTimer[i] == 0)
                    {
                        // The time for a double push has elapsed, reset the
                        // state machine (state = BTSM_START).
                        _u8BtnSM[i] &= 0xF0;
                    }
                    else
                    {
                        // Waiting...
                        _u16BtnTimer[i]--;
                    }
                    break;

                case BTSM_PRESSED_SECOND:
                    if (_u8BtnDebounce[i] == 0xFF)
                    {
                        // The double push event is perfect, the user has 
                        // released the button a second time.

                        // Set the flag for the double push event and reset the
                        // state machine (state = BTSM_START).
                        _u8BtnSM[i] &= 0xF0;
                        _u8BtnSM[i] |= BTSM_DOUBLE_MASK;
                    }
                    break;
            }
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputButtonReset(eButtonID eBtn)
{
    if (eBtn == ALL_BTN)
    {
        BYTE i = 0;
        for ( ; i < BTN_COUNT; i++)
        {
            _u8BtnSM[i] = BTSM_START;
        }
    }
    else
    {   
        _u8BtnSM[eBtn] = BTSM_START;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputButtonPushedOnce(eButtonID eBtn)
{
    if ((_u8BtnSM[eBtn] & BTSM_PUSH_TEST_MASK) == BTSM_PUSH_MASK)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputResetButtonPush(eButtonID eBtn)
{
    _u8BtnSM[eBtn] &= ~BTSM_PUSH_MASK;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputResetPowerButton(void)
{
    _u8PwrSM = BTSM_START;
    _u8BtnSM[PWR_BTN] = BTSM_START;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputButtonPushedTwice(eButtonID eBtn)
{
    if (_u8BtnSM[eBtn] & BTSM_DOUBLE_MASK)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputButtonPushedLong(eButtonID eBtn)
{
    if (eBtn == PWR_BTN)
    {
        if (_u8PwrSM == BTSM_LONG_PUSH_MASK)
        {
            return TRUE;
        }
    }
    else
    {
        if (_u8BtnSM[eBtn] == BTSM_LONG_PUSH_MASK)
        {
            return TRUE;
        }
    }
    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BYTE u8InputButtonQuickPushed(void)
{
    if (_bCheckPush(F1_BTN))
    {
        return 0;
    }
    if (_bCheckPush(F2_BTN))
    {
        return 1;
    }
    if (_bCheckPush(F3_BTN))
    {
        return 2;
    }
    if (_bCheckPush(F4_BTN))
    {
        return 3;
    }   

    return 0xFF;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL _bCheckPush(eButtonID eBtn)
{
    if (eBtn == ALL_BTN)
    {
        return FALSE;
    }
    else if ((_u8BtnSM[eBtn] & (BTSM_DOUBLE_MASK | BTSM_PUSH_MASK)) || 
        (_u8BtnSM[eBtn] == BTSM_LONG_PUSH_MASK))
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputButtonPressed(eButtonID eBtn)
{
    if (_u8BtnDebounce[eBtn] == 0x00)
    {
        return TRUE;
    }
    
    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputButtonPushed(eButtonID eBtn)
{
    if (eBtn == ALL_BTN)
    {
        eButtonID i = 0;
        for (i=PWR_BTN; i <= ENC_BTN; i++)
        {
            if(_bCheckPush(i)==TRUE)
            {
                return TRUE;
            }
        }
        return FALSE;
    }
    else 
    {
        return _bCheckPush(eBtn);
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputEncoderInit(SHORT s16Val, SHORT s16Min, SHORT s16Max, BYTE u8Flags)
{
    BOOL tmp = PIE1bits.CCP1IE;     // Remember current interrupt state.

    // Thread safe access.
    PIE1bits.CCP1IE = 0;

    if (u8Flags & ENC_NOCHANGE_MASK)
    {
        InputEncoderSetValue(s16Val, FALSE);
    }
    else
    {
        InputEncoderSetValue(s16Val, TRUE);
    }

    _s16EncMin = s16Min;
    _s16EncMax = s16Max;
    _u8EncFlags = u8Flags;

    if (((s16Max - s16Min) <= 30) || ((u8Flags & ENC_TURBO_MASK)==0))
    {
        _u16EncMaxInc = 1;
    }
    else if ((s16Max - s16Min) <= 99)
    {
        _u16EncMaxInc = 5;
    }
    else
    {
        _u16EncMaxInc = 10;
    }

    // Reset interrupt to last state.
    PIE1bits.CCP1IE = tmp;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

SHORT s16InputEncoderGetValue(void)
{
    SHORT tmpEncVal;
    BOOL tmp = PIE1bits.CCP1IE;     // Remember current interrupt state.

    // Thread safe access.
    PIE1bits.CCP1IE = 0;

    _s16EncLastVal = _s16EncVal;
     tmpEncVal = _s16EncVal;

    // Reset interrupt to last state.
    PIE1bits.CCP1IE = tmp;

    return tmpEncVal;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputEncoderSetValue(short s16NewVal, BOOL bRemember)
{
    BOOL tmp = PIE1bits.CCP1IE;     // Remember current interrupt state.

    // Thread safe access.
    PIE1bits.CCP1IE = 0;

    _s16EncVal = s16NewVal;
    if (bRemember == TRUE)
    {
        _s16EncLastVal = s16NewVal+1;// For requesting bInputEncoderValueChanged()
    }
    else
    {
        _s16EncLastVal = s16NewVal;
    }

    // Reset interrupt to last state.
    PIE1bits.CCP1IE = tmp;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInputEncoderValueChanged(void)
{
    BOOL ret = TRUE;
    BOOL tmp = PIE1bits.CCP1IE;     // Remember current interrupt state.
    PIE1bits.CCP1IE = 0;            // Thread safe access.

    if (_s16EncLastVal == _s16EncVal)
    {
        ret = FALSE;
    }

    // Reset interrupt to last state.
    PIE1bits.CCP1IE = tmp;

    return ret;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void InputForceChangedEncoderValue(void)
{
    BOOL tmp = PIE1bits.CCP1IE;     // Remember current interrupt state.
    PIE1bits.CCP1IE = 0;            // Thread safe access.

    _s16EncLastVal = _s16EncVal+1;

    // Reset interrupt to last state.
    PIE1bits.CCP1IE = tmp;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL InputEncoderGetDirection(void)
{
    return _bEncDirection;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL IsEncoderTurning(void)
{
    return _bEncTurning;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////


#if 0

static BYTE u8EncTestSM = 0;

void InputEncoderTest(void)
{
    switch(u8EncTestSM)
    {
    case 0:
        InputEncoderInit(0, 0, 10000, ENC_TURBO_MASK);
        u8EncTestSM++;
        // Intended fall through.

    case 1:
        if (bInputEncoderValueChanged() == TRUE)
        {
            lcd_addr1 = 0;
            sprintf(lcdram_row2, (ROM char *) "%hu", s16InputEncoderGetValue());
            lcd_addr2 = 0;
            lcd_status = LCD_CLR_MASK | LCD_ROW2_MASK;
        }
    }
    return;
}

#endif

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void initTimer(void)
{
    // Init the 10 ms timer:
    T3CON = 0;  // Timer1 as clock source for CCP1
    T1CON = 0;  // Stop timer.
    // Init the periode register for a 10 ms duration and 1:2 prescaler...
    CCPR1H = (GetPeripheralClock() * 0.002) / 256;
    CCPR1L = (GetPeripheralClock() * 0.002);
    CCP1CON = 0x0A;     // Compare mode, generate software interrupt on match.
    IPR1bits.CCP1IP = 0;    // Low interrupt priority.
    PIE1bits.CCP1IE = 0;    // Disable the interrupt flag.

    PIR1bits.CCP1IF = 0;    // Clearing the compare match interrupt flag.
    TMR1H = 0;              // Clearing the 
    TMR1L = 0;              // timer values.
    T1CON = 0x81;           // 16 Bit | 1:1 Prescaler | internal source | on
    PIE1bits.CCP1IE = 1;    // Enable the interrupt.
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

// Define the encoder periodic of timer in units of ms:
#define ENCODER_CYCLE   2u

#define ENCODER_PAUSE                       (250u)
#define ENCODER_PAUSE_CYCLE                 (10u)
#define ENCODER_FIRST_ACCELERATION_STEP     (30u)
#define ENCODER_SECOND_ACCELERATION_STEP    (10u)



// Calculation defines, do not change!
#define ENCODER_PAUSE_CALCED    (ENCODER_PAUSE / ENCODER_CYCLE)
#define ENCODER_PAUSE_CYCLE_CALCED  (ENCODER_PAUSE_CYCLE / ENCODER_CYCLE)
#define ENCODER_FIRST_ACCELERATION_STEP_CALCED  (ENCODER_FIRST_ACCELERATION_STEP / ENCODER_CYCLE)
#define ENCODER_SECOND_ACCELERATION_STEP_CALCED (ENCODER_SECOND_ACCELERATION_STEP / ENCODER_CYCLE)


void InputInterruptHandler(void)
{
    if (PIR1bits.CCP1IF == 0)
    {
        return;
    }


    // ////////////////////////////////////////////////////////////////////////
    // Rotary encoder input handling
    // ////////////////////////////////////////////////////////////////////////

    if (_bEncTurning == TRUE)
    {
        if (_bEncTrigger == FALSE)
        {
            if (_u8EncPause++ > ENCODER_PAUSE_CALCED)
            {
                _bEncTurning = FALSE;
                _u16EncIncrement = 1;
                _u8EncPause = 0;
            }
        }
        else
        {
            if ((_u8EncPause == 0) || (_u8EncPause > ENCODER_FIRST_ACCELERATION_STEP_CALCED))
            {
                // First step || big delay between the triggers: Small step.
                _u16EncIncrement = 1;
            }
            else if (_u8EncPause > ENCODER_SECOND_ACCELERATION_STEP_CALCED)
            {
                // Middle delay between the triggers: Middle step.
                if (_u16EncMaxInc >= 10)
                {
                    _u16EncIncrement = 5;
                }
                else
                {
                    _u16EncIncrement = _u16EncMaxInc;
                }
            }
            else
            {
                // Small delay between the triggers: Big step.
                _u16EncIncrement = _u16EncMaxInc;
            }

            _u8EncPause = ENCODER_PAUSE_CYCLE_CALCED;
        }
    }


    // Read in the rotary encoder inputs:
    _u16Enc = (_u16Enc << 2) & 0x0C;
    _u16Enc |= (PORTD >> 1) & 0x03;

    
    // Check for any pushes on the encoder button. If detected, abort the 
    // rotary input processing for a better usage.
    if(_u8BtnSM[ENC_BTN] <= BTSM_IDLE)
    {
    
        // ////////////////////////////////////////////////////////////////////////
        // Analysing the encoder value (Greycode statemachine):
        // -> Bit 3 and bit 2 are the old states, bit 1 and bit 0 are the new ones.
        // -> State transitions, which are not allowed in greycode are ignored. 
        // -> State transitions, where the old state is equal the new state are 
        //    ignored.
        // State table (4 bit means 16 possibilities):
        // Index |      Old      |      New      |  Addend for
        //       | Bit 3 | Bit 2 | Bit 1 | Bit 0 | encoder value
        //       | RIGHT | LEFT  | RIGHT | LEFT  |
        //   0   |   0   |   0   |   0   |   0   |       0     
        //   1   |   0   |   0   |   0   |   1   |       0   
        //   2   |   0   |   0   |   1   |   0   |       0
        //   3   |   0   |   0   |   1   |   1   |      -1
        //   4   |   0   |   1   |   0   |   0   |       0
        //   5   |   0   |   1   |   0   |   1   |       0
        //   6   |   0   |   1   |   1   |   0   |       0
        //   7   |   0   |   1   |   1   |   1   |       0 
        //   8   |   1   |   0   |   0   |   0   |      -1
        //   9   |   1   |   0   |   0   |   1   |       0
        //  10   |   1   |   0   |   1   |   0   |       0
        //  11   |   1   |   0   |   1   |   1   |      +1
        //  12   |   1   |   1   |   0   |   0   |      +1
        //  13   |   1   |   1   |   0   |   1   |       0
        //  14   |   1   |   1   |   1   |   0   |       0
        //  15   |   1   |   1   |   1   |   1   |       0
        // It appears from the indices when increment the encoder value: 12, 11.
        // And the decrement indices are: 3, 8. The rest of the indices are
        // don't cares.
    
    
        _bEncTrigger = FALSE;
    
        switch(_u16Enc)
        {
        case 12:
        case 11:
            if ((_bEncTurning == FALSE) || (_bEncDirection==FALSE))
            {
                // Only jump in here if the encoder wheel is already turning
                // or if turning the direction is left.
    
                _s16EncVal += _u16EncIncrement;
                _bEncTurning = TRUE;
                _bEncDirection = FALSE;
                _bEncTrigger = TRUE;
    
                if (_s16EncVal > _s16EncMax)
                {
                    if (_u8EncFlags & ENC_ENDSTOP_MASK)
                    {
                        _s16EncVal = _s16EncMax;
                    }
                    else
                    {
                        _s16EncVal = _s16EncMin;
                    }
                }
            }
            break;
    
        case 3:
        case 8:
            if ((_bEncTurning == FALSE)||(_bEncDirection==TRUE))
            {
                // Only jump in here if the encoder wheel is already turning
                // or if turning the direction is right.
    
                _s16EncVal -= _u16EncIncrement;
                _bEncTurning = TRUE;
                _bEncDirection = TRUE;
                _bEncTrigger = TRUE;
    
                if (_s16EncMin > _s16EncVal)
                {
                    if (_u8EncFlags & ENC_ENDSTOP_MASK)
                    {
                        _s16EncVal = _s16EncMin;
                    }
                    else
                    {
                        _s16EncVal = _s16EncMax;
                    }
                }
            }
            break;
        }
    }

    // Clear interrupt flag before leaving:
    PIR1bits.CCP1IF = 0;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

---