Über einen µC Laufzeit messen und über RS232 ausgeben

[Roman (Gast)]

Guten Tag,

ich komme mit meinem Programm nicht mehr weiter.

Es soll ein 8 Kanal Laufzeitmesser werden der über RS232 die Laufzeit an 
den PC sendet. Genauichkeit +/-5 Minuten abweichung am Tag sind 
tolerierbar.

Testweise habe ich derzeit nur 2 Kanäle im Programm.

Die Funktion ist simpel.
Es wird ein Starttaster gedrückt um die Messung zu starten.
Eine Status LED zeigt an ob die Messung läuft.
Wenn am Eingang die Spannung von 5V ausfällt wird die Zeit über RS232 an 
den PC gesendet.

Das Funktioniert auch "fast" alles wunderbar.
Das Problem ist das der Timer nicht sofort aufhört sondern noch die 60 
Sekunden nachzählt bis er sich auf 0 zurücksetzt.

Ein Auszug aus dem Terminal Programm:

#1 Laufzeit_1 0:00:01:44 Spannung am Eingang fällt auf 0V, Ausgabe 
korrekt
#2 Laufzeit_1 0:00:00:51 hier müsste der Timer wieder mit 0 anfangen.
#3 Laufzeit_1 0:00:00:58 aber er zählt die Sekunden von Zeile 1 mit 
"44"weiter
#4 Laufzeit_1 0:00:00:01 die Minute wird hingegen nicht mehr 
hochgezählt.

Er hat nur zum Teil die Zeit richtig zurückgesetzt nur die Sekunden 
zählen nach.


Die Programmierung ist etwas "durchwachsen" und unübersichtlich dies 
bitte ich zu entschulden, da ich mich erst vor einigen Montaten mit "C" 
und µC von Atmel beschäftige.


Ich bin für jede Hilfe dankbar. :-)

[spontan (Gast)]

>   if (PINB &(1<<PINB0)) // Kanal 1 5V fallen aus
>
>   if (PINB &(1<<PINB2)) // Kanal 1 5V fallen aus

Findet sich beides im Programm. Was gilt wirklich?

[Christian (Gast)]

if (PINB &(1<<PINB2)) // Kanal 1 5V fallen aus
        {
          Kanal_1=0;
          tage=0, stunden=0, minuten=0, sekunden=0;
        }
      if (PINB &(1<<PINB3)) // Kanal 2 5V fallen aus
        {
          Kanal_2=0;
          tage_1=0, stunden_1=0, minuten_1=0, sekunden_1=0;

        }


Ich denke du musst nicht nur den Sekundenzähler zurücksetzen sondern 
auch die variable timer die du in der ISR verwendest.

[Christian (Gast)]

if (sekunden!=timer)
      {
        sekunden=timer;

Da beschreibst du die Variable sekunden nämlich wieder mit dem Wert, der 
noch in timer steht. und das ist nicht Null.

[Roman (Gast)]

if (PINB &(1<<PINB0)) // Kanal 1 5V fallen aus
bezieht sich auf die Ausgabe auf RS232

if (PINB &(1<<PINB2)) // ist der Starttaster


Sorry, Kommentar falsch im Programmcode.

[Roman (Gast)]

Christian schrieb:
> if (PINB &(1<<PINB2)) // Kanal 1 5V fallen aus
>         {
>           Kanal_1=0;
>           tage=0, stunden=0, minuten=0, sekunden=0;
>         }
>       if (PINB &(1<<PINB3)) // Kanal 2 5V fallen aus
>         {
>           Kanal_2=0;
>           tage_1=0, stunden_1=0, minuten_1=0, sekunden_1=0;
>
>         }
>
> Ich denke du musst nicht nur den Sekundenzähler zurücksetzen sondern
> auch die variable timer die du in der ISR verwendest.

      if (PINB &(1<<PINB2)) // Kanal 1 Starttaster
        {
          Kanal_1=0;
          tage=0, stunden=0, minuten=0, sekunden=0;
          timer=0;
        }
      if (PINB &(1<<PINB3)) // Kanal 2 Starttaster
        {
          Kanal_2=0;
          tage_1=0, stunden_1=0, minuten_1=0, sekunden_1=0;
          timer=0;
          
        }

Das habe ich jetzt damit gemacht.
Neues Problem, es werden alle Timer an allen Eingängen zurückgesetzt 
sobald ein Eingang auf 0V fällt.

Mit meinem Wissenstand kann ich das Problem nur mit Acht 16 Bit Timern 
Timer_1 Timer_2 Timer_n usw lösen, diese hat der Atmega8 natürlich 
nicht.

Man müsste den Timer Kanalunabhänig machen.

[spontan (Gast)]

Dann mach es doch kanal-unabhängig.

Wie wäre so:

Es gibt nur eine Uhrzeit im System, die immer tage, stunden, min ... 
hochzählt.

Start eines Kanals speichert diese Zeit auf der Variablen für diesen 
Kanal ab.
Stop des Kanals berechnet die Differenz zwischen aktueller Uhrzeit und 
Startzeit.

Geht mit beliebig viel Kanälen.

[meine wenigkeit (Gast)]

So wie du das machst ist das ja auch extrem umständlich und 
verschwenderisch.
Mach es doch folgenddrmaßen:

Du nimmst einen uint32 zähler als variable. Der zähler zählt immer 
weiter über den hw-timer.
Werden jetzt an einem kanal 5v angelegt setzt du den einen uint32 als 
startwert = zähler
Fällt die spannung auf 0v setzt du den stopwert auf den aktuellen 
zähler.
Die verstichene zeit ist dann stopwert-startwert in was immer der zähler 
als zeitintervall zählt.
Du gibst die zeit aus und fertig ist die laube.

Vorteile: nur ein hw-timer und nur zwei variablen pro kanal zu 
verwalten.
Nachteile: uint32 sind nicht gerade schnell auf dem avr jedoch sollte es 
schnell genug sein.

[Roman (Gast)]

Danke für die Tipps!

Das erste Testprobramm läuft mit zwei Kanälen gut.

[Roman (Gast)]

Danke nochmal für die Hilfe,

das Programm habe ich jetzt auf 4 Kanäle erweitert.

Funktioniert super. :-)

Jetzt müsste ich das ganze was kleiner bekommen.
Bin schon bei 6734 bytes.

Einige uint32_t muss ich noch was verkleinern und einige if else 
Anweisung in der Sekunden-> Std:Min:sek Zeitumrechnung sind überflüssig.

Noch weitere Ideen wie man es kleiner bekommen könnte?

Geplant sind insgesammt 8 Kanäle.

[Martin V. (oldmax)]

Hi
Alternative... Zeitzähler in Controller. Wenn du die Frequenz kennst, 
also den Zeitwert, dann kannst du einfach die Zählerdifferenz akt. 
Zähler - Startwert an den PC senden. Der kann auch rechnen und du 
belastest nicht den Controller mit dieser Aufgabe. Denkbar ist auch die 
Differenz im PC zu berechnen.
Also,
Startwert bei Ereignis X mit Zählerwert setzen
Endwert bei Ereignis Y mit Zählerwert setzen
   -> Senden: Kanal, Startwert, Endwert..
Im PC berechnen Endwert - Startwert. Ist Ergebnis negativ, dann max. 
Zählerwert dazu addieren.
Beispiel:
Deine "Counter"-Variable zählst du im Sekundentakt hoch. Bei 16 Bit wäre 
die größte Zahl 65 535, dann beginnt die Zählerei von vorn. Das 
Zeitfenster ist somit 18 Stunden, 12 Minuten und 12 Sekunden. Wenn du 
nur 10 Sekunden Genauigkeit brauchst, dann sind das schon über 180 
Stunden...
OK, angenommen Startwert ist 12301, Endwert ist 46122. Demnach ist 
Zeitwert Endwert-Startwert also 32821 Sekunden.
Es kann aber auch genau umgekehrt sein, das bei der Zeitzählung ein 
Überlauf stattgefunden hat.
Startwert 43113, Endwert 30251. Hier ergibt sich ein Wert von -12882. Da 
das Ergebnis negativ ist addierst du nun den max. Zählwert der Variable 
hinzu, also + 65535 und erhälst 52653
Somit brauchst du nicht unbedingt 32 Bit zum Zählen und belastet auch 
sonst nicht deinen µC. Für den PC ist das auch nix besonderes.
Gruß oldmax

[Karl H. (kbuchegg)]

Roman schrieb:

> Jetzt müsste ich das ganze was kleiner bekommen.

Funktionen sind schon erfunden wurden.

Wenn du für jeden Kanal einfach den kompletten Code erneut duplizierst, 
ist klar, dass dir das alles axplodiert.


> Einige uint32_t muss ich noch was verkleinern und einige if else
> Anweisung in der Sekunden-> Std:Min:sek Zeitumrechnung sind überflüssig.


Ist sinnvoll.
ABer dein Hauptproblem ist, dass du exzessive Codeduplizierung betreibst 
anstatt dir eine Funktion zu schreiben, der man die Werte für 1 Kanal 
übergibt! Ist doch immer die gleiche Berechnung, nur die Variablen sind 
andere.

[Karl H. (kbuchegg)]

Da du sowieso printf benutzt

Was soll das

>             if (minerg<10)
>             {
>               printf("0%i:", minerg);
>             }
>             else
>             {
>               printf("%i:", minerg);
>             }
>

das kann printf auch alleine

   printf( "%02d:", minerg );

fertig.
Ich muss mich korrigiern. Dein Hauptproblem ist, dass du mit lediglich 
5% Wissen über deine Programmiersprache, dich an ein Projekt wagst.

[Karl H. (kbuchegg)]

zb den ganzen Teil hier

>         hour = (counter_4_end/3600);
>         if(counter_4_end%3600 == 0)
>         {
>           stderg = hour;
>           minerg = 0;
>           sekerg = 0;
>           if (stderg<10)
>           {
>             printf("0%i:", stderg);
>           }
>           else
>           {
>             printf("%i:", stderg);
>           }
> 
>           if (minerg<10)
>           {
>             printf("0%i:", minerg);
>           }
>           else
>           {
>             printf("%i:", minerg);
>           }
> 
>           if (sekerg<10)
>           {
>             printf("0%i ", sekerg);
>           }
>           else
>           {
>             printf("%i ", sekerg);
>           }
> 
>         }
> 
>         else
>         {
>           minute = ((counter_4_end - (hour * 3600))/60);
>           if((counter_4_end-(hour*3600))%60 == 0)
>           {
>             minerg = minute;
>             sekerg = 0;
>             if (minerg<10)
>             {
>               printf("0%i:", minerg);
>             }
>             else
>             {
>               printf("%i:", minerg);
>             }
> 
>             if (sekerg<10)
>             {
>               printf("0%i ", sekerg);
>             }
>             else
>             {
>               printf("%: ", sekerg);
>             }
> 
>           }
>           else
>           {
>             second = (counter_4_end-(hour*3600))%60;
>             stderg = hour;
>             minerg = minute;
>             sekerg = second;
>             if (stderg<10)
>             {
>               printf("0%i:", stderg);
>             }
>             else
>             {
>               printf("%i:", stderg);
>             }
> 
>             if (minerg<10)
>             {
>               printf("0%i:", minerg);
>             }
>             else
>             {
>               printf("%i:", minerg);
>             }
> 
>             if (sekerg<10)
>             {
>               printf("0%i ", sekerg);
>             }
>             else
>             {
>               printf("%i ", sekerg);
>             }
>           }
>         }
>       }
>     }
>

kann man in eine Funktion stecken und anders rechnen

void printf_time( uint32 time )
{
  uint8_t sekunde;
  uint8_t minute;
  uint16_t hour;

  sekunde = time % 60;
  time = time / 60;
  minute = time % 60;
  hour = time / 60;
  
  printf( "%04d:%02d:%02d", hour, minute, sekunde );
}

und dann ruft man eben die Funktion mit wechselnden Aufrufparametern 
auf, wenn man sie braucht:

int main()
{
....
    // KANAL 1
    if (PIND &(1<<PIND4)) // Kanal 1 5V fallen aus
    {
      counter_1_end = timer_1 - counter_1_start;

      if (Kanal_1 == 0)
      {
        printf("Laufzeit Kanal 1: ");
        PORTC^=(1<<PC0); // Status LED ausschalten

        printf_time( counter1_end );
      }
    }

    // KANAL 2
    if (PIND &(1<<PIND5)) // Kanal 2 5V fallen aus
    {
      counter_2_end = timer_2 - counter_2_start;

      if (Kanal_2==0)
      {
        printf("Laufzeit Kanal 2: ");
        PORTC^=(1<<PC1); // Status LED ausschalten
        Kanal_2 = 1; // Zum testen auf "0"

        printf_time( counter_2_end );
      }
    }

    // KANAL 3
    if (PIND &(1<<PIND6)) // Kanal 3 5V fallen aus
    {
      counter_3_end = timer_3-counter_3_start;

      if (Kanal_3 == 0)
      {
        printf("Laufzeit Kanal 3: ");
        PORTC ^= (1<<PC2); // Status LED ausschalten
        Kanal_3 = 1; // Zum testen auf "0"

        printf_time( counter_3_end );
      }
    }
    
    // KANAL 4
    if (PIND &(1<<PIND7)) // Kanal 4 5V fallen aus
    {
      counter_4_end = timer_4-counter_4_start;
      if (Kanal_4 == 0)
      {
        printf("Laufzeit Kanal 4: ");
        PORTC ^= (1<<PC3); // Status LED ausschalten
        Kanal_4 = 1; // Zum testen auf "0"

        printf_time( counter_4_end );
      }
    }
....

und schon ist dein Code nicht mehr 25 Seiten lang, sondern nur noch 2. 
Was ja dann auch der Übersicht im Code zu gute kommt. Und selbst das 
könnte man noch eindampfen, wenn man nicht 2 Millionen einzelne 
Variablen macht, sondern die in Arrays (noch besser wären Strukturen und 
ein Array von Strukturen) zusammenfasst.

Wie gesagt: wer etwas bauen will, muss sein Werkzeug kennen und damit 
umgehen können. Dein Werkzeug ist eine Programmiersprache. Ich sehe aber 
nicht, das du damit umgehen könntest.

struct channel
{
  uint8_t  show;
  uint32_t ticks;
  uint32_t end;
  uint32_t start;
  uint8_t  status_led;
  uint8_t  eingang;
};

#define ANZAHL_KANAL  4
struct channel kanal[ANZAHL_KANAL] =
{
  { 1, 0, 0, 0, 1<<PC0, 1<<PIND4 },
  { 0, 0, 0, 0, 1<<PC1, 1<<PIND5 },
  { 0, 0, 0, 0, 1<<PC2, 1<<PIND6 },
  { 0, 0, 0, 0, 1<<PC3, 1<<PIND7 }
};


int main(void)
{
  uint8_t i;

  TIMSK |= _BV(TOIE1);   //aktivieren des Überlaufinterrupts von Timer1
  TCCR1B |= (1<<CS12) | (1<<CS10); // Berechnet mit http://evolutec.publicmsg.de/index.php?menu=software&content=prescalertools
  TCNT1 = 0xFFFF;     //Zählregister vorladen mit FFFF zum Sofortstart
  sei();  //Interrupts aktivieren

  DDRC|=(1<<PC0)|(1<<PC1)|(1<<PC2)|(1<<PC3)|(0<<PC4)|(0<<PC5);  // LED 0-3 Stauts LED 4+5 Taster Kanal 1+2
  DDRC=0b00001111; //Eingang Taster 1+2 =  Eingang 5V PD1+2 bereits mit RXD TXD belegt
  DDRD=0x00; // Eingang Taster 3 = PIND 2 bis PIND 3 Start PIND4-PIND7 Eingang 5V


  initUART();

  stdout = &mystdout;

  do
  {
    if (1) // (sekunden!=timer)
    {
      for( i = 0; i < ANZAHL_KANAL; i++ )
      {
        kanal[i].ticks = timer + 1;
      }
    }
    
    // Starttaster

    if (PINC &(1<<PINC4)) // Kanal 1 Starttaster
    {
      kanal[0].start = kanal[0].ticks;
      kanal[0].show = 1;
      PORTC |= kanal[0].status_led;
    }

    if (PINC &(1<<PINC5)) // Kanal 2 Starttaster
    {
      kanal[1].start = kanal[1].ticks;
      kanal[1].show = 1;
      PORTC |= kanal[1].status_led;
    }

    if (PIND &(1<<PIND2)) // Kanal 3 Starttaster
    {
      kanal[2].start = kanal[2].ticks;
      kanal[2].show = 1;
      PORTC |= kanal[2].status_led;
    }

    if (PIND &(1<<PIND3)) // Kanal 4 Starttaster
    {
      kanal[3].start = kanal[3].ticks;
      kanal[3].show = 1;
      PORTC |= kanal[3].status_led;
    }

    for( i = 0; i < ANZAHL_KANAL; i++ )
    {
      if (PIND & kanal[i].eingang)
      {
        kanal[i].end = kanal[i].ticks - kanal[i].start;

        if (kanal[i].show)
        {
          printf("Laufzeit Kanal %d: ", i + 1);
          printf_time( kanal[i].end );
          printf("\n");
          
          PORTC ^= kanal[i].status_led; // Status LED ausschalten
        }
      }
    }
  }
}

und wenn du deine Starttaster noch ein wenig anders anordnen würdest, 
dann könnte man auch die noch einfach mit ins Array reinnehmen und den 
ganzen Programmteil rund um die Starttaster ebenfalls auf 1 Schleife 
eindampfen. Was dann wieder die Möglichkeit eröffnet, alle 3 SChleifen 
zu lediglich einer einzigen for-Schleife zusammenzufassen.

Dann ist dein Code in main() gerade mal 1/2 Bildschirmseite lang :-)

[M. N. (Gast)]

Roman schrieb:
> Jetzt müsste ich das ganze was kleiner bekommen.
> Bin schon bei 6734 bytes.

Wozu sparsam programmieren, wenn andere µCs mit viel mehr Speicher 
daherkommen? Optimieren ist doch nur etwas für Streber :-)
Ein pinkompatibler ATmega328 mit seinen 32kB Flash erlaubt es Dir, 
sämtliche Schleifen 'auseinander zu rollen'.

[Peter D. (peda)]

M. N. schrieb:
> Optimieren ist doch nur etwas für Streber :-)

Nö, sondern für die Leute, die noch nach ein paar Monaten im Code 
durchsehen wollen. Oder die leicht Änderungen/Erweiterungen durchführen 
wollen.

Dieser ganze Wust läßt sich für 8 Zeitmesser auf eine Schleife i = 0..7 
reduzieren, die nur eine Funktion aufruft.
Ein Array enthält dann die 8 Zeitspeicher und ein Array die Bitmasken 
für die 16 Eingangspins.

[M. N. (Gast)]

Peter Dannegger schrieb:
> Ein Array enthält

Wie, soll er noch ein Array kaufen?

Bei A..i gibt es momentan Keramikmeseer. Vielleicht kann man die ja zu 
einem Laufzeitmesser umbauen?

[Roman (Gast)]

Karl Heinz Buchegger schrieb:
> und wenn du deine Starttaster noch ein wenig anders anordnen würdest,
> dann könnte man auch die noch einfach mit ins Array reinnehmen und den
> ganzen Programmteil rund um die Starttaster ebenfalls auf 1 Schleife
> eindampfen. Was dann wieder die Möglichkeit eröffnet, alle 3 SChleifen
> zu lediglich einer einzigen for-Schleife zusammenzufassen.
>
> Dann ist dein Code in main() gerade mal 1/2 Bildschirmseite lang :-)

Gesagt getan.

struct channel
{
  uint8_t  show;      // Startsperre
  uint32_t ticks;      // Systemlaufzeit
  uint32_t end;      // Gemessene Zeit
  uint32_t start;      // Startzeit der Messung
  uint8_t  status_led;  // Status der Messung
  uint8_t  eingang;    // Start Taster
  uint8_t  spannung;    // Eingangsspannung
};

#define ANZAHL_KANAL  4
struct channel kanal[ANZAHL_KANAL] =
{
{ 1, 0, 0, 0, 1<<PC0, 1<<PIND4, 1<<PINB0},
{ 0, 0, 0, 0, 1<<PC1, 1<<PIND5, 1<<PINB1},
{ 0, 0, 0, 0, 1<<PC2, 1<<PIND6, 1<<PINB2},
{ 0, 0, 0, 0, 1<<PC3, 1<<PIND7, 1<<PINB3}
};


int main(void)
{
  uint8_t i;

  TIMSK |= _BV(TOIE1);   //aktivieren des Überlaufinterrupts von Timer1
  TCCR1B |= (1<<CS12) | (1<<CS10); // Berechnet mit http://evolutec.publicmsg.de/index.php?menu=software&content=prescalertools
  TCNT1 = 0xFFFF;     //Zählregister vorladen mit FFFF zum Sofortstart
  sei();  //Interrupts aktivieren

  DDRC|=(1<<PC0)|(1<<PC1)|(1<<PC2)|(1<<PC3);  // LED 0-3 Stauts LED
  DDRB=0x00; // Eingangsspannung 
  DDRD=0x00; // Messung starten PIND4-PIND7 Ue=5V


  initUART();

  stdout = &mystdout;

  do
  {
    for( i = 0; i < ANZAHL_KANAL; i++ )
    {
      {
        kanal[i].ticks = timer + 1;
      }
      
      if (PINB & kanal[i].spannung)
      {
        kanal[i].start = kanal[i].ticks;
        kanal[i].show = 1;
        PORTC |= kanal[i].status_led; // Status LED an
      }

      if (PIND & kanal[i].eingang)
      {

        kanal[i].end = kanal[i].ticks - kanal[i].start;

        if (kanal[i].show)
        {
          printf("Laufzeit Kanal %d: ", i + 1);
          printf_time( kanal[i].end );
          printf("\n");
          
          PORTC ^= kanal[i].status_led; // Status LED aus
          kanal[i].show=0; // 5V Eingang sperren
        }
      }
    }
  }
while (1);
}

Danke für die großartige Hilfe und Kritiken.

Diese Version ist viel übersichtlicher und mit 2320 Bytes auch 
schlanker, die Erweiterbarkeit ist auch gegeben.

Und wieder etwas dazu gelernt.

[Karl H. (kbuchegg)]

Jo. So wird das was.
Und die Erweiterung auf 8 Kanäle ist jetzt trivial. :-)

[Peter D. (peda)]

Die "end" brauchst Du nicht und die "ticks" zählst Du gemeinsam für 
alle:

uint32_t ticks;
//..
      if (PINB & kanal[i].spannung)
      {
        kanal[i].start = ticks;
        kanal[i].show = 1;
        PORTC |= kanal[i].status_led; // Status LED an
      }
      if (PIND & kanal[i].eingang)
      {
        if (kanal[i].show)
        {
          printf("Laufzeit Kanal %d: ", i + 1);
          printf_time( ticks - kanal[i].start );
//..

[Roman (Gast)]

2266 Bytes

Wenn es so weiter geht wird es ein 3 Zeiler. :-)