Entprellungsproblem MSP430

[A. H. (dernetteeddie1978)]

Hi,

ich versuche schon die ganze Zeit mein Entprellungsproblem zu lösen und 
schnalls einfach net.

Eigentlich will ich nur die rote LED blinken lassen und mit Druck auf 
den Taster die güne ein- und wieder ausschalten.

Leider schaltet die güne LED kurz nach Tastendruck ab und zu ein zweites 
Mal (je nachdem entweder ein oder aus) aber auch nicht immer. Auch 
schaltet sie bei Tastendruck manchmal verzögert.

Eigentlich dachte ich mir der Tastendruck löst einen Interrupt aus, in 
dem  die Interrupts des P1 disabled und die Flags gelöscht werden und 
die grüne LED geschaltet wird. Innerhalb dieses Interrupts schalte ich 
den Watchdog auf Intervall und mit erreichen desselben wird ein zweiter 
Interrupt ausgelöst in dem der Interrupt für P1 wieder aktiviert wird. 
Dann solls von vorne losgehen.

Was ich rausfinden konnte ist dass die Interruptroutine von P1 teilweise 
zweimal ausgelöst wird. Ich hatte in beide ISR`s je eine Zählvariable 
eingefügt. Die Frage ist wieso? In der ISR von P1 werden die Interrupts 
von P1 ja disabled und erst nach 250ms wiedre aktiviert. Von daher 
solltre ein prellen ausgeschlossen sein.

/*
 * main.c
 */


#include "msp430g2553.h"

void InitializeClocks(void);

void main(void) {
  
  InitializeClocks();

  WDTCTL = WDTPW + WDTHOLD;
  IFG1 &= ~OFIFG;
  P1DIR = BIT6+BIT0;
  P1REN = BIT3;
  P1OUT = BIT3;
  P1IES = BIT3;
  P1IFG = 0;
  IFG1 &= ~WDTIFG;                     /* clear interrupt flag */
  P1IE = BIT3;
  _BIS_SR(GIE);

  while(1)
  {
    __delay_cycles(500000);
      P1OUT ^= BIT0;
  }
}

void InitializeClocks(void)
{
  BCSCTL1 = CALBC1_1MHZ;                    // Set range
  DCOCTL = CALDCO_1MHZ;
  BCSCTL2 &= ~(DIVS_3);                     // SMCLK = DCO = 1MHz
  BCSCTL1 |= DIVA_1;                        // ACLK/2
  BCSCTL3 |= LFXT1S_2;                      // ACLK = VLO
}

#pragma vector=PORT1_VECTOR
__interrupt void PORT1_ISR (void)
{
  P1IE &= ~BIT3;
  P1IFG = 0;
  IE1 |= WDTIE;
  P1OUT^=BIT6;
  WDTCTL = WDT_ADLY_250;


}

// WDT Interrupt Service Routine used to de-bounce button press
#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR(void)
{
  IE1 &= ~WDTIE;                   /* disable interrupt */
    IFG1 &= ~WDTIFG;                 /* clear interrupt flag */
    WDTCTL = WDTPW + WDTHOLD;        /* put WDT back in hold state */
    P1IE |= BIT3;                  /* Debouncing complete */
}

[Karl H. (kbuchegg)]

A. H. schrieb:


> eingefügt. Die Frage ist wieso? In der ISR von P1 werden die Interrupts
> von P1 ja disabled und erst nach 250ms wiedre aktiviert.

Tja. Aber nur weil du Interrupts disabled hast, werden sie ja deswegen 
nicht verworfen.
Selbstverständlich wird ein Interrupt Ereignis auch dann registriert, 
wenn die Interrupts disabled sind. Einzig das Auslösen des Aufrufs der 
ISR unterbleit, aber der µC hat sich in einem Bit in einem Register 
gemerkt, dass eine entsprechende 'Anforderung' eingetroffen ist. Und 
sobald die Interrupts wieder freigegeben werden, wird dann dieser 
Interrupt 'nachgeholt'.

Also entweder du suchst dir in der Doku, welches Bit in welchem Register 
diese 'Speicherung' macht und löscht es, bevor du die Interrupts wieder 
freigibst oder du akzeptierst, dass man zum Abfragen von Tasten keine 
externen Interrupts braucht, sondern das genau das im Grunde genommen 
mehr Aufwand ist, als wie wenn du das genau so machst wie es der Rest 
der (vernünftigen) Programmiererwelt auch macht: mit einem Timer, der 
alle paar Millisekunden einen Interrupt auslöst, in dem ganz banal 
nachgesehen wird, ob die Taste gedrückt ist und wenn in der Interrupt 
Routine das zb 4 mal hintereinander festgestellt wurde, dann gilt die 
Taste als gedrückt. So schnell kannst du als Mensch eine Taste gar nicht 
drücken und wieder loslassen, dass der µC mit seiner 'Nachschau' alle 
paar Millisekunden das nicht mitbekommen würde.

[A. H. (dernetteeddie1978)]

Okay,

danke für die schnelle Hilfe. Ich dachte man sollte nen Taster per 
Interrupt abfragen eben damit nicht ständig nachgeschaut werden muss. So 
hette ich es auch mal in nem Lehrbuch gelesen. Ist auch mein erstes µC 
Programm...

Den Code hatte ich aus dem, von Werk beim Launchpad mitgelieferten, 
Demoprogramm Temperaturesense genommen und adaptiert.

So oder so ist dein Vorschlag natürlich auch ne gute Idee an sowas 
heranzugehen. Vor allem weil es kompliziertere Entprellmechanismen 
umgeht.

Was unun den Fehler anbelangt, so versteh ich das noch nicht ganz. Ich 
lösche ja in der ISR alle Flags, und schalte dann nur den Enable für den 
Port des Tasters wieder ein. Der Rest ist aus.

LG

[A. H. (dernetteeddie1978)]

Okay, habs grad gerafft. Ich muss die Flags natürlich nach der 
Warteschleife löschen.

[A. H. (dernetteeddie1978)]

#pragma vector=PORT1_VECTOR
__interrupt void PORT1_ISR (void)
{
  P1IE &= ~BIT3;
  IE1 |= WDTIE;
  P1OUT^=BIT6;
  WDTCTL = WDT_ADLY_250;
  P1IFG = 0;

[A. H. (dernetteeddie1978)]

Okay, das wars auch noch net. So schalte ich die Interrupts ja natürlich 
auch wieder vor Löschung der Flags ein. Also ab mit dem Befehl in die 
WDT ISR:

#pragma vector=PORT1_VECTOR
__interrupt void PORT1_ISR (void)
{
  P1IE &= ~BIT3;
  IE1 |= WDTIE;
  P1OUT^=BIT6;
  WDTCTL = WDT_ADLY_250;
}

// WDT Interrupt Service Routine used to de-bounce button press
#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR(void)
{
  IE1 &= ~WDTIE;                   /* disable interrupt */
    IFG1 &= ~WDTIFG;                 /* clear interrupt flag */
    WDTCTL = WDTPW + WDTHOLD;     /* put WDT back in hold state */
    P1IFG = 0;
    P1IE |= BIT3;                  /* Debouncing complete */
}

So, nun scheint nix mehr zu prellen.

Aber das Programm ist sehr langsam. Die Tastendrücke werden nur mit fast 
1 Sek. Wartezeit dazwischen registriert und auch wenn der Druck 
registriert ist so geht die grüne LED nicht immer unmittelbar an. 
Eigentlich sollte das WDT Intervall ja nur 250ms dauern.
Evtl. ist die Taktung falsch eingestellt. Wenn das Programm aber an der 
Stelle hängt, dann dürfte die rote LED in der zeit ja eigentlich nicht 
blinken. Die main ist ja eigentlich unterbrochen. Naj, mal schauen ob 
ich das auch noch finde.

LG

[Konrad S. (maybee)]

Wenn du mal von der Rumbastelei die Nase voll hast und du dich etwas 
entspannen willst, dann ist das hier ein gute Lektüre:
http://www.mikrocontroller.net/articles/Entprellung

[A. H. (dernetteeddie1978)]

Danke,

den Artikel hatte ich schon gefunden. Ich wollte nur verstehen warum 
meine nicht funktioniert. Das Prinzip ist ja letztenendes gleich. Es 
wird eine gewisse Zeit gewartet und dann  der Taster wieder "scharf" 
geschaltet.

Die Lösung für die lange Wartezeit zwischen den Drücken hab ich 
mittlerweile auch gefunden. Die Taktung scheint falsch gewesen zu sein. 
Ich hab mal zwei Zeilen auskommentiert:

void InitializeClocks(void)
{
  BCSCTL1 = CALBC1_1MHZ;                    // Set range
  DCOCTL = CALDCO_1MHZ;
  BCSCTL2 &= ~(DIVS_3);                     // SMCLK = DCO = 1MHz
  //BCSCTL1 |= DIVA_1;                        // ACLK/2
  //BCSCTL3 |= LFXT1S_2;                      // ACLK = VLO
}

Nun ists schneller.

Nachdem ich mich mit SingleStep mal zwischen Breakpoints durchgeklickt 
hab, hab ich auch gesehen dass der Code nach  Start des WDT Intervalls 
nicht direkt in die WDT ISR springt sondern erstmal wieder in die main 
und kurz drauf in die WDT ISR.

Offenbar läuft der WDT Timer quasi parallel zum Rest ab. Ich hatte erst 
gedacht wenn er gestartet ist wird gewartet bis er abgelaufen ist und 
dann gehts weiter im Code.

Jetzt muss ich noch versuchen die Taktung so zu ändern das die 250ms 
kürzer werden. So ists eindeutig zu lang, da werden schnelle 
Tastendrücke verschluckt.

LG