[Tiny 13] LED on/off schaltung | Interrupt | Anfängerproblem

[µCBeginner (Gast)]

Hallo Leute

Ich habe vor kurzem ein Buch über µC Gekauft und ein bisschen 
herumprobiert.
Ich will nun ein Programm schreiben, mitdem ich per Knopfdruck eine LED 
an bzw aus machen kann.

Habe dazu den ATtiny 13 benutzt.
An Port PB0 ist eine LED angeschlossen,
an Port PB4 ein Taster der bei Tastendruck auf GND liegt.

hier der Code:

#define F_CPU      1200000

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>


int on;    // led on oder off?

ISR (INT0_vect) {
    if(on) { DDRB = 0b000000; on = 0;  }//ausschalten
  if(!on) { DDRB = 0b000001; on = 1;  }//einschalten
} 

int main(void)
{
    DDRB = 0b000001; //PortB0 als output

  PORTB = 0b000001; //Einschalten, testen
  _delay_ms(1000);
  PORTB = 0b000000;
  on = 0;


    DDRB &= ~_BV(PB4);  //Einganb bei Port PB4
  PORTB |= _BV(PB4);  //Pull-Up Aktivieren
  PCMSK |= (1<<4); //Ext Interrupt an PinB4
  GIMSK  |= (1<<INT0);  // Ext. Interrupt an INT0
    MCUCR |=(0<<ISC01) | (0<<ISC00);           // Interrupt wenn INT0 = GND
    sei();    //Interrupts Erlauben




  while (1)
  {  

  }
  return 0;
}

Das Licht geht am Anfang an und wieder aus, aber auf Tastendruck 
passiert nichts.
Was mach ich falsch?
Danke schonmal :)

[Jannis C. (kabelwurm)]

Hallo,
dafür einen Interupt zu benutzen ist nicht sinvoll.
Man schreibt sowas eher so:

#define F_CPU      1200000

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>

uint8_t on 0;//variable definieren und Wert zuweisen

int (main) void 
{
 while (1);
 DDRB = 0b1;// PortB0 als Ausgang Rest eingänge
 PORTB = 0b100;//Pullup an PortB4
 //testen
 PORTB = (1<<PORTB0); // Nur PORTB0 verändern
 _delay_ms(1000);
 PORTB &= ~(1<<PORTB0);

 if (!(PORTB(1<<PORTB4)
   {
    if (on == 0) {
      PORTB = (1<<PORTB0);
      on = 1;
   }
    if (on == 1) {
       PORTB &= ~(1<<PORTB0);
       on = 0;
   }
  }
  return 0;
 }

Gruß Jannis

[Sam .. (sam1994)]

µCBeginner schrieb:
> Das Licht geht am Anfang an und wieder aus, aber auf Tastendruck
> passiert nichts.
Reagiert der INT nicht nur auf fallende oder steigende Flanke?
> Was mach ich falsch?
Den Taster kann man nicht einfach einmal per INT Interrupt "abfragen". 
Stichwort Tastenentprellung.

[Karl H. (kbuchegg)]

Jannis sagte schon: Ein Interrupt ist dafür nicht besonders gut 
geeignet. Allerdings hat Jannis das Programm an anderen Stellen 
verbockt.

Daher von vorne. Gehen wir dein Programm durch

ISR (INT0_vect) {
    if(on) { DDRB = 0b000000; on = 0;  }//ausschalten
  if(!on) { DDRB = 0b000001; on = 1;  }//einschalten
}

(Im folgenden ist x immer der Name eines Ports. Also zb bei Port B wäre 
x daher B, und dein PORTx wäre dann PORTB, DDRx wäre dann DDRB, PINx 
wäre PINB. Für den Port C wäre das dann PORTC, PINC und DDRC etc. etc)

DDRx
Das DDRx Register steuert, welcher Pin Eingang ist und welcher Pin 
Ausgang. Typischerweise stellt man das am Programmanfang ein (man weiß 
ja welcher Pin was sein soll) und lässt diese Einstellung danach in 
Ruhe!

Wenn du ausgeben willst, dann wird an das PORTx Register ausgegeben!
Wenn du einlesen willst, dann kriegst du diese Information vom PINx 
Register.

Aber das DDRx Register lässt du in Ruhe!

WEnn du einen AUsgangspin auf 1 setzen willst, dann lautet die Phrase

   PORTx |= ( 1 << Pinnummer );

Wenn du denselben Ausgangspin auf 0 setzen willst, dann lautet die 
Phrase

   PORTx &= ~( 1 << Pinnummer );

Um einen Portpin abzufragen, lautet die Phrase

   if( PINx & ( 1 << Pinnummer ) ) {
     ... der Eingangspin ist auf 1
   }
   else {
     ... der Eingangspin ist auf 0
   }

oder

   if( !( PINx & ( 1 << Pinnummer ) ) {
     ... der Eingangspin ist auf 0
   }
   else {
     ... der Eingangspin ist auf 1
   }

der grundsätzliche Programmaufbau sieht (fürs erste) IMMER so aus

#include ....

int main()
{

   Einstellen aller beteiligten Komponenten
   das bedeutet: Pins auf Eingang oder Ausgang
                 Pullupwiderstände ein/aus
                 Timern ihre Grundkonfiguration
                 UART einstellen
                 ...

   eventuell ein sei(), wenn mit Interrupts gearbeitet wird

   while( 1 ) {

      hier kommt die eigentliche Arbeit, die der µC machen soll.
      Wie zb Pins abfragen und andere Pins auf 1 oder 0 stellen

   }
}

Du wirst die nächsten 30 Programme mit diesem Grundgerüst durchkommen.
Tasten macht man nicht über Interrupts. Denn du hast da ein 
Grundproblem: Tasten prelln. Dieses Prellen ist mechanisch bedingt und 
du kannst es nicht so einfach umgehen. Prellen bedeutet: Du drückst 
einmal auf den Taster; dein µC registriert aber 2 bis 4 Schaltvorgänge, 
weil Taster nun mal keine idealen mechanischen Bauteile sind.

[Probier (Gast)]

doch lieber mal BASCOM , das hast Du schneller eine Erfolgserlebnis.

[Sam .. (sam1994)]

Statt

if(on) { PORTB = 0b000000; on = 0;  }//ausschalten
  if(!on) { PORTB = 0b000001; on = 1;  }//einschalten

Kann man auch

on = PORTB = 1 - on;

schreiben.
Oder ohne beeinflussen der bits 2-8:

on = PORTB = on ^ 0b00000001;

Im übrigen sollte man on als volatile deklarieren, damit es im SRAM 
gespeichert wird. Sonst könnte es beim Interrupt zufällig nicht im 
adressierten Register liegen. Schließlich weiß der Compiler nicht, dass 
die ISR überhaupt aufgerufen wird.

Probier schrieb:
> doch lieber mal BASCOM , das hast Du schneller eine Erfolgserlebnis.

Probier das lieber nicht. Zwar hast du anfangs schnellere 
Erfolgerlebnisse, wenn du aber C dann mal beherscht, erleichtert es dir 
die Arbeit enorm.

[Karl H. (kbuchegg)]

Samuel K. schrieb:

> Im übrigen sollte man on als volatile deklarieren, damit es im SRAM
> gespeichert wird. Sonst könnte es beim Interrupt zufällig nicht im
> adressierten Register liegen. Schließlich weiß der Compiler nicht, dass
> die ISR überhaupt aufgerufen wird.

Das alles trifft in seinem Fall nicht zu. Der Compiler ist sowieso 
verpflichtet am Ende einer Funktion (auch eine ISR ist letzten Endes nur 
eine Funktion) alle Variablen zurückzuschreiben.
Bei volatile geht es um was anderes.

[µCBeginner (Gast)]

Danke für eure Hilfe!

Hab jetzt mein Programm etwas umgeschreiben:

#define F_CPU      1200000

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>


int on;    // led on oder off?
/*
ISR (INT0_vect) {
    if(on) { DDRB = 0b000000; on = 0;  }//ausschalten
  if(!on) { DDRB = 0b000001; on = 1;  }//einschalten
} 
*/
int main(void)
{
    DDRB = 0b000001; //PortB0 als output

  PORTB = 0b000001; //Einschalten, testen
  _delay_ms(1000);
  PORTB = 0b000000;
  on = 0;

    DDRB &= ~_BV(PB4);  //Einganb bei Port PB4
    PORTB |= _BV(PB4);  //Pull-Up Aktivieren

  while (1)
  {  
      if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
      {
          if(on) //led ist an
    {
                   PORTB = 0b000000; //ausschalten
       on = 0;
    }
    else if (!on) //led ist aus
    {
       PORTB = 0b000001; //einschalten
       on = 1;
                }
            }
  }
  return 0;
}

So kann ich die LED am anfang zwar einschalten, aber bei einem zweiten 
Tastendruck geht sie nicht mehr aus. Warum?
Außerdem flackert die LED hin und wieder. Von was kommt das?
Um Tasten abzufragen benutzt man also keine Interrupts. Für was benutzt 
man sie dann?

Gruß

[A. F. (frankalicious)]

Hast du dir die beiden schon angeschaut:
http://www.mikrocontroller.net/articles/Entprellung
und
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
?

[Jannis C. (kabelwurm)]

Hallo,
wenn ich mich diemal im Text nicht wieder so katastrophal verschreibe 
ist es wahrscheinlich richtig. Also dein Programm krankt noch an dieser 
Stelle:

      if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
      {
           if(on)//led ist an
    {
                   PORTB = 0b000000; //ausschalten
       on = 0;
    }
    else if (!on) //led ist aus
    {
       PORTB = 0b000001; //einschalten
       on = 1;
                }

Meines Wissen nachs kann man das mit dem if(on) nicht einfach so 
schreiben.
Das Codefragment also überarbeitet:

      if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
      {
          if(on== 1){ //led ist an
             PORTB = 0b000000; //ausschalten
             on = 0;
             _delay_ms(100); //Entprellen
          }
          else{            
            PORTB = 0b000001; //einschalten
            on = 1;
            _delay_ms(100);//Entprellen
          }
       }

Die zweite If-Abfrage kann man sich sparen da es nur zwei Zustände gibt.
Das Entprellen ist notwendig, damit ein Tastendruck nicht als zwei oder 
noch mehr gezählt werden.
Gruß Jannis

[Sam .. (sam1994)]

µCBeginner schrieb:
>   while (1)
>   {
>       if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
>       {
>           if(on) //led ist an
>           {
>               PORTB = 0b000000; //ausschalten
>               on = 0;
>           }
>           else if (!on) //led ist aus
>           {
>               PORTB = 0b000001; //einschalten
>               on = 1;
>           }
>       }
>   }

Wenn du deinen Code ein bisschen formatierst kann ihn jeder wunderbar 
lesen.

Für dein Codestück ist (abgesehen von der fehlenden Entprellung), dieser 
Operator ideal: ^ (XOR)
01 ^ 11 = 10
Mit XOR kann man bits umdrehen und geanu das brauchst du.

if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
{
    on = on ^ 0b00000001;
    PORTB = on;
    //oder kurz: PORTB = on ^= 0x01;
    delay_ms(100); //Entprellen wie Vorposter beschrieben hat,
                   //es gibt aber bessere Methoden
}

Das on kannst dir bei dieser Variante schenken. Wenn du es drin lässt 
verbesserst es sich die Performance um einen Takt, was aber 
vernachlässigbar ist.

[µCBeginner (Gast)]

Hab jetzt den Code verändert:

#define F_CPU      1200000

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>


int on;    // led on oder off?

int main(void)
{
    DDRB = 0b000001; //PortB0 als output

    PORTB = 0b000001; //Einschalten, testen
    _delay_ms(1000);
    PORTB = 0b000000;
    on = 0;

    DDRB &= ~_BV(PB4);  //Einganb bei Port PB4
    PORTB |= _BV(PB4);  //Pull-Up Aktivieren
    
    while (1)
    {  
        if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
        {
        
           on = on ^ 0b00000001;
           PORTB = on;
          //oder kurz: PORTB = on ^= 0x01;
          _delay_ms(100);//Entprellen wie Vorposter beschrieben hat,
                   //es gibt aber bessere Methoden
        }
    }
    return 0;
}

Wenn ich jetzt jedoch den taster drücke Blinkt die LED. Warum?

[Jannis C. (kabelwurm)]

Hallo,
hast du mal die Entprellzeit verändert?
Gruß Jannis

[Sam .. (sam1994)]

µCBeginner schrieb:
> Wenn ich jetzt jedoch den taster drücke Blinkt die LED. Warum?
dafür brauchst du einen Variable die speichert ob der Taster schon 
gedrückt war oder neu gedrückt ist.

//vor while
uint8_t state = 0;

//in while
if( !(PINB & ( 1 << PINB4 )) ) //eingang auf gnd
{
     if(!state)
     {
           on = on ^ 0b00000001;
           PORTB = on;
          //oder kurz: PORTB = on ^= 0x01;
          _delay_ms(100);//Entprellen wie Vorposter beschrieben hat,
          //es gibt aber bessere Methoden
          state = 1;
     }
}
else
    state = 0;