PushButton.c

Go to the documentation of this file.

#include <stdbool.h>        // typedef bool, const true, const false
#include <stdint.h>         // typedef uint8_t, typedef uint16_t
#include <util/atomic.h>    // #define ATOMIC_BLOCK(), ATOMIC_RESTORESTATE
#include "PushButton.h"     // Prototypes of this module
#include "sysdef.h"         // BUTTON_PORT, BUTTON_PINS, BUTTON_BACK_PIN,
                            // BUTTON_DOWN_PIN, BUTTON_ENTER_PIN, BUTTON_UP_PIN
#include "Timer.h"          // WaitTimer()

/* -- Constants and types --------------------------------------------------- */

typedef enum {
    BUTTON_ENTER = 0,   
    BUTTON_BACK  = 1,   
    BUTTON_UP    = 2,   
    BUTTON_DOWN  = 3,   
    NUM_BUTTONS  = 4    
} button_t;

static const uint16_t BUTTON_PRESSED_VALUE = 5;

static const uint16_t BUTTON_REPEAT_VALUE = 50;

static const uint16_t UP_DOWN_WAIT = 250;

/*
 * Bit values (flag) for push buttons (see ucButtonStatus).
 * Used with _BV() to set or test the flags.
 * 0 = pressed, 1 = repeat, 2-6 = reserved, 7 = served
 */

#define BUTTON_PRESSED 0

#define BUTTON_REPEAT 1

#define BUTTON_SERVED 7

/* -- Variable for buttons -------------------------------------------------- */

static volatile uint16_t uiButtonDebounce[NUM_BUTTONS];

static volatile uint8_t ucButtonStatus[NUM_BUTTONS];

/* -- Function prototypes for push buttons ---------------------------------- */

static bool PushButtonSingleShotAction(button_t ucButton);

void PushButtonInit(void)
{
    // Initialize Portbits
    // set DDRx: Done by reset 
    // Pullup on
    BUTTON_PORT |= ( _BV(BUTTON_ENTER_PIN) | _BV(BUTTON_BACK_PIN)
                     | _BV(BUTTON_UP_PIN) | _BV(BUTTON_DOWN_PIN) );

    // Initialize variables
    for (button_t i = 0; i < NUM_BUTTONS; i++)
    {
        uiButtonDebounce[i] = 0;
        ucButtonStatus[i] = 0;
    }
}

#pragma GCC diagnostic push // avoid false positive on gcc 4.9.2
#pragma GCC diagnostic ignored "-Wreturn-type"
static uint8_t PushButtonReadStatus(button_t buttonIdx)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) // save SREG, cli() and restore SREG
    {
        return ucButtonStatus[buttonIdx];
    }
}
#pragma GCC diagnostic pop

static void PushButtonSetStatusServed(button_t ucButton)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        if (ucButtonStatus[ucButton] != 0)
        {
            ucButtonStatus[ucButton] |= _BV(BUTTON_SERVED);
        }
    }
}

bool PushButtonSingleShotEnter(void)
{
    return PushButtonSingleShotAction(BUTTON_ENTER);
}

bool PushButtonSingleShotBack(void)
{
    return PushButtonSingleShotAction(BUTTON_BACK);
}

bool PushButtonSingleShotUp(void)
{
    return PushButtonSingleShotAction(BUTTON_UP);
}

bool PushButtonSingleShotDown(void)
{
    return PushButtonSingleShotAction(BUTTON_DOWN);
}

static bool PushButtonSingleShotAction(button_t ucButton)
{
    uint8_t ucbut0;

    // single shot
    ucbut0 = PushButtonReadStatus(ucButton); //atomic read!!
    if ((ucbut0 >= _BV(BUTTON_PRESSED)) && ((ucbut0 & _BV(BUTTON_SERVED)) == 0))
    {
        PushButtonSetStatusServed(ucButton);
        return true;
    }
    else 
    {
        return false;
    }
}

uint8_t PushButtonGetUpDownValue(uint8_t ucbut, uint8_t ucmin, uint8_t ucmax)
{
    //TODO: ist hier UP/DOWN getauscht?
    //      DOWN: NmUhr -> ShutD -> Progr -> NmZZt -> NmAZt -> NmSZt -> NmVkz -> NmSvr -> NmUhr
    //      Nein: bei numerischen Werten ist es richtig
    uint8_t ucbut0 = 0;
    uint8_t ucbut1 = 0;

    ucbut1 = ucbut;
    // repeated action up
    ucbut0 = PushButtonReadStatus(BUTTON_UP); 
    if ((ucbut0 & _BV(BUTTON_REPEAT)) != 0)
    {
        WaitTimer(UP_DOWN_WAIT);
        ucbut1++;
        if (ucbut1 > ucmax) ucbut1 = ucmin;
    }
    else if ((ucbut0 >= 1) && ((ucbut0 & _BV(BUTTON_SERVED)) == 0))
    {
        PushButtonSetStatusServed(BUTTON_UP);
        ucbut1++;
        if (ucbut1 > ucmax) ucbut1 = ucmin;
    }
    // repeated action down
    ucbut0 = PushButtonReadStatus(BUTTON_DOWN); 
    if ((ucbut0 & _BV(BUTTON_REPEAT)) != 0)
    {
        WaitTimer(UP_DOWN_WAIT);
        ucbut1--;
        if ((ucbut1 > ucmax) || (ucbut1 < ucmin)) ucbut1 = ucmax;
    }
    else if ((ucbut0 >= 1) && ((ucbut0 & _BV(BUTTON_SERVED)) == 0))
    {
        PushButtonSetStatusServed(BUTTON_DOWN);
        ucbut1--;
        if ((ucbut1 > ucmax) || (ucbut1 < ucmin)) ucbut1 = ucmax;
    }
    return ucbut1;
}

static inline void PushButtonPressed(button_t ucButton)
{
    uiButtonDebounce[ucButton]++; // will overflow after 10 minutes
    if (uiButtonDebounce[ucButton] == BUTTON_PRESSED_VALUE)
    {
        ucButtonStatus[ucButton] |= _BV(BUTTON_PRESSED);
    }
    if (uiButtonDebounce[ucButton] == BUTTON_REPEAT_VALUE)
    {
        ucButtonStatus[ucButton] |= _BV(BUTTON_REPEAT);
    }
}

static inline void PushButtonRelease(button_t ucButton)
{
    uiButtonDebounce[ucButton] = 0;
    ucButtonStatus[ucButton] = 0;
}

void PushButtonInterrupt(void)
{
    // Enter
    if ((BUTTON_PINS & _BV(BUTTON_ENTER_PIN)) == 0)
    {
        PushButtonPressed(BUTTON_ENTER);
    }
    else
    {
        PushButtonRelease(BUTTON_ENTER);
    }

    // Back
    if ((BUTTON_PINS & _BV(BUTTON_BACK_PIN)) == 0)
    {
        PushButtonPressed(BUTTON_BACK);
    }
    else
    {
        PushButtonRelease(BUTTON_BACK);
    }

    // Up
    if ((BUTTON_PINS & _BV(BUTTON_UP_PIN)) == 0)
    {
        PushButtonPressed(BUTTON_UP);
    }
    else
    {
        PushButtonRelease(BUTTON_UP);
    }

    // Down
    if ((BUTTON_PINS & _BV(BUTTON_DOWN_PIN)) == 0)
    {
        PushButtonPressed(BUTTON_DOWN);
    }
    else
    {
        PushButtonRelease(BUTTON_DOWN);
    }
}