Variable für PIN-Input und Interrupt richtig definieren

[Basti (Gast)]

Variable für PIN-Input und Interrupt richtig definieren

Ich programmiere einen Atmel-Controller in C mit AVRStudio 5.0 und 
möchte gerne vier Werte über Interrupteingänge einlesen, die mit 
Schaltern/Tastern bedient werden. Jeweils zwei Öffner und zwei 
Schließer.
Wenn sich an einem Pin ein Wert ändert (Pin-Change Interrupt) möchte ich 
aber alle vier Werte einlesen um daraus Aktionen abzuleiten.

Meine Vorgehensweise ist zur zeit folgende:

#define _S_aus        0x01  //PD0 / SCL/INT0    // Schalter "aus"
#define _T_ein        0x02  //PD1 / SDA/INT1    // Taster "ein"
#define _NA2          0x04  //PD2 / RXD1/INT2   // NOT-Aus 2
#define _NA1          0x08  //PD3 / TXD1/INT3   // NOT-Aus 1


/*globale Variablen */

volatile uint8_t _ein_aus = (_NA1|_NA2|_T_ein|_S_aus);

/* Interrupts */

ISR(INT0_vect)    // Interrupt Vector INT0 
{
  // keine Aktion erforderlich???
}

int main (void)
{
if ((_ein_aus <= 0xB) & (_ein_aus >= 4)
  {
    //Fehlerfall
    // Code hier
  }
  else
  {
    switch (_ein_aus)
    {
    case 0:
    case 1:
    case 2:
    case 3:
      //NOT-AUS FAll
    //Code hier
    break;
    case 0xD:
      // etwas ausschalten
    break;
    case 0xE:
      // etwas einschalten
    break;
    default:
      // nicht definiert, keine Aktion
    break;
      //       
    }
  }  
}

- In der Interrupt - Routine muss ich nichts hineinschreiben, da ich in 
der main nur meine Variablen auswerten möchte und meine Variable 
(_ein_aus) als volatile deklariert ist - richtig?
- Muss ich alle ISRs (INT1...INT3) definieren, wie INT0 oben?
- Ist die globale Variable für diesen Fall richtig definiert? als 
Volatile?
- Ist die globale Variable richtig verknüpft? (_NA1|_NA2|_T_ein|_S_aus) 
?

Natürlich werde ich noch die Interrupt-Register setzen, das fehlt hier 
im Code.

[Justus S. (jussa)]

_ein_aus muss sich schon auch irgendwo ändern können...

[Basti (Gast)]

passiert das nicht durch den Interrupt?

[Ralf (Gast)]

interrupt = Unterbrechung
Der Programmablauf wird unterbrochen damit man was machen kann.

[Justus S. (jussa)]

Basti schrieb:
> passiert das nicht durch den Interrupt?

wenn du in den Interrupt nichts reinschreibst dann natürlich nicht...im 
Moment ist deine Variable einfach immer nur 0b00001111...

[Basti (Gast)]

Das ist mir klar.
Der Interrupt wird ausgelöst, wenn sich ein Signal am entsprechendem 
Eingang ändert (PIN-Change an INT0...INT3)
Die Variable _ein_aus wird automatisch angepasst (geändert) weil Sie ja 
als volatile deklariert wurde.

Soweit so theoretisch...

[Justus S. (jussa)]

arbeite dich erstmal durch das Tutorial hier durch und komm dann 
zurück...

[tuxadi (Gast)]

Basti schrieb:
> Die Variable _ein_aus wird automatisch angepasst (geändert) weil Sie ja
> als volatile deklariert wurde.

Von wem?

Denke mal darüber nach, wer oder was oder wie der Inhalt einer Variablen 
geändert wird.

Have fun
Adi

[Justus S. (jussa)]

du fragst nirgendwo den Pinstatus auch nur einmal ab und sowas wie ein 
"dynamisches Linken" einer Variablen an Pins gibt es nicht...

[Ralf (Gast)]

Basti schrieb:
> Die Variable _ein_aus wird automatisch angepasst (geändert) weil Sie ja
> als volatile deklariert wurde.
... und nachts ist es kälter als draußen.
(Will sagen: das eine hat mit dem anderen nichts zu tun!)

[Basti (Gast)]

Man, ich depp!

Vermutlich muss in die Interrrupt Routine folgendes ergänzt werden:

Zustand = 0x0F & (PIND)

Und "Zustand" dann als globale volatile Variable definieren.
die defines brauche ich dann ja prinzipiell nicht mehr.

Also hier mal abgeändert:

#define _S_aus        0x01  //PD0 / SCL/INT0    // Schalter "aus"
#define _T_ein        0x02  //PD1 / SDA/INT1    // Taster "ein"
#define _NA2          0x04  //PD2 / RXD1/INT2   // NOT-Aus 2
#define _NA1          0x08  //PD3 / TXD1/INT3   // NOT-Aus 1


/*globale Variablen */

volatile uint8_t Zustand;

/* Interrupts */

ISR(INT0_vect)    // Interrupt Vector INT0 
{
  Zustand = 0x0F & (PIND);
}

int main (void)
{
if ((Zustand <= 0xB) & (Zustand >= 4)
  {
    //Fehlerfall
    // Code hier
  }
  else
  {
    switch (Zustand)
    {
    case 0:
    case 1:
    case 2:
    case 3:
      //NOT-AUS FAll
    //Code hier
    break;
    case 0xD:
      // etwas ausschalten
    break;
    case 0xE:
      // etwas einschalten
    break;
    default:
      // nicht definiert, keine Aktion
    break;
      //       
    }
  }  
}

[J.-u. G. (juwe)]

Basti schrieb:
> ISR(INT0_vect)    // Interrupt Vector INT0

INT_vect0 ist der Interruptvektor für den externen Interrupt INT0.

Du benötigst aber den Vektor für den Pinchange-Interrupt von PIND.
Vermutlich:

ISR(PCINT3_vect)

Schau am besten nochmal ins Datenblatt Deines Controllers.

[J.-u. G. (juwe)]

Weiterhin könnte es sinnvoll sein, dass Du Dich mit dem Thema 
Entprellung

http://www.mikrocontroller.net/articles/Entprellung

befasst.

[Basti (Gast)]

J.-u. G. schrieb:
> INT_vect0 ist der Interruptvektor für den externen Interrupt INT0.
>
> Du benötigst aber den Vektor für den Pinchange-Interrupt von PIND.
> Vermutlich:ISR(PCINT3_vect)


INT_vect0 ist in der Tat der Interruptvector für den Externen Interupt 
INT0 der sich an PIN D0 befindet. In den Registern kann ich einstellen 
wann er ausgelöst wird.
Low Level  Pin change  falling edge  und rising edge.

[J.-u. G. (juwe)]

Basti schrieb:
> INT_vect0 ist in der Tat der Interruptvector für den Externen Interupt
> INT0 der sich an PIN D0 befindet. In den Registern kann ich einstellen
> wann er ausgelöst wird.
> Low Level  Pin change  falling edge  und rising edge.

Dann wird aber beim Betätigen der Taster PD1, PD2 und PD3 kein Interrupt 
ausgelöst.

[Basti (Gast)]

J.-u. G. schrieb:
> Basti schrieb:
>> INT_vect0 ist in der Tat der Interruptvector für den Externen Interupt
>> INT0 der sich an PIN D0 befindet. In den Registern kann ich einstellen
>> wann er ausgelöst wird.
>> Low Level  Pin change  falling edge  und rising edge.
>
> Dann wird aber beim Betätigen der Taster PD1, PD2 und PD3 kein Interrupt
> ausgelöst.

Ja klar, wird analog zu INT0 auch bei INT1, INT2 und INT3 gemacht, 
selber Inhalt wie bei INT0

[J.-u. G. (juwe)]

Basti schrieb:
> Ja klar, wird analog zu INT0 auch bei INT1, INT2 und INT3 gemacht,
> selber Inhalt wie bei INT0

OK. Dann haben wir aneinander vorbeigeredet. Welchen Controller hast Du 
denn?

[Basti (Gast)]

Ich benutze den AT90CAN64.

Die Register müsste ich dann so setzen:

EIMSK = 0x0F // aktiviert INT0...INT3
EICRA = 0xAF // NA1 / NA2   = Falling edge (1010 = A)
             // S_aus/T_ein = Rising edge  (1111 = F)

[Basti (Gast)]

Was ist an dieser Konbination falsch?

[...]
#define A-Zustand 2;
#define B-Zustand 3;
[...]
uint16_t Shut_Down (uint8_t Auszustand)
{
  switch (Auszustand)
  {
    case 1: // normal
      return(60);
    case 2: // A-Zustand
      return(10);
    case 3: // B-Zustand
      return(1200);
    default: //alles Andere gibt es nicht
      return(0);
      break;
  } 
}
[...]
uint16_t = time_off = 0xFFFF;
[...]
time_off = Shut_Down(A-Zustand);
[...]

[Basti (Gast)]

es kommt folgende Fehlermeldung:

expected ')' before ';' token

[ikorb (Gast)]

Basti schrieb:
> es kommt folgende Fehlermeldung:

Und die Zeilennummer sollen wir erraten?

[J.-u. G. (juwe)]

Basti schrieb:
> uint16_t = time_off = 0xFFFF;

Mach mal des erste Gleichheitszeichen weg.

[Basti (Gast)]

Hallo, ich wollte eine kurze Rückmeldung geben, ich habs gefunden.

J.-u. G. schrieb:
>> uint16_t = time_off = 0xFFFF;
>
> Mach mal des erste Gleichheitszeichen weg.

Im Code ist es weg, war nur ein Schreibfehler hier im Forum.

Der fehler liegt am Semikolon hinter dem define! Das gehört dort 
natürlich nicht hin:
Falsch:

#define A-Zustand 2;

Richtig:

#define A-Zustand 2

Ich hatte nur im Code geschaut und nicht in den defines, daher ist es 
mir auch erst später aufgefallen.

[Karl H. (kbuchegg)]

Und jetzt überlegst du noch wie dein Compiler wohl

int A;
int Zustand;
int c;

   c = A-Zustand;


von deinem

A-Zustand

auseinanderhalten soll.


Kauf dir doch ein C-Buch und arbeite das erst mal durch. So wie du dir 
das vorstellst, durch Raten, wirst du das nie lernen.

Und das man Taster nicht per Interrut auswertet hat auch einen guten 
Grund. Zum einen kann kein Mensch einen Taster schnell genug drücken und 
loslassen, ohne dass es durch Polling in der Hauptschleife nicht 
registriert werden würde, zum anderen prellen Taster.

[Basti (Gast)]

Karl Heinz Buchegger schrieb:
> Und das man Taster nicht per Interrut auswertet hat auch einen guten
> Grund. Zum einen kann kein Mensch einen Taster schnell genug drücken und
> loslassen, ohne dass es durch Polling in der Hauptschleife nicht
> registriert werden würde, zum anderen prellen Taster.

Also reicht es aus, wenn ich die Entprell-Routine von P.Danegger einbaue 
und in der Hauptschleife einmal den Status abfrage?
Dann entfällt die Sache mit Interrupt auf Flankenwechsel?