Zähler der immer gleich schnell zählt

HALLO

Ich laufe meiner Progermierzeit bin ich mir draufgekommen das zähler unterschiedlich schnell zählen

Es hängt ja davon ab wie lange das Programm ist oder

#include asuro.h
.........
........
........
x++
if(x>1000)
LANG++
if(x>1000)
x=0;


//Programm(die geschwindigkeit der Zählers kommt drarauf an wie lange dieser Teil hier ist)




if(LANG>500)
LANG=0;

Jetzt wollte ich fragen ob ich einen Zähler machen kann der immer gleich schnell zählt
Es müsste quasi im hintergrund immer ein Zähler laufen
Es wärr super das zu wissen.
Lg

Ein Prozessor arbeitet sein Programm immer Schritt für Schritt ab. Jeder Schritt braucht etwas Zeit also brauchen viele Schritte mehr Zeit als wenige. Was Du da gemacht hast ist auch kein echter Zähler sondern eine Programmschleife und je öfter diese durchlaufen wird je mehr Zeit wird benötigt.

Zähler für bestimmte Zeiten werden mit Timer "Gebaut" oder wenn man externe Takte zählen will mit Counter da Hilft Dir RN Wissen weiter.

Aber auch solche Timer benötigen je nachdem wie oft sie zählen müssen eine gewisse Zeit.

Gruß Richard

Egal in welcher Sprache Du programmierst wird Dein Zähler immer mehr oder weniger Zeit benötigen. Selbst wenn Du den Zähler in Silizium gießt z.B. als TTL-Sarg hast Du immer noch Gatterlaufzeiten die spätestens beim Überlauf auf die nächsthöhere Stelle bemerkbar werden.
Um konstante UP-/DOWN-Countzeiten zu bekommen kannst Du nur eine Totzeit programmieren um sicher zu stellen dass der Zähler auch gezählt hat und alle Überträge gemacht hat. Allerdings gehen Dir dann u.U. Zählereignisse verloren welche während der Totzeit eingetroffen sind.
Je nachdem wie präzise und wie schnell gezählt werden muss, solltest Du eventuell auf einen DSP oder sonstigen spezifischen Counterchip setzen.

Hallo

In der erweiterten Lib gab es mal die Funktion Gettime(). Ich gehe davon aus, dass diese Funktion auch in der aktuellen Library vorhanden ist. Sie zählt die Millisekunden seid dem Programmstart in einer 32-Bit-Longint-Variablen. Damit kann man wunderbar einfach nichtblockierende Zeitverzögerungen basteln:

Code:

---

#include "asuro.h"

unsigned long umschaltpunkt, blinken;
unsigned char statusled, backled;

int main(void)
{
        Init();

        statusled = 1;                                                                // 1 ist grün, 2 ist rot, 3 ist gelb
        umschaltpunkt = Gettime() + 5000;                // nach 5 Sekunden StatusLED umschalten

        BackLED(ON, OFF);
        backled = 0;
        blinken = Gettime() + 500;                                // BackLEDs mit 1Hz blinken
       
        while(1)
        {
                if(Gettime() > umschaltpunkt)      // Umschaltzeitpunkt überschritten?
                {
                  umschaltpunkt = Gettime() + 3000;// neuen Umschaltzeitpunkt festlegen
                  statusled++;
                  if(statusled > 3) statusled=1;
                  StatusLED(statusled);
                }
               
                if(Gettime() > blinken)
                {
                  blinken = Gettime() + 500;                // Blinkintervall neu laden
                  backled = !backled;                                        // bisschen schummeln :)
                  if(backled) BackLED(OFF, ON);
                      else BackLED(ON, OFF);
                }
                if(Gettime() & (1<<7)) FrontLED(ON);// mit 7 blinkt die FrontLED mit ca. 2Hz
                  else FrontLED(OFF);              // 0 wäre 36kHz (theoretisch)
                 
                // Ab hier ist dann Platz für weitere Funktionen

        }
        return(0);
}

---

(ungetestet)

Gruß

mic

P.S.: Warum schreibst du eigentlich nicht in der asuro-Rubrik?

Und noch ein Edit:

Um es nicht unnötig ungenau zu machen, müsste man es wohl so formulieren:

Code:

---

                if(Gettime() > umschaltpunkt)      // Umschaltzeitpunkt überschritten?
                {
                  umschaltpunkt += 3000;                                // neuen Umschaltzeitpunkt festlegen

---

Hallo!

So wie der Hessibaby schon geschrieben hat, ist es unmöglich einen Zähler länger als 4-bit, dessen alle Ausgänge dem Eigangsimpuls immer gleich folgen, sowohl software- als auch hardwaremässig zu kriegen.

Bei 4-bit ist es nur mit s.g. Synchronzähler hardwaremässig mit z.B. 74XX161, 74XX162, 74XX163 und 74XX164 möglich.

Man könnte es mit "Lookahead curry generator" 74XX182 probieren, habe es aber selber bisher noch nie gebraucht.

MfG

Es gibt schon auch 8 Bit ( z.B: 74HC590) und auch 16 Bit Syncronzähler. Die kann man auch Kaskadieren. Ich glaube aber das geht an der ursprünglichen Frage vorbei.


Für das konstante hochzählen einer Zahl haben fast alle µCs Timer hardware dirn. Da wird ein Zähler mit 8, 16 oder ggf. auch 32 Bit Länge unabhängig von der eigentlichen CPU kontinuierlich hochgezählt.
Bei Asuro hat man 2 Timer mit 8 Bit und einen mit 16 Bit. Die Frequenz zum hochzählen kann man per Vorteiler auswählen, z.B. als µC takt / 1024 oder Takt / 8. Wenn einem die 16 Bit nicht reichen kann man das per Interrupt erweitern auf 32 Bit oder auch mehr wenn man Geduld hat. Im Wissens Bereich unter Timer steht einiges dazu.

Laut Datenblatt ist der 74HC590 kein Synchronzähler, da die Takteingänge der Flip-Flops intern nicht paralell miteinander geschaltet sind ... :(

MfG

Ich vermute jetzt einfach einmal das der Ursprungs Poster sich nur etwas ungenau ausgedrückt hat und eigentlich etwas anderes fragen wollte? Das man schlecht in gleicher Zeit bis 5 oder bis 500 zählen kann weiß jeder der schon einmal irgend etwas mit Hilfe seiner grauen Masse gezählt hat. Ich jedenfalls brauch um bis 5 (geht gerade noch), weitaus weniger Zeit als wenn ich is 500 zählen sollte. :-)

Gruß Richard

Zitat:

---

Zitat von radbruch

Hallo


P.S.: Warum schreibst du eigentlich nicht in der asuro-Rubrik?


[/code]

---

Weil ich das heute in der schule fast neben lehrer gemacht habe und irgendwie auf asuro geklickt habe aber dann waren die Themen hier

Lg

Habe da ein Problem meine Variable ist mit unsigned int z=0; deklariert

Das heißt es müsste eigentlich von 0 - 65535 zählen.

Aber.......

Hier ist mein Code

Code:

---

#include <stdbool.h>
#include <stdio.h>
#include <asuro.h>
        int main(void)
{
        Init();
        char zC[2];
        unsigned char umschaltpunkt = 0;
        int t = 0;
        unsigned int z=0;
/*******************************************************************************************/
while( 1 )
{
        if(Gettime() > umschaltpunkt)      // Umschaltzeitpunkt überschritten?
        {
        umschaltpunkt += 10000;              // neuen Umschaltzeitpunkt festlegen
        z++;
        }

        if (umschaltpunkt > 10000)
                umschaltpunkt = 0;

if (PollSwitch() == 1)
        z=0;


if (PollSwitch() == 2)
        z = 90;

if (PollSwitch() == 4)
        z = 32750;

if (PollSwitch() == 32)
        z = 990;

/**********************************************************************/
                sprintf(zC, "%d", z);                //Übertragen
                SerWrite(zC, 6);                        //Übertragen
                SerWrite (" zC\n\r", 5);        //Übertragen
        for
                (t=0; t< 40; t++)                        //Übertragen
        {                                                        //Übertragen
        Sleep (72);                                        //Übertragen
        }                                                        //Übertragen
/***********************************************************************/


               
}
        return 0;
}

---

Hier ist die ausgabe von Hyper T.

Code:

---

22760 zC
32761 zC
32762 zC
32763 zC
32764 zC
32765 zC
32766 zC
32767 zC
-32768 zC
-32767 zC
-32766 zC
-32765 zC
-32764 zC
-32763 zC

---

Hat da jemand eienn Idee wieso er nicht bis 65... zählt

habe "z" auch schon mit int deklariert aber da ist es zählt er auch so


Lg