Condivisione della tecnologia

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

introduzione

Temporizzatori e contatori sono moduli hardware utilizzati per misurare intervalli di tempo o contare eventi. Possono essere utilizzati in molte applicazioni come la generazione di ritardi temporali precisi, la misurazione delle frequenze, il conteggio di eventi esterni, ecc. Il timer del microcontrollore 51 appartiene alle risorse interne del microcontrollore e la connessione e il funzionamento del suo circuito vengono completati all'interno del microcontrollore. Questo articolo introdurrà in dettaglio il principio di funzionamento, il metodo di configurazione e l'applicazione di timer e contatori nel microcontrollore 51.

Questo capitolo tratterà le conoscenze relative agli interrupt. Per contenuti specifici, fare riferimento a:Spiegazione del sistema di interruzione

Nota: le risorse del timer sono correlate al modello del microcontrollore. Diversi modelli di microcontrollore possono avere un numero diverso di timer e metodi operativi, ma in generale, i metodi operativi di T0 e T1 sono comuni a tutti i 51 microcontrollori.

Come funziona il timer

Il timer è come una piccola sveglia all'interno del microcontrollore. In base al segnale di uscita dell'orologio, il valore dell'unità di conteggio aumenta di uno ogni "un secondo". Quando il valore dell'unità di conteggio aumenta fino al "tempo di promemoria dell'allarme impostato", l'unità di conteggio invierà una richiesta di interruzione al sistema di interruzione, genererà un "promemoria di squillo" e farà passare il programma alla funzione di servizio di interruzione per l'esecuzione .

Il principio di funzionamento del timer/contatore si basa sugli impulsi di clock. In modalità timer, utilizzano una sorgente di clock interna per contare; in modalità contatore, utilizzano una sorgente di impulsi esterna per contare. Ciascun timer/contatore dispone di un registro che memorizza il valore del conteggio corrente.

Registro della modalità operativa del timer/contatore TMOD

Le funzioni di temporizzazione e conteggio sono controllate dai bit di controllo del registro delle funzioni speciali TMOD. $C\sqrt{T}$ Per effettuare una selezione le informazioni del registro TMOD sono riportate nella tabella seguente. Si può notare che i 2 temporizzatori/contatori hanno quattro modalità di funzionamento, selezionate tramite M1 e M0 di TMOD. Le modalità 0, 1 e 2 dei due timer/contatori sono le stesse, ma la modalità 3 è diversa. Le funzioni in ciascuna modalità sono le seguenti:

Modalità di funzionamento del timer

Impostando M1 e M0 nel registro TMOD, il timer/contatore 0 e 1 hanno quattro diverse modalità operative.

Modalità 0 (timer/contatore a 13 bit)

Il diagramma della modalità di funzionamento è il seguente:

Modalità 1 (timer/contatore a 16 bit)

La modalità 1 è esattamente uguale alla modalità 0, tranne per il fatto che vengono utilizzati tutti i 16 bit di TH0 e TL0. In questa modalità, l'overflow di 8 bit di TL0 porta a TH0 e l'overflow di TH0 imposta il flag di overflow TF0 in TCON.

Quando GATE=0(TMOD.3), se TR0=1, il timer conta. Quando GATE=1, l'ingresso esterno INTO può controllare il timer 0, in modo da poter ottenere la misurazione dell'ampiezza dell'impulso. TRO è il bit di controllo nel registro TCON Per la descrizione specifica della funzione di ciascun bit del registro TCON, vedere l'introduzione del registro TCON nella sezione precedente.

Nota: il timer del microcontrollore della serie STC89C51RC/RD+ ha due velocità di conteggio: una è in modalità 12T, aggiungendo 1 ogni 12 orologi, come il tradizionale microcontrollore 8051, l'altra è in modalità 6T, aggiungendo 1 ogni 6 orologi, la velocità The La velocità T0, che è 2 volte quella del tradizionale microcontrollore 8051, viene impostata nel programmatore STC-ISP durante la masterizzazione del programma utente.

Modalità 2 (modalità di ricarica automatica a 8 bit)

In questa modalità, il timer/contatore può ricaricare automaticamente il contatore a 8 bit. L'overflow di TL0 non solo imposta TF0, ma ricarica anche il contenuto di TH0 in TL0. (TH0 può essere impostato per primo e il contenuto di TH0 rimarrà invariato durante la reinstallazione)

Modalità 3 (due contatori a 8 bit)

Per il timer 0, in questa modalità, il timer 1 interrompe il conteggio e l'effetto è lo stesso dell'impostazione di TR1 su 0.

---

Per il timer 0, in questa modalità, TL0 e TH0 del timer 0 funzionano come due contatori indipendenti a 8 bit. La figura seguente mostra il diagramma logico del timer 0 in modalità 3. TL0 occupa il bit di controllo del timer 0:$C\sqrt{T}$ , GATE, TRO, INTO e TFO. THO è limitato alla funzione timer (periodo contatore) e occupa TR1 e TF1 del timer 1. In questo momento, TH0 controlla l'interruzione del timer 1.

La modalità 3 viene fornita per aggiungere un ulteriore timer/contatore a 8 bit, fornendo al microcontrollore tre timer/contatori. La modalità 3 è applicabile solo al timer/contatore 0. Quando il timer T1 è in modalità 3, equivale a TR1-0 e interrompe il conteggio e T0 può essere utilizzato come due timer.

Processo di configurazione del timer

1. Assegna valori a TMOD per determinare come funzionano T0 e T1.
2. Calcolare il valore iniziale in base al tempo da cronometrare e scriverlo in TH0, TL0 oppure TH1, TL1.
3. Se vengono utilizzati gli interrupt, assegnare un valore a EA e aprire l'interrupt totale del timer.
4. Impostare TR0 o TR1 per avviare la temporizzazione o il conteggio del timer/contatore.

Nota: lo strumento di programmazione STC-ISP viene fornito con il valore iniziale del tempo da calcolare. È possibile copiare il codice in base alla modalità scelta.

Dimostrazione del codice: il LED1 lampeggia a intervalli di 1 secondo

La spia LED1 è controllata per lampeggiare a intervalli di 1 secondo attraverso l'interruzione del timer 0. Lo schema fisico è collegato: D1 è collegato al pin P2_0. Viene utilizzato l'orologio da 12.000 MHz. L'interruzione viene attivata a un intervallo di un millisecondo ogni volta La funzione di attivazione dell'interruzione viene utilizzata per il conteggio. Quando è 1000, è un secondo.

#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

Dimostrazione del codice: il pulsante 1 controlla lo stato della luce di marcia a LED

In questa dimostrazione vengono utilizzate le funzioni _crol_left shift e _cror_right shift nella libreria INTRINS.H. Quando si preme il pulsante KEY1, la luce di marcia a LED cambierà lo stato di direzione e lampeggerà. Collegamento fisico dell'immagine: K1 è collegato al pin P0_0 e le otto luci LED sono inserite nel pin P2.

• crore(unsigned char val, unsigned char n): ruota i caratteri a destra e ruota val a destra di n bit.
• crollo(unsigned char val, unsigned char n): ruota i caratteri a sinistra, ruota val a sinistra di n bit

#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

Dimostrazione del codice: display dell'orologio con timer LCD1602

Questo codice dimostrativo utilizza il modulo LCD1602 come display. Il modulo LCD1602 non verrà spiegato in dettaglio e le istruzioni nei capitoli speciali verranno fornite in seguito. Se hai bisogno della libreria LCD1602 puoi scrivermi in privato. Collegamento fisico dell'immagine: basta collegare il modulo LCD1602 alla scheda.

#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

---