taster abfrage

[andreas (Gast)]

guten tag,
ich benutze die
taster-Entprell-Routine von Peter Dannegger die auch super Funktioniert.
Nun hab ich das Problem, ich hab eine eigene selbstgeschrieben Funktion 
in einer externen C-Datei die auch eingebunden ist, wenn ich in dieser 
Funktion
die Taster-Abfrage reinschreibe bekomm ich Folgende Warnings angezeigt:
implicit declaration of funktion 'get_key_short'
implicit declaration of funktion 'get_key_press'
implicit declaration of funktion 'get_key_rpt'

Die Warnung besagt, daß eine Funktion verwendet wird, für welche der
Compiler den Prototyp raten muss.

Bloss wie mach ich den Prototyp für diese Funktion zugänglich.
mfg

[Ben S. (theben)]

prototypen werden eigentlich immer in ein h (header) file geschrieben
Also zB. key.c ist dan die Header Datei key.h

[andreas (Gast)]

vielleicht könnte mir jemand von ihnen einen Tip geben
wie ich die warnings beseitigen kann.
mfg


in meiner led.h steht:
extern void ledan(void);

in meiner led.c steht:
void ledan(void)
{
   if ( get_key_short( 1<<key1 )){
    PORTC |=  (1 << PC3);
    }
   if ( get_key_short( 1<<key1 )){
    PORTC &= ~(1 << PC3);
    }
}

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/
 
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#include "led.h"

 
#ifndef F_CPU
#define F_CPU           1000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif
 
#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)
 
#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms
 
#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LED0            0
#define LED1            1
#define LED2            2
 
volatile uint8_t key_state;                                // debounced and inverted key state:
                                                  // bit = 1: key pressed
volatile uint8_t key_press;                                // key press detect
 
volatile uint8_t key_rpt;                                  // key long press and repeat
 
 
ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  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
 
  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();                                          // read and clear atomic !
  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 being 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;
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
  cli();                                          // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}
 
int main( void )
{
      
 
  // Configure debouncing routines
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors
 
  TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt
 
  sei();
 
  while(1){
    ledan();
    }
  }
}

[Karl H. (kbuchegg)]

andreas schrieb:
> vielleicht könnte mir jemand von ihnen einen Tip geben
> wie ich die warnings beseitigen kann.

Du brauchst ein Header File, in dem du die Protoypen der Funktionen 
reinmachst. So wie man das bei allen Funktionen macht, die in einem 
anderen C-File existieren und von wo ganz woanders aufgerufen werden 
sollen.

key.h
*****

uint8_t get_key_press( uint8_t key_mask );
uint8_t get_key_rpt( uint8_t key_mask );
uint8_t get_key_short( uint8_t key_mask );
uint8_t get_key_long( uint8_t key_mask );

Und dieses Header File inkludierst du dann in main.c (zur Sicherheit) 
und in allen anderen C-Files, die die Funktionen benutzen möchten.

Hast du doch mit den Funktionen aus led.c auch nicht anders gemacht. Du 
hast dir eine led.h gemacht, in der die entsprechenden 
Funktionsprototypen enthalten sind.

Bei deinem bisherigen Vorgehen war das nicht notwendig, weil die 
Funktionen in main.c enthalten waren und vor der ersten Verwendung 
definiert wurden. In dem Fall gilt dann die Funktionsdefinition als ihr 
eigener Prototyp und daher brauchte man für einen Aufruf in main.c keine 
expliziten Protoypen. Aber jetzt sollen sie von woanders aufgerufen 
werden und daher sind dann Protoypen dafür notwendig. So gesehen sind 
die Funktionen in main.c um nichts anders als jede andere Funktion in 
irgendeinem sonstigen File, welches zum Projekt gehört, auch.

[Karl H. (kbuchegg)]

PS:

Das hier

void ledan(void)
{
   if ( get_key_short( 1<<key1 )){
    PORTC |=  (1 << PC3);
    }
   if ( get_key_short( 1<<key1 )){
    PORTC &= ~(1 << PC3);
    }
}

wird so nicht funktionieren. So schnell und so exakt bist du als Mensch 
nicht, dass du exakt einen Tastendruck zwischen die beiden (identischen) 
Abfragen platzieren kannst.

Wenn du mit einem Tastendruck eine LED umschalten willst, dann musst du 
das etwas anders angehen.
Wundert mich jetzt aber, denn genau das gleiche Problem hast du ja auch, 
wenn alles, also auch die LED Funktion, in der main.c enthalten wäre.