Universidad Autónoma de Ciudad Juárez

Instituto de Ingeniería y Tecnología

Medición del ciclo de trabajo de una

señal modulada en ancho de pulso
“Practica 4”

Nombres:
• Kelvyn Alexis Alba Pérez
• Sebastián Serrano Márquez
Materia: Instrumentación electrónica
Grupo: A
Maestro(a): Juan de Dios Cota Ruiz
1
Fecha: miércoles 30 marzo del 2022
 Índice
Portada ------------------------------------------------------------------------------------------------ Pág. 1
Objetivo ----------------------------------------------------------------------------------------------- Pág. 3
Material y/o equipo utilizado --------------------------------------------------------------------- Pág. 3
Introducción ------------------------------------------------------------------------------------------ Pág. 4
Marco teórico ---------------------------------------------------------------------------------------- Pág. 4
• ¿Qué es el PWM? ------------------------------------------------------------------------ Pág. 4
• Arduino PWM con Arduino UNO------------------------------------------------------- Pág. 5
• ¿Qué son los flancos de subida o de bajada? ------------------------------------- Pág. 5
• Los contadores internos del timer----------------------------------------------------- Pág. 6
Metodología ------------------------------------------------------------------------------------------ Pág. 6
• Desarrollo experimental ------------------------------------------------------------------ Pág. 6
Resultados ------------------------------------------------------------------------------------------ Pág. 11
• Código en Arduino para estimar el valor resistivo ------------------------------- Pág. 11
• Explicación del código empleado ---------------------------------------------------- Pág. 13
• Conexiones de los componentes en proteus y programa funcionando ----- Pág. 13
Conclusiones --------------------------------------------------------------------------------------- Pág. 18
Bibliografía ------------------------------------------------------------------------------------------ Pag .18

2
 Objetivo
• Analizar y entender el funcionamiento de cómo funciona el sistema de reloj
interno de los timers del microcontrolador ATMEGA328 para medición del ciclo
de trabajo
Material y/o equipo utilizado
• Computadora/laptop
• Software PROTEUS
• HARDWARE
➢ Simulino UNO
➢ Resistencja de 10K
➢ Lampara de CD de 12v
➢ PushButtons
➢ Generador de funciones
➢ Osciloscopio

3
 Introducción
En esta práctica se realizará la estimación del ciclo de trabajo de una determinada
frecuencia, además se tendrá que hacer la modificación de un código que solamente
calcula filos de subida. Con ayuda de varios pasos que se tienen que seguir el principal
objetivo es estimar de la manera más acertada en porcentaje del duty-cycle, así como la
correcta programación del código. Se explicará el código empleado, así como las
modificaciones que se hicieron. Cabe recalcar que no se tenia el conocimiento de toda
la terminológica que conlleva el código. Hubo la necesidad de realizar una investigación
aparte para conocer los términos y su funcionamiento. Es el primer acercamiento al tema
de los duty-cycles y es una buena practica para complementar lo adquirido en tema de
simulación de Arduino en proteus con la implementación del código elaborado en
Arduino. Ya se tenía conocimiento en cuanto a la relación entre la frecuencia y el periodo,
mas no se había aplicado explícitamente en el código en Arduino. Es interesante el ver
el funcionamiento en conjunto de todos estos componentes y conocimientos adquiridos
en esta y en otras materias.

Marco teórico
¿Qué es el PWM?
Para empezar, se muestran las definiciones para entender el Arduino PWM. PW es pulse
width (ancho de pulso) representa el ancho del pulso, en función al periodo de la señal
tiempo donde el periodo representa el tiempo en el que se repite dicha señal. Usualmente
ta se define como el tiempo en alto y T como el periodo.
La frecuencia se define como la cantidad de veces que una señal periódica se repite en
un segundo. Se mide en Hertz y es inversamente proporcional al periodo (T). De esta
manera su expresión matemática es la inversa del periodo:
Frecuencia= 1/T
Asi pues, es una señal digital muy usada para controlar el valor promedio de un voltaje
de una señal cuadrada. De esta manera, si hay un voltaje analógico constante y se divide
en pulsos variando el ancho de pulso; el valor promedio del voltaje puede modificarse.
También hay otro concepto el ciclo de trabajo, el cual debe tener presente cuando habla
de la función Arduino PWM. Ademas el ciclo de trabajo (Duty Cycle en inglés), se mide
en porcentaje y describe el periodo de tiempo que una señal digital se encuentra en alto;
en función del tiempo.

Arduino PWM con Arduino UNO

El Arduino PWM es una función para implementar la modulación de ancho de pulso con
nuestra placa Arduino UNO. En este tutorial, se verá una aplicación básica regulando la

4
intensidad de un LED. Recordemos que la modulación de ancho de pulso o PWM es la
variación del tiempo en alto de una señal cuadrada respecto a su periodo. Usualmente
se mide en porcentaje (%). Existen diferentes maneras de generar señales PWM con
Arduino, entre las más convencionales están, por software y mediante el módulo de
PWM. Por software, usualmente es con retardos, esperando un determinado tiempo y
conmutando el estado del pin. Con el módulo es usando los registros del temporizador.
Arduino PWM ya gestiona el uso de los módulos para proveer la señal PWM de acuerdo
con nuestras necesidades con una simple instrucción.

Figura 1 Duty-cycle al 25%

¿Qué son los flancos de subida o de bajada?

El flanco de subida consiste en el cambio de una señal nivel bajo a un nivel alto, por el
contrario, el flanco de bajada es el cambio de un nivel alto a uno bajo, es realmente
importante conocer estos conceptos si programamos autómatas o electrónica, incluido
el famoso Arduino.

Figura 2 Flancos de subida y de bajada

5
Los contadores internos del timer
Los Arduinos UNOS y MEGAs tienen un cristal que bate a 16 MHz, o 16.000.00 de
veces por segundo.
Teóricamente se puede fijar una interrupción cada 1/16000000 segundos, lo que no
sería muy útil porque cada instrucción de Arduino necesita varios pulsos de reloj para
ejecutarse (y algunos muchos pulsos).
Por eso cada Timer dispone de un registro interno que indica cada cuantos ticks del
reloj debe dispararse. Básicamente el que nos interesa es un Timer cuyo registro es un
entero sin signo de 16 bits, lo que le permite contar hasta 2 16 = 65.536
Si este contador se disparase cada tick del cristal, no nos serviría de mucho porque, el
máximo tiempo que el contador podría abarcar sería de:

Metodología
A continuación, se mostrarán los pasos que se siguieron para poder obtener el resultado
esperado:

Desarrollo experimental

PARTE 1. Generación de una salida modulada en ancho de pulso variable

1.- Armar el circuito generador PWM (Pulse Width Modulation) mostrado en la Figura No.
1 en PROTEUS. Deberás utilizar los componentes que se muestran en la Tabla 1. Como
se aprecia en la figura, la salida PWM es generada en el pin 9 (OC1A), el cual controla

6
la cantidad de potencia que se le aplica a una lampara de corriente directa de 12V por
medio de un MOSFET como driver.

D L1
12V

SIM1

V1
12v
Q1
AREF 2N7000
13
13
12

ARDUINO
RESET 12
11
R1
~11 10k
10
5V ~10
9
~9
8

SIMULINO
POWER

8
GND
BTN1
ATMEGA328P

DIGITAL (PWM~)
7
6
~6 BUTTON
ATMEL

A0 5
ANALOG IN

A0 ~5
A1 4
A1
A2
A2 ~3
4
3 BTN2
A3 2
A3 2
A4 1
A4 TX > 1 BUTTON
A5 0
A5 RX < 0
www.arduino.cc
blogembarcado.blogspot.com
SIMULINO UNO

RXD

TXD

RTS

CTS

Figura 1. Circuito generador PWM con incremento/decremento controlado externamente.

2.- En la Figura 1 se muestra también dos push-buttons configurados como entradas

en las patillas 5 y 7 para el incremento y decremento del duty-cycle, respectivamente.
Como se aprecia en el código de la Figura 2, el ciclo de trabajo (Duty-cycle)
básicamente es controlado por el valor del registro OC1A el cual es de 10 bits de
resolución, por lo que su valor deberá estar entre 0 y 1023 para un ciclo de trabajo del
0 al 100%, respectivamente. El comportamiento del duty cycle se puede observar
visualmente en el canal A del osciloscopio y en la salida del Serial Monitor una vez que
se corre el programa en PROTEUS. Por ejemplo, para un valor de OCR1A=512, la
señal PWM tendrá un ciclo de trabajo (CT) de 𝐶𝑇 = (𝑂𝐶𝑅1𝐴⁄1023) ∗ 100 = 50%.

7
PARTE 2. Medición de frecuencias cuadradas utilizando el sistema “Input Capture”
del timer1 del Arduino UNO.

1.- Armar el circuito medidor de frecuencias mostrado en la Figura No. 2 en PROTEUS.

Como se aprecia, deberás utilizar un osciloscopio (oscilloscope), un generador de
funciones (Signal generator) y un terminal serial (Virtual terminal).

RXD

TXD

RTS

CTS
13
12

10
11

9
8

7
6
5
4
3
2
1
0

SIM2
RX < 0
13
12

~10
~9
8

7
~6
~5
4
~3
2
TX > 1
AREF

~11

SIMULINO UNO
+
DIGITAL (PWM~)

SIMULINO
blogembarcado.blogspot.com

ARDUINO -
AM FM
www.arduino.cc

ATMEGA328P
ATMEL

POWER
RESET

ANALOG IN
GND

A0
A1
A2
A3
A4
A5
5V

A0
A1
A2
A3
A4
A5

Ilustración 1

3.- Se deberá configurar el generador de funciones para generar un voltaje TTL a una
frecuencia de 2.9KHz como lo muestra la Figura 3.

Ilustración 2

4.- Una vez que se le grabe el código al Arduino se deberá correr y observar el despliegue
de la frecuencia estimada por el sistema como lo muestra la Figura 4.

8
 Figura 4. Estimación de la frecuencia introducida en el pin 8 del Arduino con un generador de funciones.

5.- El sistema detecta filos de subida (rising edge), en el pin 8, donde por cada filo de
subida se genera una interrupción (ISR(TIMER1_CAPT_vect)), la cual que básicamente
captura el valor del contador del timer en X1 y X2, el cual tiene como frecuencia de
referencia un cristal de 16MHz. Por lo que al detectar dos filos de subida consecutivos
se puede medir el tiempo transcurrido entre los dos filos de subida (periodo de la señal
del pin 8) 𝑇 = (𝑋2 − 𝑋1)⁄16𝑀𝐻𝑧 y por ende estimar la frecuencia de la señal como 𝐹 =
1⁄𝑇. Este proceso se describe gráficamente la Figura 5.

Figura 5. Esquema básico de la medición de una señal cuadrada utilizando una fuente de referencia de alta frecuencia.

PARTE 3. Medición del duty-cycle de una señal PWM utilizando el sistema “Input
Capture” del timer1 del Arduino UNO.

9
6.- Armar el circuito mostrado en la Figura No. 6 en PROTEUS. Como se aprecia en la
figura, se tiene que usar el circuito desarrollado en la parte 1(Generador PWM) para
simular un sensor el cual entrega una salida PWM en función de la variable de medición.
Algunos ejemplos de estos sensores son descritos brevemente en la Tabla 4. Además,
deberás integrar también el circuito desarrollado en la parte 2, el cual mide frecuencias
cuadradas.

Tabla 4. Sensores con salida PWM

Sensor Variable de medición
TMP100, MAX6672, MAX6673, etc. Temperatura
DRV5057, HAL2850, etc. Efecto Hall
SMT172-220, Si1120, Proximidad basada en incidencia de luz
AS5161 Posición y rotación.
Si7023-A20 Humedad

D L1
12V

SIM1

V1
12v
Q1
AREF 2N7000
13
13
12
ARDUINO

RESET 12
11
R1
~11 10k
10
5V ~10
9
~9
8
SIMULINO
POWER

8
GND
INCREMENTA RXD
ATMEGA328P

7
DIGITAL (PWM~)

7 TXD
6
~6 BUTTON
ATMEL

A0 5
ANALOG IN

A0 ~5 RTS
A1 4
A1
A2
A2 ~3
4
3 DECREMENTA
A3 2 CTS
A3 2
A4 1
A4 TX > 1 BUTTON
A5 0
A5 RX < 0
www.arduino.cc
blogembarcado.blogspot.com
13
12

10
11

9
8

7
6
5
4
3
2
1
0

SIMULINO UNO
SIM2
RX < 0
13
12

~10
~9
8

7
~6
~5
4
~3
2
TX > 1
AREF

~11

SIMULINO UNO
DIGITAL (PWM~)

SIMULINO
blogembarcado.blogspot.com

ARDUINO
RXD
www.arduino.cc

TXD ATMEGA328P
ATMEL

RTS
POWER
RESET

ANALOG IN
GND

CTS
A0
A1
A2
A3
A4
A5
5V

A0
A1
A2
A3
A4
A5

Figura 6. Medición del ciclo de trabajo usando el sistema input-capture del timer 1 del Arduino Uno

7.- Como se observa en la Figura 6. El objetivo principal de esta práctica es modificar el

código presentado para que el Arduino mostrado en la parte inferior pueda medir también

10
el duty-cycle de la señal PWM que está adquiriendo por el pin 8. Para lograr esto la idea
es la siguiente:
-Considerando la Figura 7, primeramente, el sistema deberá configurar la detección de
un evento externo (rising edge o filo de subida) para poder capturar el contador del
timer1, marcado como X1 en la Figura 7, en la rutina de servicio a la interrupción
ISR(TIMER1_CAPT_vect). Posteriormente, una vez capturado el contador del timer1en
X1, se deberá re-configurar el pin 8 para que detecte un filo de bajada (falling edge)
dentro en la misma rutina ISR(TIMER1_CAPT_vect) para poder capturar el evento
registrado como X2 en la Figura 7. Posteriormente, se debera volver a re-configurar el
pin 8 para que nuevamente detecte un filo de subida para poder capturar el valor X3,
mostrado en la Figura 7. Una vez hecho esto, se podrá estimar el tiempo de encendido
𝑇𝑂𝑁 = 𝑋2 − 𝑋1⁄16𝑀𝐻𝑧 y tiempo de apagado 𝑇𝑂𝐹𝐹 = 𝑋3 − 𝑋2⁄16𝑀𝐻𝑧.
-Una vez capturados los tiempos de encendido y apagado se podrá estimar el ciclo de
trabajo del PWM como: 𝐷𝑢𝑡𝑦𝐶𝑦𝑐𝑙𝑒 = (𝑇𝑂𝑁 ⁄(𝑇𝑂𝑁 + 𝑇𝑂𝐹𝐹 ))𝑥100.

Figura 7. Medición del tiempo TON y TOFF usando el sistema del input-capture.

Resultados
Código en Arduino para estimación de duty-cycle

//PRACTICA 4
//ALBA PEREZ KELVYN ALEXIS
//SERRANO MARQUEZ SEBASTIAN

11
const float Tclk = 0.0000000625; //(16 Mhz)^(-1) Se calcula el periodo de la señal del
Arduino.
volatile int edge_sel = 0; //Diferenciamos entre el 1er y el 2do filo. ********
volatile int edge_sel_bajada = 0; //********
volatile long int edge1 = 0; //Captura cuenta de reloj al 1er filo de subida.
volatile long int edge2 = 0; //Captura cuenta de reloj al 2do filo de subida.
volatile long int edge_pre = 0;
volatile long int Tclk_Count = 0; //Cuenta final de T. Cuenta de numero de pulsos.
volatile long int Tclk_Count_1 = 0;
volatile unsigned int TOF_count = 0; //Guarda el numero de overflows entre el 1er y el
2do filo.
int inPin8 = 8; // Input Capture (Pin8).
float T;
float N;
float M;
float duty_cycle;

void setup()
{
cli(); //noInterrupts() cli(). Critical, time-sensitive code here.
Serial.begin(9600);
TCCR1A = 0; //Modo de overflow (Config: 00000000).
TCCR1B = 0; //(Config: 00000000).
TIMSK1 = 0x21; //Mascara de interrupcion. Enable timer overflow and input capture
interrupts (Config: 00100001).
TCCR1A = 0x00; //(Config: 00000000).
TCCR1B = 0x41; //ICNC1=0, ICES1=1 rising edge, no prescaling (16MHz) (Config:
01000001).
pinMode(inPin8, INPUT_PULLUP); // Establece el pin 8 como entrada.

12
 sei(); //Se habilitan los interrupts() sei(). Other code here.
}

void loop()
{
float frequency;
while(1)
{
frequency = 1/(float)(Tclk_Count*Tclk); //Calcula la frecuencia.
T = (float)(Tclk_Count*Tclk);
N = Tclk_Count*Tclk;
M = (float)(Tclk_Count_1*Tclk);
duty_cycle = (M / N) * 100;
Serial.print(" Frecuencia: ");
Serial.print(frequency,5); //La imprime en interfaz virtual.
Serial.print(" Ciclo de trabajo: ");
Serial.println(duty_cycle,5);
delay(500);
}

ISR(TIMER1_CAPT_vect)
{
unsigned int a = 0;
a = ICR1L; //Se guarda el valor low del contador.
a = a + ICR1H * 256; //a=ICR1; Se guarda el valor high del contador.

13
 if (edge_sel == 0 && edge_sel_bajada == 0)
{
edge1 = a; //Se captura el 1er filo.
edge_sel = 1; //Una vez que entra al 1er filo, ya no regresará aqui, se va al caso else.
TCCR1B = 0x01; //(Config: 00000001). ********
edge_sel_bajada = 1;
TOF_count = 0; //Se borra el conteo de los overflow.

}
else if (edge_sel == 1 && edge_sel_bajada == 1) //********
{
edge_pre = a; //Se captura el 1er filo.
edge_sel = 1; //Una vez que entra al 1er filo, ya no regresará aqui, se va al caso else.
TCCR1B = 0x41; //(Config: 00000001). ********
edge_sel_bajada = 0;
Tclk_Count_1 = (long int)(TOF_count*65535)+(edge_pre-edge1);
TOF_count = 0; //Se borra el conteo de los overflow.
}
else if (edge_sel == 1 && edge_sel_bajada == 0) //********
{
edge2 = a; //Se captura el 2do filo.
edge_sel = 0; //Edge_sel se regresa al valor cero.
TCCR1B = 0x41; //(Config: 00000001). ********
Tclk_Count = (long int)(TOF_count*65535)+(edge2-edge1); //TOF_count es la cuenta
de overflows
TOF_count = 0; //Se borra el conteo de los overflow.

14
 TIFR1 |= 0x20; //Clear the input-capture flag. Se borra la bandera.
}

ISR(TIMER1_OVF_vect)
{
TOF_count++; //Se entra a esta funcion cuando hay un overflow. Cuando lo haya, se
suma 1 a la variable TOF_count.
}
Explicación del código empleado
En el código anterior se tuvo como base otro código de la parte del desarrollo
experimental. En base a ese se tuvieron que realizar algunas modificaciones. Primero se
declararon más variables para poder realizar los cálculos del duty-cycle. Y una variable
para mostrar el valor de la estimación de este.
Lo siguiente fue realizar los cálculos necesarios para obtener la frecuencia. Para ello se
obtuvo el inverso del periodo y se multiplico por el timer clock. Para la ecuación del duty-
cycle se usaron o declararon otras dos variables con las cuales calculan el tiempo OFF
y el tiempo ON de la señal.
Ahora dentro del bloque ISR se realizaron las modificaciones más significativas. Lo
primero que se esta capturando o tomando es el 1er filo de subida, enseguida de este
tiene que saber el registro para el cual se usara, en este caso como ira al Toff se usa
0X41 para así decirle que se encuentra en el Toff. Lo que sigue es regresar al Ton
cambiando la configuración del registro y además capturar el 2do filo.
La variable Tclk_Count sera en este caso el valor de T, es decir el periodo, para así poder
calcular el duty-cycle correctamente.

15
Conexiones de los componentes en proteus y programa funcionando (estimación)

16
Comparación de valores en las terminales virtuales
Duty-Cycle generado con Estimacion del Duty- Error
el PWM de Arduino Cycle
25.32 % 25.39 % 0.07
35.09 % 35.15 % 0.06
17
 44.67 % 44.72 % 0.05
50.15 % 50.19 % 0.04
60.12 % 60.15 % 0.03
69.21 % 60.23 % 0.02
78.10 % 78.12 % 0.02

Como se observa en la tabla anterior, los valores de estimación no están muy alejados
del que nos da la terminal donde generamos el PWM con ayuda del Arduino, esto quiere
decir que el programa está funcionando correctamente.
Tal vez uno de los errores que pueden surgir es que como la frecuencia del Arduino es
de 16.6KHz no se observen de manera correcta los duty-cycles menores a 15% y
mayores al 80%. Pero se podría observar tal vez de una mejor manera con un generador
de funciones para así poder generar los duty-cycles desde ahí.

Conclusiones
Sebastián Serrano Márquez, 177116
Se cumple el objetivo el cual es analizar y entender el cálculo del duty-cycle, así como la
modificación del código que se tuvo de base para poder desarrollar la práctica. Se
tuvieron ciertas dificultades al momento de estar realizando el código para el correcto
funcionamiento del circuito, nos tuvimos que guiar a partir de uno en el que se usaban
&& para hacer la selección de filos de subida o de bajada, así como secuencias anidadas
para poder hacer la elección entre un filo y otro.

Kelvyn Alexis Alba Pérez, 182308

Como conclusión se puede decir que esta práctica fue algo difícil de realizar, la lógica
que se empleo fue en base a un ejercicio en el cual checaban los filos por separado y
tenían otro nombre asignado. Esta tenía nombres como HIGH y LOW para así poder
diferenciar de que filo a que filo se estaba calculando. Fue una práctica muy retadora,
sin embargo, se pudo realizar, pero con algunos detalles de funcionamiento. El objetivo
principal era calcular el ciclo de trabajo en base a un procedimiento sencillo, pero en este
caso no todos los porcentajes son exitosos. Creo que el problema o error es al momento
de realizar el cálculo, no lo detecta. Es por ello por lo que en estos casos el resultado no
es favorable para valores menores a 15% y mayores a 80% aproximadamente. Aprendí
como realizar los cálculos necesarios para obtener el ciclo de trabajo correctamente, así
como los cambios necesarios para poder pasar de un filo a otro y viceversa. Esto es
gracias al uso de registro del timer del Arduino cambiando de 0X41 a 0X01.
Bibliografía

18
• Torres, H. (2021). Arduino PWM. Recuperado 29 de marzo de 2022, de
HETPRO TUTORIALES website: https://hetprostore.com/TUTORIALES/arduino-
pwm/
• Valencia, N. (2015). Flancos de subida y bajada. Recuperado 29 de marzo de
2022, de DROUIZ website: https://www.drouiz.com/blog/2015/05/26/flancos-de-
subida-y-bajada-con-arduino/

19