Hallo, hat jemand ne Idee, wie ich diese Folientastatur von Pollin mit einem Atmega16 auswerten kann? http://www.pollin.de/shop/dt/MTUzOTc1OTk-/Bauelemente_Bauteile/Mechanische_Bauelemente/Schalter_Taster/Folientastatur_15A807.html Stehe irgendwie auf dem Schlauch, denn wenn ich ja an zwei pins, beispielsweise 1 und 2 GND anlege, hab ich keine eindeutige Auswertung! Vielleicht hat ja jemand eine Idee wie das machen kann! Vielen Dank schon mal im Voraus!!! Gruß Denis
Hi, Denis schrieb: > beispielsweise 1 und 2 GND anlege, hab ich keine eindeutige Auswertung! abwechselnd 1 ODER 2 mit GND beschalten (multiplexen), dann hast Du eine Zuordnung. Gruß, Bernd
Das sieht doch bestimmt so aus:
Pin 1 ---A--------B
| |
Pin 2 ---C--------D
| |
Pin 3 Pin 4
http://www.sprut.de/electronic/pic/grund/tasten/tasten.htm
Leg alle 4 Tastenkontakte an 4 IO Pins. Tastenpin 1 und 2 als Out, 3 und 4 als Input. Dann legst Du Pin 1 auf L und 2 auf H und liest die 3 und 4 ein. Danach Pin 2 auf L und 1 auf H und liest wieder 3 und 4 ein. Ist nur eine Variante.
So wie jede Tastaturmatrix, eine Folientastatur ist da nichts besonderes. http://www.atmel.com/Images/doc2532.pdf
Pin x auf Ausgang setzen Pin x auf low setzen Pin y auf Eingang setzen Pin y pull-up einschalten Pin y Eingangslevel einlesen (low = taster zwischen x+y gedrückt, high = nicht gedrückt) Mit x=1, y=3 f für linken Taster. Für jeden der Taster wiederholen. Fertig.
Nach dem Umschalten der Richtung und der Pullups haben sich je nach Takt ein paar NOPs bewährt. Sonst liest man evtl. eher, bevor das Signal sauber ist.
Vielen Dank für die schnellen Antworten!!!
Ich nutze momentan immer die Tastenentprellung von Peter.
Hier auch einen Dank an Peter!
Kann man das Wechsel von pin 1 und 2 in die Tastenenprellung von Peter
mit einbeziehen oder wie könnte ich das machen?
Gruß Denis
/***********************************************************************
*/
/*
*/
/* Debouncing 8 Keys
*/
/* Sampling 4 Times
*/
/* With Repeat Function
*/
/*
*/
/* Author: Peter Dannegger
*/
/* danni@specs.de
*/
/*
*/
/***********************************************************************
*/
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.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 )
{
LED_PORT = 0xFF;
LED_DDR = 0xFF;
// 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){
if( get_key_short( 1<<KEY1 ))
LED_PORT ^= 1<<LED1;
if( get_key_long( 1<<KEY1 ))
LED_PORT ^= 1<<LED2;
// single press and repeat
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
uint8_t i = LED_PORT;
i = (i & 0x07) | ((i << 1) & 0xF0);
if( i < 0xF0 )
i |= 0x08;
LED_PORT = i;
}
}
}
Hallo, wie man das in die Entprellroutine mit einbringen kann, würde mich auch interessieren. Dann kann ich auch meine tasten in Matrix Form anordnen und entprellen. Also wär echt cool, wenn da jemand helfen könnte! Tim
Denis schrieb: > i = key_state ^ ~KEY_PIN; // key changed ? Du mußt nur diese eine Zeile ändern. ~KEY_PIN ist dann eben kein Macro, sondern der Returnwert einer Matrixausleseroutine. Hier ein Beispiel dazu: Beitrag "Tastenmatrix auslesen über nur 2 Leitungen" http://www.mikrocontroller.net/attachment/21656/keyboard.pdf Peter
Hallo, vielen Dank für deine Hilfe Peter! Aber ich weiß immer noch nicht so richtig, wie ich das machen muss. Bin noch relativer Anfänger, deswegen bitte Nachsicht. Kannst du mir noch etwas auf die Sprünge helfen? Gruß Tim
Tim schrieb: > Kannst du mir noch etwas auf die Sprünge helfen? Mach erst mal die Auswertung. Also das Erkennen und Auseinander-sortieren welche Taste gerade gedrückt ist. Und erst dann baust du das in die Entprellung ein. Wenn deine Auswertung funktioniert, dann überlegst du dir, wie du das in eine Funktion verpacken kannst, so dass die Funktion die Information liefert, welche Taste gerade gedrückt ist (ohne Rücksicht auf Prellen). Und diese Funktion benutzt du dann anstelle des Pin-Zugriffs im Entprellcode. Aber erst mal heißt es: Leitungen so ansteuern, dass du erkennen kannst welche Taste gerade gedrückt ist. Tips dazu wurden ja am Thread Anfang schon gegeben. Es hilft auch, wenn man sich die Sache mal ein wenig aufmalt und am Papier gedanklich durchspielt.
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.