Der Mikro C Compiler verhält sich etwas anders als die Arduino Umgebung, darum hier eine angepasste Version der Tastenentprellungsroutine. Für die Arduino-Version siehe hier.

Link: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Tasten

 

Debounced_Keys_example.c

/* ========================================================================
* Tasteneingaben
* erweitertes Beispielprogramm nach Idee von Peter Dannegger, portiert auf mikroC Pro
* ————————————————————————————–
* Version: 1.0 für mikroC Pro
* Liest bis zu 8 Taster an einem Port aus und entprellt sie, es können kurze und lange
* Tastendrücke erkannt werden, ebenso gibt es eine Autorepeat-Funktion
* ————————————————————————————–
* zur Portierung:
* 1) mikroC Pro kennt #warning nicht
* 2) includes sind nicht nötig, über search paths einbindbar (aus Arduino)
* 3) typedef müssen im lokalen File stehen, unit8_t etc.
* 4) sei(),cli() ist als Macro nachgebildet
* 5) Interrupts so: void timerinterrupt( void ) org IVT_ADDR_TIMER0_OVF
* Definitionen in ATMEGA16.c (Ctrl-Alt-D)
* ========================================================================
*/

//#include <stdint.h>
//#include <io.h>
//#include <interrupt.h>

#ifndef F_CPU
#define F_CPU 8000000 // processor clock frequency
//#warning kein F_CPU definiert
#endif

#define KEY_DDR DDRB // alles Tasten am Port B gleichzeitig auslesbar
#define KEY_PORT PORTB
#define KEY_PIN PINB
#define KEY0 0
#define KEY1 1
#define KEY2 2
#define KEY3 3
#define ALL_KEYS (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3)

#define REPEAT_MASK (1<<KEY2 | 1<<KEY3) // repeat: key2
#define REPEAT_START 100 // after 1000ms
#define REPEAT_NEXT 10 // every 100ms
#define LONG_MASK (1<<KEY1) // secondary action on long press: key1
#define LONG_START 100 // after 1000ms
#define LONG_NEXT 10 // every 100ms

#define LED_DDR DDRC
#define LED_PORT PORTC
#define LED0 0
#define LED1 1
#define LED2 2

#define CLI SREG_I_bit = 0;
#define SEI SREG_I_bit = 1;

typedef unsigned short uint8_t;
typedef signed int int16_t;

volatile uint8_t key_state; // debounced and noninverted key state:
 // bit = 0: key pressed
volatile uint8_t key_press; // key press detect
volatile uint8_t key_rpt; // key long press and repeat
volatile uint8_t key_long; // key long press no repeat

void timerinterrupt( void ) org IVT_ADDR_TIMER0_OVF // every 10ms
{
 static uint8_t ct0, ct1, rpt, secac;
 volatile uint8_t i;

 TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms

 i = key_state ^ KEY_PIN; // key changed ?
 ct0 = ~( ct0 & i ); // reset or count ct0
 ct1 = ct0 ^ (ct1 & i); // reset or count ct1
 i &= ct0 & ct1; // count until roll over ?
 key_state ^= i; // then toggle debounced state
 key_press |= key_state & i; // 0->1: key press detect
 // missing: reset key repeat when key is released

 if( (key_state & LONG_MASK) == 0 ) // check secondary function
 secac = LONG_START; // start delay
 if( --secac == 0 ){
 key_long |= key_state & LONG_MASK;
 }
 if( (key_state & REPEAT_MASK) == 0 ) // check repeat function
 rpt = REPEAT_START; // start delay
 if( --rpt == 0 ){
 rpt = REPEAT_NEXT; // repeat delay
 key_rpt |= key_state & REPEAT_MASK;
 }
}

//
// check if a key has been pressed. Each pressed key is reported only once
//
uint8_t get_key_press( uint8_t key_mask )
{
 CLI // interrupt disable
 key_mask &= key_press; // read key(s)
 key_press ^= key_mask; // clear key(s)
 SEI
 return key_mask;
}

//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported beeing pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
 CLI; // read and clear atomic !
 key_mask &= key_rpt; // read key(s)
 key_rpt ^= key_mask; // clear key(s)
 SEI;
 return key_mask;
}

//
// check if a key has been pressed long enough such that the
// secondary functionality kicks in.
//
uint8_t get_key_long( uint8_t key_mask )
{
 CLI; // read and clear atomic !
 key_mask &= key_long; // read key(s)
 key_long ^= key_mask; // clear key(s)
 SEI;
 return key_mask;
}

//
// read key state and key press atomic !
//
uint8_t get_key_short( uint8_t key_mask )
{
 CLI;
 return get_key_press( ~key_state & key_mask );
}

void main( void )
{
 uint8_t j;
 KEY_DDR &= ~ALL_KEYS; // konfigure key port for input
 KEY_PORT |= ALL_KEYS; // and turn on pull up resistors

 TCCR0 = (1<<CS02)|(1<<CS00); // divide by 1024
 TIMSK = 1<<TOIE0; // enable timer interrupt

 LED_PORT = 0xFF; // switch on all LEDs
 LED_DDR = 0xFF;

 SEI; // enable interrupts

 while(1){
 if( get_key_short( 1<<KEY0 )) // kurzer Tastendruck schaltet LED um
 LED_PORT ^= 1<<LED0;
 if( get_key_long (1<<KEY1 )) // langer Tastendruck schaltet LED um
 LED_PORT ^= 1<<LED1;

 // langer Tastendruck mit Autorepeat, die LEDS schalten sich der Reihe nach um,
 // solange die Taste gedrückt bleibt
 if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 ))
 { j = LED_PORT;
 j = (j & 0x07) | ((j << 1) & 0xF0);
 if( j < 0xF0 )
 j |= 0x08;
 LED_PORT = j;
 }

 // und invertieren
 if( get_key_press( 1<<KEY3 ) || get_key_rpt( 1<<KEY3 ))
 {
 LED_PORT ^= 0xF8;
 }
 }
}