Tutorial de temporizador Arduino

Los temporizadores son una característica esencial de los microcontroladores, lo que le permite realizar tareas a intervalos precisos sin depender de demoras. El Arduino UNO tiene tres temporizadores de hardware incorporados (Timer0, Timer1 y Timer2) que se pueden configurar para varias funciones como la generación de señales PWM, eventos de tiempo o tareas de programación. Este tutorial lo guiará a través de la comprensión y el uso de los temporizadores de Arduino.

Lo que necesitarás

1. Arduino Uno (o una placa compatible)
2. LED y resistencia de 220 ohmios (para ejemplos basados ​​en el tiempo)
3. Cables de placa y jersey
4. Arduino IDE instalado en su computadora

Paso 1: Comprensión de los temporizadores de Arduino

El microcontrolador ATMEGA328P de Arduino Uno tiene tres temporizadores de hardware:

Características clave de los temporizadores

• Los temporizadores pueden generar señales PWM.
• Los temporizadores pueden activar interrupciones.
• Los temporizadores se utilizan internamente mediante funciones de Arduino como delay() y millis().

Paso 2: Generación de una señal PWM simple

Las señales PWM (modulación de ancho de pulso) se usan comúnmente para controlar el brillo del LED o la velocidad del motor. Usemos Timer0 para crear una señal PWM.

Código de ejemplo: control de brillo LED con PWM

#define ledPin 6 // Pin 6 uses Timer0 for PWM

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness); // Increase brightness
    delay(10);
  }

  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness); // Decrease brightness
    delay(10);
  }
}

Paso 3: Uso de temporizadores con interrupciones

Puede configurar temporizadores para activar interrupciones a intervalos regulares. Por ejemplo, Timer1 se puede configurar para alternar un LED cada segundo.

Código de ejemplo: Timer1 Interruption

#define ledPin 13 // Built-in LED

void setup() {
  pinMode(ledPin, OUTPUT);

  // Configure Timer1
  noInterrupts(); // Disable interrupts during setup
  TCCR1A = 0;     // Clear Timer1 control registers
  TCCR1B = 0;
  TCNT1 = 0;      // Initialize counter value to 0

  OCR1A = 15624;  // Compare match register (1Hz at 16MHz with 1024 prescaler)
  TCCR1B |= (1 << WGM12); // CTC mode
  TCCR1B |= (1 << CS12) | (1 << CS10); // 1024 prescaler
  TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

  interrupts(); // Enable interrupts
}

ISR(TIMER1_COMPA_vect) {
  digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED
}

void loop() {
  // Main loop does nothing; timer handles the LED
}

Paso 4: tiempo de medición con temporizadores

Puede usar temporizadores para medir duraciones precisas. Timer2 es adecuado para intervalos pequeños porque es un temporizador de 8 bits.

Código de ejemplo: Timer2 para la medición del tiempo

volatile unsigned long overflowCount = 0;

void setup() {
  Serial.begin(9600);

  // Configure Timer2
  noInterrupts();
  TCCR2A = 0;
  TCCR2B = 0;
  TCNT2 = 0;

  TCCR2B |= (1 << CS22); // Prescaler 64
  TIMSK2 |= (1 << TOIE2); // Enable Timer2 overflow interrupt

  interrupts();
}

ISR(TIMER2_OVF_vect) {
  overflowCount++;
}

void loop() {
  unsigned long timeElapsed = overflowCount * 16.384; // Each overflow = 16.384ms
  Serial.print("Time elapsed: ");
  Serial.print(timeElapsed);
  Serial.println(" ms");
  delay(1000);
}

Paso 5: Uso de bibliotecas de temporizador

Para simplificar el trabajo con temporizadores, puede usar bibliotecas como Timerone o TimerThree.

Usando la biblioteca de TimerOne

1. Instale la biblioteca de TimerOne en el IDE Arduino.
2. Úselo para programar tareas fácilmente:

#include <TimerOne.h>
#define ledPin 13

void toggleLED() {
  digitalWrite(ledPin, !digitalRead(ledPin));
}

void setup() {
  pinMode(ledPin, OUTPUT);
  Timer1.initialize(1000000); // Set timer to 1 second (1,000,000 microseconds)
  Timer1.attachInterrupt(toggleLED); // Attach the interrupt function
}

void loop() {
  // Main loop does nothing; Timer1 handles the LED
}

Aplicaciones de temporizadores

1. Generación de señales PWM precisas para el control del motor
2. Programación de tareas sin código de bloqueo (por ejemplo, multitarea)
3. Medición de intervalos de tiempo para eventos
4. Creando retrasos precisos sin usar delay()
5. Gestionar acciones periódicas como LED parpadeantes o enviar datos

Solución de problemas

• Conflictos de temporizador: Asegúrese de no utilizar el mismo temporizador para múltiples funciones (por ejemplo, Servo Library y PWM).
• Las interrupciones no funcionan: Verifique que las interrupciones estén habilitadas con interrupts().
• Comportamiento inesperado: Verifique el prescalor de doble verificación y compare los valores de coincidencia para el tiempo correcto.

Conclusión

Has aprendido a usar temporizadores de Arduino para generar señales PWM, manejo de interrupciones y medir el tiempo. Mastering Timers desbloquea características potentes para crear proyectos Arduino eficientes y precisos. ¡Experimente con diferentes configuraciones y aplique temporizadores para optimizar su próximo proyecto!