button.c

Go to the documentation of this file.

//mtA
//#include <inavr.h>
//#include "iom169.h"
#include <avr/io.h>
#include <avr/interrupt.h>
//#include <avr/signal.h>//This header file is obsolete.  Use <avr/interrupt.h>.
#include <inttypes.h>
//mtE

#include "main.h"
#include "types.h"
#include "button.h"
#include "timer0.h"
#include "vs1001.h"
#include "mmc.h"
#include "uart.h"

extern volatile uint8_t gPowerSaveTimer; 
extern volatile uint16  gPlayTimeSeconds;
extern volatile uint8   gMode;          // mode of player, idle, playing, off, etc
// mt  unsigned char gButtonTimeout = FALSE;
volatile uint16 gButtonTimeout = FALSE;
volatile uint8 gButtonLongTimeout =FALSE; // this is to detect long presses on the button
//mtA
//char KEY = NULL;
//char KEY_VALID = FALSE;
volatile uint8 KEY = NULL;
volatile uint8 KEY_VALID = FALSE;
volatile uint8 KEY_SHIFT = FALSE;
#ifdef MATRIX_BUTTONS 
volatile uint8 KEY_COL = 0;
#endif
//mtE

//char CountdownTimerHandle;
int long_timeout_count=0;

void ButtonTimer(void);


#ifdef MATRIX_BUTTONS 

void Matrix_timer(void)
{
    static int delay = 0;
    char temp;
    char matrixmask;
    
    matrixmask = (1<<(MATRIXCOLS))-1; // mask for all matrix bits 
    temp = MATRIXPORT  & ~matrixmask ;                // save status of port 
    if (delay++>MATRIXDELAY){
        delay = 0;                  // reset delay count
        KEY_COL++;                  // next column
        if (KEY_COL>MATRIXCOLS-1)   // limit 0..MATRIXCOLS
           KEY_COL=0;
        MATRIXPORT = (~(1<<KEY_COL) & matrixmask ) | temp  ;  // Set new scan Column
    }
        
}

void Matrix_init(void)
{
    MATRIXDDR  |= (1<<(MATRIXCOLS))-1 ;        // set to output
    MATRIXPORT |= (1<<(MATRIXCOLS))-1;                      // disable all columns
    Timer0_RegisterCallbackFunction(Matrix_timer);  // setup timer to scan matrix
}

#endif

void Button_Init(void)
{
    // Init port pins
    DDRB &= ~PINB_MASK;
    PORTB |= PINB_MASK;
    
        DDRE &= ~PINE_MASK;
    PORTE |= PINE_MASK;

    // Enable pin change interrupt on PORTB and PORTE
        PCMSK0 = PINE_MASK; 
        PCMSK1 = PINB_MASK;
        EIFR = (1<<PCIF0)|(1<<PCIF1);
        EIMSK = (1<<PCIE0)|(1<<PCIE1);

    #ifdef MATRIX_BUTTONS 
    Matrix_init();
    #endif
   
//      CountdownTimerHandle = Timer0_AllocateCountdownTimer();
}


void PinChangeInterrupt(void)
{
    uint8 buttons;

    uint8 key;

/*
    Read the buttons:

    Bit             7   6   5   4   3   2   1   0
    ---------------------------------------------
    PORTB           B   A       O
    PORTE                           D   C
    ---------------------------------------------
    PORTB | PORTE   B   A       O   D   C
    =============================================
*/


    buttons = (~PINB) & PINB_MASK;
    buttons |= (~PINE) & PINE_MASK;

    // Output virtual keys
    if (buttons & (1<<BUTTON_A))
        key = KEY_PLUS;
    else if (buttons & (1<<BUTTON_B))
        key = KEY_MINUS;
    else if (buttons & (1<<BUTTON_C))
        key = KEY_PREV;
    else if (buttons & (1<<BUTTON_D))
        key = KEY_NEXT;
    else if (buttons & (1<<BUTTON_O))
        key = KEY_ENTER;
    else
        key = KEY_NULL;
    

        
    if(key != KEY_NULL)
    {
        
#ifdef MATRIX_BUTTONS 
        key = key +  (MATRIXROWS * KEY_COL);
#endif
        
        if(gButtonTimeout)  // gButtonTimeout is set in the LCD_SOF_interrupt in LCD_driver.c
        {
                        //gButtonLongTimeout = FALSE; // clear the hold down timer
                        //long_timeout_count=0;
                        
            if (!KEY_VALID)
            {
                KEY = key;          // Store key in global key buffer
                                KEY_VALID = TRUE;
            }
                        
                        gButtonTimeout = FALSE;
                        
        }
    }else/*{ // make key only valid when released.
            if(gButtonTimeout)  // gButtonTimeout is set in the LCD_SOF_interrupt in LCD_driver.c
        {       
            if (!KEY_VALID)
            {
                KEY_VALID = TRUE;
                                KEY_SHIFT = FALSE;
            }
                        
                        gButtonTimeout = FALSE;
                        
        }
                
        
        }*/
    
    EIFR = (1<<PCIF1) | (1<<PCIF0);     // Delete pin change interrupt flags

   //gPowerSaveTimer = 0;                // Reset the Auto Power Down timer
    
}


char getkey(void)
{
    uint8 k;

    cli(); // mt: __disable_interrupt();

    if (KEY_VALID)              // Check for unread key in buffer
    {
                k=KEY;
        KEY_VALID = FALSE;
                //if (KEY_SHIFT){
                //      k += 8;
                //      KEY_SHIFT = FALSE;
        //      }
                gButtonTimeout = FALSE;
        //      gButtonLongTimeout = TRUE;
    }
    else
        k = KEY_NULL;           // No key stroke available

    sei(); // mt: __enable_interrupt();

    return k;
}


// #pragma vector = PCINT0_vect
// __interrupt void PCINT0_interrupt(void)
SIGNAL(SIG_PIN_CHANGE0)
// mtE
{
        PinChangeInterrupt();
}

// mtA
// #pragma vector = PCINT1_vect
// __interrupt void PCINT1_interrupt(void)
// mtE
SIGNAL(SIG_PIN_CHANGE1)
{
        PinChangeInterrupt();
}