Schnelles Schalten mit Interrupt 2

[patrick b. (calalex)]

hallo, ich hab meinen vorherigen Code verändert [[Schnelles Schalten mit 
Interrupt]]  und bin auf Feedback gespannt, ob er vielleicht nun so 
funktionieren kann!
Bei jeder Flanke soll der Timer auf 0 gesetzt werden, anschließend
hochgezählt werden, sofern dann der compare Wert erreicht wird, soll PA0
aktiviert werden. Kommt vorher die nächste Flanke, wird der timer wieder
rechtzeitig zurückgesetzt. So meine Theorie.
Vielen Dank für nützliches Feedback!

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

#define IN_PORT  PORTD
#define IN_DDR  DDRD
#define IN_PIN  PD6

#define OUT_PORT  PORTA
#define OUT_DDR    DDRA
#define OUT_PIN    PA0

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


ISR (TIMER1_COMPA_vect)
{
  PORTA |=(1<<PA0);          // falls kein Puls PA0 aktivieren
}

ISR(INT0_vect)
{
    TCCR1B |= (1 << WGM12)|(1 << CS10);    // timer setzen, ohne prescale
    TCNT1 = 0;                // counter init
    OCR1A = 3199;              // compare modus init: flck=16MHz => tclk=62.5ns,
                        // 200ns Pause + 20ns Toleranz = 220ns
                        // 220ns/62.5ns =3200 Zählschritte -1 = 3199
    TIMSK |= (1 << OCIE1A);          // compare modus aktivieren
  
}

int main(void)
{
  
  DDRD &= ~(1<<PD2);         //PD2 als Eingang
  PORTD|= (1<<PD2);         //Pullup aktivieren
  DDRA = (1<<PA0);        //PA0 als Ausgang
  
  sei();              //global interrupts
    
                
  MCUCR |= ((1<<ISC01)|(1<<ISC00));    //interrupt bei steigender Flanke
  GICR |= (1<<INT0);            //interrupt modus aktivieren
  
  
  
  
  while(1)
  {
    
  };
  
}

[Karl H. (kbuchegg)]

patrick bateman schrieb:
> hallo, ich hab meinen vorherigen Code verändert [[Schnelles Schalten mit
> Interrupt]]  und bin auf Feedback gespannt, ob er vielleicht nun so
> funktionieren kann!

Das allerbeste Feedback gibt dir der µC selber.
Zur Not tuts auch der Simulator im AVR-Studio

Edit: Den Teil 'Zur Not' nehm ich zurück. Tatsächlich ist das in vielen 
Fällen eine sehr gute Möglichkeit um erst mal zu sehen, was im Programm 
warum passiert.

[patrick b. (calalex)]

kann ich dem Simulator auch einen zeitlichen Input geben?

[Karl H. (kbuchegg)]

patrick bateman schrieb:
> kann ich dem Simulator auch einen Input geben?

Natürlich.
Im Simulator siehst du alle µC-Register aller Hardware Komponenten. Zum 
Beispiel auch die PORT und PIN Register, aufgeschlüselt in die einzelnen 
Bits. Nichts und niemand hindert dich daran, da drauf zu klicken und dem 
µC auf seinem PIN Register einen Input von 1 (oder 0) zu liefern.

Mach dich ein bischen damit vertraut, das wirst du in deiner Karriere 
noch oft benötigen.

[Karl H. (kbuchegg)]

Einen Tip gib ich dir. Denk mal ein bischen über Reihenfolgen nach. Es 
ist nicht egal, in welcher Reihenfolge man Dinge tut. Ein Timer beginnt 
dann zu laufen, sobald er einen Vorteiler bekommt. Es ist daher nicht 
egal, ob man gewisse Einstellungen erst macht NACHDEM der Timer schon 
losgelaufen ist, oder ob man die macht BEVOR der Timer läuft. Und: 
Compare-Matches werden IMMER geprüft! Egal ob du schon was ans OCR1A 
Register zugewiesen hast oder nicht. Denn die Register erwachen nicht 
zum Leben, wenn du das erste mal etwas zuweist. Die Register sind immer 
da und wenn du nichts zugewiesen hast, dann steht da eben 0 drinnen 
(oder welcher Wert auch immer beim Reset des µC von der Hardware 
eingestellt wird)

[patrick b. (calalex)]

das heißt, die zwei Zeilen

OCR1A = 3199;  
TIMSK |= (1 << OCIE1A);

pack ich in int main (void)?

Das Zurücksetzen des Timers klappt dann so, dass ich ihn zuerst auf 
TCNT1 = 0; initialisiere und mit der nächsten Zeile lasse ich in ja 
direkt starten.

Kann man dem Simulator auch eine Textdatei geben?

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

#define IN_PORT  PORTD
#define IN_DDR  DDRD
#define IN_PIN  PD6

#define OUT_PORT  PORTA
#define OUT_DDR    DDRA
#define OUT_PIN    PA0

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


ISR (TIMER1_COMPA_vect)
{
  PORTA |=(1<<PA0);          // falls kein Puls PA0 aktivieren
}

ISR(INT0_vect)
{
    TCNT1 = 0;                // counter init
    TCCR1B |= (1 << WGM12)|(1 << CS10);    // timer setzen, ohne prescale
   
}

int main(void)
{
  
  DDRD &= ~(1<<PD2);         //PD2 als Eingang
  PORTD|= (1<<PD2);         //Pullup aktivieren
  DDRA = (1<<PA0);        //PA0 als Ausgang
  
  sei();              //global interrupts
    
                
  MCUCR |= ((1<<ISC01)|(1<<ISC00));    //interrupt bei steigender Flanke
  GICR |= (1<<INT0);            //interrupt modus aktivieren
  
      OCR1A = 3199;              // compare modus init: flck=16MHz => tclk=62.5ns,
                        // 200ns Pause + 20ns Toleranz = 220ns
                        // 220ns/62.5ns =3200 Zählschritte -1 = 3199
    TIMSK |= (1 << OCIE1A);          // compare modus aktivieren
  
  
  
  while(1)
  {
    
  };
  
}

[Falk B. (falk)]

@ patrick bateman (calalex)

>hallo, ich hab meinen vorherigen Code verändert [[Schnelles Schalten mit
>Interrupt]]

Ist es so schwer, eine Link direkt einzufügen?

Beitrag "Schnelles Schalten mit Interrupt"

>und bin auf Feedback gespannt, ob er vielleicht nun so
>funktionieren kann!

Was ist das hier? Heiteres C-Code raten? Oder doch vielleicht mal 
nachdenken und was gescheites programmieren?

>Bei jeder Flanke soll der Timer auf 0 gesetzt werden,

Was selten sinnvoll ist. Meistens ist es besser, den Timer durchlaufen 
zu lassen.

> anschließend
>hochgezählt werden, sofern dann der compare Wert erreicht wird, soll PA0
>aktiviert werden. Kommt vorher die nächste Flanke, wird der timer wieder
>rechtzeitig zurückgesetzt.

Nennt sich Monoflop, hier in Software.

> So meine Theorie.

Wo sind die ZAHLEN dazu? Denn es ist ein Unterschied, ob wir von 1kHz 
oder 1 MHz reden.


>    TCCR1B |= (1 << WGM12)|(1 << CS10);    // timer setzen, ohne prescale

Man muss dem Timer nicht dauern neu initialisieren, schon gar nicht bei 
deinen Wunschpulsbreiten.

>    TCNT1 = 0;                // counter init

Naja.

>    OCR1A = 3199;              // compare modus init: flck=16MHz => >tclk=62.5ns,
>                        // 200ns Pause + 20ns Toleranz = 220ns
>                        // 220ns/62.5ns =3200 Zählschritte -1 = 3199

Fehlt hier ne Null? Oder zwei? Oder hast du Mikrosekunden mit 
Nanosekunden verwechselt? Die Zahen in den Kommentaren stimmen nicht.

>    TIMSK |= (1 << OCIE1A);          // compare modus aktivieren

Dito, das macht man EINMALIG am Programmanfang!

>int main(void)
>{

>  DDRD &= ~(1<<PD2);         //PD2 als Eingang
>  PORTD|= (1<<PD2);         //Pullup aktivieren
>  DDRA = (1<<PA0);        //PA0 als Ausgang

>  sei();              //global interrupts

Interrupts freigeben ohn vorher den Timer gescheit initialisiert zu 
haben? intessant.

>  MCUCR |= ((1<<ISC01)|(1<<ISC00));    //interrupt bei steigender Flanke
>  GICR |= (1<<INT0);            //interrupt modus aktivieren

Hier das Gleiche.

Solche Monoflops in Software sind nur für Zeiten von einigen 
Mikrosekunden oder mehr sinnvoll, für kleinere Zeiten macht man sowas in 
Hardware, siehe Monoflop.

[Falk B. (falk)]

@patrick bateman (calalex)


>OCR1A = 3199;
>TIMSK |= (1 << OCIE1A);
>pack ich in int main (void)?

Ja.

>Das Zurücksetzen des Timers klappt dann so, dass ich ihn zuerst auf
>TCNT1 = 0; initialisiere

Ja.

> und mit der nächsten Zeile lasse ich in ja
>direkt starten.

Warum, er läuft doch schon. Und man kann ihm während des Betriebs neu 
laden, ohne ihn anzuhalten.

[patrick b. (calalex)]

- Kommentarzeile hatte einen Fehler
- sei () steht jetzt am Ende
-

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

#define IN_PORT  PORTD
#define IN_DDR  DDRD
#define IN_PIN  PD6

#define OUT_PORT  PORTA
#define OUT_DDR    DDRA
#define OUT_PIN    PA0

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


ISR (TIMER1_COMPA_vect)
{
  PORTA |=(1<<PA0);              // falls kein Puls PA0 aktivieren
}

ISR(INT0_vect)
{
    TCCR1B |= (1 << WGM12)|(1 << CS10);    // 16bit timer setzen, ohne prescale
    TCNT1 = 0;                // counter init
}

int main(void)
{
  
  DDRD &= ~(1<<PD2);               //PD2 als Eingang
  PORTD|= (1<<PD2);               //Pullup aktivieren
  DDRA = (1<<PA0);              //PA0 als Ausgang
  
  
                
  OCR1A = 3199;                // compare modus init: flck=16MHz => tclk=62.5ns,
                        // 200us Pause + 20us Toleranz = 220us
                        // 220us/62.5ns =3200 Zählschritte -1 = 3199
  TIMSK |= (1 << OCIE1A);            // compare modus aktivieren
  
                  
  MCUCR |= ((1<<ISC01)|(1<<ISC00));      //interrupt bei steigender Flanke
  GICR |= (1<<INT0);              //interrupt modus aktivieren
  
  sei();                    //global interrupts
  
  while(1)
  
  {
    
  };
  
}

[Karl H. (kbuchegg)]

Was ist eigentlich, wenn die Anlage eingeschaltet wird und das 5Khz 
Signal auch dann schon nicht da ist?

Was ist, wenn das Signal ausfällt und wiederkommt?


Ist die Reaktion deines Programmes dann richtig?

Im übrigen:
Ab in den Simulator und testen.
Programm auf einen µC brennen und testen.

Sorry. Aber so ist das nun mal. Die eigentliche Arbeit des 
Programmschreibens  sind vielleicht 40% eines kompletten Projektes. 
Testen ist ein wesentlicher integraler Bestandteil eines jeden 
Projektes. Und das gehört genauso zur Arbeit eines SW-Entwicklers dazu, 
dass man lernt, wie man so testet, dass man das rausfindet was man 
wissen will.

[patrick b. (calalex)]

Im Fall der Interrupt wird ausgelöst und der Port geschaltet...

ISR (TIMER1_COMPA_vect)
{
  PORTA |=(1<<PA0);          // falls kein Puls PA0 aktivieren
}

wie lange wird der Port geschaltet oder bleibt der dann aktiv?

kann man globale Interrupts mit sei(); auch erst nach einem Tastendruck 
aktivieren? oder ist das ungeschickt? Ich würde das Programm gern erst 
aktivieren, wenn man eine Button drückt.