Multiplex+ICP

[Fan_AT (Gast)]

Tach liebe Gemeinde,
Ich expirementire grad mit Frequenzmessung per ICP des ATmega88a und 
4xSieben-Segment-Anzeigen. Leider flackert die Anzeige mit steigender 
Frequenz immer mehr zwischen Werten "Null" und der richtigen Frequenz :(

Überschneiden sich da etwa die Interrupts?

LG

[holger (Gast)]

>Überschneiden sich da etwa die Interrupts?

Woher soll das jemand wissen der deinen Code nicht kennt?

[Falk B. (falk)]

Zeile 42!

[Fan_AT (Gast)]

Natürlich, wo bleiben meine Manieren? ;)

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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


volatile unsigned short z=0;    // Zählvariable des Timer1
volatile char UpdateDisplay = TRUE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes

unsigned long zaehlschritte = 0;

uint8_t bitmaske = 0b00010000; // Funktion: Keinen Strom auf PortD4 geben, da TTL

uint16_t freq = 0;
uint16_t zahl = 0; // Kopie von freq

volatile unsigned long Startzeit = 0;  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {                // Messung noch nicht aktualisiert. 
      return;        
  }                    
  
    static char ErsteFlanke = TRUE;
  static  uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  


 
  
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  
   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
    {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
    }
  }
  
  // das ist die zweite Flanke im Messzyklus. Die Messung wird gestoppt
  
  
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  
  
  

}


ISR (TIMER2_OVF_vect)  // timer0 overflow interrupt
{
    
   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  TCNT2 += 0; // nicht nötig
    
    PORTC = 0b00000000;    // alle Digits aus
    
  position++;      // beim nächsten Mal nächstes Digit
  if(position == 4)  // wenn alle Digits durch
  {
    position = 0;  // von vorne beginnen
  }
}

int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1); // Interrupts akivieren, Capture und Overflow - das ODER | am Anfang hinzugefügt
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
    
  TIMSK |= (1 << TOIE2);           // Interrupt aktivieren, Overflow
    TCCR2 |= (1 << CS22)|(1 << CS21);  // Vorteiler auf 256

  sei();          // Interruptbehandlung ein
  

  
  while(1)
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          //zaehlschritte = (unsigned long)(0.5+(65536.0*zaehler1_ovf) + Zeitdifferenz);
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit);   
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
          
      
      
            zahl = freq;
          
            tausender =  zahl/1000;  // Tausender Dezimalstelle
            zahl = zahl % 1000;
    
            hunderter = zahl/100;  // Hunderter Dezimalstelle
            zahl = zahl % 100;
  
            zehner = zahl/10;    // Zehner Dezimalstelle
            zahl = zahl % 10;
    
            einer = zahl;      // Einer Dezimalstelle
          
          
            switch (position)    // aktuelle Stelle ausgeben
        {
          case 0 : if (tausender==0) 
            {  PORTD=numbers[10];
            PORTC |= (1 << PC0);} 
          else
            {  PORTD=numbers[tausender];
            PORTC |= (1 << PC0);}      
          break;
    
        case 1 : if ((tausender==0)&&(hunderter==0))
            {  PORTD=numbers[10];
            PORTC |= (1 << PC1);}
          else
            {  PORTD=numbers[hunderter];
            PORTC |= (1 << PC1);}
          break;
         
        case 2 : if ((tausender==0)&&(hunderter==0)&&(zehner==0))
            {  PORTD=numbers[10];
            PORTC |= (1 << PC2);}
          else
            {  PORTD=numbers[zehner];
            PORTC |= (1 << PC2);}
          break;
         
        case 3 :     PORTD=numbers[einer];
            PORTC |= (1 << PC3);
          break;
        }
    
          
        
          UpdateDisplay = FALSE;
      }
    }
      
      
  }

return 0;
}

[Peter D. (peda)]

Ich finde nirgends den Timerinterrupt der das Multiplex macht.
Multiplex im Main scheitert immer.

[holger (Gast)]

Du machst deine LED Matrixausgabe in der Main Loop.
Das kann so nicht gehen. Die wird je nach Interruptlast
mehr oder weniger flackern. Und noch schlimmer, wenn
ein Interrupt komplett blockiert können dir die LEDs
wegen zu hohem Strom kaputt gehen.

Deine LED Matrixausgabe muss in einen Timerinterrupt.
Die Berechnung was ausgegeben werden soll kannst du in der
Main Loop machen.

[Fan_AT (Gast)]

So war auch die letzte Version - in der aktuellen ist in 
ISR(TIMER2_OVF_vect) ja nur die Positionierung des eingeschalteten 
Segments.

Mein Gedanke war, dass ICP so mehr Priorität bekommt. Völlig unwichtig, 
funktioniert beides nicht.

Aber prinzipiell dürfte ICP+Multiplxing nichts im Wege stehen oder?

[Fan_AT (Gast)]

Hat also in etwa so ausgesehen:

#define F_CPU 16000000UL // uC läuft mit 8MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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

//static inline void digit(uint8_t wert, uint8_t pin);

volatile unsigned short z=0;    // Zählvariable des Timer1
//volatile unsigned short UpdateDisplay;   // Verzögerung
volatile char UpdateDisplay = TRUE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes
//unsigned int zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1
unsigned long zaehlschritte = 0;

uint8_t bitmaske = 0b00010000; // Funktion: Keinen Strom auf PortD4 geben, da TTL

uint16_t freq = 0;


volatile unsigned long Startzeit = 0;  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  



  static char ErsteFlanke = TRUE;

  
    static  uint8_t LowByte = 0;
  
    static uint8_t HighByte = 0;
    
  


 
  
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  
  //DIe Interruptvorziehung abgeschaltet - 07.08.13 - der Wechsel zu Null ist nun langsamer
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
    {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
    }
  }

  
  
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  
  
  

}


ISR (TIMER2_OVF_vect)  // timer0 overflow interrupt
{
    
   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  TCNT2 += 0; // add 6 to the register (our work around)  // bei größeren Frequenzen half TCNT0=190 gegen Flimmern
    
    PORTC = 0b00000000;    // alle Digits aus
    
  switch (position)    // aktuelle Stelle ausgeben
  {
    case 0 : if (tausender==0) 
          {  PORTD=numbers[10];
            PORTC |= (1 << PC0);} 
         else
          {  PORTD=numbers[tausender];
            PORTC |= (1 << PC0);}      
         break;
    
    case 1 : if ((tausender==0)&&(hunderter==0))
          {  PORTD=numbers[10];
            PORTC |= (1 << PC1);}
         else
          {  PORTD=numbers[hunderter];
            PORTC |= (1 << PC1);}
         break;
         
    case 2 : if ((tausender==0)&&(hunderter==0)&&(zehner==0))
          {  PORTD=numbers[10];
            PORTC |= (1 << PC2);}
         else
          {  PORTD=numbers[zehner];
            PORTC |= (1 << PC2);}
         break;
         
    case 3 :     PORTD=numbers[einer];
            PORTC |= (1 << PC3);
         break;
  }
    
  
  position++;      // beim nächsten Mal nächstes Digit
  if(position == 4)  // wenn alle Digits durch
  {
    position = 0;  // von vorne beginnen
  }
}


void zahl_ausgeben(uint16_t zahl)        // Auch diese Zugriffe atomar gestalten!!!! Können sonst unterbrochen werden
{
  tausender =  zahl/1000;  // Tausender Dezimalstelle
  zahl = zahl % 1000;
  
  hunderter = zahl/100;  // Hunderter Dezimalstelle
  zahl = zahl % 100;
  
  zehner = zahl/10;    // Zehner Dezimalstelle
  zahl = zahl % 10;
  
  einer = zahl;      // Einer Dezimalstelle
}



int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1); // Interrupts akivieren, Capture und Overflow - das ODER | am Anfang hinzugefügt
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  

  
  TIMSK |= (1 << TOIE2);           // Interrupt aktivieren, Overflow
    TCCR2 |= (1 << CS22)|(1 << CS21);  // Vorteiler auf 256


  

  sei();          // Interruptbehandlung ein
  

  
  while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
      
            zahl_ausgeben(freq);
          

          UpdateDisplay = FALSE;
      }
    }
      
      
  }

return 0;
}

[holger (Gast)]

>ISR (TIMER2_OVF_vect)  // timer0 overflow interrupt
>{
>
>   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der 
>vorhergehenden
>    {             // Messung noch nicht aktualisiert. Die nächste Messung
>    return;         // verzögern, bis die Start- und EndTime-Variablen >wieder
>  }                    // gefahrlos beschrieben werden können

Mach dieses   if(UpdateDisplay)

da weg. Dein Matrixdisplay muss immer upgedatet werden,
egal ob deine Messung noch läuft oder nicht. Zeig dort
halt immer den letzten Wert an. Du kannst das
multiplexen deiner Matrix nicht einfach unterbrechen.
Dann flackert das Viech wie Hölle.

[Fan_AT (Gast)]

Oh danke, nicht aufgepasst. Das Problem ist eben folgendes: Es gibt kein 
Flimmern wie beim falscheingestellten Multiplex. Die Anzeige flackert 
immer zwischen Null und der richtigen Frequenz. Nur wird das Flackern 
bei steigender Freqenz immer schneller.
Und ich weiß dafür einfach keinen Grund

[Axel S. (a-za-z0-9)]

Fan_AT schrieb:

> Aber prinzipiell dürfte ICP+Multiplxing nichts im Wege stehen oder?

Nein, natürlich nicht. Funktionierende Schaltung + Code kannst dir hier 
ansehen: Frequenzzählermodul

Da flackert gar nix, obwohl sich die LED-Displays die Controllerpins 
sogar mit dem Vorteiler und den Jumpern teilen.

Ein Vorschlag zur allgemeinen Strukturierung:

1. mach einen Display-Buffer für den darzustellenden Inhalt deines 
Displays. Bei 7-Segment bietet es sich an, hier direkt die Segmente 
abzuspeichern.

2. such dir eine Interruptquelle, die ca. 100Hz * Anzahl Stellen hat. 
Das kann ein Timerüberlauf sein oder ein Compare Match. Wichtig: 
regelmäßig muß es sein und nicht zu langsam (dann flimmert die Anzeige)

3. schreib eine ISR für diesen Interrupt, der den Display-Buffer 
zyklisch ausliest und die jeweils nächste Stelle ausgibt.

Die eigentliche Messung machst du in der Mainloop. Und wenn du ein neues 
Ergebnis hast, dann schreibst du es in den Display-Buffer. Auf diese 
Weise ist es auch trivial, einen Meßwert "einzufrieren".

Wenn es nur kurzzeitig ist, darfst du dann in der Mainloop auch cli/sei 
verwenden. Mit etwas Geschick kann man sogar das Display für ein paar µs 
ausschalten, die Pins für was anderes verwenden (Vorteiler und Jumper 
auslesen) und dann wieder einschalten. Obiger Frequenzzähler macht das 
in main.c Zeile 136 bis 180.


XL

[Karl H. (kbuchegg)]

und auch den QUatsch schmeisst du raus.
Das hat alles im Multiplex nichts verloren.

  switch (position)    // aktuelle Stelle ausgeben
  {
    case 0 : if (tausender==0) 
          {  PORTD=numbers[10];
            PORTC |= (1 << PC0);} 
         else
          {  PORTD=numbers[tausender];
            PORTC |= (1 << PC0);}      
         break;
    
    case 1 : if ((tausender==0)&&(hunderter==0))
          {  PORTD=numbers[10];
            PORTC |= (1 << PC1);}
         else
          {  PORTD=numbers[hunderter];
            PORTC |= (1 << PC1);}
         break;
         
    case 2 : if ((tausender==0)&&(hunderter==0)&&(zehner==0))
          {  PORTD=numbers[10];
            PORTC |= (1 << PC2);}
         else
          {  PORTD=numbers[zehner];
            PORTC |= (1 << PC2);}
         break;
         
    case 3 :     PORTD=numbers[einer];
            PORTC |= (1 << PC3);
         break;
  }

Die Multiplexroutine kümmert sich nicht mehr um logische Zusammenhänge. 
Das ist alles der Job des Codes, der die auszugebenden Bitmuster für die 
Anzeigen zusammenstellt. Die Multiplexroutine schaufelt nur noch Daten 
raus. Nicht mehr und nicht weniger.

PS: Anstatt Einzelvariablen für Tausender, Hunderter etc. ist ein Array 
eine ganz einfache Sache. Deine Multiplexroutine sieht dann ganz einfach 
so aus

volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;
uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };

ISR (TIMER2_OVF_vect)  // timer0 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus

  digit_position++;
  if( digit_position == 4 )
    digit_position = 0;

  PORTD = digits[ digit_position ];
  PORTC = digitControl[ digit_position ];
}

fertig, Das ist deine ganze Multiplexroutine.
Wenn irgendein andere Code was auf die Anzeige zaubern will, dann hat er 
gefälligst die entsprechenden Bytes in das digit-Array zu stellen.

Ob da jetzt bei Zahlen eine führende 0 angezeigt wird oder nicht, das 
entscheidet die Funktion, die einen int in die einzelnen Digits zerlegt 
und die zugehörigen auszugebenden Bitmuster in das digit Array schreibt. 
Das entscheidet NICHT die Multiplexroutine! Die schaufelt nur Bytes raus 
auf die Anzeige. Und wenn in den digits enthalten ist, dass immer nur 
die oberen Querbalken der einzelnen Segmente leuchten sollen, dann ist 
das eben so - das hat die Multiplexroutine nicht zu kümmern. Ab sofort 
gibt es für den Rest des Programms nur noch dieses digits-Array. Was 
auch immer da an auszugebendem Leuchtmuster in die einzelnen Stellen 
reingeschrieben wird, das wird angezeigt.

void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[4] = numbers[ zahl % 10 ];
  zahl /= 10;

  for( i = 3; i != 255; i-- )
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[ zahl % 10 ];
      zahl = zahl / 10;
    }
    else
      digits[i] = numers[10];
  }
}

und nein, die zahl_ausgeben darf auch durch einen Interrupt unterbrochen 
werden. Du hast dann ganz kurz eine falsche Zahl an der Anzeige. Das ist 
aber so kurz, dass du es nicht sehen wirst. Viel wichtiger ist, dass die 
Multiplex-ISR in gleichen Abständen arbeiten darf. Ob da ein paar 
Millisekunden lang eine zusammengewürfelte Anzeige sichtbar ist oder 
nicht, ist für uns Menschen nicht merkbar.

[Karl H. (kbuchegg)]

> Die Anzeige flackert immer zwischen Null und der richtigen Frequenz

Nachdem du den Multiplex korrekt gemacht hast, musst du dann eben 
nachsehen, warum in deinen Berechnungen immer abwechselnd 0 und ein 
anderer Wert rauskommt.

[Fan_AT (Gast)]

Wow, da sitzt man, programmiert - und dann geht das noch tausendfach 
kompakter -.-

Aktuell sieht es so aus, leider noch irgendwo ein kleiner Fehler drin - 
es wird gar nichts angezeigt. Aber vielen Dank schonmal für die Tipps.

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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

volatile unsigned short z=0;    // Zählvariable des Timer1
volatile char UpdateDisplay = FALSE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

//volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
//volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes
//unsigned int zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1
unsigned long zaehlschritte = 0;

uint16_t freq = 0;


volatile unsigned long Startzeit = 0;

volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  }
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
    {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
    }

  
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  

}


ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus
  TCNT2 += 0; 

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[3] = numbers[zahl % 10];  // Die letzte Ziffer wird gesichert
  zahl /= 10;

  for( i=2; i>=0 ; i-- ) // das Gleiche wie  for( i = 3; i != 255; i-- )?
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[zahl % 10];
      zahl /= 10;
    }
    else
      digits[i] = numbers[10];
  }
  
  if(freq==0)
  {digits[3] = numbers[0];}
}



int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, Capture und Overflow, Overlow-Interrupt aktivieren
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  
    TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256


  sei();          // Interruptbehandlung ein
  

  while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
      
            zahl_ausgeben(freq);
          

          UpdateDisplay = FALSE;
      }
    }
      
      
  }

return 0;
}

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> Aktuell sieht es so aus, leider noch irgendwo ein kleiner Fehler drin -
> es wird gar nichts angezeigt.


Mir fehlt da

int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, Capture und Overflow, Overlow-Interrupt aktivieren
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  
    TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256

...

die Freigabe des Overflow Interrupts beim Timer 2.
Dann ist natürlich klar, dass dein Multiplexing nicht anspringt.

[Karl H. (kbuchegg)]

Nur um sicher zu gehen. Teste mal das Multiplexing ganz alleine. Zuviele 
Änderungen gleichzeitig sind nicht gut in der Entwicklung. D.h. wir 
gehen mal einen Schritt zurück und sehen nach, ob die Basis auch 
wirklich funktioniert.

int main(void)
{
  uitn16_t cnt = 0;

  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  TIMSK |= (1 << TOIE2);
  TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256
  
  sei();

  while(1)
  {
    zahl_ausgeben( cnt++ );
    if( cnt == 10000 )
      cnt = 0;

    _delay_ms( 200 );
  }

  return 0;
}

Sobald dann von dir die Bestätigung kommt, dass das funktioniert, ist 
damit dann das Thema Multiplexing vom Tisch. Darum brauchst du dich dann 
nicht mehr kümmern.

[Fan_AT (Gast)]

In deinem Quote, nur eine Zeile später kommt sei(); vor. Damit aktiviere 
ich doch auch global die Interrupts?

Wie dem auch sei - irgendwo habe ich einen Fehler eingebaut - der 
Multiplex funktioniert gar nicht. Die Anzeige ist aber intakt.

Hier der Code für reinen Multiplex-Betrieb:

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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


volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };

uint16_t cnt = 0;

const uint8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.  // 08.08.13 - int8_t numbers[11], nicht uint8_t
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};

void delay_ms(uint16_t ms)
{
  for(uint16_t t=0; t<=ms; t++)
    _delay_ms(1);
}
    

ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus
  TCNT2 += 0; 

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[3] = numbers[ zahl % 10 ];
  zahl /= 10;

 for( i=2; i>=0 ; i-- )
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[ zahl % 10 ];
      zahl = zahl / 10;
    }
    else
      digits[i] = numbers[10];
  }
}


int main(void)
{
  

  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  TIMSK |= (1 << TOIE2);
  TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256
  
  sei();

  while(1)
  {
    zahl_ausgeben( cnt++ );
    if( cnt = 10000 )
      cnt = 0;

    delay_ms(200);
  }

  return 0;
}

[Fan_AT (Gast)]

Ich melde mich, sobald ich den Fehler finde, wird vllt. noch etwas 
dauern :D

[Fan_AT (Gast)]

Gut, digitControl kann man als volatile deklarieren. Ändern tut sich 
aber nichts.

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Ich melde mich, sobald ich den Fehler finde, wird vllt. noch etwas
> dauern :D


Moment. Hast du den Overflow Interrupt jetzt freigegeben?
In deinem Programm hat das hier

  TIMSK |= (1 << TOIE2);

gefehlt!

> Gut, digitControl kann man als volatile deklarieren. Ändern tut sich aber 
nichts.


Wer hat was von einem fehlenden volatile gesagt? Da fehlt keiner.

[Karl H. (kbuchegg)]

> In deinem Quote, nur eine Zeile später kommt sei(); vor. Damit aktiviere ich 
doch auch global die Interrupts?

Argh.
sei() ist das Rundumschlag - 'Jetzt gilt es. Alle aktivierten Interrupts 
sind auch aktiv und können Funktionsaufrufe auslösen'. Sozusagen der 
Hauptschalter.


Aber nichts desto trotz musst du auch mal wo festlegen, welche 
Interrupts auch zugelassen sind. Der Mega hat viele mögliche 
INterrupt-Quellen. Die interessieren dich aber alle nicht.
Dich interessiert der Interrupt vom Overflow des Timers 2. Daher

  TIMSK |= (1 << TOIE2);

[Karl H. (kbuchegg)]

Hmm.
Hab ich deine Hardware-Belegung aus dem Original-Code falsch 
rausgelesen?

Am Port-D hängen die Segmentleitungen. Ein 1-bit aktiviert das Segment
Am Port-C, Pins 0 bis 3, hängen die Digit-Leitungen. Ein 1 Bit aktiviert 
das entsprechende Digit.

[Fan_AT (Gast)]

> TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, 
>Capture und Overflow, Overlow-Interrupt aktivieren

Die Freigabe erfolgte nur zusammen in einer Zeile mit dem Rest - aber 
sie war da.

Von 'E' halte ich sehr viel, wenn es funktioneirt. Du wirst wohl lachen, 
aber der Code funktioniert nicht. Hier:

#define F_CPU 16000000UL // uC läuft mit 16MHz

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


volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

volatile uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };

uint16_t cnt = 0;

const int8_t numbers[12] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000,    // leere Anzeige
  0b11101001,    // 'E'
};

void delay_ms(uint16_t ms)
{
  for(uint16_t t=0; t<=ms; t++)
    _delay_ms(1);
}
    

ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  //PORTC = 0b00000000;    // alle Digits aus

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  if( zahl > 9999 )
  {
    digits[0] = digits[1] = digits[2] = digits[3] = numbers[11]; //'E'
    return; 
  }

  digits[4] = numbers[ zahl % 10 ];
  zahl /= 10;

  for( i = 3; i != 255; i-- )
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[ zahl % 10 ];
      zahl = zahl / 10;
    }
    else
      digits[i] = numbers[10];
  }
}

int main(void)
{
  

  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  TIMSK |= (1 << TOIE2);
  TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256
  
  sei();

  while(1)
  {
    zahl_ausgeben( cnt++ );
    if( cnt = 10000 )
      cnt = 0;

    delay_ms(200);
  }

  return 0;
}

Mir ist die Schleifenbedingung allerdings nicht ganz geheuer oO
ginge das nicht mit

 for( i=2; i>=0 ; i-- )

[Karl H. (kbuchegg)]

Hier steckt der Fehler.

Beim Mega88 steckt das entsprechende Bit nicht im TIMSK, sondern im 
TIMSK2.

  TIMSK2 |= ( 1 << TOIE2 );

[Fan_AT (Gast)]

4x 7-Segment Anzeigen mit je gemeinsamen Kathode. Die Steuerleitungen 
für die Digits liegen auf PORTC=0b0000XXXX.
Die einzelnen Segmente liegen auf PORTD.

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> Von 'E' halte ich sehr viel, wenn es funktioneirt.

Gut ich poste dann den Code nochmal. Hab ihn wieder rausgelöscht, damit 
der Thread kein Durcheinander wird.

> Du wirst wohl lachen,
> aber der Code funktioniert nicht.

Ich lache gar nicht.
Ich sollte eher weinen, weil ich dir aus deinem Urprogramm geglaubt 
habe, dass

   TIMSK |= ( 1 << TOIE2 );

richtig ist, wenn es das tatsächlich nicht ist.

   TIMSK2 |= ( 1 << TOIE2 );

Ich hätte es eigentlich mit dem Datenblatt kontrollieren sollen. Getreu 
dem Motto: nimm nichts als richtig an, ehe du es nicht überprüft hast.

[Fan_AT (Gast)]

Nein, keine Sorge - es funktioniert immer noch nicht. Teste es aktuell 
auf 'nem ATmega8 und vergessen, den Codeschnipsel zu ändern. Tut mir 
Leid.

Also: klappt weder auf dem uC, noch auf dem anderen. Ich gehe nochmal 
alle Register durch.

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> Mir ist die Schleifenbedingung allerdings nicht ganz geheuer oO

Allerdings hast du recht.

Asche auf mein Haupt

> ginge das nicht mit
>

>  for( i=2; i>=0 ; i-- )
>

So zwar nicht, denn i ist sowieso als unsigned Wert IMMER größer oder 
gleich 0. i kann nicht negativ sein

Allerdings hat ich noch einen kapitalen Bock geschossen. Einen richtigen 
Anfängerfehler.
Hier ist die Korrektur

void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  if( zahl > 9999 )
  {
    digits[0] = digits[1] = digits[2] = digits[3] = numbers[11]; //'E'
    return; 
  }

  digits[3] = numbers[ zahl % 10 ];
  zahl /= 10;

  for( i = 2; i != 255; i-- )
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[ zahl % 10 ];
      zahl = zahl / 10;
    }
    else
      digits[i] = numbers[10];
  }
}

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Nein, keine Sorge - es funktioniert immer noch nicht. Teste es aktuell
> auf 'nem ATmega8 und vergessen,


grrrrrrrrr

[Fan_AT (Gast)]

Hoppla! Das war echt die for-Bedingung :(
Hätte mir, Deppen, auch einfallen können... die ungleich 255 hängt mit 
der max.Größe des uint8_t zusammen?

Vielen, vielen Dank schonmal dafür - ich sah den Wald vor lauter Bäumen 
nicht mehr...

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Hoppla! Das war echt die for-Bedingung :(
> Hätte mir, Deppen, auch einfallen können... die ungleich 255 hängt mit
> der max.Größe des uint8_t zusammen?
>
> Vielen, vielen Dank schonmal dafür - ich sah den Wald vor lauter Bäumen
> nicht mehr...

Puh.
Da muss ich mir jetzt erst mal den Schweiss von der Stirn wischen.

Ich seh grad, den anderen Fehler, der mich wie einen absoluten Tölpel 
hat aussehen lassen, hast du selbst schon korrigiert gehabt und 
Stillschweigen darüber bewahrt. Anständig von dir!

    digits[4] = numbers[ zahl % 10 ];

könnt mich jetzt noch in den Allerwertesten beissen deswegen.

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Hoppla! Das war echt die for-Bedingung :(
> Hätte mir, Deppen, auch einfallen können... die ungleich 255 hängt mit
> der max.Größe des uint8_t zusammen?
>

Jep.
Ist quasi -1 für einen unsigned Wert mit 8 Bit

Ja ich weiss. ist nicht so toll. Aber mir ist auf die Schnelle nichts 
anderes eingefallen :-)

[Fan_AT (Gast)]

Das ist alles besser, als das von mir Geleistete ;)

Hier nochmal der gesamte Code - der in seiner Gesamtheit - wieder nichts 
anzeigt. Ob du den Fehler auf Anhieb siehst?
Das Ganze läuft jetzt auf ATmega8 - die Register scheinen alle richtig 
zu sein. Überprüfe ich aber grade. Danke dir für die ganze Mühe...

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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

volatile unsigned short z=0;    // Zählvariable des Timer1
volatile char UpdateDisplay = TRUE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

//volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
//volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes
//unsigned int zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1
unsigned long zaehlschritte = 0;

uint16_t freq = 0;


volatile unsigned long Startzeit = 0;

volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const uint8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.  // 08.08.13 - int8_t numbers[11], nicht uint8_t
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  }
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
    {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
    }

  
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  

}


ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus
  TCNT2 += 0; 

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[3] = numbers[zahl % 10];  // Die letzte Ziffer wird gesichert
  zahl /= 10;

  for( i = 2; i != 255; i-- ) 
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[zahl % 10];
      zahl /= 10;
    }
    else
      digits[i] = numbers[10];
  }
  
  if(freq==0)
  {digits[3] = numbers[0];}
  
}



int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, Capture und Overflow, Overlow-Interrupt aktivieren
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  
    TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256


  sei();          // Interruptbehandlung ein
  

  while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
      
            zahl_ausgeben(freq);
          

          UpdateDisplay = FALSE;
      }
    }
      
      
  }

return 0;
}

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Das ist alles besser, als das von mir Geleistete ;)
>
> Hier nochmal der gesamte Code - der in seiner Gesamtheit - wieder nichts
> anzeigt.

D.h. das Multiplexing, Zahlenausgabe, Überlauferkennung in der 
Zahlenausgabe läuft erst mal?

(Sorry wenn ich nachfrage. Aber ich hab nur das, was du schreibst. Und 
ich brauch klare Bestätigungen was geht und was nicht geht. Ist für mich 
wichtig, damit ich weiß, welche Teile ich aus der Fehlersuche 
ausklammern kann)

[Karl H. (kbuchegg)]

void zahl_ausgeben(uint16_t zahl)
{
  ....
  if(freq==0)
  {digits[3] = numbers[0];}
  
}

Das hat in der Funktion nichts verloren.

Disziplin!

Eine Funktion hat eine Aufgabe.
Die Aufgabe der Funktion zahl_ausgeben ist es, eine Zahl auszugeben. 
Egal welche. Ob freq 0 ist oder nicht, interessiert hier nicht.
Wenn der restliche Code eine Anzeige von 0 haben will, dann soll er 
zahl_ausgeben(0) aufrufen. Aber nicht hier in der Funktion irgendwelche 
Hacks einbauen. Das sind alles Dinge, die dir früher oder später auf den 
SChädel fallen.
Frag dich immer:
Welche Aufgabe hat eine Funktion? Was gehört zu dieser Aufgabe? Was 
gehört NICHT zu dieser Aufgabe?

[Fan_AT (Gast)]

Gut, Disziplin, gemerkt. Und gelöscht.

Gut, also... Nein, eher schlecht. Unser letztes Programm, reines 
Multiplxing zeigt zwar eine Null an - aber dabei bleibt's auch. Ich bin 
noch nicht fündig geworden.

[Karl H. (kbuchegg)]

Lass uns den Teil in main mal korrekt einrücken. Dann sieht man schon 
mal mehr

  while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
    {
      ATOMIC_BLOCK(ATOMIC_FORCEON)
      {
        zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
      }
        
      
      if (zaehlschritte==0)
      {
        freq = 0;
      }
      else
      {
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          // Die abschließende Berechnung der Schritte pro Sekunde
          freq = (uint16_t) (F_CPU/(zaehlschritte));
        }
        zahl_ausgeben(freq);
          

        UpdateDisplay = FALSE;
      }
    }
  }

  return 0;
}

Hä?
Da stimmt doch in der logischen Struktur was nicht.
Damit zahl_ausgeben aufgerufen werden kann, müssen ein paar 
Vorbedingungen gültig sein.

Aber noch viel schlimmer.
Damit UpdateDisplay je FALSE werden kann, müssen ebenfalls ein paar 
Vorbedingungen gültig sein. Bei einem 0 Ergebnis in zaehlschritte, wird 
UpdateDisplay nicht FALSE. Was dann wiederrum im Gegenzug dazu führt, 
das in der ISR

ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  ...

keine weitere Messung mehr durchgeführt wird, die dafür sorgen könnte, 
dass zaehlschritte ungleich 0 werden könnte.


Das muss in main anders angeordnet werden!
Ein 0 Ergebnis ist kein fehlerhaftes Ergebnis, sondern einfach nur 0.
Auch das wird angezeigt und UpdateDisplay auf FALSE gesetzt, damit eine 
weitere Messung durchgeführt werden kann.


Saubere Einrückungen sind nicht einfach nur eine optische Sache!
Sie helfen dir die Codestruktur zu überblicken!

[Fan_AT (Gast)]

Hm, UpdateDisplay muss außerhalb der if-Abfrage stehen.

Struktur ist sehr gut, man muss aber auch die Sprache beherrschen :) Ist 
jetzt auf mich bezogen.

Mein letzter Post bezog sich auf das reine Multiplex-Programm, was 
lediglich eine Null anzeigt und nicht weiterzählt.

[Karl H. (kbuchegg)]

Der Kommentar hier

    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen

sollte anders aussehen.
Das ist nicht 'wenn zweite Flanke'. D.h. technisch ist es das schon. 
Aber an dieser Stelle ist es besser zu lesen als:

Wenn eine Messung fertig ist.

Dieses Flag hat 2 Aufgaben:
Zum einen ist es die Benachrichtigung aus der ISR in die main() "Ich 
habe eine Messung fertig". Zum anderen ist es die Verriegelung der ISR 
mit isch selbst, so lange keine weitere Messung zu machen, bis die 
main() das Ergebnis verarbeitet hat.
D.h. wenn main() die Messergebnisse der ISR ausgewertet hat, dann muss 
sie UpdateDisplay wieder auf FALSE setzen. Egal was dann bei der 
Auswertung rauskommt. Das FALSE-setzen von UpdateDisplay ist quasi die 
Rückmeldung von main() in die ISR "OK, ich hab mir deinen Messwert 
geholt, du kannst wieder loslegen und die nächste Messung machen". Das 
aber, muss IMMER passieren. Egal was dann bei der Auswertung rauskommt

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> Mein letzter Post bezog sich auf das reine Multiplex-Programm, was
> lediglich eine Null anzeigt und nicht weiterzählt.


Was jetzt?
Wir reden aneinander vorbei.

Können wir uns erst mal auf eine Sache, und nur auf eine Sache 
konzetrieren?

int main(void)
{
  

  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  TIMSK |= (1 << TOIE2);
  TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256
  
  sei();

  while(1)
  {
    zahl_ausgeben( cnt++ );
    if( cnt = 10000 )         //   <------- *** das ist kein Vergleich ***
      cnt = 0;

    delay_ms(200);
  }

  return 0;
}

läuft das (mit der Korrektur): ja oder nein.
Zeigt die Anzeige hochzählende Zahlen: ja oder nein.

[Fan_AT (Gast)]

Gut, bleiben wir erstmal beim reinen Multiplex.

Ja, das Programm läuft und zeigt eine Null an, ohne Flimmer, Flackern.

Nein, das Programm zählt nicht, sondern bleibt konstant bei Null.

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Gut, bleiben wir erstmal beim reinen Multiplex.
>
> Ja, das Programm läuft und zeigt eine Null an, ohne Flimmer, Flackern.
>
> Nein, das Programm zählt nicht, sondern bleibt konstant bei Null.

Ok. Dann korrigier mal

    if( cnt = 10000 )

zu

    if( cnt == 10000 )

[Fan_AT (Gast)]

Genau, mit dem Vergleich läuft es nun durch und beginnt von neu.

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Genau, mit dem Vergleich läuft es nun durch und beginnt von neu.

Gut. Wie willst du weitermachen?
Mit dem Overflow-E bei der Zahlausgabe?
Wär vernünftig, damit zu große Rechenergebnisse in der 
Frequenzberechnung nicht alles durcheinander schmeissen.

[Karl H. (kbuchegg)]

Ist schnell gemacht und schnell getestet (Ich weiß nämlich nicht, ob ich 
die 7-Seg Darstellung fürs 'E' richtig gemacht habe)

const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000,    // leere Anzeige
  0b11101001,    // 'E'
};

void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  if( zahl > 9999 )
  {
    digits[0] = digits[1] = digits[2] = digits[3] = numbers[11]; 'E'
    return; 
  }

  digits[3] = numbers[zahl % 10];  // Die letzte Ziffer wird gesichert
  zahl /= 10;

  for( i = 2; i != 255; i-- ) 
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[zahl % 10];
      zahl /= 10;
    }
    else
      digits[i] = numbers[10];
  }
}

und getestet

int main()
{
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  TIMSK |= (1 << TOIE2);
  TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256
  
  sei();

  while(1)
  {
    zahl_ausgeben( 500 );
    delay_ms(1000);
    zahl_ausgeben( 10000 );
    delay_ms(1000);
  }

  return 0;
}

offensichtlich sollte die Anzeige zwischen 500 und lauter E im 
Sekundentakt wechseln.

[Karl H. (kbuchegg)]

Wenn die Anzeige 'wild' aussieht, dann hab ich mich wahrscheinlich hier

    0b11101001,    // 'E'

bei den Bits vertan.

[Fan_AT (Gast)]

Die Frequenzbegrenzung ist bereits fertig und wird noch vor den 
Frequenzzähler geschaltet. Aber das "E"-Programm funktioniert 
einwandfrei.

Jetzt das Programm in seiner Gesamtheit. UpdateDisplay ist nun außerhalb 
der if-Abfrage. Es wird nichts angezeigt.

Hier der Code:

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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

volatile unsigned short z=0;    // Zählvariable des Timer1
volatile char UpdateDisplay = TRUE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

//volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
//volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes
//unsigned int zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1
unsigned long zaehlschritte = 0;

uint16_t freq = 0;


volatile unsigned long Startzeit = 0;

volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.  // 08.08.13 - int8_t numbers[11], nicht uint8_t
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  }
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
    {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
    }

  
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  

}


ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus
  TCNT2 += 0; 

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[3] = numbers[zahl % 10];  // Die letzte Ziffer wird gesichert
  zahl /= 10;

  for( i = 2; i != 255; i-- ) 
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[zahl % 10];
      zahl /= 10;
    }
    else
      digits[i] = numbers[10];
  }
  
  
}



int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, Capture und Overflow, Overlow-Interrupt aktivieren
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  
    TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256


  sei();          // Interruptbehandlung ein
  

  while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
      
            zahl_ausgeben(freq);
          
          }
          
          UpdateDisplay = FALSE;
      }
    
      
      
  }

return 0;
}

[Fan_AT (Gast)]

Ups, mein Fehler:

while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
            zahl_ausgeben(0);
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
            }
      
            zahl_ausgeben(freq);
          
          }
          
          UpdateDisplay = FALSE;
      }
    
      
      
  }

[Fan_AT (Gast)]

Bei dem aktuellen Stand bleibt imemr die Null leuchten - unabhängig, ob 
ein Signal anliegt oder nicht.

[Karl H. (kbuchegg)]

Ok. Sieht wohl so aus, als ob die Ausgabe damit zuverlässig wäre. Auch 
wenn ich nicht verstehe, warum du schon wieder Code präsentierst, in dem 
die Overflow-Behandlung in zahl_ausgabe nicht enthalten ist.


Konzentrieren wir uns mal auf die Capture ISR und schreiben die mal 
übersichtlicher. Dein Klammern Einrückschema macht mich nämlich 
wahnsinnig.

ISR(TIMER1_CAPT_vect)
{
  if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
  {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  

  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  }

  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
  {   
    // wartenden Timer Overflow Interrupt vorziehen
    ++z;         
    TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
  }
  else
  {
    Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
    zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
    Startzeit = 0;
    z=0;  // Nach dem Sichern - annullieren
  }  
}

Hmm. Das kann nicht stimmen. Das 'else' in dem der UpdateDisplay=TRUE 
sitzt, gehört zum

  if ((HighByte < 128) && (TIFR & (1<<TOV1)))

das ist aber ganz sicher nicht die Bedingung, die einen Update 
verhindern sollte. Das else sollte zur Abfrage der ersten Flanke 
gehören. Zweck des ganzen ist es doch, abwechselnd den Capture Wert dem 
Beginn eines Pulses bis zum Beginn des nächsten Pulses zuzuordnen.

[Karl H. (kbuchegg)]

PS: mit welcher Eingangsfrequenz testest du eigentlich? Welche Frequenz 
wirfst du dem Teil vor?
Nur damit man mal ein bischen nachrechnen kann, was da so an 
Zählerwerten rauskommen müsste.

[Karl H. (kbuchegg)]

Nope. Das sieht nicht richtig aus.
Können wir uns darauf einigen, die Overflowbehandlung erst mal beiseite 
zu lassen und du gibst dem Tei lnur Frequenzen zu schlucken, die keinen 
zu berücksichtigenden Overflow auslösen werden?

IMOH müsste das ganze zumindest so aussehen

ISR(TIMER1_CAPT_vect)
{
  if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
  {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  

  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  }
  else
  {
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
    zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
    Startzeit = 0;
    z=0;  // Nach dem Sichern - annullieren
  }  
}

und in main dann:

        ....
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = Zeit;
        }
        ....

[Fan_AT (Gast)]

Wie ich bereits schrieb - die Frequenzbegrenzung ist bereits fertig und 
wird noch vor den Frequenzzähler geschaltet. Darum habe ich mich bereits 
gekümmert. Die genaue Frequenz kann ich an der Skala des 
Funktionsgenerators ablesen, die ich zuvor mit 'nem Oszilloskop 
eingezeichnet habe.
Ist also nicht das Problem, das Testen.
Der Frequenzbereich ist mit 1-1400 Hz klein gehalten und einige 
Variablen könnten noch kleiner deklariert werden.

ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H; 
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
  {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
  } 
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  }
   
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  

}

Du hast Recht, es ist die Bedingung, die einen verpassten Interrupt 
wieder miteinbezieht.

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:
> PS: mit welcher Eingangsfrequenz testest du eigentlich? Welche Frequenz
> wirfst du dem Teil vor?
> Nur damit man mal ein bischen nachrechnen kann, was da so an
> Zählerwerten rauskommen müsste.


Was hast du an Werten.
Du hast 16Mhz und Prescaler 1.

D.h. der Timer1 mit seinen 16 Bit wird in 1 Sekunde ...

  16000000 / 65536 = 244.1

... 244 mal überlaufen.

D.h. jede Eingangsfrequenz, die höher als 244Hz ist, dürfte dann 
eigentlich keinen zu berücksichtigenden Overflow während des Captures 
verursachen. Sicherheitshalber noch höher gehen. 1kHz, wenn du hast, 
sollte eine gute Basis sein, um damit zu testen.

[Fan_AT (Gast)]

Klar, dann arbeiten wir erstmal ohne einen Overflow.

[Karl H. (kbuchegg)]

> Der Frequenzbereich ist mit 1-1400 Hz

1 ist zuwenig!

Du brauchst erst mal eine Eingangsfrequenz, so dass dir der Timer keine 
Differenz liefern müsste, die größer als 65535 ist! Also keinen zu 
berücksichtigenden Overflow!

[Fan_AT (Gast)]

Ich meinte den gesamten Bereich. Nehmen wir als Referenzfrequenz dann 
die 1,400Khz

[Karl H. (kbuchegg)]

Stell mal 1kHz ein. Rechnet sich leichter als 1.4kHz :-)

Was ergibt sich daraus?
1kHz bedeutet, dass der Capture Interrupt alle 1ms aufgerufen werden 
müsste.

Wie weit kann der Timer in 1ms zählen?
In 1 Sekunde würde er bis 16000000 zählen. In 1ms (also 1/1000) Sekunde 
kommt er logischerweise nur 1/1000 so weit. Also bis 16000.

D.h.
Aus

ISR(TIMER1_CAPT_vect)
{
  if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
  {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H;  

  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  }
  else
  {
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
    zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
    Startzeit = 0;
    z=0;  // Nach dem Sichern - annullieren
  }  
}

müssten sich Werte für 'Zeit' von um die 16000 ergeben.
16000 kannst du auf einer 4 stelligen 7_seg nicht anzeigen. ABer 1/10 
davon.

Also

int main()
{
  ...

  while(1)  // unendliche Schleife
  {
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
    {
      ATOMIC_BLOCK(ATOMIC_FORCEON)
      {
        zaehlschritte = Zeit / 10;
      }
      zahl_ausgeben( zaehlschritte );
      UpdateDisplay = FALSE;
    }
  }
  return 0;
}

Hast du bei 1kHz die erwarteten 1600 (+- ein paar Zerquetschte) auf der 
Anzeige?

[Karl H. (kbuchegg)]

:-)
Und du siehst hoffentlich jetzt auch, warum ich so drauf gedrängt habe, 
die Zahlenausgabe erst mal fehlerfrei zu machen.
Denn die brauchen wir jetzt! Die muss zum jetzigen Zeitpunkt über jeden 
Fehler erhaben sein.
Denn was ich jetzt nicht brauchen kann, das ist, das ich nicht weiß ob 
ein Fehler in der Messung oder in der Ausgabe passiert. Die Ausgabe und 
Anzeige MUSS zum jetzigen Zeitpunkt etwas sein, um das ich mich nicht 
mehr kümmern brauchen darf.
Daher die ganzen Vortests um sicher zu stellen, dass die Zahlenausgabe 
auf jeden Fall korrekt funktioniert.
Wenn jetzt auf der Anzeige 832 steht, dann muss auch zahl_ausgeben mit 
832 aufgerufen worden sein. Oder eben mit 0, wenn in der Anzeige 0 
steht. Da darf es keinerlei Unsicherheiten mehr geben.

[Fan_AT (Gast)]

So... Noch einbisschen geändert.
Jap, du hast absolut Recht. Knapp über 1600.

Ich habe es jetzt mal mit dem Gesamtcode getestet: die Messung war ja 
auch davor schon korrekt, aber die Anzeige flimmerte.

Nun ist es folgendermaßen:
Bei Frequenzen kleiner 500Hz sieht man den schnellen Wechsel zwischen 
der richtigen Frequenz und Null
Bei Frequenzen kleiner 1000Hz flimmern die letzten 1-2 Ziffern.
Bei größeren Frequenzen flimmert nur manchmal die letzte Ziffer, was 
vllt. auch nur ein Rundungsfehler ist.

[Fan_AT (Gast)]

Ich glaube, deine Arbeitsweise muss ich mir mal angewöhnen, gehe etwas 
chaotisch vor udn versuche über alles einen gleichzeitigen Überblick zu 
behalten ;)

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> So... Noch einbisschen geändert.
> Jap, du hast absolut Recht. Knapp über 1600.

gut.

> Ich habe es jetzt mal mit dem Gesamtcode getestet:

Ich gebs auf.
Vergiss den Gesamtcode.
Immer noch nicht begriffen? Wir bauen das ganze systematisch neu auf!

[Fan_AT (Gast)]

Entschuldige bitte. Also - die zaehlschritte ergeben irgendwas mit 1600.

Wie ist das weitere Vorgehen?

[Karl H. (kbuchegg)]

> gehe etwas chaotisch vor

Du wärst schon längst fertig, wenn du nicht so am bestehenden 
Originalcode hängen würdest, sondern das ganze Programm systematisch neu 
aufbauen würdest

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Entschuldige bitte. Also - die zaehlschritte ergeben irgendwas mit 1600.
>
> Wie ist das weitere Vorgehen?

OK. wenn du die Frequenz variierst, ändert sich der Wert.
Wie muss er sich verändern? Je schneller die Frequenz, desto weniger 
weit kann der Zähler zählen.

Wieder etwas rechnen:
1.4kHz, macht eine Periodendauer von 1/1400 = 0.7ms.
0.0007 * 16000000 = 11428
Ein Zehtnel davon in der Anzeige. Die Anzeige muss 1142 anzeigen


In der anderen Richtung: 500Hz
500Hz sind 2ms. 0.002 * 16Mio = 32000. 1/10 davon in der Anzeige, macht 
3200
Mit 3200 ist noch Spielraum. (6535 ist unsere Grenze)

300Hz
300Hz sind 0.33 ms. 0.0033 * 16Mio = 52800. 1/10 davon in der Anzeige 
macht 5280

D.h. du hast

  eingestellte Frequenz      Anzeige

 1.4kHz                      1142
 1.0kHz                      1600
 500Hz                       3200
 300Hz                       5280

Wenn dein Programm tatsächlich diese Werte, bei den eingestellten 
Frequenzen auf die 7-Segment zaubert, dann geb ich mich erst mal 
zufrieden. Das akzeptiere ich als Funktionstest der grundlegenden 
Messung.


Ich hab jetzt absichtlich noch nicht auf die Frequenz in der Anzeige 
umgerechnet, auch wenns trivial wäre.
Aber unser Problem wird der Zählbereich ab 65535 sein. D.h. da ist der 
Zählerwert der interessante.

[Karl H. (kbuchegg)]

Ach ja. Flimmern.

Ganz exakt wird deine Anzeige wahrscheinlich nicht ruhig stehen. Die 
letzte Stelle, schätze ich mal, wird ein wenig verwaschen sein. Aber der 
Rest muss ruhig stehen, ohne irgendwas. Da darf auch kein Wechsel 
zwischen 0 und einer anderen Zahl sein.

Wenn dein Frequenzgenerator es zulässt exakt 1Khz einzustellen, dann 
muss da auf der Anzeige 1600 rock solid dort stehen. Vielleicht mal 
1599, vielleicht mal 1601. Aber mehr darf das Ding da nicht rumzappeln.
Wenns zu sehr (zu schnell) zappelt, denn machen wir uns da mal eine 
Pause zwischen die einzelnen Messzyklen rein um zu sehen, zwischen 
welchen Werten es zappelt.

[Fan_AT (Gast)]

Also, alles nachgemessen:

1400Hz - 1083-1082
1000Hz - 1865-1686
500Hz - flimmert schnell zwischen 3146 und 59xx
300Hz - flimmert stark, nichts zu erkennen

Das ist auch mein ursprüngliches Problem, dem wir wohl näher kommen :)

[Fan_AT (Gast)]

bei 1000Hz sind es 1685-1686, Tippfehler

[Fan_AT (Gast)]

1400 werden bis auf die letzte Stelle auch genau registriert. Aber da 
schwankt es um eine Ziffer. Das Problem ist wohl beim Überlauf, bei 
kleineren Frequenzen

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Also, alles nachgemessen:
>
> 1400Hz - 1083-1082
> 1000Hz - 1685-1686
> 500Hz - flimmert schnell zwischen 3146 und 59xx
> 300Hz - flimmert stark, nichts zu erkennen

Hmm.
Sollte eigentlich nicht sein.
Wie sehr vertraust du deinem Frequenzgenerator?


Probier mal

  while(1)  // unendliche Schleife
  {
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
    {
      ATOMIC_BLOCK(ATOMIC_FORCEON)
      {
        zaehlschritte = Zeit / 10;
      }
      zahl_ausgeben( zaehlschritte );
      UpdateDisplay = FALSE;
    }

    _delay_ms( 500 );
  }

Ziel der Sache ist es, den Display Refresh zu verlangsamen um einen 
Überblick über die Zahlenwechsel zu bekommen. Kannst auch mal ein wenig 
mit den Delay Zeiten variieren, so dass du noch einigermassen gut 
ablesen kannst, was gemessen wird.

> Das Problem ist wohl beim Überlauf, bei kleineren Frequenzen

Bei den Frequenzen sollte sich ein Timerüberlauf noch nicht bemerkbar 
machen. Die unsigned Rechnung gleicht diesen einen Überlauf aus, so dass 
man sich nicht drum kümmern braucht.

[Fan_AT (Gast)]

Das ist auch genau mein Problem. Auf eine andere Weise bin ich eben auch 
auf den Wechsel der long-Variable gekommen, aber kenne keine Lösung.

Der Generator ist genau. Zumindest war er das bei dem letzten 
Oszilloskop-Test. Ich gehe jetzt einfach mal vom Fehler meinerseits aus, 
da ich nicht annehmen kann, dass der Generator PLUS Oszilloskop kaputt 
sind ;)

Das Dealay-Programm ist nun ausprobiert worden. in den unteren beiden 
Bereichen (300,500) ist ein stärkeres Schwanken zu sehen.
300Hz - 5446,7989, 8117

Bei 1400 Hz ist mal konstant bei 1086, aber zwischendurch springt es auf 
3870. Und ich verstehe beim besten Willen nicht den Grund.

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> Der Generator ist genau.
ok, zur Kenntnis genommen.

> Bei 1400 Hz ist mal konstant bei 1086, aber zwischendurch springt es auf
> 3870. Und ich verstehe beim besten Willen nicht den Grund.

Versteh ich auch noch nicht.
Dem müssen wir aber auf den Grund gehen. Solange das nicht geklärt ist, 
macht es keinen Sinn, darauf aufbauend das Programm weiter zu treiben. 
Die Zwischenziele müssen korrekte Werte ergeben. Sonst ist alles darauf 
aufbauende automatisch falsch.


Zeig nochmal das Programm in seiner vollen Pracht.

[Fan_AT (Gast)]

Das komplette Paket oder das Delay-Programm aus dem letzten Schritt?

Hier ist das Delay-Programm:

#define F_CPU 16000000UL // uC läuft mit 16MHz

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


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

volatile unsigned short z=0;    // Zählvariable des Timer1
volatile char UpdateDisplay = TRUE;      // char-1Byte // Einen Wert TRUE definiert 
volatile unsigned long Zeit = 0;      // unsigned long-4Bytes

//volatile uint8_t tausender, hunderter, zehner, einer;  // Speicher für die eizelnen Digits
//volatile uint8_t position = 0;

volatile unsigned short zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1, short-2Bytes
//unsigned int zaehler1_ovf = 0;    // Anzahl der Überläufe des Timer1
unsigned long zaehlschritte = 0;

uint16_t freq = 0;


volatile unsigned long Startzeit = 0;

volatile uint8_t digits[4];  // Speicher für die eizelnen Digits
volatile uint8_t digit_position = 0;

uint8_t digitControl[4] = { (1 << PC0), (1 << PC1), (1 << PC2), (1 << PC3) };  


//float korrekturfaktor = 1; // für Abgleich anpassen (z.B. 0.9997)


const int8_t numbers[11] =    // Array zur Darstellung der Zeichen auf der 7-Seg-Anz.  // 08.08.13 - int8_t numbers[11], nicht uint8_t
{

  0b01101111,    // 0
  0b00000110,    // 1
  0b10101011,    // 2
  0b10001111,    // 3
  0b11000110,    // 4
  0b11001101,    // 5
  0b11101101,    // 6
  0b00000111,    // 7
  0b11101111,    // 8
  0b11001111,    // 9
  0b00000000    // leere Anzeige
  
};


ISR(TIMER1_OVF_vect) 
{
  ++z;
  //TIFR = (1<<TOV1); //Beim Überlauf von Timer1 und dem anschließenden Interrupt erfolgt eine Zurücksetzung auf Null
  //Braucht nicht gelöscht zu werden. Jeder Interrupt löscht automatisch sein eigenes Flag beim Aufruf der ISR.
  
}


ISR(TIMER1_CAPT_vect)
{

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können
  
  
  static char ErsteFlanke = TRUE;
  static uint8_t LowByte = 0;
  static uint8_t HighByte = 0;
    
  LowByte = ICR1L;         // LowByte zuerst, HighByte später gepuffert
  HighByte = ICR1H; 
  
  
  if ((HighByte < 128) && (TIFR & (1<<TOV1)))
  {   
      // wartenden Timer Overflow Interrupt vorziehen
      ++z;         
      TIFR = (1<<TOV1);    // Timer Overflow int. löschen, da schon hier ausgeführt // macht der uC angeblich selbst
  } 
  

   
  
  if(ErsteFlanke)
  {
    Startzeit = ICR1;
    z = 0;
    ErsteFlanke = FALSE;       // Nach der nächsten Flanke beginnt die Ausgabe
  
  }
   
  else
  {
  Zeit = 0;
    Zeit = ICR1 - Startzeit;
    UpdateDisplay = TRUE;      // Eine vollständige Messung. Sie kann ausgewertet werden
    ErsteFlanke = TRUE;        // Bei der nächsten Flanke beginnt der nächste Messzyklus
  
  
  zaehler1_ovf = z;    // Anzahl der Überläufe wird in zaehler1_ovf kopiert
  Startzeit = 0;
  z=0;  // Nach dem Sichern - annullieren
  
  }  
  

}


ISR(TIMER2_OVF_vect)  // timer2 overflow interrupt
{
  PORTC = 0b00000000;    // alle Digits aus
  TCNT2 += 0; 

  digit_position++;
  
  if( digit_position == 4 )
    {digit_position = 0;}

  PORTD = digits[digit_position];
  PORTC = digitControl[digit_position];
}


void zahl_ausgeben(uint16_t zahl)
{
  uint8_t i;

  digits[3] = numbers[zahl % 10];  // Die letzte Ziffer wird gesichert
  zahl /= 10;

  for( i = 2; i != 255; i-- ) 
  {
    if( zahl > 0 )
    {
      digits[i] = numbers[zahl % 10];
      zahl /= 10;
    }
    else
      digits[i] = numbers[10];
  }
  
  
}



int main(void)
{
  // Definition von Ein- und Ausgängen des uC Boards
  DDRB = 0xFE;  // Mit Ausnahme des ICP1-Pins alles als Ausgang
  DDRC = 0xFF;  // PORTC als Ausgang - über PORTC werden die jeweiligen Segmente einer 7-Seg. Anzeige gesteuert
  DDRD = 0xFF;  // PORTD als Ausgang
  PORTC = 0b00000000;
  
  
  TIMSK |= (1<<TICIE1) | (1<<TOIE1) | (1 << TOIE2); // Interrupts akivieren, Capture und Overflow, Overlow-Interrupt aktivieren
  TCCR1B |= (1<<ICES1)  | (1<<CS10); // Input Capture Edge, kein Prescaler
  
    TCCR2 |= (1 << CS22)|(1 << CS21);    // Vorteiler auf 256


  sei();          // Interruptbehandlung ein
  

  /*while(1)  // unendliche Schleife
  {
  
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
      {
        
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }
        
      
        if (zaehlschritte==0)
          {
            freq = 0;
            zahl_ausgeben(freq);
          }
        else
          {
            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
              
            }
      
            zahl_ausgeben(freq);
          
          }
          
          UpdateDisplay = FALSE;
      }*/
      
     while(1)  // unendliche Schleife
     
  {
    if(UpdateDisplay)    // Erst nach zweiter Flanke ausführen
    {  
    
      ATOMIC_BLOCK(ATOMIC_FORCEON)
      {
      zaehlschritte = Zeit / 10;
      }
    
      zahl_ausgeben( zaehlschritte );
      UpdateDisplay = FALSE;
    }

    _delay_ms( 500 );
  }
  return 0;
}

[Karl H. (kbuchegg)]

Fan_AT schrieb:
> Das komplette Paket oder das Delay-Programm aus dem letzten Schritt?

Immer die letzte Version. Die dir wir gerade entwicklen.

[Fan_AT (Gast)]

Gut, das ist sie. Ausgeklammert sind die Programmleichen.

[Georg G. (df2au)]

Einwurf eines Mitlesers: wie groß ist numbers[]? Wirklich nur 11 
Elemente? Eigentlich sollte der Compiler das aber merken...

[Karl H. (kbuchegg)]

Hmm. Lass mich mal überlegen.
Könnte es sein, das wir ein Problem mit pending Interrupts haben?
Ich denke nicht, denn genau dazu gibt es den Capture Interrupt. Auf der 
anderen Seite, wenn wir einen Capture verpassen ...
Das muss ich mir durch den Kopf gehen lassen. Moment

[Fan_AT (Gast)]

@Georg.G.
Danke für's Mitlesen und für die Anmerkung. Bei der Deklaration wird in 
der eckigen Klammer die Gesamtanzahl der beinhaltenden Elemente 
angegeben. Und aktuell sind es doch 11 oder irre ich mich?

@Karl Heinz Buchegger
Die einzige Idee von mir wäre vllt. noch die Überprüfung, ob der ICF1 
Flag gesetzt ist...

[Fan_AT (Gast)]

@Georg.G.
Danke für's Mitlesen und für die Anmerkung. Bei der Deklaration wird in 
der eckigen Klammer die Gesamtanzahl der beinhaltenden Elemente 
angegeben. Und aktuell sind es doch 11 oder irre ich mich?

@Karl Heinz Buchegger
Die einzige Idee von mir wäre vllt. noch die Überprüfung, ob der ICF1 
Flag gesetzt ist... Denn die Überprüfung auf einen verpassten Interrupt 
wird ist doch bereits implementiert und High-/LowBytes werden in 
richtiger Reihenfolge ausgelesen.

[Karl H. (kbuchegg)]

Fan_AT schrieb:

> @Karl Heinz Buchegger
> Die einzige Idee von mir wäre vllt. noch die Überprüfung, ob der ICF1
> Flag gesetzt ist... Denn die Überprüfung auf einen verpassten Interrupt
> wird ist doch bereits implementiert und High-/LowBytes werden in
> richtiger Reihenfolge ausgelesen.

Ja ich weiß.
Das sollte eigentlich alles stimmen.
Nur tut es das nicht. Verblüffender Weise.

[Georg G. (df2au)]

Fan_AT schrieb:
> Und aktuell sind es doch 11 oder irre ich mich?

Ich zähle 0...9, Leerstelle und das E. Meine Enkeltochter meint, das 
wären 12 Elemente.

[Fan_AT (Gast)]

Die Enkeltochter ist sehr gut :)
In der aktuellen Version ist das 'E' nicht vorhanden, da keine 
Frequenzbegrenzung benötgt wird und somit auch kein zu großer Wert 
angezeigt werden kann.

Aber habe grad gesehen, dass der Timer2 höhere Priorität besitzt, als 
CaptureEvent. Wage einen kurzen Versuch.

[Fan_AT (Gast)]

So... Der Timer0 hat eine niedrigere Priorität als das Capture Event.

Folgendermaßen sieht das jetzt aus:
Bei TCNT0 flackert die ganze Anzeige. Doch umgerechnet wird bis 700Hz 
wird die völlig korrekte Frequenz dargestellt.
Ab da wird wieder die zwischendurch erscheinende Null erkennbar.

[Fan_AT (Gast)]

Ich meinte natürlich TCNT0=0.

Frequenzen größer 700Hz werden korrekt gemessen, ein Flimmern des 
Multiplex ist wahrnehmbar.

[Karl H. (kbuchegg)]

Hast du neue Ideen?

Ich denke nicht, dass es irgendwas mit den 'Prioritäten' zu tun hat. 
Dazu sind deine Abweichungen einfach zu groß. Die ISR sind allesamt 
klein, die sind in kürzester Zeit, in der Größenordnung von 1 bis 2 µs 
(maximal) abgearbeitet. Im Capture darf man das überhaupt nicht sehen, 
dazu hat man ja den Hardware-Capture. Und auf den Anzeigen ist dieser 
Jitter zu kurz, dals das er sich bemerkbar machen kann. So gut sind 
deine Augen nicht.


Ich denke in eine ganz andere Richtung: Kann es sein, dass dein µC 
zwischendurch ein paar Reset macht?

[Fan_AT (Gast)]

Guten Tag,

Ideen... Habe noch einpaar Versuche gestartet, wie atomare Zugriffe auf 
Variablen größer 8Bit, doch ohne Erfolg.
Wenn nichts Besseres einfällt, werde ich wohl den uC auswechseln, 
Treiber.
Ich packe mal den Schaltplan hier rein - den nehrlich gesagt weiß ich 
nicht, wieso ein Reset durchgeführt werden sollte.
Aber Gott sei Dank gibt es ja auch erfahrene Leute ;)

[Fan_AT (Gast)]

die Idee ist aber nicht schlecht, habe erstmal Brown-out detection level 
auf VCC=2,7V gemacht - keine Änderung.
Dann werde ich mal die Spannung nicht aus dem Generator beziehen, 
sondern extern.

[Georg G. (df2au)]

Hat nichts mit deinem Fehler zu tun: Die Referenzspannung des AD sollte
nicht hart an VCC gebunden sein. Das ist u.U. ein Ausgang. Offen lassen.

[Fan_AT (Gast)]

So, habe es nun mit stabilisierter Spannung durchgezogen - minimale 
positive Änderung zu sehen, aber immer noch der gleiche Fehler mit 
schnellem Wechseln zu Null und zurück.
Ja, danke für die Anmerkung - wird das nächste Mal beachtet :)

Was könnte noch einen ständigen Reset auslösen?

[holger (Gast)]

>Was könnte noch einen ständigen Reset auslösen?

Watchdog?

[Fan_AT (Gast)]

Ist zwar eien Idee, aber dafür muss ja das Programm in einer 
unpassierbaren Schleife stecken o.ä., nicht wahr?

Habe ihn zwar nicht mal angemacht, aber das Deaktivieren ginge doch 
unter Verwendung von <avr/wdt.h> mit dem Befehl

wdt_disable();

möglich?

[Fan_AT (Gast)]

Zumindest macht sich kein Fortschritt bemerkbar mit diesem Befehl...

[Peter D. (peda)]

Sende mal das komplette compilierbare Programm als Anhang.

[Fan_AT (Gast)]

Hier - die .c Datei.

[Peter D. (peda)]

ATOMIC_BLOCK(ATOMIC_FORCEON)
haben im Interrupt nichts zu suchen, die sind nur für Main-Tasks.

[Fan_AT (Gast)]

Hast Recht, war mein letzter Versuch irgendwas zu ändern :)

Siehst du irgendwelche groben Fehler?

[Peter D. (peda)]

       
        ATOMIC_BLOCK(ATOMIC_FORCEON)
        {
          zaehlschritte = (unsigned long)((65536.0*zaehler1_ovf) + Zeit); // sonst am Ende: +Zeitdifferenz;  
        }

Nur die Interruptvariable atomar in einer lokalen speichern,
Nicht für einen riesen Salm an Berechnungen sperren.

            ATOMIC_BLOCK(ATOMIC_FORCEON)
            {
              // Die abschließende Berechnung der Schritte pro Sekunde
              freq = (uint16_t) (F_CPU/(zaehlschritte));
              
            }

Wozu hier?

[Fan_AT (Gast)]

Beim ersten wird die Unterbrechung eigentlich auch nur bedingt benötigt 
- zaehler1_ovf wird bereits in ISR gesichert.

Wie gesagt, ich habe vosichtshalber bei jeder Schreiboperation, die mehr 
als 1 Taktzyklus benötigt die Interrupts pausiert.

Habe soeben alle  ATOMIC_BLOCK(ATOMIC_FORCEON) entfernt - kein Erfolg. 
Es muss doch was geben, was ich übersehe?

[Fan_AT (Gast)]

Gut, vielleicht ist es etwas Grundlegendes, nicht die Software selbst.
Den uC habe ich bereits ausgetauscht. Eine andere Spannungsquelle 
benutzt.

Bei den Fuses setze ich Ext.Crystal Resonator High Freq.; Start-Time 
16CK+64ms. Hinzu kommt noch das CKOPT fuse.

Das Ganze schreiben tue ich mithilfe des mySmartUSB MK2.

Watchdog-Timer ist von vornherein nicht aktiviert.

[Peter D. (peda)]

   if(UpdateDisplay)          // Das Display wurde mit den Ergebnissen der vorhergehenden
    {             // Messung noch nicht aktualisiert. Die nächste Messung
    return;         // verzögern, bis die Start- und EndTime-Variablen wieder
  }                    // gefahrlos beschrieben werden können

Was dieses "UpdateDisplay" macht, ist mir noch nicht klar. Es könnte 
Probleme machen.
Ich würde einfach jeden Timestamp abspeichern, mehr nicht.
Und das Main nimmt sich einfach 2 aufeinanderfolgende Timestamps, wenn 
es Lust dazu hat.

ISR(TIMER1_CAPT_vect)
{
  last_time = current_time;
  current_time = ICR1;
}
// main:
  uint16_t delta_time;
  ATOMIC_BLOCK(ATOMIC_FORCEON)
    delta_time = current_time - last_time;
  machwas( delta_time );

Beschreib dochmal in Prosa, wie das Programm funktionieren sol.
Wie ist überhaupt der gewünschte Meßbereich?

[Fan_AT (Gast)]

Karl Heinz Buchegger, warum hast du mich verlassen? :D

@Peter Dannegger:
[QUOTE]
Dieses Flag hat 2 Aufgaben:
Zum einen ist es die Benachrichtigung aus der ISR in die main() "Ich
habe eine Messung fertig". Zum anderen ist es die Verriegelung der ISR
mit isch selbst, so lange keine weitere Messung zu machen, bis die
main() das Ergebnis verarbeitet hat.
D.h. wenn main() die Messergebnisse der ISR ausgewertet hat, dann muss
sie UpdateDisplay wieder auf FALSE setzen. Egal was dann bei der
Auswertung rauskommt. Das FALSE-setzen von UpdateDisplay ist quasi die
Rückmeldung von main() in die ISR "OK, ich hab mir deinen Messwert
geholt, du kannst wieder loslegen und die nächste Messung machen". Das
aber, muss IMMER passieren. Egal was dann bei der Auswertung rauskommt
[/QUOTE]

Der gewünschte Messbreich ist 1-1400Hz, was eigentlich kein Problem 
darstellen sollte, aber trotzdem nicht per Capture-Event klappt.

Die aktuelle Version des Programms kann man eben in zwei Prozeduren 
gliedern: Capture, Multiplex.

Mittlerweile werden alle Messvariablen gleich in den ISR gesichert - das 
erspart das Ausschalten von Interrupts zwischendurch, mit evtl. Ausnahme 
von unsigned long Berechnungen. (zwischenschritte in main() )

Bei steigender Flanke des eingehenden TTL-Signals erfolgt das 
Capture-Event, bei dem der Zählerstand gesichert wird - unter 
Voraussetzung, dass die Anzeige (zahl_ausgeben) abgearbeitet wurde 
(UpdateDisplay = FALSE)

Erst bei zweiter Flanke wird die Differenz der Start-Und End...

OMFG....LEUTE....

 Zeit =  ICR1 - Startzeit;

Und was, wenn nach einem Timerüberlauf ICR1 kleiner ist als Startzeit? 
Dann ergbit dann... genau richtig: Null!

Folglich muss es heißen:

[c]
Zeit = zaehler1_ovf*65536.0 + ICR1 - Startzeit;
/c]

Ich laufe udn teste es ausgiebig, wünscht mir Glück oO

[Fan_AT (Gast)]

Es hat funktioniert! Der Fehler mit dem ständigen Flimmern zu Null und 
zurück ist weg! Ich müsste mir jetzt paar Gedanken zur 
Optimierungsroutine machen - Einer-, manchmal Zehnerstelle flackert ab 
und zu ganz unschön, so dass man die Zahl nicht ablesen kann.

[Ulrich (Gast)]

Das flackern der Anzeige kann verschiedene Ursachen haben. Ein Problem 
ist das wohl ein Update der Anzeige sehr schnell erfolgt wenn die 
Frequenz hoch ist. Damit kann die letzte Stelle immer leicht flackern.

Da ist auch noch ein kleiner Fehler mit drin: Die Zahl der Überläufe 
sollte aus der Variable z kommen, nicht der alten  Kopie von der letzten 
Periode. Dazu sollte man Fließkomma Zahlen vermeiden, also:
[c]
Zeit = z*65536UL + ICR1 - Startzeit;
/c]

Die Multiplikation mit 65536 ließe sich ggf. über den Zugriff als union 
auch noch einsparen - es könnte sein das der Compiler das auch schon hin 
bekommt, ich fürchte aber nicht.

[Fan_AT (Gast)]

Hallo Ulrich,

danke für die Rückmeldung, korrigiert - auch bei Kleinigkeiten spart man 
sich schon paar Taktzyklen.
Interessant wird dann die Behebung des Problems, denn das ist wirklich 
ein Ableseproblem - an manchen Stellen kann man die Zahl bei Zehner-und 
Einerstellen nicht richtig einstellen. Du hast 'ne auf 8 flimmernde 7, 
doch eher du die 8 flimmerfrei machen kannst, kriegst du schon die 9! oO

Also meinst du, dass man bei den Frequenzen, wo das Problem anfängt, in 
meinem Fall ab 70-80Hz, kurzzeitig den Multiplex... einfrieren lässt?

[Fan_AT (Gast)]

Mal den Timer1 Vorteiler und Noise Canceler ausprobiert - ohne Erfolg, 
beim Vorteiler sogar schlimmer.
Beim Vorteiler dachte ich, es wäre so, als ob ich die eingehende 
Frequenz teilen würde, was mir somit einen langsameren Multiplex 
beschert hätte...
Gibt es Alternativen, etwa in Richtung D-FlipFlops, der die Frequenz 
halbiert oder Methoden, wie man das Flackern bekämpft?

[Ulrich (Gast)]

Für eine Stabilere Anzeige könnte man eine neue Messung erst nach einer 
gewissen zeit (z.B. 0,5 s) starten, oder besser erst dann übernehmen.

Wenn man mag könnte man auch die Zeit für mehr als eine Periode Messen, 
so dass man z.B. auf eine "Torzeit" von z.B. 0,5-1 s kommt. Der Start 
geht so wie jetzt, aber das Ende wird erst nach etwa 0,5 s (wohl ein 
gewisser Wert für z) genommen und davor werden nur die Perioden gezählt. 
Bei z.B. 1 kHz wird dann nicht die Zeit für eine Periode gemessen, 
sondern die Zeit für z.B. 505 Perioden und dann durch die Zahl geteilt. 
Das gibt ein höhere Auflösung und auch gleich eine langsamere Messung.

Der Vorteiler beim Timer reduziert die Auflösung der Messung. Den 
braucht man bei der Messung über ICP mit zählen der Überläufe nicht. 
Sinnvoll wäre ggf. ein Vorteiler für das Signal, wenn die Frequenz zu 
hoch (so ab 50-500 kHz) wird. Für niedriger Frequenzen geht es aber 
besser ohne Vorteiler.

[Fan_AT (Gast)]

Naja, das Ding ist, ich hatte die Schaltung bereits mit Torzeiten auf 
T0, da war mir jedoch die Wartezeit/Offset viel zu groß. Mit ICP habe 
ich mir eben viel schnellere Messungen erhofft.
Bei solchen kleinen Frequenzen habe ich erwartet, dass es funktionieren 
würde.

[Ulrich (Gast)]

Die Messung geht ja auch schneller, nur halt jetzt zu schnell um das 
noch auf der Anzeige noch gut zu erkennen. Vor allem bei den höheren 
Frequenzen (so ab etwa 100 Hz) muss man für mehr Auflösung dann halt die 
Zeit für mehr Perioden messen. Der Unterschied zum Zählen mit fester 
Torzeit ist, dass man über ICP eine etwa von der Frequenz unabhängige 
relative Auflösung bekommt.

[Fan_AT (Gast)]

Gut, dann bleibt mir nichts anderes übrig. Ich versuche es erstmal mit 
insgesamt zwei Messungen ab 80Hz.
Vielen Dank für die Hilfe - falls neue Ideen kommen, würde ich sie 
selbstverständlich wissen wollen :)

[m.n. (Gast)]

Fan_AT schrieb:
> falls neue Ideen kommen, würde ich sie
> selbstverständlich wissen wollen :)

Die Ideen sind schon alt, nur die Verpackung ist eine neue :-)
Multiplexen fehlt zwar, läßt sich aber im Timer1-OVF-Interrupt ergänzen.
http://www.mino-elektronik.de/fmeter/fm_software.htm
und für 4-stellige Anzeige völlig ausreichend:
http://www.mino-elektronik.de/7-Segment-Variationen/LCD.htm#lcd2