Interrupt löst nicht aus?

[Christian M. (krusti)]

Hallo,
ich sitze nun schon seit Stunden am externen Interrupt und sehe langsam 
den Wald vor lauter Bäumen nicht.
Mein Interrupt soll einfach nur bei steigender Flanke auslösen, einen 
Wert hoch zählen und dann wie den Rest auch auf meinem Display bzw UART 
ausgeben.
Ich habe das Gefühl der Interrupt löst nicht aus oder ich mache etwas 
grundlegendes bei der weiteren Verarbeitung falsch. Das Signal kommt am 
Pin an. Das habe ich mit dem Oszi gecheckt.

[Johnny B. (johnnyb)]

initInterrupt() auskommentiert

[Peter II (Gast)]

wo wird denn initInterrupt aufgerufen?

was soll das darstellen?

ISR (INT0_vect);

und cli() und  sei() habe auch nichts in einer ISR zu suchen.

[Christian M. (krusti)]

Johnny B. schrieb:
> initInterrupt() auskommentiert

Die ist inzwischen leer, deswegen auch auskommentiert. Das findet 
derzeit in der normalen init() statt.

[Johnny B. (johnnyb)]

Christian M. schrieb:
> Johnny B. schrieb:
>> initInterrupt() auskommentiert
>
> Die ist inzwischen leer, deswegen auch auskommentiert. Das findet
> derzeit in der normalen init() statt.

Na dann bitte den aktuellen Code wieder reinstellen, ist ja kein Quiz 
zum Zeitvertreib hier.

[Einer K. (Gast)]

Peter II schrieb:
> und cli() und  sei() habe auch nichts in einer ISR zu suchen
Das wird in diesem konkreten Fall richtig sein, ist aber in dieser 
allgemeinen Form/Ansage falsch.


Wobei, ich würde dann, wenn es nötig ist, sicherlich auf die atomic 
Macros zurückgreifen, aber die mache im Grunde ja das gleiche.

[Peter II (Gast)]

Arduino F. schrieb:
> Das wird in diesem konkreten Fall richtig sein, ist aber in dieser
> allgemeinen Form/Ansage falsch.
ok, gilt für die Atmels ( 8bitter).

> Wobei, ich würde da sicherlich auf die atomic Macros zurückgreifen, aber
> die mache im Grunde ja das gleiche.

auch das mach in einer ISR keine sinn.

[Christian M. (krusti)]

Johnny B. schrieb:
> Christian M. schrieb:
>> Johnny B. schrieb:
>>> initInterrupt() auskommentiert
>>
>> Die ist inzwischen leer, deswegen auch auskommentiert. Das findet
>> derzeit in der normalen init() statt.
>
> Na dann bitte den aktuellen Code wieder reinstellen, ist ja kein Quiz
> zum Zeitvertreib hier.
Gerne auch wenn es keine Änderung am ausgeführten Code gibt.

Peter II schrieb:
> wo wird denn initInterrupt aufgerufen?
>
> was soll das darstellen?
>
>

> ISR (INT0_vect);
>

Ein Überbleibsel meiner vielen Versuche. Ist entfernt
>
> und cli() und  sei() habe auch nichts in einer ISR zu suchen.
Ebenso entfernt

[Peter II (Gast)]

initInterrupt ist doch immer noch aus kommentiert.

[Einer K. (Gast)]

Peter II schrieb:
> auch das mach in einer ISR keine sinn.
Du bist zu absolut.

Macht selten Sinn, da stimme ich zu.
Man muss dann extrem aufpassen, da stimme ich auch zu.

Aber KEINEN Sinn?
Im Sinne von NIE?
Da gibts einen Einspruch!

[Markus F. (mfro)]

Wenn ich das lese:


Christian M. schrieb:
> einen
> Wert hoch zählen und dann wie den Rest auch auf meinem Display bzw UART
> ausgeben.

und das lese:

//Interrupt 0 -> Pin PD2
ISR (INT0_vect)  {  
  
  way = 1;
  
}

dann scheint mir das Programm beim "hochzählen" nicht allzu weit zu 
kommen, selbst wenn der Interrupt triggert.

[Johnny B. (johnnyb)]

Peter II schrieb:
> initInterrupt ist doch immer noch aus kommentiert.

So ist es.

[Thomas E. (thomase)]

Christian M. schrieb:
> ich sitze nun schon seit Stunden am externen Interrupt und sehe langsam
> den Wald vor lauter Bäumen nicht.

Und warum fällst du die Bäume dann nicht?

int main(void)
{
  MCUCR |= ((1<< ISC01)| (1<< ISC00));
  GICR |= ((1<<INT0);
  sei();

  while(1)
  {
  }
}

ISR(INT0_vect)
{
  //Toggle irgendeinen freien Pin, weil da hängt der Oszi dran.
}

Wenn das geht, bist du schon mal nicht zu doof, den Interrupt 
einzuschalten. Vor allen Dingen erhärtet es den Verdacht, daß der Fehler 
ganz woanders liegt.

Arduino F. schrieb:
> Aber KEINEN Sinn?
> Im Sinne von NIE?
> Da gibts einen Einspruch!

Genau: Blödsinn, Unsinn, Schwachsinn,... Jede Menge Sinn.

[neugierig (Gast)]

Welcher µC wird benutzt?

[Christian M. (krusti)]

So, das war gestern nicht mehr mein Tag. Geistig war nicht nicht mehr so 
fit (wie man initInterrupt gesehen hat). Also habe ich alles weggelegt 
und gehe heute mit "leerem Kopf" wieder ran.

Zur Info, ich nutze einen Mega16.

Als erstes habe ich den Vorschlag umgesetzt:
Thomas E. schrieb:
> Christian M. schrieb:
> Und warum fällst du die Bäume dann nicht?

Ich habe alles raus geschmissen und folgenden Code geschrieben. Zuerst 
ohne Ausgabe auf dem Display, als das klappte mit dem Display:

#include "defines.h"
#include "global.h"

volatile int16_t way = 0;
char s[100];

int main(void)
{  
  lcd_init();
  
  DDRB |= (1 << DDB0);
  //Interrupt mit Erkennung von steigender Flanke
  MCUCR |= ((1<< ISC01)| (1<< ISC00));
  //Interrupt aktivieren
  GICR |= ((1<<INT0) /*| (1<<INT1)*/);
  sei();
  
    while (1) 
    {        
      //////////////////////////////////////////////////////////////////////////
      //Weg ausgeben
      uart_puts("Weg: ");
      uart_puts(itoa (way, s, 10));
      uart_putc('\0');
      lcd_setcursor(3,1);
      lcd_string("Weg : ");
      lcd_string(s);
      
      _delay_ms(1000);        
  }
}

//////////////////////////////////////////////////////////////////////////
//Interrupt 0 -> Pin PD2
ISR (INT0_vect)  {  
  
  way ++;
  PORTB ^= (1<<PB0);
}

Und siehe da. Es funktioniert. Also doch nicht ganz doof. Jetzt versuche 
ich Schritt für Schritt wieder den Rest einzubinden. Ich habe eine 
Ahnung an was es liegen könnte aber erklären werde ich es mir nicht 
können. Dazu fehlt mir das tiefer gehende Wissen.
Jetzt erst mal sehen wie weit ich komme.

[Peter II (Gast)]

Christian M. schrieb:
> uart_puts(itoa (way, s, 10));

der zugriff auf way muss bei einer 16bit variabel Atomar sein.

int16_t tmp;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
   tmp = way;
}
uart_puts(itoa (tmp , s, 10));

[Christian M. (krusti)]

Peter II schrieb:
> Christian M. schrieb:
>> uart_puts(itoa (way, s, 10));
>
> der zugriff auf way muss bei einer 16bit variabel Atomar sein.
>
>

> int16_t tmp;
> ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
>    tmp = way;
> }
> uart_puts(itoa (tmp , s, 10));
>

Ok das sind jetzt Regionen über die ich schon was gelesen habe, aber 
mich nicht so gut auskenne.

Muss ich dass dann auch hier vorher machen? Also atomar?

tmp8 = convertWay(way);

[Einer K. (Gast)]

Christian M. schrieb:
> Ok das sind jetzt Regionen über die ich schon was gelesen habe, aber
> mich nicht so gut auskenne.

Gute Gelegenheit da weiter zu machen...!!

Tipp:
Wenn du einmal das "Warum atomar?" verstanden hast, dann ist das "Was 
atomar?" leicht selber zu beantworten.
(vermute ich mal)

[Peter II (Gast)]

Christian M. schrieb:
> Muss ich dass dann auch hier vorher machen? Also atomar?tmp8 =
> convertWay(way);

vermutlich, aber ich kann nicht wissen wo du das convertWay im Code 
hinschreibt. In dem letzten Quellcode gibt es das noch nicht.

[Christian M. (krusti)]

Arduino F. schrieb:
> Christian M. schrieb:
>> Ok das sind jetzt Regionen über die ich schon was gelesen habe, aber
>> mich nicht so gut auskenne.
>
> Gute Gelegenheit da weiter zu machen...!!
>
> Tipp:
> Wenn du einmal das "Warum atomar?" verstanden hast, dann ist das "Was
> atomar?" leicht selber zu beantworten.
> (vermute ich mal)

Soweit ich das verstanden habe, wird bei der atomaren Schreibweise (kann 
man das so nennen?) verhindert, dass sich ein Wert aus dem Interrupt 
ändert, während dieser Wert weiter verarbeitet wird. Ganz grob gesagt, 
es ist ähnlich einem cli().
Gerade bei 16bit großen Zahlen, die in zwei 8bit-Paketen verarbeitet 
werden kann es sein, dass dann die einen 8bit (LSB, denke ich oder 
umgekehrt) zum alten Wert gehören während die anderen (MSB)bei einem 
inzwischen erfolgten Interrupt die neuen Werte haben könnten.

[Christian M. (krusti)]

Peter II schrieb:
> Christian M. schrieb:
>> Muss ich dass dann auch hier vorher machen? Also atomar?tmp8 =
>> convertWay(way);
>
> vermutlich, aber ich kann nicht wissen wo du das convertWay im Code
> hinschreibt. In dem letzten Quellcode gibt es das noch nicht.

Habe hier meinen aktuellen Code. Läuft im groben und ganzen ganz gut. 
Habe die Variable way für einen anderen Wert genommen und die alte way 
in pulse umbenannt.
Jetzt stehe ich nur vor der Aufgabe meine UART- und Displayausgabe aus 
der main () zu bekommen bzw zu vereinfachen. Und das am Ende bei meiner 
Weganzeige die Nachkommastelle richtig angezeigt wird wenn die Zahl 
negativ ist.

#include "defines.h"
#include "global.h"

int main(void)
{  
  init();
  initADC();
  initUART();
  lcd_init();
  initInterrupt();
    /* Replace with your application code */
  
  char s[100];
  char t[100];
  uart_puts( "Test" );
  uart_putc('\0');
  
  uint8_t tmp8 = 0;
  int16_t tmp16 = 0;
  uint16_t adcValueOld = 0;
  
  sei();
  
    while (1) 
    {  
    adcValue = ADC_Read(ADC_CHANNEL);
    pressureValue = convertADC(adcValue);
    way = convertWay(pulse);
    
    
    if (adcValue != adcValueOld)  {
      adcValueOld = adcValue;
      //////////////////////////////////////////////////////////////////////////
      //ADC-Wert ausgeben
      uart_puts("ADC-Wert: ");
      uart_puts(utoa (adcValue, s, 10));
      uart_putc('\0');
          
      lcd_setcursor(1,1);
      lcd_string("ADC-Wert: ");
      lcd_string("      ");
      lcd_setcursor(1,11);
      lcd_string(s);
    
      //////////////////////////////////////////////////////////////////////////
      //Dezimaler Druckwert
      uart_puts("Druck: ");
      uart_puts(utoa (pressureValue / 10, s, 10));
      uart_puts(".");
      uart_puts(utoa (pressureValue % 10, t, 10));
      uart_puts(" bar");
      uart_putc('\0');
    
      lcd_setcursor(2,1);
      lcd_string("Druck : ");
      lcd_setcursor(2,9);
      lcd_string(s);
      lcd_string(".");
      lcd_string(t);
      lcd_string(" bar");
      
      //////////////////////////////////////////////////////////////////////////
      //Impulse ausgeben
      uart_puts("Impulse: ");
      uart_puts(itoa (pulse, s, 10));
      uart_putc('\0');
      
      lcd_setcursor(3,1);
      lcd_string("Impulse : ");
      lcd_string("          ");
      lcd_setcursor(3,11);
      lcd_string(s);
      
      //////////////////////////////////////////////////////////////////////////
      //Weg ausgeben
      uart_puts("Weg: ");
      uart_puts(itoa (way / 10, s, 10));
      uart_puts(".");
      uart_puts(utoa (way % 10, t, 10));
      uart_puts(" mm");
      uart_putc('\0');
      
      lcd_setcursor(4,1);
      lcd_string("Weg : ");
      lcd_string("          ");
      lcd_setcursor(4,7);
      lcd_string(s);
      lcd_string(".");
      lcd_string(t);
      lcd_string(" mm");
      uart_putc('\0');
      
      _delay_ms(1000);        
    }
  }
}

//////////////////////////////////////////////////////////////////////////
//Interrupt 0 -> Pin PD2
ISR (INT0_vect)  {  
  
  if (PIND & (1<<SENSOR1B))  {
    pulse ++;
  }
  if (!(PIND & (1<< SENSOR1B))) {
    pulse --;
  }
  
  PORTB ^= (1<<PB0);  //Für Testzwecke drin
}

[Peter II (Gast)]

Christian M. schrieb:
> if (PIND & (1<<SENSOR1B))  {
>     pulse ++;
>   }
>   if (!(PIND & (1<< SENSOR1B))) {
>     pulse --;
>   }

das sieht doch stark nach einen Drehgeber aus, wenn ja ist es so nicht 
zu empfehlen.

https://www.mikrocontroller.net/articles/Drehgeber

[Christian M. (krusti)]

Peter II schrieb:
> Christian M. schrieb:
>> if (PIND & (1<<SENSOR1B))  {
>>     pulse ++;
>>   }
>>   if (!(PIND & (1<< SENSOR1B))) {
>>     pulse --;
>>   }
>
> das sieht doch stark nach einen Drehgeber aus, wenn ja ist es so nicht
> zu empfehlen.
>
> https://www.mikrocontroller.net/articles/Drehgeber

Du meinst wegen dem Prellen? Ich habe hier einen bzw. später zwei 
Glasmaßstäbe, das sollte, falls du das prellen meinst, keine Rolle 
spielen.