Partage de technologie

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

introduction

Les minuteries et les compteurs sont des modules matériels utilisés pour mesurer des intervalles de temps ou compter des événements. Ils peuvent être utilisés dans de nombreuses applications comme générer des temporisations précises, mesurer des fréquences, compter des événements externes, etc. La minuterie du microcontrôleur 51 appartient aux ressources internes du microcontrôleur, et la connexion et le fonctionnement de son circuit sont effectués à l'intérieur du microcontrôleur. Cet article présentera en détail le principe de fonctionnement, la méthode de configuration et l'application des minuteries et des compteurs dans le microcontrôleur 51.

Ce chapitre couvrira les connaissances liées aux interruptions. Pour un contenu spécifique, veuillez vous référer à :Explication du système d'interruption

Remarque : Les ressources de minuterie sont liées au modèle du microcontrôleur. Différents modèles de microcontrôleurs peuvent avoir un nombre différent de minuteries et de méthodes de fonctionnement, mais de manière générale, les méthodes de fonctionnement de T0 et T1 sont communes aux 51 microcontrôleurs.

Comment fonctionne la minuterie

La minuterie est comme un petit réveil à l'intérieur du microcontrôleur. Selon le signal de sortie de l'horloge, la valeur de l'unité de comptage augmente de un toutes les « secondes ». Lorsque la valeur de l'unité de comptage augmente jusqu'au « temps de rappel d'alarme défini », l'unité de comptage émettra une demande d'interruption au système d'interruption, générera un « rappel de sonnerie » et fera passer le programme à la fonction de service d'interruption pour exécution. .

Le principe de fonctionnement du minuteur/compteur est basé sur des impulsions d'horloge. En mode minuterie, ils utilisent une source d'horloge interne pour compter ; en mode compteur, ils utilisent une source d'impulsions externe pour compter. Chaque minuterie/compteur possède un registre qui stocke la valeur de comptage actuelle.

Registre de mode de fonctionnement minuterie/compteur TMOD

Les fonctions de synchronisation et de comptage sont contrôlées par les bits de contrôle du registre de fonctions spéciales TMOD. $C\sqrt{T}$ Pour effectuer une sélection, les informations du registre TMOD sont répertoriées dans le tableau suivant. On constate que les 2 temporisateurs/compteurs ont quatre modes de fonctionnement, sélectionnés via M1 et M0 du TMOD. Les modes 0, 1 et 2 des deux minuteries/compteurs sont identiques, mais le mode 3 est différent. Les fonctions de chaque mode sont les suivantes :

Mode de fonctionnement de la minuterie

En réglant M1 et M0 dans le registre TMOD, les temporisateurs/compteurs 0 et 1 ont quatre modes de fonctionnement différents.

Mode 0 (minuterie/compteur 13 bits)

Le diagramme du mode de fonctionnement est le suivant :

Mode 1 (minuterie/compteur 16 bits)

Le mode 1 est exactement le même que le mode 0 sauf que les 16 bits de TH0 et TL0 sont utilisés. Dans ce mode, le dépassement de 8 bits de TL0 est transmis à TH0 et le dépassement de TH0 définit l'indicateur de dépassement TF0 dans TCON.

Lorsque GATE=0(TMOD.3), si TR0=1, le timer compte. Lorsque GATE=1, l'entrée externe INTO est autorisée à contrôler la minuterie 0, afin que la mesure de la largeur d'impulsion puisse être réalisée. TRO est le bit de contrôle dans le registre TCON Pour la description spécifique de la fonction de chaque bit du registre TCON, voir l'introduction du registre TCON dans la section précédente.

Remarque : la minuterie du microcontrôleur de la série STC89C51RC/RD+ a deux taux de comptage : l'un est en mode 12T, ajoutant 1 toutes les 12 horloges, le même que le microcontrôleur 8051 traditionnel, l'autre est le mode 6T, ajoutant 1 toutes les 6 horloges, la vitesse ; Le taux T0, qui est 2 fois supérieur à celui du microcontrôleur 8051 traditionnel, est défini dans le programmeur STC-ISP lors de la gravure du programme utilisateur.

Mode 2 (mode de rechargement automatique 8 bits)

Dans ce mode, le temporisateur/compteur peut recharger automatiquement le compteur 8 bits. Le débordement de TL0 règle non seulement TF0, mais recharge également le contenu de TH0 dans TL0. (TH0 peut être défini en premier et le contenu de TH0 restera inchangé lors de la réinstallation)

Mode 3 (deux compteurs 8 bits)

Pour la minuterie 0, dans ce mode, la minuterie 1 arrête de compter et l'effet est le même que si l'on réglait TR1 sur 0.

---

Pour le temporisateur 0, dans ce mode, TL0 et TH0 du temporisateur 0 fonctionnent comme deux compteurs 8 bits indépendants. La figure ci-dessous montre le schéma logique du temporisateur 0 en mode 3. TL0 occupe le bit de contrôle du timer 0 :$C\sqrt{T}$ , GATE, TRO, INTO et TFO. THO est limité à la fonction timer (compteur période) et occupe TR1 et TF1 du timer 1. À ce moment, TH0 contrôle l’interruption du temporisateur 1.

Le mode 3 est fourni pour ajouter une minuterie/compteur 8 bits supplémentaire, donnant au microcontrôleur trois minuteries/compteurs. Le mode 3 s'applique uniquement à la minuterie/compteur 0. Lorsque la minuterie T1 est en mode 3, elle équivaut à TR1-0 et arrête de compter, et T0 peut être utilisé comme deux minuteries.

Processus de configuration de la minuterie

1. Attribuez des valeurs à TMOD pour déterminer le fonctionnement de T0 et T1.
2. Calculez la valeur initiale en fonction du temps à chronométrer et écrivez-la dans TH0, TL0 ou TH1, TL1.
3. Si des interruptions sont utilisées, attribuez une valeur à EA et ouvrez l'interruption totale de la minuterie.
4. Réglez TR0 ou TR1 pour démarrer la minuterie/compteur ou le comptage.

Remarque : L'outil de programmation STC-ISP est livré avec la valeur initiale du temps à calculer. Vous pouvez copier le code selon le mode que vous choisissez.

Démonstration du code - la LED1 clignote à un intervalle de 1 seconde

Le voyant LED1 est contrôlé pour clignoter à intervalles de 1 seconde via l'interruption de la minuterie 0. Le schéma physique est connecté : D1 est connecté à la broche P2_0. L'horloge 12 000 MHz est déclenchée à un intervalle d'une milliseconde. à chaque fois. La fonction de déclenchement d'interruption est utilisée pour le comptage. Lorsqu'il est 1000, c'est une seconde.

#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

Démonstration de code - le bouton 1 contrôle l'état du feu de position LED

Dans cette démonstration, les fonctions _crol_left shift et _cror_right shift de la bibliothèque INTRINS.H sont utilisées. Lorsque le bouton KEY1 est enfoncé, le feu de position LED change d'état de direction et clignote. Connexion d'image physique : K1 est connecté à la broche P0_0 et les huit lumières LED sont insérées dans la broche P2.

• crore(unsigned char val, unsigned char n) : faites pivoter les caractères vers la droite et faites pivoter val vers la droite de n bits.
• crouler(unsigned char val, unsigned char n) : faites pivoter les caractères vers la gauche, faites pivoter val vers la gauche de 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

Démonstration de code - Affichage de l'horloge de la minuterie LCD1602

Ce code de démonstration utilise le module LCD1602 comme affichage. Le module LCD1602 ne sera pas expliqué en détail et des instructions de chapitre spéciales seront fournies plus tard. Si vous avez besoin de la bibliothèque LCD1602, vous pouvez m'envoyer un message en privé. Connexion d'image physique : branchez simplement le module LCD1602 à la carte.

#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

---