Aprender

Interrupciones de temporizador en Arduino: Timer1 en un Uno, cada segundo

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: tres tareas a tres ritmos, cronometradas con millis()en vivo0.000 s 0.00x
Mantén presionado el botón
Cada lámpara mantiene su propio ritmo. Una interrupción de temporizador es la otra forma de hacer algo a tiempo.

Una interrupción de temporizador ejecuta una función tuya a un ritmo fijo, sin importar lo que esté haciendo loop(). En un Uno configuras uno de los tres temporizadores del chip para contar, le indicas cuándo detenerse y volver a empezar, y escribes la función con ISR(TIMER1_COMPA_vect). El temporizador 1 es la elección habitual: el temporizador 0 lleva millis() y delay(), y el 2 lleva tone().

El circuito de arriba hace tres tareas a tres ritmos de la otra forma, revisando millis() en loop(). Imprime "three rates, no delay" y luego cuánto tardó la pasada más lenta por loop(), y ese número explica por qué funciona: nada se bloquea. Una interrupción de temporizador es la herramienta para el día en que algo deba ocurrir a tiempo aunque loop() esté ocupado.

Abajo hay una interrupción de Timer1 que marca una vez por segundo, la suma detrás de sus números, un ritmo más rápido, la biblioteca TimerOne que hace las sumas por ti, y las cuatro formas en que falla, cada una ejecutada en un Uno con lo que imprimió.

¿Quieres la versión paso a paso? La lección "Timing without delay" recorre esto con puntos de control.

Abrir la lección

Timer1, una vez por segundo

El sketch de abajo configura el temporizador 1 para contar a 16 MHz dividido entre 1024, volver a 0 al llegar a 15624, y llamar al manejador cada vez que lo haga. El manejador cuenta e invierte el LED del pin 13. loop() imprime el conteo cuando cambia. Imprimió "tick 1 at 999", "tick 2 at 1999" y "tick 3 at 2999": un tick por segundo, al milisegundo.

Las líneas de setup en orden: limpia los dos registros de control, inicia la cuenta en 0, fija el tope en OCR1A, activa WGM12 para el modo CTC (contar hasta OCR1A y volver a 0), activa CS12 y CS10 para dividir entre 1024, y activa OCIE1A en TIMSK1 para encender la interrupción. noInterrupts() e interrupts() a su alrededor evitan que un temporizador configurado a medias se dispare.

Una interrupción de Timer1 cada segundo
volatile unsigned long ticks = 0;

ISR(TIMER1_COMPA_vect) {
  ticks++;
  digitalWrite(13, !digitalRead(13));
}

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  noInterrupts();
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  OCR1A = 15624;
  TCCR1B |= (1 << WGM12);
  TCCR1B |= (1 << CS12) | (1 << CS10);
  TIMSK1 |= (1 << OCIE1A);
  interrupts();
}

void loop() {
  static unsigned long shown = 0;
  noInterrupts();
  unsigned long now = ticks;
  interrupts();
  if (now != shown) {
    shown = now;
    Serial.print("tick ");
    Serial.print(now);
    Serial.print(" at ");
    Serial.println(millis());
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

La suma: de dónde sale 15624

OCR1A = reloj / (preescalador × frecuencia) − 1. El reloj del Uno es de 16,000,000 Hz; dividido entre 1024 el temporizador cuenta 15,625 veces por segundo; para una interrupción por segundo cuenta 15,625 pasos, de 0 a 15624. El −1 es porque el 0 también es un paso.

El temporizador 1 es de 16 bits, así que OCR1A puede llegar hasta 65535. Elige el preescalador más pequeño (1, 8, 64, 256 o 1024) que mantenga el resultado por debajo de ese valor. Para 1000 interrupciones por segundo, un preescalador de 64 da 16,000,000 / (64 × 1000) − 1 = 249: activa CS11 y CS10 en lugar de CS12 y CS10. Contado durante un segundo, ese sketch imprimió 1000.

Lo mismo con la biblioteca TimerOne

TimerOne hace el cálculo por ti: dale un período en microsegundos y una función. El sketch de abajo pide 500,000 µs e imprimió "tick 1 at 499", "tick 2 at 999", "tick 3 at 1500" y "tick 4 at 1999". La función sigue siendo un controlador de interrupciones, con las mismas reglas. MsTimer2 es la misma idea en el temporizador 2, en milisegundos: MsTimer2::set(500, flash) llamó a flash() tres veces en 1.55 segundos. El temporizador 2 también es el de tone(), así que un sketch usa uno u otro.

TimerOne, dos veces por segundo
#include <TimerOne.h>

volatile unsigned long ticks = 0;

void tick() {
  ticks++;
}

void setup() {
  Serial.begin(9600);
  Timer1.initialize(500000);
  Timer1.attachInterrupt(tick);
}

void loop() {
  static unsigned long shown = 0;
  noInterrupts();
  unsigned long now = ticks;
  interrupts();
  if (now != shown) {
    shown = now;
    Serial.print("tick ");
    Serial.print(now);
    Serial.print(" at ");
    Serial.println(millis());
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Leer lo que escribe el controlador

ticks is volatile, because the handler can change it between any two lines of loop(). Leave volatile out and a loop that waits for it can wait forever: while (ticks == 0) {} without it never ended, and "a second went by" never printed. The interrupts page shows the same with a button.

Un unsigned long ocupa 4 bytes y el Uno lo lee un byte a la vez, así que el controlador podría cambiarlo a mitad de una lectura. Por eso loop() lo copia entre noInterrupts() e interrupts(), lo que toma unos microsegundos y no pierde ningún tick. Un contador del tamaño de un byte no lo necesita.

Cuatro formas de que salga mal

analogWrite() en el pin 9 o el 10. El PWM de esos dos pines viene del temporizador 1, y analogWrite() fija OCR1A para su ciclo útil. Tras un tick en el primer segundo, analogWrite(9, 128) hizo que el conteo saltara: 121 ticks más en el segundo siguiente, porque el temporizador ahora contaba hasta 128. Usa los pines 3, 5, 6 u 11 para PWM en un sketch que use el temporizador 1. La biblioteca Servo de Arduino también corre sobre el temporizador 1 en un Uno, así que no uses ambas.

Un nombre de vector mal escrito. ISR(TIMER1_COMPA_vector) compiló sin ningún error y el conteo se quedó en 0: el chip nunca llama a una función con ese nombre. El nombre termina en _vect.

Demasiado dentro del controlador. Mientras corre, otras interrupciones esperan, incluida millis(). No llames a delay() ni imprimas desde ahí: pon una bandera o incrementa un contador, y haz el trabajo lento en loop().

Tocar el temporizador 0. Pertenece a millis(), delay() y al PWM de los pines 5 y 6. Cambia sus registros y cada delay del sketch cambia de duración.

Abre este circuito en el editor. Arduino Uno: tres tareas a tres frecuencias, cronometradas con millis(), conectado como corre al inicio de esta página. Cambia un componente o un valor y vuelve a ejecutarlo.

Preguntas

¿Cómo hago que un temporizador de Arduino interrumpa cada segundo?

En un Uno, pon el temporizador 1 en modo CTC con un preescalador de 1024 y OCR1A = 15624, habilita OCIE1A en TIMSK1 y escribe ISR(TIMER1_COMPA_vect). O usa la biblioteca TimerOne con Timer1.initialize(1000000).

¿Qué temporizador debo usar en un Arduino Uno?

El temporizador 1, el de 16 bits. El temporizador 0 corre millis() y delay(), y el temporizador 2 corre tone(). Usar el temporizador 1 cuesta el PWM de los pines 9 y 10.

¿Puedo usar delay() o Serial.print() en una interrupción de temporizador?

No. Ambos esperan a otras interrupciones, que quedan detenidas mientras corre la tuya. Pon una bandera volatile en el controlador y actúa en loop().

¿Un ESP32 usa los mismos registros de temporizador?

No. TCCR1A, OCR1A y TIMSK1 pertenecen al ATmega328P del Uno. Las placas ESP32 tienen sus propios temporizadores, configurados con las funciones de temporizador del núcleo en lugar de registros.

¿Cuál es la diferencia entre una interrupción de temporizador y millis()?

El cronometraje con millis() funciona solo mientras loop() sigue volviendo. Una interrupción de temporizador se dispara a tiempo aunque loop() esté atascado en una tarea lenta, a cambio de las reglas que todo controlador de interrupciones tiene.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.