INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA

MECÁNICA Y ELÉCTRICA

PRÁCTICA 11: FUNCIONES DE TEMPORIZACIÓN/CONTEO.

GRUPO: 5EM2 SECCIÓN: A EQUIPO: 2

MATERIA: ELECTRONICA III

DOCENTE:

DELGADO MENDOZA JOSE LUIS

MEMIJE GARDUÑO DANIEL

INTEGRANTES BOLETA
MEJÍA ROMERO ARMANDO 2020302845
KEVIN FLORES DE JESUS

ENTREGA: 25/06/2024
Contenido
MARCO TEÓRICO...................................................................................................................................... 4
PROCEDIMIENTO ...................................................................................................................................... 6
PRACTICA 11 A ...................................................................................................................................... 6
Código ................................................................................................................................................... 6
Simulación ............................................................................................................................................ 7
Implementación..................................................................................................................................... 8
PRACTICA 11B ....................................................................................................................................... 9
Código ................................................................................................................................................... 9
Simulación .......................................................................................................................................... 11
Implementación................................................................................................................................... 11
PRACTICA 11C ..................................................................................................................................... 12
Código ................................................................................................................................................. 12
Simulación .......................................................................................................................................... 13
PRACTICA 11D ..................................................................................................................................... 13
Código ................................................................................................................................................. 13
Simulación .......................................................................................................................................... 14
Implementación................................................................................................................................... 14
PRACTICA 11E ...................................................................................................................................... 15
Código ................................................................................................................................................. 15
Simulación .......................................................................................................................................... 17
Implementación................................................................................................................................... 18
PRACTICA 11F ...................................................................................................................................... 20
Código ................................................................................................................................................. 20
Simulación .......................................................................................................................................... 22
Implementación................................................................................................................................... 22
EVIDENCIA ............................................................................................................................................... 24
CONCLUSIONES ...................................................................................................................................... 30
Índice de imagenes
Imagen 1.Código práctica 11A .................................................................................................................... 6
Imagen 2. Simulación práctica 11a .............................................................................................................. 7
Imagen 3. Implementación 1 práctica 11a ................................................................................................... 8
Imagen 4. Implementación 2 práctica 11a ................................................................................................... 8
Imagen 5. Código práctica 11b .................................................................................................................... 9
Imagen 6. Simulación práctica 11b ............................................................................................................ 11
Imagen 7. Implementación 1 práctica 11b ................................................................................................. 11
Imagen 8. implementación 2 práctica 11b ................................................................................................. 11
Imagen 9. Código práctica 11c................................................................................................................... 12
Imagen 10. Simulación práctica 11c .......................................................................................................... 13
Imagen 11. Código práctica 11d ................................................................................................................ 13
Imagen 12. Simulación práctica 11d .......................................................................................................... 14
Imagen 13. Implementación 1 práctica 11d ............................................................................................... 14
Imagen 14. implementación 2 práctica 11d ............................................................................................... 15
Imagen 15. Código práctica 11e................................................................................................................. 15
Imagen 16. Simulación práctica 11e .......................................................................................................... 17
Imagen 17. Implementación 1 práctica 11e ............................................................................................... 18
Imagen 18. Implementación 2 práctica 11e ............................................................................................... 18
Imagen 19. Implementación 3 práctica 11e ............................................................................................... 19
Imagen 20. Código práctica 11f ................................................................................................................. 20
Imagen 21. Simulación práctica 11f........................................................................................................... 22
Imagen 22. Implementación 1 práctica 11f ................................................................................................ 22
Imagen 23. Implementación 2 práctica 11f ................................................................................................ 23
Imagen 24. Implementación 3 prácctica 11f .............................................................................................. 23
Imagen 25. Evidencia 1.............................................................................................................................. 24
Imagen 26. Evidencia 2.............................................................................................................................. 25
Imagen 27. Evidencia 3.............................................................................................................................. 26
Imagen 28. Evidencia 4.............................................................................................................................. 27
Imagen 29. Evidencia 5.............................................................................................................................. 28
Imagen 30. Evidencia 6.............................................................................................................................. 30
 MARCO TEÓRICO

¿Qué son las interrupciones?

Una interrupción es una señal que indica al procesador que debe pausar temporalmente la ejecución del
programa principal para atender un evento específico. Este evento puede ser generado por diferentes
fuentes, como hardware externo (botones, sensores) o interno (temporizadores, ADC).

Tipos de interrupciones

1. Interrupciones de hardware: Generadas por periféricos o dispositivos externos, como botones,

sensores, o señales de comunicación. Ejemplo: Un botón presionado genera una interrupción para
que el procesador registre la acción.
2. Interrupciones de software: Generadas por el propio programa para gestionar condiciones
especiales o errores.
3. Interrupciones internas: Generadas por eventos internos del microcontrolador, como el
desbordamiento de un temporizador o la finalización de una conversión ADC.

avr/io.h

La biblioteca avr/io.h es una parte fundamental del entorno de desarrollo AVR-GCC para
microcontroladores AVR de Atmel (ahora parte de Microchip Technology). Proporciona acceso
a todos los registros de entrada/salida (E/S)

Ejemplo:

• Definiciones de registros y bits:

Define todos los registros y bits específicos del microcontrolador, como PORTB, DDRB,
TCCR0B, TIMSK0, entre otros. Estas definiciones permiten que el código sea más legible y
portable.

• Configuración de puertos:

Permite configurar los puertos de E/S, como definir si un pin es de entrada o salida.

• Configuración de periféricos:
 Proporciona acceso a la configuración de periféricos internos del microcontrolador, como
temporizadores, contadores, ADC (Convertidor Analógico a Digital), USART
(Transmisión/Receptor Universal Sincrónico/Asincrónico), etc.

avr/interrupt.h

La biblioteca avr/interrupt.h proporciona un conjunto de macros y funciones para manejar

las interrupciones en microcontroladores AVR. Las interrupciones permiten que el
microcontrolador responda a eventos externos o internos (como el temporizador) sin tener que
consultar constantemente el estado de estos eventos en un bucle.

• Habilitación y deshabilitación de interrupciones:

Proporciona funciones para habilitar (sei()) y deshabilitar (cli()) las interrupciones

globalmente.

• Definición de rutinas de servicio de interrupción (ISR):

Permite definir las funciones que se ejecutarán cuando ocurra una interrupción específica. La
macro ISR(vector) se utiliza para declarar una rutina de servicio de interrupción.
 PROCEDIMIENTO
PRACTICA 11 A
Código

Imagen 1.Código práctica 11A

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

Estas bibliotecas incluyen las definiciones necesarias para manejar los registros de E/S y las
interrupciones del microcontrolador.

int main(){
// Configuración inicial
TCCR0B |= (1<<CS00 | 1<<CS02); // Prescaler a
TIMSK0 |= (1<< TOIE0); // Habilita el sobreflujo Reg:TOMSK0
sei(); // Función que habilita INT globales
DDRB |= (1<<PB0); // Configura PB0 como salida
PORTB &= ~(1<<PB0); // Asegura que PB0 comienza en bajo

while(1){
// Código principal que se ejecuta repetidamente
}

return 0;
}
 • TCCR0B |= (1<<CS00 | 1<<CS02); Configura el prescaler del temporizador 0. Esta
línea establece el prescaler a 1024, lo que significa que el temporizador contará a una
velocidad más lenta, permitiendo que la interrupción de sobreflujo ocurra a intervalos
más largos.
• TIMSK0 |= (1<<TOIE0);: Habilita la interrupción de sobreflujo del temporizador 0.
• sei();: Habilita las interrupciones globales.
• DDRB |= (1<<PB0);: Configura el pin PB0 como salida.
• PORTB &= ~(1<<PB0);: Asegura que el pin PB0 comience en bajo.

El while(1) es un bucle infinito que mantiene el programa en ejecución.

ISR(TIMER0_OVF_vect){
PORTB ^= (1<<PB0); // Alterna el estado del pin PB0
TIFR0 |= (1 << TOV0); // Limpia la bandera de interrupción de sobreflujo
}

• PORTB ^= (1<<PB0);: Alterna el estado del pin PB0. Si estaba en alto, lo pone en bajo y
viceversa. Esto crea un parpadeo en un LED conectado a PB0.
• TIFR0 |= (1 << TOV0);: Limpia la bandera de interrupción de sobreflujo del
temporizador 0 para permitir que la interrupción se dispare nuevamente.

Simulación

Imagen 2. Simulación práctica 11a

Implementación

Imagen 3. Implementación 1 práctica 11a

Imagen 4. Implementación 2 práctica 11a

PRACTICA 11B
Código

Imagen 5. Código práctica 11b

#include <avr/io.h>
#include <avr/interrupt.h>
#define LDT PD4

Estas bibliotecas proporcionan acceso a las definiciones y funciones necesarias para trabajar con
los registros de E/S y las interrupciones en microcontroladores AVR. #define LDT PD4 define
el pin PD4 como LDT para que sea más fácil de leer en el código.

int main() {
// Variables y configuraciones iniciales
uint8_t timerOverFlowCont = 0; // Contador de desbordamientos del
temporizador
DDRD = 0xFF; // Configura todo el puerto D como salida
TCNT0 = 0x00; // Inicializa el contador del
temporizador 0 en 0
 TCCR0B |= (1 << CS00 | 1 << CS02); // Configura el prescaler del
temporizador 0 a 1024

• uint8_t timerOverFlowCont = 0;: Define un contador de desbordamientos del

temporizador.
• DDRD = 0xFF;: Configura todos los pines del puerto D como salidas.
• TCNT0 = 0x00;: Inicializa el contador del temporizador 0 a 0.
• TCCR0B |= (1 << CS00 | 1 << CS02);: Configura el temporizador 0 con un prescaler
de 1024. Esto significa que el temporizador incrementará su valor cada 1024 ciclos del
reloj del sistema.

while ((TIFR0 & 0x01) == 0) {

// Reinicia el temporizador y limpia la bandera de interrupción
TCNT0 = 0x00;
TIFR0 = 0x01;

// Incrementa el contador de desbordamientos

timerOverFlowCont++;

// Si el contador alcanza 6, alterna el estado del pin LDT

if (timerOverFlowCont >= 6) {
PORTD ^= (0x01 << LDT); // Alterna el estado del pin PD4
timerOverFlowCont = 0; // Reinicia el contador
}
}

• while ((TIFR0 & 0x01) == 0): Este bucle se ejecuta mientras la bandera de
interrupción de desbordamiento del temporizador (TOV0) no esté establecida. Sin
embargo, la lógica parece incorrecta aquí ya que la bandera TOV0 debería ser revisada
fuera del bucle para una lógica correcta.
• TCNT0 = 0x00;: Reinicia el contador del temporizador a 0 en cada iteración.
• TIFR0 = 0x01;: Limpia la bandera de interrupción de desbordamiento del temporizador
estableciendo el bit TOV0.
• timerOverFlowCont++;: Incrementa el contador de desbordamientos del temporizador.
• if (timerOverFlowCont >= 6): Si el contador alcanza 6, alterna el estado del pin LDT
(PD4).
o PORTD ^= (0x01 << LDT);: Alterna el estado del pin PD4 (LDT).
o timerOverFlowCont = 0;: Reinicia el contador de desbordamientos.
Simulación

Imagen 6. Simulación práctica 11b

Implementación

Imagen 7. Implementación 1 práctica 11b

Imagen 8. implementación 2 práctica 11b

PRACTICA 11C
Código

Imagen 9. Código práctica 11c

TCCR0B = (1 << CS00) | (1 << CS02);

Configura el temporizador 0 en modo normal con un prescaler de 1024. Esto hace que el
temporizador cuente con una frecuencia reducida.

DDRB |= (1 << PB0);

Configura el pin PB0 (pin digital 8 en Arduino Uno) como salida.

while (1) {
TCNT0 = 0;
if ((milis += 10) >= RETARDO) {
// Cambia el estado del LED conectado a PB0
PORTB ^= (1 << PB0);
// Reinicia el contador de milisegundos
milis = 0;
}
_delay_ms(10); // Espera de 10 milisegundos
}
 • TCNT0 = 0;: Reinicia el contador del temporizador.
• milis += 10: Incrementa el contador de milisegundos en 10 milisegundos.
• if ((milis += 10) >= RETARDO): Cuando han pasado 1000 milisegundos, alterna el
estado del pin PB0, haciendo que el LED conectado parpadee.
• _delay_ms(10);: Espera de 10 milisegundos entre cada iteración del bucle para cumplir
con el intervalo deseado.

Simulación

Imagen 10. Simulación práctica 11c

PRACTICA 11D
Código

Imagen 11. Código práctica 11d

• TCCR1B = (1 << CS10) | (1 << CS12);: Configura el temporizador 1 en modo normal con un
prescaler de 1024.

• OCR1A = 1562;: Establece el valor de comparación para generar un retraso aproximado de 100 ms
(detallado más abajo).

• TCNT1 = 0;: Reinicia el contador del temporizador 1Simulación

• while ((TIFR1 & (1 << OCF1A)) == 0);: Espera hasta que se produzca un
desbordamiento del temporizador T1.
• PORTD ^= (1 << LDT);: Alterna el estado del pin PD5 utilizando la operación XOR para
alternar el bit.
• TCNT1 = 0;: Reinicia el contador del temporizador 1 para el próximo ciclo.
• TIFR1 |= (1 << OCF1A);: Limpia el indicador de desbordamiento del temporizador T1.

Simulación

Imagen 12. Simulación práctica 11d

Implementación

Imagen 13. Implementación 1 práctica 11d

 Imagen 14. implementación 2 práctica 11d

PRACTICA 11E
Código

Imagen 15. Código práctica 11e

#include <TimerOne.h>

const int led = 13; // Pin donde está conectado el LED

int ledState = LOW; // Estado inicial del LED (apagado)
volatile unsigned long blinkCount = 0; // Contador de parpadeos, definido
como volatile

• TimerOne.h: Se incluye esta biblioteca para configurar y manejar el temporizador.

• led: Se define como el pin digital 13 donde está conectado el LED.
• ledState: Variable para almacenar el estado actual del LED (HIGH o LOW).
• blinkCount: Contador de veces que el LED ha parpadeado, marcado como volatile
para indicar que puede cambiar en una interrupción.

void setup(void) {
pinMode(led, OUTPUT); // Configura el pin del LED como salida
Timer1.initialize(250000); // Inicializa el temporizador para
disparar cada 250 ms
Timer1.attachInterrupt(ISR_Blink); // Asocia la interrupción a la función
ISR_Blink
Serial.begin(9600); // Inicializa la comunicación serial a
9600 baudios
}

• pinMode(led, OUTPUT);: Configura el pin del LED (pin 13) como salida.
• Timer1.initialize(250000);: Inicializa el temporizador para interrumpir cada 250 ms
(1/4 de segundo).
• Timer1.attachInterrupt(ISR_Blink);: Asocia la función ISR_Blink como la rutina
de interrupción para el temporizador.
• Serial.begin(9600);: Inicia la comunicación serial a 9600 baudios para enviar datos a
la computadora.

void loop(void) {
unsigned long N; // Variable local para almacenar
blinkCount

digitalWrite(led, ledState); // Establece el estado del LED

(encendido o apagado)

noInterrupts(); // Deshabilita las interrupciones para

leer blinkCount de manera segura
N = blinkCount; // Realiza una copia de blinkCount
interrupts(); // Habilita las interrupciones
nuevamente

Serial.print("Ciclos = ");
Serial.println(N); // Imprime el valor actual de blinkCount
por el puerto serial

delay(100); // Espera 100 milisegundos

}

• digitalWrite(led, ledState);: Configura el estado del LED según ledState (HIGH

o LOW), alternando entre encendido y apagado.
 • noInterrupts(); y interrupts();: Deshabilita y luego habilita las interrupciones
alrededor de la lectura de blinkCount para evitar inconsistencias.
• Serial.print() y Serial.println(N);: Imprime el número de veces que el LED ha
parpadeado (blinkCount) a través del puerto serial.
• delay(100);: Espera 100 milisegundos entre cada iteración del bucle para reducir la
velocidad de impresión en serie y evitar sobrecargar el puerto serial.

void ISR_Blink() {
ledState = !ledState; // Invierte el estado del LED (lo apaga
si está encendido y viceversa)
blinkCount++; // Incrementa el contador de parpadeos
del LED
}

• ISR_Blink(): Esta función se ejecuta cada vez que el temporizador 1 genera una
interrupción.
• ledState = !ledState;: Alterna el estado del LED cada vez que se llama a la
interrupción, lo que hace que parpadee.
• blinkCount++;: Incrementa el contador blinkCount, registrando cuántas veces ha
parpadeado el LED.

Simulación

Imagen 16. Simulación práctica 11e

Implementación

Imagen 17. Implementación 1 práctica 11e

Imagen 18. Implementación 2 práctica 11e

Imagen 19. Implementación 3 práctica 11e
PRACTICA 11F
Código

Imagen 20. Código práctica 11f

unsigned long elapsedTime, previousTime;

•
• elapsedTime: Almacena el tiempo transcurrido desde la última ejecución de la función
onTimer().
• previousTime: Guarda el tiempo anterior, utilizado para calcular elapsedTime.

void onTimer() {
static boolean state = HIGH;
elapsedTime = millis() - previousTime;
Serial.print(F("Set LED 13 : "));
 if (state) {
Serial.print(F("ON"));
} else {
Serial.print(F("OFF"));
}
Serial.print(F(" - "));
Serial.print(elapsedTime);
Serial.println(F("ms"));
digitalWrite(13, state);
state = !state;
previousTime = millis();
}

• state: Variable estática que alterna entre HIGH y LOW, controlando el estado del LED.
• elapsedTime: Calcula el tiempo transcurrido desde la última vez que se ejecutó
onTimer().
• Imprime mensajes en serie que indican el estado del LED (ON o OFF) y el tiempo
transcurrido.
• digitalWrite(13, state): Cambia el estado del LED en el pin 13 según state.
• previousTime = millis(): Actualiza previousTime con el tiempo actual para el
próximo ciclo.

void setup() {
Serial.begin(9600);
pinMode(13, OUTPUT);
cli(); // Deshabilita todas las interrupciones
TCCR2A = (1 << WGM21) | (0 << WGM20); // Modo CTC
TIMSK2 = (1 << OCIE2A); // Habilita la interrupción local OCIE2A
TCCR2B = (0 << WGM22) | (1 << CS22) | (1 << CS21); // Frecuencia 16Mhz /
256 = 62500
OCR2A = 250; // 250 * 125 = 31250 = 16Mhz / 256 / 2
sei(); // Habilita todas las interrupciones
}

• Serial.begin(9600): Inicia la comunicación serial a 9600 baudios para la salida de

mensajes.
• pinMode(13, OUTPUT): Configura el pin 13 como salida para controlar el LED.
• cli(): Deshabilita todas las interrupciones antes de configurar el temporizador.
• TCCR2A, TIMSK2, TCCR2B: Configuran el Timer2 para funcionar en modo CTC (Clear
Timer on Compare Match) y establecen el prescaler a 256.
• OCR2A: Establece el valor de comparación para generar una interrupción cada 500 ms
aproximadamente.
• sei(): Habilita todas las interrupciones después de configurar el temporizador.

ISR(TIMER2_COMPA_vect) {
static int counter = 0;
if (++counter >= 125) { // 125 * 4 ms = 500 ms
 counter = 0;
onTimer(); // Llama a la función onTimer() cada 500 ms
}
}

• Esta función se ejecuta cada vez que el temporizador Timer2 alcanza el valor de
comparación (OCR2A).
• counter: Contador utilizado para contar las interrupciones y determinar cuándo llamar a
onTimer().
• Llama a onTimer() cada 500 ms aproximadamente (cada 125 veces que se llama esta
función).

• El bucle loop() está vacío porque la lógica de parpadeo del LED y la gestión del tiempo se
realiza a través de las interrupciones del temporizador

Simulación

Imagen 21. Simulación práctica 11f

Implementación

Imagen 22. Implementación 1 práctica 11f

 Imagen 23. Implementación 2 práctica 11f

Imagen 24. Implementación 3 prácctica 11f

este código configura el Timer2 del Arduino Uno para generar interrupciones periódicas cada 500 ms.
Cuando se produce una interrupción, se llama a la función onTimer(), que cambia el estado del LED en
el pin 13 y muestra mensajes en serie sobre el estado del LED y el tiempo transcurrido desde la última
ejecución. Este método utiliza interrupciones para permitir que el programa principal (loop()) funcione
de manera eficiente sin esperar activamente en un bucle de retardo.
EVIDENCIA

Imagen 25. Evidencia 1

Imagen 26. Evidencia 2
Imagen 27. Evidencia 3
Imagen 28. Evidencia 4
Imagen 29. Evidencia 5
 Imagen 30. Evidencia 6

CONCLUSIONES

Mejía Romero Armando:

En esta práctica de laboratorio, exploramos el uso de temporizadores y interrupciones

en Arduino Uno mediante varios códigos. A través de estos ejemplos, aprendimos a
configurar temporizadores como Timer0 y Timer1 para generar interrupciones periódicas,
controlando acciones repetitivas con precisión de tiempo. Implementamos interrupciones
para mejorar la eficiencia del código, permitiendo que ciertas acciones se ejecuten de
manera asíncrona y sin bloquear el flujo principal del programa. Utilizamos LEDs para
visualizar cambios en el estado del sistema y la comunicación serial para monitorear y
depurar el comportamiento del programa. Esta práctica nos preparó para proyectos que
requieren precisión temporal y eficiencia en el uso de recursos

De Jesús flores Kevin:

A través de esta práctica, adquirimos una comprensión profunda de cómo configurar y

utilizar temporizadores y contadores para controlar eventos y medir intervalos de tiempo
con precisión. Implementamos varios ejemplos que nos permitieron generar señales
periódicas, medir duraciones y contar eventos externos, utilizamos LEDs y la
comunicación serial para visualizar y verificar el comportamiento de los temporizadores
y contadores, lo que nos permitió depurar y optimizar nuestras implementaciones. Esta
práctica nos proporcionó habilidades esenciales para el diseño y desarrollo de sistemas
que requieren una gestión precisa del tiempo y una respuesta rápida a eventos