- fchao-Sinus-Wechselrichter AliExpress         
Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 52

Thema: Timer für AVR ATtiny84 oder ander allgemein in C

Hybrid-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. #1
    Neuer Benutzer Öfters hier Avatar von ooweberoo
    Registriert seit
    24.02.2014
    Ort
    66482 Zweibrücken
    Alter
    40
    Beiträge
    28
    Blog-Einträge
    1


    ah ok nicht Signal sondern ISR.... Es wird ein Unterprogramm durch einen Pointer aufgerufen welches eine Syntax abarbeitet..ok.

    Den Code in die "int main (void)"- Schleife? Komisch das ist in den Tutorial nie so, sondern immer davor.

    Wie man die Register richtig setzt ist die golden Frage! Das Datenblatt ist eig. unbrauchbar.

    Mit dem Datenblatt arbeite ich die ganze Zeit. Die Befehle und Bezeichnungen die dort stehen erzeuge Fehler im AVR Studio. Dort ist nicht ein einziges Syntax- Beispiel für Timer oder anders....

    Hier mal der Auszug zum Them CTC Mode aus dem original ATtiny84 Datenblatt:

    In Clear Timer on Compare or CTC mode (WGM02:0 = 2), the OCR0A Register is used to
    manipulate the counter resolution. In CTC mode the counter is cleared to zero when the counter
    value (TCNT0) matches the OCR0A. The OCR0A defines the top value for the counter, hence
    also its resolution. This mode allows greater control of the Compare Match output frequency. It
    also simplifies the operation of counting external events.

    Als könnte man jetzt einen Code daraus erzeugen (als Anfänger). Das sind nur grobe Funktionserklärungen im Datenblatt sonst nix.

    Trotzdem danke ersmal Chris....

    Also kann mir jemand schreiben wie der Code aufzubauen ist?

  2. #2
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    8.694
    ... Das Datenblatt ist eig. unbrauchbar ...
    Stimmt. Mal was Anderes: ich setze Dich in einen Airliner und geb Dir das Betriebshandbuch. Du wirst es als unbrauchbar wegwerfen - und das Ding nicht in die Luft kriegen. Dagegen ist ein CPL-Pilot meist in der Lage ohne Einweisung mit einem nicht gerade ungebräuchlichen Jet mit Hilfe des Betriebshandbuchs in die Luft zu gehen. Tut er aber nicht - er holt sich ne Einweisung. Die brauchst Du auch: ins Datenblatt, ins Programmierhandwerk etc.

    Beispiel: der Code im Datenblatt ist möglicherweise nicht für den Compiler, den Du verwendest. Oder es sind eben nicht alle notwendigen Initialisierungen drin. Das Datenblatt ist sowieso schon sooo lang, oder? UND es wendet sich eigentlich nicht an Anfänger. Sorry, das soll nicht ätzend sein, soll Dich nicht entmutigen, es ist einfach so.

    ... kann mir jemand schreiben wie der Code aufzubauen ist? ...
    Das kann schätzungsweise jeder Zweite hier - denke ich. Und als kleine Hilfe für Dein Problem lege ich einen kompletten, lauffähigen Code für nen tiny13 dazu, bei dem der Timer zum Blinken einer LED eingesetzt wird. IDE dafür ist AVR-Studio4. Erklärungen stehen im Kommentar des Codes. Mehr schreibe ich hier nicht dazu.

    Du solltest vermutlich das eine oder andere Tutorial noch durchgehen, dann ein KLEINES Programmschnippsel Dir irgenwo abschreiben, modifizieren, schaun ob was rauskommt ausser Fehlermeldungen etc etc. Die nicht unübliche Vorgehensweise eines Anfängers. Und - Timerprogrammierung ist schon eher fortgeschrittenes Können bei den AVR´s.

    Code:
    /* >> 
      Stand  ...\...\LED_B3.c                                       x20 21Jan14 2340
     x20 21Jan14 2340 Timernutzung für Sound zusätzlich auf PB0 mit PWM 
     =============================================================================== =
      Target MCU        : ATTiny 13
      Target Hardware   : Experimentierplatine tiny13
      Target cpu-frequ. : Interner Oszillator (9,6 MHz)
     =============================================================================== =
      *** Aufgabenstellung : LED auf Port PB3 blinkt z.B. 1 Hz, Sound auf PB4
                               Taktgeber durch Timer-ISR, Variation der Timerparameter
     ============================================================================== */
    #include <stdlib.h>
    #include <avr/io.h>
    #include <avr/interrupt.h>      // Für Interruptbehandlung nötig
      
    // CPU Frequenz
    #define F_CPU 9600000UL
    //      Setze Bit
    #define SetBit(ADDR,BIT)        ((ADDR)  |=  (1<<(BIT)))
    //      Lösche Bit
    #define ClrBit(ADDR,BIT)        ((ADDR)  &= ~(1<<(BIT)))
    //      Toggel Bit
    #define ToggleBit(ADDR,BIT)     ((ADDR)  ^=  (1<<(BIT)))
    
    // - - - - - - - - - - - - - - -
    // Grüne LED auf Port PB3
    #define       L1G     3
    //      Anmerkung: die LED-Schaltung ist GND-Kathode-LED-Anode-Portpin
    
    volatile int16_t    Izeit_1;    // Wertbereich int16: 32.767. uint16: 65.535
    volatile int16_t    ZHorznt;    // Wertbereich int16: 32.767. uint16: 65.535
    volatile int16_t    Sekundn;    // Zähler für Sekunden
    
    // - - - - - - - - - - - - - - -
    //      Funktionsprototypen
     void wms(uint16_t  v)       ;  // Waitroutine (Controller zählt nur vor sich hin)
     void TC0TMR_init(void)      ;  // Init Tmr/Cntr 0, 8-Bit auf 20 kHz = 50 µs
     ISR(TIM0_COMPA_vect)        ;  // Vektor 7, Prog.Addr. 0x0006
    
    // ============================================================================= =
    // ============================================================================= =
    
    
    // ============================================================================= =
    // =====  Subroutinen  ========================================================= =
    // ============================================================================= =
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    //      PROCEDURE   wms()
    //      -  Warteroutine die NUR Zeit vertrödelt; Controller zählt runter bis Null
    //      PARAMETER
    //      -  I  uint16_t  Wartezeit in Millisekunden
    //                      Die geforderte Zeit ist i.A. nur ungefähr!
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      void wms(uint16_t ms)         // Waitroutine (Controller zählt runter bis Null)
    // - - - - - - - - - - - - - - - -
      {                             //
        for(; ms>0; ms--)           //
        {                           //
          uint16_t __c = 2395;      // Anpassung an 9,6 MHz
          __asm__ volatile (        // Beginn Assembler Routine / nicht optimieren
             "1: sbiw %0,1" "\n\t" 
             "brne 1b" 
             : "=w" (__c) 
             : "0" (__c) 
          ); 
        }   
      }                     // Ende void wms(uint16_t ms)
    // ============================================================================= =
    
    
    // ============================================================================= =
    // ===  Initialisierung des Timer0 tiny13 für CTC
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     void TC0TMR_init(void)         // Init Tmr/Cntr 0, 200µs bei 9,6 Mhz = 5kHz
    // - - - - - - - - - - - - - - - -
     {                         //
      TCCR0A        |= (1<<WGM01);  // Timer im CTC-Mode, Top=OCR0A                 73
      TCCR0B        |= (1<<CS01);   // Prescaler 8  =>  Clock = CPUclk/8            74
      OCR0A          = 239;         // Preset 239 für 200µs bei 9,6 Mhz  
                                    // 200 µs <=> 2,5 kHz
      TIMSK0        |= (1<<OCIE0A); // Tmr/Cntr0 CompareA interrupt enabled
     }              // Ende void TC0TMR_init(void)
    // ============================================================================= =
    
    
    // ============================================================================= =
    // ===  Nicht unterbrechbare ISR für timer0
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     ISR(TIM0_COMPA_vect)         // Vektor 7, Prog.Addr. 0x0006
    // - - - - - - - - - - - - - - - -
     {                              //
      Izeit_1 --;           //  ###>>> Izeit_1 ist aktuell int16_t ==>>
                            //              bleibt im Wertebereich < 32.767
      ToggleBit (PORTB, 4); //  .. Audioport toggeln
      if ( Izeit_1 )        // Interrupt-Timer = 1 ... 40 000 ... (1 sec blink)
        {  }                // WENN Izeit_1 =|= Null => wahr => Anweisung ausgeführen
      else                  // Izeit_1 = Null = unwahr, daher "else" ausführen
      {                     // Eine Sekunde ist voll =>
        Izeit_1 = ZHorznt;  //  .. daher: Rückstellen auf Zeithorizont
        ToggleBit (PORTB, L1G );    //  .. und LED toggeln
        Sekundn ++;         // "Sekundencounter" hochzählen
      }             // Ende if (Izeit_1 )
    
      return;
     }       // Ende ISR(TIM0_COMPA_vect)
    // ============================================================================= =
    // ============================================================================= =
    
    
    // ============================================================================= =
    // =====  ENDE    Subroutinen  ================================================= =
    // ============================================================================= =
    
    
    // ============================================================================= =
    // ===  HAUPTProgramm ========================================================== =
    //      FUNCTION    main()
    //      -  Initialisierungen
    //      -  LED kurzblinken als Signal für Programmstart
    //      -  Pause 100 ms ohne Aktion
    //      -  Hauptschleife
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     int main(void)         // Hauptprogramm
     {                      //
    // - - - - - - - - - - - - - - -
    //       Variablendefinition
      uint16_t i;           // Zählvariable
      uint16_t ton;         // Zählvariable
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    // ===  Grundlegende Initialisierungen der Hardware, Portdefinition
    //PCINT5,/RESET,ADC0,dW PB5   1        8   Vcc
    //     PCINT3,CLKI,ADC3 PB3   2        7   PB2 SCK,ADC1,T0,PCINT2
    //         PCINT4, ADC2 PB4   3        6   PB1 MISO,AIN1,OC0B,INT0,PCINT1
    //                      GND   4        5   PB0 MOSI,AIN0,OC0A,PCINT0
    // - - - - - - - - - - - - - - -
    //  Portbelegung und Initialisierung der Anschlüsse : 
    //               /RESET PB5   1 A   + 28   Vcc 
    //                  L1G PB3   2 A   A 27   PB2 nc
    //              Piezo1  PB4___3 A   A 26___PB1 nc
    //              Piezo   GND   4 -   A 25   PB0 nc
    // - - - - - - - - - - - - - - -
    // Portkonfiguration
    // Ports+Pins als Ein- (0) oder Ausgänge (1) konfigurieren, Pull Ups (1) aktiv.
    //      A = Ausgang, E = Eingang ohne , EU = Eingang MIT PullUp
      DDRB  = 0b11111111;   // siehe aktuell oben
      PORTB = 0b00000000;   //    und Port/Pull Ups (1)  aktivieren
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
      TC0TMR_init ();       // Initialisierung des Timers
      sei();                // Interrupts zulassen
    
    // ============================================================================= =
    //      Es folgt das eigentliche "Hauptprogramm" mit den Aktionen
    // ============================================================================= =
    
    //      Einstellen der Werte
      ZHorznt   =  5000;    // Zeithorizont einstellen
      Izeit_1   =  ZHorznt; // Zeithorizont für Timer übernehmen
      Sekundn   =     0;    // Boardzeit initialisieren
    //      Eine kurze Zeit Dauerton
      while (Sekundn < 5)   // Schleife ca. x sec
      {                     //
      }             // Ende while ( Sekundn < ...
    
    
    // - - - - - - - - - - - - - - - -
    //      Jetzt Ton ab- und anschwellend
      cli();
      ZHorznt       =  5000;        // Setze Zeithorizont
      Sekundn       =     0;        // Sekunden zurücksetzen
      sei();
      i             =     0;        // Schleifenzähler setzen
      ton           = OCR0A;        // 
      while ( Sekundn < 10 )
      {
        for (i = 0; i<50; i++)      //
        {                           //
          ton--;                    // Ton tiefer stellen
          OCR0A     = ton;          //
          wms (  10);
        }                           //
        for (i = 0; i<50; i++)      //
        {                           //
          ton++;                    // Ton hochdrehen
          OCR0A     = ton;          // 
          wms (  10);
        }                           //
      }             // Ende while ( Sekundn < 10 )
    
    // - - - - - - - - - - - - - - - -
    //      Konstanten Ton einschalten
      cli();
      ZHorznt       =  5000;        // Setze Zeithorizont
      Sekundn       =     0;        // Sekunden zurücksetzen
      sei();
    //      Eine kurze Zeit Dauerton
      while (Sekundn < 5)           // Schleife ca. x sec
      {                             //
      }             // Ende while ( Sekundn < ...
    
    // - - - - - - - - - - - - - - -
    //      Zum Abschluss wieder Sirenentöne ab- und anschwellend
      i             =     0;        // Schleifenzähler setzen
    //ton           = OCR0A;        // 
      ton           = 255;        // 
      while ( 1 )
      {
        for (i = 0; i< 100; i++)    //
        {                           //
          ton--;                    // Ton tieferstellen
          OCR0A     = ton;          //
          wms (  20);
        }                           //
        for (i = 0; i< 100; i++)    //
        {                           //
          ton++;                    // Ton hochdrehen
          OCR0A     = ton;          //
          wms (  20);
        }                           //
      }             // Ende while ( 1 ...
    
    // - - - - - - - - - - - - - - -
      return 0;             //
     }                      //        
    // =====  Ende
    // ============================================================================= =
    // ============================================================================= =
    Diesen Code hatte ich extra für ne Anfängerschulung geschrieben. Die Leute hatten davor schon ein paar wenige Stunden Einweisung hinter sich.

    Und natürlich wünsche ich Dir viel Erfolg. Und Geduld.


    Nachtrag: der tiny84 hat Prescaler. Für den Timer0 beispielsweise siehe Documentation 8006K–AVR–10/10, Seite 84.

    Nochn Nachtrag:
    ... Datenblatt ist eig. unbrauchbar ... Mit dem Datenblatt arbeite ich die ganze Zeit ...
    Zitat Zitat von ooweberoo Beitrag anzeigen
    ... #define F_CPU 1000000UL //max. Takt ATtiny84 ...
    Auf Seite 1 des Datenblatts steht der maximale Takt des tiny84 mit 20 MHz angegeben . . . Dazu muss natürlich der entsprechende Quarz benutzt werden.
    Geändert von oberallgeier (27.02.2014 um 23:06 Uhr) Grund: Hinweis auf prescaler und max. Taktrate
    Ciao sagt der JoeamBerg

  3. #3

  4. #4
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    Die Sache mit ISR() bzw. der alten Ausführung Signal(...) ist eine Compilerspezifische Erweiterung von C - im C Standard fehlt das einfach.

    Die Timer bei den AVRs sind schon recht ähnlich, aber halt nicht alle gleich. Entsprechend unterscheidet sich die Programmierung der Register etwas. Für genau so etwas muss dann auch ein Anfänger mal ins Datenblatt schauen, wenn man nicht gerade den µC nutzt der auch im Tutorial beschrieben wird. Die AVR Datenblätter sind da sogar noch relativ übersichtlich. Wichtig ist vor allem die Registerbeschreibung, also Abschnitt 11.9 im Datenblatt zum Tiny24/44/84. Da findet man dann z.B. Das im Register TCCR0A der CTC Mode ausgewählt werden kann, aber nicht der Prescaler. Der Prescaler steht dann in TCCR0B. Das Register um dann den Interrupt zu Timer0 einzustellen heißt beim Tiny84, wie bei fast neueren AVRs dann TIMSK0.

    Für die Anwendung hier ist der 8 Bit Timer 0 sowieso keine gute Wahl ist. Der 16 Bit Timer 1 ist da deutlich besser, weil da die 10000 auch ins Compare Register passen. .

  5. #5
    Neuer Benutzer Öfters hier Avatar von ooweberoo
    Registriert seit
    24.02.2014
    Ort
    66482 Zweibrücken
    Alter
    40
    Beiträge
    28
    Blog-Einträge
    1
    Hallo,

    danke erst mal für euer Info's.

    @ oberallgeier = für dass, das hier jeder 2 den Code aufbauen kann tut es aber keiner Mit deinem Code kann ich leider nichts anfangen. Zu viel durcheinander drin.
    Klar kann der Tiny84 20MHz, aber laut Datenblatt erst ab 4,5V. Ich nutze nur 3V.

    @ Wsk8 = Danke für dier Tutorials, werde sie durcharbeiten. Mal schauen ob dich dann schlauer bin...

    @ Besserwissi = Habe ganz unten im Datenblatt die gesamte Registerbeschreibung gefunden. Wie man so was vermeidlich unwichtiges ganz nach hinten ins DB macht verstehe ich auch nicht.
    Deine Angaben kann ich bestätigen. Scheinbar muss man die Register kreuz und quer ohne Sinn verwenden damit man die gewünscht Funktion erhält

    Ich habe aus den Angaben folgenden Code generiert:

    #include <stdlib.h>
    #include <avr/io.h>
    #include <avr/interrupt.h>

    #define F_CPU 1000000UL

    unsigned char wert;

    ISR(SIG_OUTPUT_COMPARE0B)
    {
    wert++;
    }
    //----------------------------
    int main(void)
    {
    TCCR0B= (1<<CS00)&&(1<<CS02)&&(1<<WGM02); CPU Takt/1024
    OCR0B= xxx ;
    TIMSK0 = (1<<OCR0B);
    sei();
    wert=0;
    //------------------------------
    while(1)
    {
    if (wert=1)
    {
    DDRA = 0x06;//wenn Zählerwert 1 erreicht ist gib 1 als BCD an 7-Segmentanzeige aus
    }
    }
    //-----------------------------
    }

    Vergleichswert muss ich noch schaue wie man den angibt. Im Datenblatt steht "(CSn2:0 = 7)" CS = Vergleichswert, n = Variable von 1bis..., aber was 2:0=7 bedeutet weis ich nicht.
    Wird ja im Datenblatt nirgends erwähnt was ATMEL's fiktive Rechenoperationen bedeuten.

    Kann mir wenigstens jemand sagen wo der Fehler in meinem Code ist?
    Geändert von ooweberoo (28.02.2014 um 17:23 Uhr)

  6. #6
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    Code:
    #include <avr/io.h>
    #include <avr/interrupt.h>
    
    
    #define F_CPU 1000000UL		// 1MHz
    
    
    
    
    volatile uint16_t timerVal = 0;
    
    
    
    
    void InitTimer() {
    	TCCR1B = (1<<WGM12) | (1<<CS12) | (1<<CS10);	// CTC Mode, CLK/1024
    	TIMSK1 = (1<<OCIE1A);	// Output Compare A Match Interrupt Enable
    	
    	OCR1A = 10000;	// Top value
    }
    
    
    
    
    int main(void) {
    	timerVal = 0;
    
    
    	InitTimer();
    
    
    	sei();
    
    
    	while(1) {
    		if(timerVal == 1) {
    			DDRA = 0x06;
    			timerVal = 0;
    		}
    	}
    
    
    	return 0;
    }
    
    
    
    
    ISR(TIMER1_COMPA_vect) {
    	timerVal++;
    }
    Mal schnell programmiert, kA obs stimmt.

    mfg

  7. #7
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    Die Schreibweise mit dem 2:0 steht für die Bits 0 bis 2. In dem Beispiel (CSn2:0 = 7) also das CSn2, CSn1 und CSn0 zusammen als Binärzahl interpretiert 7 ergeben, also alle 3 Bits auf 1.

  8. #8
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    8.694
    Zitat Zitat von oberallgeier Beitrag anzeigen
    ... Du solltest vermutlich das eine oder andere Tutorial noch durchgehen ...
    Und, tust Du das? Ich denke nicht, ich glaube dass Du nur abschreibst - und das noch dazu falsch. Trotzdem mal ein Punkt zur Hilfe:
    Zitat Zitat von ooweberoo Beitrag anzeigen
    ...
    Code:
    ...
        TCCR0B = (1<<WGM02) && (1<<CS01);               // CTC Modus, Vorteiler 8, // ((1000000/8)/1000) = 125
    ...
        TIMSK0 = (1<<OCIE0B);                                     // Interups EIN
    ...
    //------DB1------------------------------------------------------------------------------------------------------------------------
    ISR(TIM0_COMPA_vect)
    {   ...
    }
    ...
    Der Kommentar zu TIMSK0 ist falsch. Ich meine nicht die Rechtschreibung sondern der Plural. Es wird nur EIN Interrupt frei eingeschaltet, der von Kanal B. Deshalb tut sich nix bei Deiner Interruptroutine für den Kanal A *ggg*. Wie leider oben gesagt - abgeschrieben, aber vermutlich nix gedacht. Mehr schreibe ich nicht, denn Du meinst ja, mit meinem Code kannst Du "leider nichts anfangen. Zu viel durcheinander drin". Aber der Code funktioniert bestens *gg*.

    Zitat Zitat von ooweberoo Beitrag anzeigen
    ... vielleicht sollte ich doch den 2313 bestellen ...
    Der programmiert sich auch nicht von selbst! Deshalb fürchte ich, dass Du bei dem mit Deiner gegenwärtigen Programmiermethode (bzw. Deiner Abschreibetechnik) auch auf die Nase fällst. Und - das täte mir dann doch leid.
    Ciao sagt der JoeamBerg

  9. #9
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    Code:
    int main(void) {
    	TCCR0A |= (1<<WGM01);		// CTC Modus
    	TCCR0B |= (1<<CS01);		// Vorteiler 8
    	OCR0A = 125-1;				// ((1000000/8)/1000) = 125
    	TIMSK0 = (1<<OCIE0A);		// Interups EIN
    	sei();
    	
        while(1) {}
    }
    mfg

  10. #10
    Neuer Benutzer Öfters hier Avatar von ooweberoo
    Registriert seit
    24.02.2014
    Ort
    66482 Zweibrücken
    Alter
    40
    Beiträge
    28
    Blog-Einträge
    1
    Hallo,

    @ oberallgeier: ziemlich voreingenommen zu behaupten ich würde nur abschreiben. Ich habe das Tutorial hier, auf Microcontroller.net und
    andere gemacht. Überall ist es anders. Jeder verwendet einen andern Chip und zufälligerweise keiner den 84er.
    Den Befehl " TIMSK0" habe ich aus meinem Datenblatt da in diesem Register das Bit "OCIE0B" existiert. Das es Falsch ist
    konnte ich nicht ahnen, wie auch wenn es so in den Tutorials angegeben ist.
    Ich meinte ja nur das es im Netz eher Hilfe zum 2313er gib als vom 84er.

    @ Wsk8: Danke dir. Aber so wie du das geschrieben hast setze ich im Register (TCCR0A) von Timer 0 den
    CTC- Modus und im Register (TCCR0B) von Timer 0 die entsprechenden Vorteilerbits ???

    Im Microcontroler.net wird ein 2313 verwendet und hier im Tutorial ein mega32. Habe mich halt an die Tutorials gehalten und die Registerbezeichnungen vom 84 eingesetzt. Wenn das dann nicht hinhaut liegt das bestimmt nicht daran das ich nicht nachdenke. Wollte lediglich etwas Hilfe.
    Zudem was soll mir ein Programm bringen in dem auch ein 2313 verwendet wird??? Da bin ich genauso nass wie in den Tutorials.
    Dann sollte man ein Tutorial für alle chips machen. Aber mich nicht anhauen weil ich Tutorials falsch interpretiere.


    Mal der Code aus dem Roboternetz Tutorial hier:

    Code:
    /* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz 
       mit 7,3728 MHz betrieben wird. Im Abstand von 0,01 ms erzeugt der Timer 
       einen Interrupt, also eine Frequenz von 100000 Hz (oder 100 kHz). 
       Der Timer wird auf einen Prescaler von 1 und einem OCR2-Wert von 73 konfiguriert. */
    
    volatile uint8_t countTimer2;	// Speichert den aktuellen Zählerwert
    
    SIGNAL(SIG_OUTPUT_COMPARE2)
    {
      countTimer2++;
    }
    
    // Initialisierung:
    TCCR2 = (1<<CS20) | (1<<WGM21);	// Prescaler von 1 | CTC-Modus (siehe unten für Beschreibung)
    OCR2  = 73;			// Vergleichswert
    TIMSK |= (1<<OCIE2);		// Interrupts aktivieren und damit Timer starten
    sei();
    
    // Funktionen zum benutzen der Timer:
    /** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
    Bei t=100 schläft die Funktion 1 ms. */
    inline void sleep(uint8_t t)
    {
    	// countTimer2 wird in der ISR oben inkrementiert
    	countTimer2 = 0;
    	while (countTimer2 < t);
    }
    
    /** Schläft x-Millisekunden. */
    inline void sleep_millisec(uint16_t msec)
    {
    	uint16_t i;
    	for(i=0; i<msec; i++) {
    		sleep(100);
    	}
    }
    --------------------------------------------------------------------------------

    Ich wollte zufällig die gleiche Funktion wie im Beispiel. Das dann an dem Code alles falsch ist kann ich ja nicht wissen.

    Falsch bei mir war : ISR statt SIGNAL, SIG_OUTPUT_COMPARE2 war auch falsch, statt TIMSK sthet bei mir TIMSK0, auch falsch,
    statt OCR2 muss ich TCCR0A oder TCCR0B verwenden....
    Also werde ich es mal mit den 2 Registen getrennt versuchen (TCCR0A &&TCCR0B)..... Mal sehen...

    Danke
    Geändert von ooweberoo (05.03.2014 um 11:47 Uhr)

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Datenübertragung Bluetooth (oder Funk allgemein)
    Von Bumbum im Forum Software, Algorithmen und KI
    Antworten: 0
    Letzter Beitrag: 21.09.2012, 09:02
  2. ATTiny84 Pegelbegrenzung mit Zenerdiode oder wie?
    Von DanielSan im Forum AVR Hardwarethemen
    Antworten: 25
    Letzter Beitrag: 01.12.2011, 13:40
  3. 5V Netzteil gesucht oder allgemein guter Hersteller
    Von kini im Forum Suche bestimmtes Bauteil bzw. Empfehlung
    Antworten: 5
    Letzter Beitrag: 25.03.2010, 11:33
  4. Ander controller programmieren?
    Von BlackDevil im Forum Elektronik
    Antworten: 10
    Letzter Beitrag: 26.08.2006, 00:20
  5. Bspcode in assembler für AVR Timer
    Von Shadowrun im Forum AVR Hardwarethemen
    Antworten: 5
    Letzter Beitrag: 09.02.2005, 13:55

Stichworte

Berechtigungen

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

fchao-Sinus-Wechselrichter AliExpress