-         

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 29

Thema: Zähler der immer gleich schnell zählt

  1. #1
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.11.2010
    Ort
    Österreich
    Alter
    23
    Beiträge
    173

    Zähler der immer gleich schnell zählt

    Anzeige

    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

  2. #2
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    08.01.2006
    Beiträge
    4.556
    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

  3. #3
    Erfahrener Benutzer Roboter Genie Avatar von Hessibaby
    Registriert seit
    20.11.2003
    Ort
    Gelsenkirchen
    Alter
    65
    Beiträge
    1.597
    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.

    Planung ersetzt Zufall durch Irrtum

    Gruß aus dem Ruhrgebiet Hartmut

  4. #4
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.782
    Blog-Einträge
    8
    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

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  5. #5
    Erfahrener Benutzer Lebende Robotik Legende Avatar von PICture
    Registriert seit
    10.10.2005
    Ort
    Freyung bei Passau in Bayern
    Alter
    66
    Beiträge
    10.970
    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

  6. #6
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    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.

  7. #7
    Erfahrener Benutzer Lebende Robotik Legende Avatar von PICture
    Registriert seit
    10.10.2005
    Ort
    Freyung bei Passau in Bayern
    Alter
    66
    Beiträge
    10.970
    Laut Datenblatt ist der 74HC590 kein Synchronzähler, da die Takteingänge der Flip-Flops intern nicht paralell miteinander geschaltet sind ...

    MfG

  8. #8
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    08.01.2006
    Beiträge
    4.556
    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

  9. #9
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.11.2010
    Ort
    Österreich
    Alter
    23
    Beiträge
    173
    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

  10. #10
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    18.11.2010
    Ort
    Österreich
    Alter
    23
    Beiträge
    173
    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

Seite 1 von 3 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •