Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

introducción

Los temporizadores y contadores son módulos de hardware que se utilizan para medir intervalos de tiempo o contar eventos. Se pueden utilizar en muchas aplicaciones, como generar retrasos de tiempo precisos, medir frecuencias, contar eventos externos, etc. El temporizador del microcontrolador 51 pertenece a los recursos internos del microcontrolador, y la conexión y operación de su circuito se completan dentro del microcontrolador. Este artículo presentará en detalle el principio de funcionamiento, el método de configuración y la aplicación de temporizadores y contadores en el microcontrolador 51.

Este capítulo cubrirá el conocimiento relacionado con las interrupciones. Para obtener contenido específico, consulte:Explicación del sistema de interrupción

Nota: Los recursos del temporizador están relacionados con el modelo del microcontrolador. Los diferentes modelos de microcontroladores pueden tener diferentes números de temporizadores y métodos de operación, pero en términos generales, los métodos de operación de T0 y T1 son comunes a los 51 microcontroladores.

Cómo funciona el temporizador

El temporizador es como un pequeño despertador dentro del microcontrolador. Según la señal de salida del reloj, el valor de la unidad de conteo aumenta en uno cada "un segundo". Cuando el valor de la unidad de conteo aumenta al "tiempo de recordatorio de alarma establecido", la unidad de conteo emitirá una solicitud de interrupción al sistema de interrupción, generará un "recordatorio de timbre" y hará que el programa salte a la función de servicio de interrupción para su ejecución. .

El principio de funcionamiento del temporizador/contador se basa en impulsos de reloj. En el modo de temporizador, utilizan una fuente de reloj interna para contar; en el modo de contador, utilizan una fuente de pulso externa para contar. Cada temporizador/contador tiene un registro que almacena el valor de conteo actual.

Registro del modo de funcionamiento del temporizador/contador TMOD

Las funciones de temporización y conteo están controladas por los bits de control del registro de función especial TMOD. $C\sqrt{yo}$ Para realizar una selección, la información del registro TMOD se enumera en la siguiente tabla. Se puede observar que los 2 temporizadores/contadores tienen cuatro modos de funcionamiento, seleccionados a través de M1 y M0 de TMOD. Los modos 0, 1 y 2 de los dos temporizadores/contadores son iguales, pero el modo 3 es diferente. Las funciones en cada modo son las siguientes:

Modo de trabajo del temporizador

Al configurar M1 y M0 en el registro TMOD, los temporizadores/contadores 0 y 1 tienen cuatro modos de funcionamiento diferentes.

Modo 0 (temporizador/contador de 13 bits)

El diagrama del modo de trabajo es el siguiente:

Modo 1 (temporizador/contador de 16 bits)

El modo 1 es exactamente igual que el modo 0 excepto que se utilizan los 16 bits de TH0 y TL0. En este modo, el desbordamiento de 8 bits de TL0 se traslada a TH0, y el desbordamiento de TH0 establece el indicador de desbordamiento TF0 en TCON.

Cuando GATE=0(TMOD.3), si TR0=1, el temporizador cuenta. Cuando GATE=1, la entrada externa INTO puede controlar el temporizador 0, de modo que se pueda lograr la medición del ancho del pulso. TRO es el bit de control en el registro TCON. Para obtener la descripción de la función específica de cada bit del registro TCON, consulte la introducción del registro TCON en la sección anterior.

Nota: El temporizador del microcontrolador de la serie STC89C51RC/RD+ tiene dos velocidades de conteo: una es el modo 12T, sumando 1 cada 12 relojes, igual que el microcontrolador tradicional 8051, la otra es el modo 6T, sumando 1 cada 6 relojes, la velocidad; La velocidad T0, que es 2 veces mayor que la del microcontrolador tradicional 8051, se establece en el programador STC-ISP al grabar el programa de usuario.

Modo 2 (modo de recarga automática de 8 bits)

En este modo, el temporizador/contador puede recargar automáticamente el contador de 8 bits. El desbordamiento de TL0 no solo configura TF0, sino que también recarga el contenido de TH0 en TL0. (TH0 se puede configurar primero y el contenido de TH0 permanecerá sin cambios durante la reinstalación)

Modo 3 (dos contadores de 8 bits)

Para el temporizador 0, en este modo, el temporizador 1 deja de contar y el efecto es el mismo que configurar TR1 en 0.

---

Para el temporizador 0, en este modo, TL0 y TH0 del temporizador 0 funcionan como dos contadores independientes de 8 bits. La siguiente figura muestra el diagrama lógico del temporizador 0 en el modo 3. TL0 ocupa el bit de control del temporizador 0:$C\sqrt{yo}$ , GATE, TRO, INTO y TFO. THO se limita a la función de temporizador (período de contador) y ocupa TR1 y TF1 del temporizador 1. En este momento, TH0 controla la interrupción del temporizador 1.

El modo 3 se proporciona para agregar un temporizador/contador adicional de 8 bits, dándole al microcontrolador tres temporizadores/contadores. El modo 3 solo se aplica al temporizador/contador 0. Cuando el temporizador T1 está en modo 3, equivale a TR1-0 y deja de contar, y T0 se puede utilizar como dos temporizadores.

Proceso de configuración del temporizador

1. Asigne valores a TMOD para determinar cómo funcionan T0 y T1.
2. Calcule el valor inicial según el tiempo a cronometrar y escríbalo en TH0, TL0 o TH1, TL1.
3. Si se utilizan interrupciones, asigne un valor a EA y abra la interrupción total del temporizador.
4. Configure TR0 o TR1 para iniciar el cronometraje o conteo del temporizador/contador.

Nota: La herramienta de programación STC-ISP viene con el valor inicial del tiempo a calcular. Puedes copiar el código según el modo que elijas.

Demostración de código: el LED1 parpadea en un intervalo de 1 segundo

La luz indicadora LED1 se controla para que parpadee a intervalos de 1 segundo mediante la interrupción del temporizador 0. El diagrama físico está conectado: D1 está conectado al pin P2_0. Se utiliza el reloj de 12.000 MHz. La interrupción se activa en un intervalo de un milisegundo. cada vez. La función de activación de interrupción se utiliza para contar. Cuando es 1000, es un segundo.

#include <REGX52.H>

sbit LED1 = P2^0;

void External0_ISR(void) interrupt 1
{
	static unsigned int count = 0;
	TL0 = 0x18;	//需要手动复原			
	TH0 = 0xFC;	//需要手动复原
    // 中断处理代码
	if(count == 1000)
	{
		count = 0;
		LED1 = !LED1;
	}
	count++;
}


void Timer0_Init(void)		//1毫秒@12.000MHz
{
	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	TL0 = 0x18;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值
	TF0 = 0;				//清除TF0标志
	ET0 = 1;//打开T0中断
	EA = 1;//打开总中断
	TR0 = 1;				//定时器0开始计时
}


void main()
{
	Timer0_Init();
	while(1)
	{
		
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

Demostración de código: el botón 1 controla el estado de la luz de marcha LED

En esta demostración, se utilizan las funciones de desplazamiento _crol_left y _cror_right en la biblioteca INTRINS.H. Cuando se presiona el botón KEY1, la luz LED de marcha cambiará el estado de dirección y parpadeará. Conexión de imagen física: K1 está conectado al pin P0_0 y las ocho luces LED se insertan en el pin P2.

• croar(car val sin firmar, char n sin firmar): rota los caracteres hacia la derecha y gira val hacia la derecha n bits.
• Crol(car val sin firmar, char n sin firmar): rotar caracteres hacia la izquierda, rotar val hacia la izquierda n bits

#include <REGX52.H>
#include <INTRINS.H>

sbit KEY1 = P0^0;
sbit KEY2 = P0^1;
unsigned char LEDMode;

void DelayXms(unsigned int xms)	//@12.000MHz
{
	unsigned char data i, j;
	
	while(xms)
	{
		i = 2;
		j = 239;
		do
		{
			while (--j);
		} while (--i);
		xms--;
	}
}

void Timer0_Init(void)		//1毫秒@12.000MHz
{
	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	TL0 = 0x18;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值
	TF0 = 0;				//清除TF0标志
	ET0 = 1;//打开T0中断
	EA = 1;//打开总中断
	TR0 = 1;				//定时器0开始计时
}

void External0_ISR(void) interrupt 1
{
	static unsigned int count = 0;
	TL0 = 0x18;	//需要手动复原			
	TH0 = 0xFC;	//需要手动复原
    // 中断处理代码
	if(count == 1000)
	{
		count = 0;
		if(LEDMode == 0)
			P2 = _crol_(P2,1);
		if(LEDMode == 1)
			P2 = _cror_(P2,1);

	}
	count++;
}

unsigned char Getkey()
{
	unsigned char keyNumber = 0;
	if(KEY1 == 0)
	{
		DelayXms(5);
		while(KEY1 == 0);
		DelayXms(5);
		keyNumber = 1;
	}
	if(KEY2 == 0)
	{
		DelayXms(5);
		while(KEY2 == 0);
		DelayXms(5);
		keyNumber = 2;
	}
	return keyNumber;
}


void main()
{
	unsigned char keyNum = 0;
	P2 = 0xfe;
	Timer0_Init();
	while(1)
	{
		keyNum = Getkey();
		if(keyNum)
		{
			if(keyNum == 1)
			{
				LEDMode++;
				if(LEDMode>=2)
				{
					LEDMode = 0;	
				}
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

Demostración de código: pantalla del reloj temporizador LCD1602

Este código de demostración utiliza el módulo LCD1602 como pantalla. El módulo LCD1602 no se explicará en detalle y se proporcionarán instrucciones de capítulos especiales más adelante. Si necesita la biblioteca LCD1602, puede enviarme un mensaje privado. Conexión física de la imagen: simplemente conecte el módulo LCD1602 a la placa.

#include <REGX52.H>
#include "LCD1602.h"

unsigned char Sec=55,Min=59,Hour;//秒分时

void DelayXms(unsigned int xms)	//@12.000MHz
{
	unsigned char data i, j;
	
	while(xms)
	{
		i = 2;
		j = 239;
		do
		{
			while (--j);
		} while (--i);
		xms--;
	}
}

void Timer0_Init(void)		//1毫秒@12.000MHz
{
	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	TL0 = 0x18;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值
	TF0 = 0;				//清除TF0标志
	ET0 = 1;//打开T0中断
	EA = 1;//打开总中断
	TR0 = 1;				//定时器0开始计时
}

void External0_ISR(void) interrupt 1
{
	static unsigned int count = 0;
	TL0 = 0x18;	//需要手动复原			
	TH0 = 0xFC;	//需要手动复原
    // 中断处理代码
	if(count == 1000)
	{
		count = 0;
		Sec++;
		if(Sec == 60)
		{
			Sec = 0;
			Min++;
			if(Min == 60)
			{
				Min = 0;
				Hour++;
				if(Hour == 24)
				{
					Hour = 0;
				}
			}

		}
	}
	count++;
}

void main()
{
	Timer0_Init();
	LCD_Init();
	LCD_ShowString(1,1,"Time:");
	LCD_ShowString(2,1,"00:00:00");
	while(1)
	{
		LCD_ShowNum(2,1,Hour,2);
		LCD_ShowNum(2,4,Min,2);
		LCD_ShowNum(2,7,Sec,2);
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

---