Posticipo segnale d'ingresso al variare della frequenza dello stesso

International Italiano Generale
21

Stai prendendo il codice nel modo giusto...cioè come "spunto" e un "punto di partenza" per un approfondimento e una tua personale personalizzazione (non voleva essere un codice pronto all'uso).
Fai bene a usare il timer2, in modalità CTC. Per il valore del contatore basta usare TCNT2, dato che è un registro a 8 bit.
Per il resto segui il consiglio di Lesto riguardante la "bibbia" dell'ATMega328.

se non erro puoi invece impostare il valore di overflow: questa tecnica è più pulita. Mettiamo il caso in cui perdi un interrupt dal timer perchè facevi altro, dato che non risetti il valore di partenza, che ripartirà da 0, non solo avrai perso un interrupt ma anche il prossimo verrà generato in modo erroneo

Si, a lui conviene usare la modalità CTC che è facilmente ottenibile cambiando leggermente i registri del timer e praticamente non cambia il principio di funzionamento del sistema. Indubbiamente rende la tecnica più pulita in quanto non si deve ripristinare il valore iniziale. Sul "perdi un interrupt", invece, avrei quache perplessità, dato che solitamente è l'interrupt che interrompe qualcosa e non viceversa, e in un tipo di sistema come quello in oggetto sarà difficile che ci siano altri interrupt concorrenti.

mamma mia, mi usate i registri per impostare l'interrupt (quando attachInterrupt anadava più che bene)...

Che ti devo dire...volendo sorvolare sui quasi 200byte che l'istruzione attachInterrupt si "mangia" allegramente, usando direttamente il port mapping per settare il timer mi sembrava quasi una "stonatura" usare un'istruzione wiring...ma queste sono fissazioni mie :slight_smile:

22

Si l'idea del timer2 in CTC mi sembrava migliore. Ho già la bibbia e mi sto documentando ma ad esempio provando a scrivere il codice con timer2 posso generare un pwm in uscita sul pin11 ma non riesco a far partire il timer quando voglio e a fermarlo quando voglio.

23

dalubar:
. Sul "perdi un interrupt", invece, avrei quache perplessità, dato che solitamente è l'interrupt che interrompe qualcosa e non viceversa, e in un tipo di sistema come quello in oggetto sarà difficile che ci siano altri interrupt concorrenti.

difficile ma non impossibile, sopratutto se fai funzioni ISR troppo lunghe, o hai interrupt con frequenze troppo alte, o parli spesso via seriale (funziona ad interrupt), o usi PWM, o il timer1 che aggiorna la micros (e quindi la millis), etc.. non è così impossibile perdere un interrupt per concorrenza

24

i pin PWM usano i timer, certi pin un timer altri un altro. vedi "la bibbia" :slight_smile:

25

il codice per il timer2 è questo

#define ledPin 11
int val=0;
void setup()
{
  pinMode(ledPin, OUTPUT);
  
  //timer2 
  noInterrupts();           // disable all interrupts
  TCCR2A = 0;
  TCCR2B = 0;
  TCNT2  = 0;

  OCR2A = 100;            // compare match register 
  TCCR2B |= (1 << WGM22);   // CTC mode
  TCCR2B |= (1 << CS21);    // 32 prescaler 
  TCCR2B |= (1 << CS20);
  TCCR2B &= ~(1 << CS22);
  TIMSK2 |= (1 << OCIE2A);  // enable timer compare interrupt
  interrupts();             // enable all interrupts
}

ISR(TIMER2_COMPA_vect)          // timer compare interrupt service routine
{
  val=!val;
  digitalWrite(ledPin, val);   // toggle LED pin
 
}

void loop()
{

}

Il problema è che cambiando il valore di OCR2A non cambia la durata della forma d'onda. e poi comunque vorrei che una volta raggiunto il valore, dentro ISR(TIMER2_COMPA_vect) si generi il segnale di uscita e si fermi il timer per poi riprendere all'arrivo di un nuovo fronte del segnale d'ingresso con il nuovo delay settato. Ma in OCR2A il valore caricato cosa è un intero? cosa rappresenta?

26

Ora hai il libro della "conoscenza"...usalo! :slight_smile:

difficile ma non impossibile, sopratutto se fai funzioni ISR troppo lunghe...

Si, Lesto, mi trovi d'accordissimo in tutto ciò che hai detto...solo che io mi riferivo specificamente al "suo" caso, cioè non credo che la sua applicazione contempli dialoghi con la seriale. Ovvio che dovendo performare il tutto per lo scopo prefissato si prenderanno tutte le (normali) precauzioni che si hanno quando si scrivono handler interrupt: ovvero poche istruzioni, uso minimo di registri, etc.
Per il millis, in verità ero convinto che Arduino gestisse uno stack interrupt...ma forse ricordo male io. Anzi se hai qualche notizia certa in merito ti sono grato :slight_smile:

27

Ci sono dietro da un bel pò ma non ci capisco. E' la prima volta che mi imbatto nei timer, ho bisogno di una bella spinta :~

28

Nella modalità CTC il timer viene azzerato ogni volta che il valore del contatore TCNT2 raggiunge un particolare registro denominato, appunto, OCR2A.
E' come se l'hw del micro eseguisse una istruzione del tipo:
if (TCNT2 == OCR2A) ISR(TIMER2_COMPA_vect)
OCR2A, quindi, definisce il valore TOP per il contatore (0xFF).

29

Ok chiaro, ma nel codice che ho postato non mi cambia il duty cycle della forma d'onda cambiando il valore di quel registro, perchè?
E comunque se volessi fare che una volta raggiunto il conteggio, nella chiamata alla ISR addetta volessi stoppare la ripartenza del conteggio?

Perchè lui poi riparte da zero, invece io voglio che riparta solamente quando glielo dico io.

30

Ok chiaro, ma nel codice che ho postato non mi cambia il duty cycle della forma d'onda cambiando il valore di quel registro, perchè?

Non può cambiare il duty cycle per il semplice fatto che la modalità CTC NON è una modalità PWM. Quindi otterrai sempre e solo periodi al 50%.

...io voglio che riparta solamente quando glielo dico io.

Allora si ritorna al sistema precedente, ovvero CTC + INT0

31

ekjk:
Perchè lui poi riparte da zero, invece io voglio che riparta solamente quando glielo dico io.

se vuoi che NON riparta allora usa una flag, che se a 0 non esegui il codice nella isr....

32

Nel codice che ho postato quindi come faccio ad impostare il flag?
il flag di compare che si attiva quando il conteggio è finito è OCF2A e sulla bibbia c'è scritto che per resettarlo si può fare manualmente impostando un bit di I/O ad 1, altrimenti di default viene resettato automaticamente.
Non ho capito se questo flag va a 1 o a 0 una volta raggiunto il conteggio. Ma se si resetta automaticamente comunque come posso farlo io solamente quando voglio far riprendere il conteggio da zero?

Qual'è la soluzione migliore quindi tra l'overflow variabile e il CTC?

Intendevo usare il timer2 perchè avendo 8 bit ottengo valori più piccoli di conteggio, il timer0 invece andrebbe ad incasinare le funzioni tipo millis che uso nel loop o no?
Un contatore vale l'altro in questo caso credo.
Potete abozzare una copia di codice perchè possa capire meglio??

Grazie

33

Nel mentre ho provato anche l'ultima soluzione di dalubar: sul pin 2 ho messo una onda quadra dal generatore di funzioni, così ad ogni fronte di salita il timer 1 parte. nella funzione di gestione dell'interrupt di overflow faccio una digitalwrite sul pin13 in modo da portare alto il segnale d'uscita e subito dopo scrivo uno zero, solo per provare con l'oscilloscopio. il comportamento è questo: avendo settato i CSxx per avere un prescaler di 64, e quindi step di 4us, se voglio far contare al timer 100us di delay, fino a che non va in overflow occorre che parta dal 65486, in hex FFCE, che carico nei registri.
Il risultato è che non ho nessun delay, o meglio circa 12us ma ci sarebbero comunque dovuti ai ritardi del micro.

Perchè?

Effettivamente l'impulso viene generato ogni fronte di salita del pin2 ma non viene ritardato di 100us come voglio.

34

non puoi ferare un timer. come ti ho detto devi usare un flag, ovvero una variabile booleana. quanto il timer va in overflow e la flag è falsa non fai nulla. Quindi quando leggi un fronte di salita azzeri il timer e metti la flag a true.

35

Scusa ma sono un elettronico cocciuto! :astonished:
Stai parlando del codice di dalubar o di quello con il timer 2?

Non capisco il tuo ragionamento.

Questo è il codice di dalubar rivisto, dato che uso già il pin3 come interrupt per generare un impulso ritardato di 100us dal primo fronte di salita.
il contatore parte da 65536-200 in hex FF38, però il ritardo non è generato.
Cosa sbaglio?

volatile boolean isTimerOn;


void setup() {
  pinMode(11, OUTPUT);
  
attachInterrupt(1, ingresso, RISING); 
  
  /* Gestione Timer1 in Overflow per generare il delay sull'impulso */
  TIMSK1 &= ~(1<<TOIE1);    // Timer disattivato
  TCCR1A &= ~((1<<WGM11) | (1<<WGM10));  
  TCCR1B &= ~((1<<WGM12) | (1<<WGM13));      
  TIMSK1 &= ~(1<<OCIE1A);  
  
  /* PRESCALER (secondo l'uso)
     qui 8
  */  
  TCCR1B |= (1<<CS11); 
  TCCR1B &= ~(1<<CS10); 
  TCCR1B &= ~(1<<CS12);   
  
}

/* Fronte di salita ricevuto...Fa partire Timer per delay */
void ingresso() {
   if (!isTimerOn) {
      // Imposta delay desiderato...da prelevare da una tabella di valori pronta (lookup)
      TCNT1H = 0xFF;  
      TCNT1L = 0x38;
      TIMSK1 |= (1<<TOIE1); 
      
      isTimerOn = true;

  }
}

/* Overflow timer */
ISR(TIMER1_OVF_vect) {  
  TIMSK1 &= ~(1<<TOIE1);  // ferma Timer1  
  TCNT1H = 0xFF;  
  TCNT1L = 0x38;
  isTimerOn = false;


  digitalWrite(11, HIGH);
  digitalWrite(11, LOW);
}


void loop()
{}

Così ad ogni fronte di salita genero un impulso sul pin 11 ok, però non viene ritardato assolutamente!

36

scusami, io non sono ferrato sui timer, e magari sbaglio ma...
se hai 16.000.000 clock al secondo, e ogni clock è un +1 sul registro timer, 200clock/16.000.000clock/sec = 0,0000125 sec pari a 0,0125 millisecondi, pari a 12,5 microsecondi, non 100 come li vuoi tu. per averne 100 devi attendere circa 2000clock (F830)

37

Ho provato come dici tu ma non cambia nulla, ho sempre quei 15us di delay fissi.

Io ho seguito la guida di dalubar che dice:

prescaler=8 -> 16000000/8=2000000 Hz
periodo richiesto = 100us -> 100us/1/2000000=200

16Bit risoluzione timer1 -> 65536-200=65336 -> valore iniziale di conteggio del timer per arrivare in overflow dopo 100us e generare questo benedetto delay.

O sbaglio qualcosa nel codice oppure ci deve essere un trucco.
Fatemi sapere, grazie.

38

ah giusto, non ho tenuto conte del prescaler. sicuro di settarlo giusto?

TCCR1A e TCCR1B cosa sono (non ho il manuale sottomano)?

perchè prima fai
TCCR1A &= ~((1<<WGM11) | (1<<WGM10));
TCCR1B &= ~((1<<WGM12) | (1<<WGM13));
e poi

TCCR1B |= (1<<CS11);
TCCR1B &= ~(1<<CS10);
TCCR1B &= ~(1<<CS12);

39

TCCR1A e TCCR1B sono i timer counter control register e il primo contiene WGM11 e WGM10 mentre il secondo WGM12 ed i CSx.

Non so perchè li faccia prima dalubar, il codice è il suo, io sto cercando di apprendere da quel codice.
Secondo te c'è differenza?

40

Per ridurre la frequenza di aggiornamento del contatore si usa il prescaler, altrimenti con un registro ad 8 bit ed un clock a 16 MHz si va da poche parti :wink: