Interrupt nicht deaktivierbar

[Athlon N. (athlon)]

Hallo!
Ich hab grad damit begonnen, mich in die Materie der MC Programmierung 
einzuarbeiten.
Verwende einen Attiny 2313A und Atmel Studio 6.

Folgendes möcht ich machen:
Durch Verwendung des Analog Comparators soll mit Hilfe eines 
Phototransistors ein Interrupt ausgelöst werden, wenn das Umgebungslicht 
eine gewisse Schwelle unterschreitet. Das funktioniert auch schon.

Dann soll in der Interrupt Routine des AC´s eine LED aktiviert und ein 
Flag gesetzt werden.

In der While Schleife im Main wird bei gesetztem Flag ein Timer im CTC 
Modus aktiviert. Außerdem wird das AC Interrupt Bit 0 gesetzt.
Erreicht der Timer/Counter den definierten Wert, wird wieder ein 
Interrupt ausgelöst und die LED wieder deaktiviert und der Timer 
gestoppt.
Das funktioniert auch schon.

Nun hab ich allerdings das Problem, dass der AC wieder ein Interrupt 
auslöst, wenn das Umgebungslicht einen gewissen Wert unterschreitet, 
obwohl ich das Interruptbit auf 0 gesetzt habe.

//Analog Comparator
  ACSR = 0<<ACIE; //clear the interrupt bit
  ACSR = 0<<ACD; //power ON analog comparator
  ACSR = 0<<ACBG; //use AIN0 as positive Input
  ACSR = 0<<ACIC; //Input Capture disabled
  ACSR = 0<<ACIS0; //Interrupt Mode (Output Toggle)
  ACSR = 0<<ACIS1; //Interrupt Mode (Output Toggle)
  ACSR = 1<<ACIE; //Enable Interrupts again
    
  //16 bit Timer1 Register A
  TCCR1B &= ( (0<<CS12) | (0<<CS11) | (0<<CS10)); //Stop Timer/Counter (Timer 1 Register A and B uses the same Clock)
  TCCR1A = 0<<COM1A1; //Normal port operation - OC1A disconnected
  TCCR1A = 0<<COM1A0; //Normal port operation - OC1A disconnected
  TCCR1A = 0<<WGM13;
  TCCR1A = 1<<WGM12; //CTC1 - CTC mode with Top OCR1A
  TCCR1A = 0<<WGM11; //disable PWM11
  TCCR1A = 0<<WGM10; //disable PWM10

  OCR1AH = 0x00; //compare register high
  OCR1AL = 0x98; //compare register low
    
  sei(); //Global Interrupts enabled
  
  
    while(1)
    {
    if(flag == 1)
    {
      cli();
      flag = 0;
      TIMSK = 1<<OCIE1A; //Timer, Output Compare A Match Interrupt enable  
      ACSR = 0<<ACIE; //Disable Analog Comparator Interrupts
      ACSR = 1<<ACD; //Disable Analog Comparator
      TCCR1B |= ( (0<<CS12) | (1<<CS11) | (1<<CS10)); //start timer/counter
      sei();
    }                 
    }
  
  return 0;
}

ISR(ANA_COMP_vect)
{
  cli();
  PORTD = 1<<PORTD2; //enable LED
  flag = 1;
  sei();
}

ISR(TIMER1_COMP1_vect)
{
  cli();
    
  PORTD = 0<<PORTD2; //disable LED
      
  TCCR1B &= ( (0<<CS12) | (0<<CS11) | (0<<CS10)); //Stop Timer/Counter
  sei();
}

Könntet Ihr mal bitte drüberschauen?

Lg

[Peter II (Gast)]

entferne erstmal sei und cli aus dem ISRs. Das gehört dort nicht rein.

[Peter II (Gast)]

TCCR1B &= ( (0<<CS12) | (0<<CS11) | (0<<CS10)); //Stop Timer/Counter

so löscht man auch keine Bits.

siehe Bitmanipulation

[Hans (Gast)]

Athlon N/a schrieb:
> 0<<

Bringt nichts wenn eine Zuweisung oder eine Veroderung erfolgt.

[Athlon N. (athlon)]

Ok, habs mal geändert:

  //Analog Comparator
  ACSR = 0<<ACIE; //clear the interrupt bit
  ACSR = 0<<ACD; //power ON analog comparator
  ACSR = 0<<ACBG; //use AIN0 as positive Input
  ACSR = 0<<ACIC; //Input Capture disabled
  ACSR = 0<<ACIS0; //Interrupt Mode (Output Toggle)
  ACSR = 0<<ACIS1; //Interrupt Mode (Output Toggle)
  ACSR = 1<<ACIE; //Enable Interrupts again
    
  //16 bit Timer1 Register A
  TCCR1B &= ~( (1<<CS12) | (1<<CS11) | (1<<CS10)); //Stop Timer/Counter
  TCCR1A = 0<<COM1A1; //Normal port operation - OC1A disconnected
  TCCR1A = 0<<COM1A0; //Normal port operation - OC1A disconnected
  TCCR1A = 0<<WGM13;
  TCCR1A = 1<<WGM12; //CTC1 - CTC mode with Top OCR1A
  TCCR1A = 0<<WGM11; //disable PWM11
  TCCR1A = 0<<WGM10; //disable PWM10

  OCR1AH = 0x00; //compare register high
  OCR1AL = 0x98; //compare register low
    
  sei(); //Global Interrupts enabled
  
  
    while(1)
    {
    if(flag == 1)
    {
      cli();
      flag = 0;
      TIMSK = 1<<OCIE1A; //Timer, Output Compare A Match Interrupt enable  
      ACSR = 0<<ACIE; //Disable Analog Comparator Interrupts
      ACSR = 1<<ACD; //Disable Analog Comparator
      TCCR1B |= ( (0<<CS12) | (1<<CS11) | (1<<CS10)); //start timer/counter
      sei();
    }                 
    }
  
  return 0;
}


ISR(ANA_COMP_vect)
{
  PORTD = 1<<PORTD2; //enable LED
  flag = 1;
}

ISR(TIMER1_COMP1_vect)
{
  //if(PIND & (1<<PIND1))
    
  PORTD = 0<<PORTD2; //disable LED
      
  TCCR1B &= ~( (1<<CS12) | (1<<CS11) | (1<<CS10)); //Stop Timer/Counter
}

Hans schrieb:
> Athlon N/a schrieb:
>> 0<<
>
> Bringt nichts wenn eine Zuweisung oder eine Veroderung erfolgt.

Meinst du beim deaktiveren des Interrupts?

[Peter II (Gast)]

PORTD = 0<<PORTD2; //disable LED

das macht auch nicht wirklich das was du willt. Da kannst du auch gleich 
PORTD = 0 schreiben.

TCCR1B |= ( (0<<CS12) | (1<<CS11) | (1<<CS10)); //start timer/counter

ist genauso unsinn. Denke doch mal drüber nach was du schreibst.

[Peter II (Gast)]

Peter II schrieb:
> TCCR1B |= ( (0<<CS12) | (1<<CS11) | (1<<CS10)); //start timer/counter
>
> ist genauso unsinn. Denke doch mal drüber nach was du schreibst.

sorry, meinste es nicht so schlimmt. Das Problem ist das du CS12 mit 
dieser anweisung nicht löschen kannst. Wenn es vorher 1 ist, bleibt es 
auch 1.

[Uwe (de0508)]

Hallo,

noch ein Tipp, welche Werte haben wohl die Register ACSR und TCCR1A ?

ACSR = 1<<ACIE
TCCR1A = 0 richtig !


> ACSR = 1<<ACIE;
> TCCR1A = 0<<WGM10;

[Bernd S. (bernds1)]

Auch ganz oben beim Anfang sind viele 0<<ACIE usw. Dort trifft das auch 
zu.
Mach eine Veroderung der einzelnen Bits und weise das ganze Byte auf 
einmal dem Register zu (z.B. ACSR).

[Jörg W. (dl8dtl) (Moderator)]

Athlon N/a schrieb:
> ACSR = 0<<ACIE; //clear the interrupt bit
>   ACSR = 0<<ACD; //power ON analog comparator
>   ACSR = 0<<ACBG; //use AIN0 as positive Input
>   ACSR = 0<<ACIC; //Input Capture disabled
>   ACSR = 0<<ACIS0; //Interrupt Mode (Output Toggle)
>   ACSR = 0<<ACIS1; //Interrupt Mode (Output Toggle)
>   ACSR = 1<<ACIE; //Enable Interrupts again
>
>   //16 bit Timer1 Register A
>   TCCR1B &= ( (0<<CS12) | (0<<CS11) | (0<<CS10)); //Stop Timer/Counter (Timer 1 
Register A and B uses the same Clock)
>   TCCR1A = 0<<COM1A1; //Normal port operation - OC1A disconnected
>   TCCR1A = 0<<COM1A0; //Normal port operation - OC1A disconnected
>   TCCR1A = 0<<WGM13;
>   TCCR1A = 1<<WGM12; //CTC1 - CTC mode with Top OCR1A
>   TCCR1A = 0<<WGM11; //disable PWM11
>   TCCR1A = 0<<WGM10; //disable PWM10

Das ist kompletter Humbug.  Die Register werden ja jedesmal komplett
überschrieben.  ACSR wird am Ende also nur ACIE gesetzt haben, und
TCCR1A steht auf 0.  Schreib das so:

ACSR = (1 << ACIE);
TCCR1A = (1 << WGM12);

Wenn du unbedingt noch kommentieren willst, was alles nicht gesetzt
ist, dann so:

ACSR = /* !ACD | !ACBG | !ACI | */ (1 << ACIE) /* | !ACIC | !ACIS0 | !ACIS1 */;

Die Bibliothek bietet noch den Makro _BV() als Abkürzung für das
Bitgeschiebe.  Meiner Meinung nach lässt er sich geringfügig besser
lesen als eine Anhäufung von (1 << BIT).

WGM12 ist nicht im Register TCCR1A angesiedelt, sondern in TCCR1B.

Zu guter Letzt liegt der Verdacht noch nahe, dass dein "flag" nicht
volatile deklariert ist.  Die Deklaration hast du uns aber
vorenthalten.

[Athlon N. (athlon)]

Auweia, da hab ich ja wirklich nen Blödsinn gemacht...
Hier nochmal alles und ausgebessert:

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

volatile int8_t flag = 0;

int main(void)
{
  cli(); //Global Interrupts disabled
  
  //Port Directions
  DDRA |= 0b00000001; //A0 as Output - MOS2 Supply
  DDRA &= 0b11111101; //A1 as Input - DIP switch #1
  DDRB &= 0b11111110; //B0 as Input - positive Analoginput - AIN0
  DDRB &= 0b11111101; //B1 as Input - negative Analoginput - AIN1
  DDRD &= 0b11111110; //D0 as Input - DIP switch #3
  DDRD &= 0b11111101; //D1 as Input - DIP switch #2
  DDRD |= 0b00000100; //D2 as Output - LED Supply
    
  //Enabling Ports (output) - Set pull Up Resistor (Input)
  PORTA &= 0b11111110; //A0 MOS2 supply Bit
  PORTA &= 0b11111101; //A1 deactivate pull Up Resistor - DIP #1
  PORTB &= 0b11111110; //B0 deactivate pull Up Resistor - AIN0
  PORTB &= 0b11111101; //B1 deactivate pull Up Resistor - AIN1
  PORTD &= 0b11111110; //D0 deactivate pull Up Resistor - DIP #3
  PORTD &= 0b11111101; //D1 deactivate pull Up Resistor - DIP #2
  PORTD &= 0b11111011; //D2 LED Voltage supply
    
  //Analog Comparator
  ACSR &= 0b11110111; //clear the interrupt bit
  ACSR &= 0b01111111; //power ON analog comparator
  ACSR &= 0b10111111; //use AIN0 as positive Input
  ACSR &= 0b11111011; //Input Capture disabled
  ACSR &= 0b11111110; //Interrupt Mode (Output Toggle)
  ACSR &= 0b11111101; //Interrupt Mode (Output Toggle)
  ACSR |= 0b00001000; //Enable Interrupts again
    
  //16 bit Timer1 Register B
  TCCR1B &= 0b11111000; //Stop Timer/Counter
  TCCR1B &= 0b11101111; //WGM13
  TCCR1B |= 0b00001000;//WGM12 - CTC mode with Top OCR1A

  OCR1AH = 0x05; //compare register high
  OCR1AL = 0x98; //compare register low
    
  sei(); //Global Interrupts enabled
  
  
    while(1)
    {
    if(flag == 1)
    {
      cli();
      flag = 0;
      TIMSK |= 0b00100000; //Timer, Output Compare B Match Interrupt enable  
      ACSR &= 0b11110111; //Disable Analog Comparator Interrupts
      TCCR1B |= 0b00000101; //start timer/counter with Clock/1024 Prescaler CS12=0, CS11=1, CS10=1
      sei();
    }                 
    }
  
  return 0;
}

ISR(ANA_COMP_vect)
{
  PORTD |= 0b00000100; //enable LED
  flag = 1;
}

ISR(TIMER1_COMP1_vect)
{
  
  PORTD &= 0b11111011;
    
  //PORTD = 0<<PORTD2; //disable LED
      
  TCCR1B &= 0b11111000; //Stop Timer/Counter 


}

Das Problem besteht leider immer noch. Flag wurde als volatile 
definiert.

[Peter II (Gast)]

Athlon N/a schrieb:
> Das Problem besteht leider immer noch. Flag wurde als volatile
> definiert.

ich glaube du hast immer noch nicht verstanden was du überhaupt machst

 PORTA &= 0b11111110; //A0 MOS2 supply Bit
 PORTA &= 0b11111101; //A1 deactivate pull Up Resistor - DIP #1

was soll das?

[Athlon N. (athlon)]

Das PORTA Register besteht doch aus 8 bit. Nun sag ich PORTA = PORTA & 
0b11111110

Das heißt, das letzte bit wird 0 gesetzt und alle anderen Bits bleiben 
so wie sie waren.
Sollte so doch gehn oda?

[Peter II (Gast)]

Athlon N/a schrieb:
> Das heißt, das letzte bit wird 0 gesetzt und alle anderen Bits bleiben
> so wie sie waren.
> Sollte so doch gehn oda?

aber welchen welchen Startwert geht du denn aus? Wenn PORTA nach dem 
init 0 ist, dann bringen deine Befehle nichts.

[Athlon N. (athlon)]

Das MOS2 Supplybit soll hier 0 gesetzt werden, das brauch ich erst wenn 
der Rest funktioniert. Egal welchen Startwert PORTA beim init hat, PORT 
A0 wird 0 gesetzt.
Diese Befehle sind hier unnötig das stimmt, ich kann mir so aber quasi 
notieren, welche Ports wie eingestellt sind.

[Falk B. (falk)]

@  Athlon N/a (athlon)

>volatile int8_t flag = 0;

Warum int? uint reicht, ist hier aber egal.

>int main(void)
>{
>  cli(); //Global Interrupts disabled

Ist überflüssig, denn hier sind die Interrupts SICHER gesperrt, nach dem 
Reset.

>  //Port Directions
>  DDRA |= 0b00000001; //A0 as Output - MOS2 Supply
>  DDRA &= 0b11111101; //A1 as Input - DIP switch #1
>  DDRB &= 0b11111110; //B0 as Input - positive Analoginput - AIN0
>  DDRB &= 0b11111101; //B1 as Input - negative Analoginput - AIN1
>  DDRD &= 0b11111110; //D0 as Input - DIP switch #3
>  DDRD &= 0b11111101; //D1 as Input - DIP switch #2
>  DDRD |= 0b00000100; //D2 as Output - LED Supply

Schreibt man anders, damit man es besser lesen kann, siehe 
Bitmanipulation.

>  //Analog Comparator

Dito. Da sieht man nur schwer durch. Probiers mal so

  ACSR = (1<<ACIE);  // enable AC interrupts
  ACSR |= (1<<ACIF); //clear the interrupt bit

>ISR(ANA_COMP_vect)
>{
>  PORTD |= 0b00000100; //enable LED
>  flag = 1;
>}

OK.

Lass mal die Timer ISR erstmal weg. Dann muss wenigstens erstmal dr 
Analogcomparator reagieren.

[Karl H. (kbuchegg)]

Du ersetzt eine bescheuerte Schreibweise durch eine andere.

Das ist doch alles Schwachsinn.

Wenn es dir so schwer fällt, da endlich mal eine ordentliche 
Schreibweise zu finden, dann mach dir von mir aus ein paar Makros

#define SET_BIT(reg,bit)  (reg) |= (1<<bit)
#define CLR_BIT(reg,bit)  (reg) &= ~(1<<bit)

und schreib dann

  CLR_BIT( ACSR, ACIE );
  CLR_BIT( ACSR, ACD );
  CLR_BIT( ACSR, ACBG ); //use AIN0 as positive Input
  CLR_BIT( ACSR, ACIC ); //Input Capture disabled
  CLR_BIT( ACSR, ACIS0 ); //Interrupt Mode (Output Toggle)
  CLR_BIT( ACSR, ACIS1 ); //Interrupt Mode (Output Toggle)
  SET_BIT( ACSR, ACIE ); //Enable Interrupts again

und für den Rest genauso. Aber eigentlich ist das Unsinn immer alle Bits 
eines Register unbedingt in Einzelanweisungen behandeln zu wollen.
Aber so wie du das machst, tappst du von einem unverständlichen Code in 
den nächsten.
Das kann doch kein Mensch mehr analysieren, was da wirklich abgeht!

[Karl H. (kbuchegg)]

> Diese Befehle sind hier unnötig das stimmt, ich kann mir so aber
> quasi notieren, welche Ports wie eingestellt sind.

Das einzige was du tust ist, du erhöhst die Komplexität soweit, dass du 
sie nicht mehr überblicken kannst.

[Karl H. (kbuchegg)]

Nur mal als Beispiel

Du schreibst

   DDRA |= 0b00000001; //A0 as Output - MOS2 Supply
   DDRA &= 0b11111101; //A1 as Input - DIP switch #1
   DDRB &= 0b11111110; //B0 as Input - positive Analoginput - AIN0
   DDRB &= 0b11111101; //B1 as Input - negative Analoginput - AIN1
   DDRD &= 0b11111110; //D0 as Input - DIP switch #3
   DDRD &= 0b11111101; //D1 as Input - DIP switch #2
   DDRD |= 0b00000100; //D2 as Output - LED Supply

Du brauchst Kommentare und ein gutes Auge um zu erkennen, welches Bit in 
jeder Zeile eigentlich das relevante ist und wo es daher am eigentlichen 
µC hardwaremässig zu finden ist.

#define MOS2_PIN      PA0    // am PORT A
#define DIP1_PIN      PA1    // an PORT A
#define DIP2_PIN      PD1    // am PORT D
#define DIP3_PIN      PD0    // am PORT D
#define LED_PIN       PD2    // am PORT D
#define POS_VOLT_PIN  PB0    // positive Spannung, Komperator
#define NEG_VOLT_PIN  PB1    // negative Spannung, Komperator
...

// Output
   DDRA |= ( 1 << MOS2_PIN );
   DDRD |= ( 1 << LED_PIN );

// Input Dip-Switches
   DDRA &= ~( 1 << DIP1_PIN );
   DDRD &= ~( 1 << DIP2_PIN );
   DDRD &= ~( 1 << DIP3_PIN );

   PORTA |= ( 1 << DIP1_PIN );
   PORTD |= ( 1 << DIP2_PIN );
   PORTD |= ( 1 << DIP3_PIN );

// Input Analog Input - Komperator
   DDRB &= ~( 1 << POS_VOLT_PIN | 1 << NEG_VOLT_PIN );

....

ISR(ANA_COMP_vect)
{
  PORTD |= ( 1 << LED_PIN );
  flag = 1;
}

ISR(TIMER1_COMP1_vect)
{
  PORTD &= ~( 1 << LED_PIN );
  TCCR1B &= ~( 1 << CS12 | 1 << CS11 | 1 << CS10 );
}

Mit ein paar #define, mit denen man den Pins Namen gibt, spart man nicht 
nur Kommentare sondern macht auch gleichzeitig den Code lesbarer. Denn 
dann steht da eben

  PORTD |= ( 1 << LED_PIN );

was man als C-Programmierer sofort als: Hier wird ein Pin auf 1 gesetzt 
liest. Welcher Pin? Der Pin an dem die LED hängt.
(Und in dem Fall sollte man für die Port-Namen dann nochmal dasselbe 
machen.

Aber so kriegt man Übersicht in seinen Code. Und dann kann man auch mit 
dem Code arbeiten.

[Peter D. (peda)]

C ist nicht zeilensensitiv.
Schreibs einfach so:

//Analog Comparator
  ACSR = 0<<ACIE  //clear the interrupt bit
       | 0<<ACD   //power ON analog comparator
       | 0<<ACBG  //use AIN0 as positive Input
       | 0<<ACIC  //Input Capture disabled
       | 0<<ACIS0 //Interrupt Mode (Output Toggle)
       | 0<<ACIS1 //Interrupt Mode (Output Toggle)
       | 1<<ACIE; //Enable Interrupts again

Athlon N/a schrieb:
> OCR1AH = 0x00; //compare register high
>   OCR1AL = 0x98; //compare register low

Wer soll sowas verstehen?
Hast Du etwa 16 Finger?

#define F_CPU   8e6
#define blablub (F_CPU / 123.4e3 - 0.5) // schreib die Formel hin,
                                        // der Compiler kann besser rechnen als du
OCR1A = blablub;

[Karl H. (kbuchegg)]

Ich würde da

   if(flag == 1)
    {
      cli();
      flag = 0;
      TIMSK |= 0b00100000; //Timer, Output Compare B Match Interrupt enable  
      ACSR &= 0b11110111; //Disable Analog Comparator Interrupts
      TCCR1B |= 0b00000101; //start timer/counter with Clock/1024 Prescaler CS12=0, CS11=1, CS10=1
      sei();
    }

sicherheitshalber vor dem Wiederzulassen der Interrupts auch as ACI Bit 
noch löschen. Nicht das währenddessen ein weiterer Intrerrupt vom 
Komperator aufgelaufen ist, der ein erneutes Triggern des Komperator 
Interrupts auslöst

   if(flag == 1)
   {
     cli();
     flag = 0;

     ACSR &= ~( 1 << ACIE );   // Interrupts disablen
     ACSR |= ( 1 << ACI );     // und eventuell noch aufgelaufene Interrupt
                               // Anforderungen löschen

     TIMSK |= ( 1 << OCIE1A );
     TCNT1 = 0;
     OCR1A = 1432;
     TCCR1B |= ( 1 << CS12 ) | ( 1 << CS10 );  // 1024

     sei();
   }

Anstatt
     OCR1A = 1432;
wärs noch besser, wenn du die gewünschte Zeit mittels des 
Timer-Prescalers (den 1024) in Beziehung zur F_CPU setzt. Der Compiler 
rechnet dir den Zahlenwert schon aus, wenn du eine Formel hast (und die 
musst du haben, schliesslich hast du das ja auch mit dem Taschenrechner 
rechnen können) und Zeit, F_CPU und die 1024 in der Formel vorgibst

[Athlon N. (athlon)]

So danke für die zahlreichen Antworten.
Hier nochmal der etwas besser lesbare Code:

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

#define MOS2_PIN  PORTA0
#define LED_PIN    PD2
#define DIP1_PIN  PORTA1
#define DIP2_PIN  PD1
#define DIP3_PIN  PD0
#define ACPOS_PIN  PORTB0
#define ACNEG_PIN  PORTB1

#define F_CPU 1e6


volatile int8_t flag = 0;

int main(void)
{  
  //Port Directions
  DDRA |= (1<<MOS2_PIN); //Pin as Output - MOS2 Supply
  DDRD |= (1<<LED_PIN); //Pin as Output - LED Supply
  
  DDRA &= ~(1<<DIP1_PIN); //Pin as Input - DIP switch #1
  DDRD &= ~(1<<DIP2_PIN); //Pin as Input - DIP switch #2
  DDRD &= ~(1<<DIP3_PIN); //Pin as Input - DIP switch #3
  
  DDRB &= ~(1<<ACPOS_PIN); //Pin as Input - positive Analoginput - AIN0
  DDRB &= ~(1<<ACNEG_PIN); //Pin as Input - negative Analoginput - AIN1
  
  
  //Enabling Ports (output) - Set pull Up Resistor (Input)
  PORTA &= ~(1<<MOS2_PIN); //MOS2 supply Bit
  PORTD &= ~(1<<LED_PIN); //LED Voltage supply
  
  PORTA &= ~(1<<DIP1_PIN); //deactivate pull Up Resistor - DIP #1
  PORTD &= ~(1<<DIP2_PIN); //deactivate pull Up Resistor - DIP #2
  PORTD &= ~(1<<DIP3_PIN); //deactivate pull Up Resistor - DIP #3
  
  PORTB &= ~(1<<ACPOS_PIN); //deactivate pull Up Resistor - AIN0
  PORTB &= ~(1<<ACNEG_PIN); //deactivate pull Up Resistor - AIN1
    
  //Analog Comparator
  ACSR &= ~(1<<ACIE); //disable AC Interrupts
  ACSR &= ~(1<<ACD); //power ON analog comparator
  ACSR &= ~(1<<ACBG); //use AIN0 as positive Input
  ACSR |= (1<<ACIE); //Enable Interrupts again
    
  //16 bit Timer1
  TCCR1B &= ~( (1<<CS12) | (1<<CS11) | (1<<CS10)); //Stop Timer/Counter
  //Timer/Counter Mode
  TCCR1B &= ~(1<<WGM13); 
  TCCR1B |= (1<<WGM12); //CTC1 - CTC mode with Top OCR1A
  
  //Timer/Counter Compare Register
  OCR1A = ((F_CPU/1024)*2.5);
    
  sei(); //Global Interrupts enabled
  
  
    while(1)
    {
    if(flag == 1)
    {
      cli();
      flag = 0;
      TIMSK |= (1<<OCIE1A); //Timer, Output Compare A Match Interrupt enable  
      ACSR &= ~(1<<ACIE); //Disable Analog Comparator Interrupts
      ACSR &= ~(1<<ACI); //Clear the Interrupt flag
      TCCR1B |= ( (1<<CS12) | (1<<CS10)); //start timer/counter with Clock/1024 Prescaler
      sei();
    }                 
    }
  
  return 0;
}

//Function for activated Interrupt caused by analog comparator
ISR(ANA_COMP_vect)
{
  PORTD |= (1<<LED_PIN); //enable LED
  flag = 1;
  
}

ISR(TIMER1_COMP1_vect)
{
  //if(PIND & (1<<PIND1))
  
  PORTD &= ~(1<<LED_PIN); //disable LED
      
  TCCR1B &= ~( (1<<CS12) | (1<<CS11) | (1<<CS10)); //Stop Timer/Counter
}

Das Problem besteht aber leider immer noch.
Der Interrupt vom AC wird einfach nicht deaktiviert bzw. lässt sich 
nicht nur einmal ausführen.

Woran kann das liegen? :/

Lg

[Karl H. (kbuchegg)]

>       ACSR &= ~(1<<ACI); //Clear the Interrupt flag


No.
Das hat schon seinen Grund warum ich

     ACSR |= ( 1 << ACI );     // und eventuell noch aufgelaufene 
Interrupt
                               // Anforderungen löschen

geschrieben habe.
Derartige Interrupt Flags werden gelöscht, indem man ein 1 Bit an die 
entsprechende Position im Register schreibt. Das war kein Tippfehler.


Aus dem Datenblatt

• Bit 4 – ACI: Analog Comparator Interrupt Flag

This bit is set by hardware when a comparator output event triggers
the interrupt mode defined by ACIS1 and ACIS0. The Analog Comparator
interrupt routine is executed if the ACIE bit is set and the I-bit in
SREG is set. ACI is cleared by hardware when executing the corresponding
interrupt handling vector. Alternatively, ACI is cleared by writing a
logic one to the flag.

Beachte den letzten Satz!

[Thomas E. (thomase)]

Athlon N/a schrieb:
> ACSR &= ~(1<<ACI); //Clear the Interrupt flag
1. wird das Flag so nicht gelöscht. Sonden indem man da eine 1 
reinschreibt. Aber das nur am Rande.

Athlon N/a schrieb:
> ISR(TIMER1_COMP1_vect)

2. Stürzt dein Programm hier ab. D.h. nicht hier sondern beim Sprung in 
die nicht vorhandene Timer-ISR.

Der Interrupt-Vektor heisst TIMER1_COMPA_vect.

Das hat aber auch Mecker vom Compiler gegeben. Warnings sind nicht zum 
ignorieren da!

mfg.

[Athlon N. (athlon)]

Ah tatsächlich, danke!

Das Problem besteht leider immer noch.
Komisch.. In die if Anweisung wird ja gesprungen, sonst würde der Timer 
nicht gestartet werden.
Gibt es noch eine andere Interrupteinstellung für den AC die ich 
übersehn hab?

Ich hab auch schon versucht den AC mittels

ACSR |= (1<<ACD);

zu deaktiveren. Das nützt aber auch nichts.

[Karl H. (kbuchegg)]

Thomas Eckmann schrieb:

>> ISR(TIMER1_COMP1_vect)
>

> 2. Stürzt dein Programm hier ab. D.h. nicht hier sondern beim Sprung in
> die nicht vorhandene Timer-ISR.
>
> Der Interrupt-Vektor heisst TIMER1_COMPA_vect.

richtig, der ist mir im Zuge des Durcharbeitens des Codes auch schon 
aufgefallen, hab aber dann vergessen zu kontrollieren, ob beim Tiny2313 
der Vektor vielleicht wirklich anders heißt, denn ...

> Das hat aber auch Mecker vom Compiler gegeben. Warnings sind nicht zum
> ignorieren da!

[Athlon N. (athlon)]

Thomas Eckmann schrieb:
> Athlon N/a schrieb:
>> ISR(TIMER1_COMP1_vect)
>
> 2. Stürzt dein Programm hier ab. D.h. nicht hier sondern beim Sprung in
> die nicht vorhandene Timer-ISR.
>
> Der Interrupt-Vektor heisst TIMER1_COMPA_vect.
>
> Das hat aber auch Mecker vom Compiler gegeben. Warnings sind nicht zum
> ignorieren da!

Danke!!! Das wars. Hab in der falschen Bibliothek nachgesehen -.-

Warnings hat er leider nicht ausgegeben :/. Hier der Output:

------ Build started: Project: Licht, Configuration: Debug AVR ------
Build started.
Project "Licht.cproj" (default targets):
Target "PreBuildEvent" skipped, due to false condition; ('$(PreBuildEvent)'!='') was evaluated as (''!='').
Target "CoreBuild" in file "D:\Programme\Atmel\Atmel Studio 6.0\Vs\Compiler.targets" from project "D:\Projects and Stuff\Projects\AtmelProjects\Licht\Licht\Licht.cproj" (target "Build" depends on it):
  Task "RunCompilerTask"
    D:\Programme\Atmel\Atmel Studio 6.0\make\make.exe all 
    make: Nothing to be done for `all'.
  Done executing task "RunCompilerTask".
  Task "RunOutputFileVerifyTask"
        Program Memory Usage   :  262 bytes   12,8 % Full
        Data Memory Usage     :  1 bytes   0,8 % Full
  Done executing task "RunOutputFileVerifyTask".
Done building target "CoreBuild" in project "Licht.cproj".
Target "PostBuildEvent" skipped, due to false condition; ('$(PostBuildEvent)' != '') was evaluated as ('' != '').
Target "Build" in file "D:\Programme\Atmel\Atmel Studio 6.0\Vs\Avr.common.targets" from project "D:\Projects and Stuff\Projects\AtmelProjects\Licht\Licht\Licht.cproj" (entry point):
Done building target "Build" in project "Licht.cproj".
Done building project "Licht.cproj".

Build succeeded.
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

Sind die Warnings defaultmäßig deaktiviert??

[Karl H. (kbuchegg)]

Athlon N/a schrieb:

> Warnings hat er leider nicht ausgegeben :/. Hier der Output:


LOL

  Task "RunCompilerTask"
    D:\Programme\Atmel\Atmel Studio 6.0\make\make.exe all 
    make: Nothing to be done for `all'.

Nothin to be done  - es gibt nichts zu tun.
Verändere mal deinen Code ein wenig, damit es was zu tun gibt. 
Leerzeichen rein/raus reicht schon.

> Sind die Warnings defaultmäßig deaktiviert??

EIn -Wall in den Compiler-flags hat noch nie geschadet.

[Athlon N. (athlon)]

Hab grad gesehn dass er die Warnung eh ausgibt -.-

Hätt mir gedacht, dass die im Output Log etwas mehr hervorgehoben werden 
würde. Nun gut wieder etwas gscheider gworden.

Das ist vorerst mal alles, danke euch!!

[Jörg W. (dl8dtl) (Moderator)]

Karl Heinz Buchegger schrieb:
> EIn -Wall in den Compiler-flags hat noch nie geschadet.

-Wall -Wextra

[Ingo (Gast)]

Ich mach immer -Werror an, so geht der Code mit einer Warnung nicht zu 
kompilieren

[Athlon N. (athlon)]

Jörg Wunsch schrieb:
> Karl Heinz Buchegger schrieb:
>> EIn -Wall in den Compiler-flags hat noch nie geschadet.
>
> -Wall -Wextra

Danke euch, was macht -Wextra? Konnte es in der Doku nicht finden.

[Jörg W. (dl8dtl) (Moderator)]

Athlon N/a schrieb:

> Danke euch, was macht -Wextra? Konnte es in der Doku nicht finden.

Du solltest natürlich die GCC-Doku lesen, nicht die für deine
Brotschneidemaschine. ;-)

http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-W-262

[Athlon N. (athlon)]

Jörg Wunsch schrieb:
> Athlon N/a schrieb:
>
>> Danke euch, was macht -Wextra? Konnte es in der Doku nicht finden.
>
> Du solltest natürlich die GCC-Doku lesen, nicht die für deine
> Brotschneidemaschine. ;-)
>
> http://gcc.gnu.org/onlinedocs/gcc/Warning-Options....

Aja tatsächlich :D.
Habs jetz in Atmel Studio unter -W gefunden. -Wextra habn sie dort wohl 
abgeschafft.

[Jörg W. (dl8dtl) (Moderator)]

Athlon N/a schrieb:
> -Wextra habn sie dort wohl
> abgeschafft.

Nein, das ist bei denen nur noch nicht angekommen.  Gibt's ja auch erst
seit ca. 10 Jahren (in ChangeLog-2003 finde ich es auf die Schnelle das
erste Mal erwähnt).

[apr (Gast)]

Die wirklich spannende Frage lautet ja: Warum macht -Wall nicht all?