Condivisione della tecnologia

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

---

提示

1 Introduzione al pulsante

1.1 Tipi di chiavi

Una chiave è un pulsante o un interruttore utilizzato per controllare la connessione e la disconnessione di un dispositivo o circuito elettronico. Di solito hanno due stati: aperto e chiuso. Di seguito è riportata un'introduzione ad alcuni pulsanti di commutazione comuni:

1. Interruttore a pulsante: questo è un semplice pulsante che collega un circuito quando viene premuto e interrompe il circuito quando viene rilasciato. Sono spesso utilizzati per controllare l'interruttore di accensione/spegnimento di un dispositivo o per attivare una funzione specifica.
2. Interruttore a levetta: un interruttore a levetta è un interruttore con una posizione fissa che può essere commutata manualmente. Di solito hanno due o più posizioni fisse (come aperto e chiuso) e la commutazione della posizione dell'interruttore collega o disconnette un circuito.
3. Interruttore a scorrimento: un interruttore a scorrimento è un interruttore che cambia stato facendo scorrere un pulsante. Di solito hanno due posizioni e il circuito viene collegato o disconnesso facendo scorrere il cursore da una posizione all'altra.
4. Interruttore a levetta: un interruttore a levetta è un interruttore che cambia stato ruotando un pulsante. Di solito hanno una posizione centrale e due posizioni estreme, con il circuito che viene collegato o disconnesso spostando il pulsante da una posizione all'altra.
5. Interruttore a pulsante: un interruttore a pulsante è simile a un interruttore a pressione, ma di solito ha un meccanismo a molla che ritorna automaticamente nella posizione originale quando il pulsante viene rilasciato. Vengono spesso utilizzati in applicazioni in cui è necessario tenere premuto un pulsante per mantenere una connessione e rilasciare il pulsante per interrompere il circuito.
6. Interruttore elettronico: un interruttore elettronico è un interruttore che utilizza componenti elettronici (come transistor o relè) per controllare la connessione e la disconnessione di un circuito.Possono controllare lo stato di commutazione tramite segnali elettrici o altri metodi di attivazione

1.2 Scenari di applicazione dei pulsanti

Alcuni scenari applicativi dei pulsanti meccanici:

1. Tastiera del computer: le tastiere meccaniche sono ampiamente utilizzate nel campo dei computer. Poiché i tasti meccanici offrono una migliore sensazione al tatto e una migliore corsa, l'esperienza di digitazione e di gioco è più comoda e precisa.
2. Attrezzatura di gioco: i tasti meccanici sono ampiamente utilizzati nelle console di gioco, nei controller di gioco e nelle tastiere meccaniche di gioco. Il feedback tattile e il tempo di risposta rapido dei pulsanti meccanici aiutano a migliorare le prestazioni di controllo del gioco.
3. Apparecchiature di controllo industriale: i pulsanti meccanici hanno una lunga durata e sono adatti a scenari che richiedono operazioni frequenti in apparecchiature di controllo industriale, come pannelli di controllo meccanici, console di robot, ecc.
4. Apparecchiature di comunicazione: i pulsanti meccanici possono essere utilizzati in apparecchiature di comunicazione come telefoni cellulari, telefoni e walkie-talkie per fornire una migliore sensibilità e affidabilità dei pulsanti.
5. Apparecchiature audio: i tasti meccanici sono ampiamente utilizzati nelle apparecchiature audio, come mixer, pannelli di controllo audio, tastiere musicali, ecc.
6. Attrezzature mediche: i pulsanti meccanici sono comunemente utilizzati nelle apparecchiature mediche, come strumenti medici, pannelli di controllo dei tavoli operatori, ecc. La stabilità e l'affidabilità dei pulsanti meccanici sono fondamentali per il normale funzionamento delle apparecchiature mediche.
7. Attrezzature automobilistiche e aeronautiche: i pulsanti meccanici possono essere utilizzati nei pannelli di controllo automobilistici, nei pannelli strumenti degli aerei e in altri scenari che richiedono elevata affidabilità e durata.
   La durata, la sensazione e l'affidabilità dei tasti meccanici li rendono la scelta preferita in molti settori. Che si tratti di migliorare l'efficienza del lavoro o di fornire una migliore esperienza all'utente, i pulsanti meccanici sono ampiamente utilizzati in molti scenari applicativi.

Circuito a 2 pulsanti

Il diagramma schematico del circuito dei tasti sulla scheda di sviluppo è il seguente. J11 viene utilizzato per controllare se i pulsanti 0/4/8/ si trovano nella tastiera a matrice o in tasti indipendenti. I 16 tasti sono controllati da un set di porte P3X.

I pulsanti effettivi della scheda di sviluppo sono come mostrati in figura

Progettazione del software a 3 pulsanti

3.1 Implementazione dei pulsanti

Innanzitutto, implementiamo pulsanti indipendenti. Utilizziamo un ponticello per cortocircuitare J11 e 2.3, in modo che i pulsanti 0/4/8/C possano essere utilizzati in modo indipendente.
1. Ingegneria del software, creiamo due nuovi file, c51_key.c e c51_key.h, applichiamo includes.h in c51_key.c, includiamo c51_key.h in includes.h e aggiungiamo i due file al progetto come mostra l'immagine.

Poiché vogliamo visualizzare il valore del pulsante, utilizziamo il tubo digitale anteriore per visualizzare i dati.
La funzione del display è mostrata di seguito.

/********************************************************
函数名称：sys_keynum_ledon
函数功能：显示按键数值
入口参数：按键数值
出口参数：
修    改：
内    容：
********************************************************/
void sys_keynum_ledon(unsigned char num)
{
	//根据原理图，将P0口全部输出高电平，P2选择0号数码管
	P0=EL[num];//取显示数据，段码
	P2=0;  	//取位码
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

In c51_key.c, implementare il rilevamento delle chiavi

bit key1=0;   //定义按键位置
bit key2=0;
bit key3=0;
bit key4=0;


/********************************************************
函数名称：sys_key_single
函数功能：按键检测
入口参数：
出口参数：按键数值
修    改：
内    容：
********************************************************/
static unsigned char key1_history = 0;//缓存上一次按键的结果
unsigned char sys_key_single(void)
{
	key1=P30;   //定义按键位置
	key2=P31;
	key3=P32;
	key4=P33;

	if(!key1)  //按下相应的按键，数码管显示相应的码值
	{
		key1_history = 1;
		return 1;
	}
	else if(!key2)
	{
		key1_history = 2;
		return 2;
	}
	else if(!key3)
	{
		key1_history = 3;
		return 3;
	}
	else if(!key4)
	{
		key1_history = 4;
		return 4;
	}
	else
	{
		return key1_history;
	}
	
}
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

Citato nel programma principale main:

#include "includes.h"



/*------------------------------------------------
                    延时子程序
------------------------------------------------*/
void delay(unsigned int cnt) 
{
 while(--cnt);
}

/*------------------------------------------------
                    主函数
------------------------------------------------*/
void main (void)
{
	//8个指示灯的操作
	sys_led();
	sys_led_test();
	sys_led_test1();
	
	sys_ledtube_on1();
	sys_ledtube_on2();
	
	//主循环中添加其他需要一直工作的程序
	while (1)
	{
		sys_keynum_ledon(sys_key_single());
	}
}
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

3.2 Metodo di filtraggio dei pulsanti

/********************************************************
函数名称：sys_key_single
函数功能：按键检测,带有消抖策略
入口参数：
出口参数：按键数值
修    改：
内    容：
********************************************************/
static unsigned char key1_history = 0;//缓存上一次按键的结果
unsigned char sys_key_single(void)
{
	key1=P30;   //定义按键位置
	key2=P31;
	key3=P32;
	key4=P33;

	if(!key1)  //按下相应的按键，数码管显示相应的码值
	{
		delay(1000);
		if(!key1)
		{
			key1_history = 1;
			return 1;
		}
		else
		{
			return key1_history;
		}
	}
	else if(!key2)
	{
		delay(1000);
		if(!key2)
		{
			key1_history = 2;
			return 2;
		}
		else
		{
			return key1_history;
		}
	}
	else if(!key3)
	{
		delay(1000);
		if(!key3)
		{
			key1_history = 3;
			return 3;
		}
		else
		{
			return key1_history;
		}
	}
	else if(!key4)
	{
		delay(1000);
		if(!key4)
		{
			key1_history = 4;
			return 4;
		}
		else
		{
			return key1_history;
		}
	}
	else
	{
		return key1_history;
	}
	
}
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

3.3 Progettazione del software dei pulsanti Matrix

//Visualizza il valore del codice segmento 01234567, che può essere visualizzato corrispondente al diagramma schematico e visualizza lo stato di configurazione del livello del punto alto del pin corrispondente a diversi grafici.

unsigned char const EL[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
		                  	 0x77,0x7c,0x39,0x5e,0x79,0x71};//0-F
1
2

unsigned char sys_key_board(void)
{
	unsigned char key = 0x00;
	unsigned char num = 0x00;
	key=keyscan();  //调用键盘扫描
	if(key == 0xFF)
	{
		num = key1_history;
	}
	else
	{
		switch(key)
		{
			case 0xee:num = 0x0;break;//0按下相应的键显示相对应的码值
			case 0xde:num = 0x1;break;//1 按下相应的键显示相对应的码值 
			case 0xbe:num = 0x2;break;//2
			case 0x7e:num = 0x3;break;//3
			case 0xed:num = 0x4;break;//4
			case 0xdd:num = 0x5;break;//5
			case 0xbd:num = 0x6;break;//6
			case 0x7d:num = 0x7;break;//7
			case 0xeb:num = 0x8;break;//8
			case 0xdb:num = 0x9;break;//9
			case 0xbb:num = 0xA;break;//a
			case 0x7b:num = 0xB;break;//b
			case 0xe7:num = 0xC;break;//c
			case 0xd7:num = 0xD;break;//d
			case 0xb7:num = 0xE;break;//e
			case 0x77:num = 0xF;break;//f
			default:num = key1_history; break;
		}
		
		key1_history = num;
	}
	return num;
}


/*------------------------------------------------
              键盘扫描程序
------------------------------------------------*/
unsigned char keyscan(void)  //键盘扫描函数，使用行列反转扫描法
{
	unsigned char cord_h,cord_l;//行列值中间变量
	P3=0x0f;            //行线输出全为0
	cord_h=P3&0x0f;     //读入列线值
	if(cord_h!=0x0f)    //先检测有无按键按下
	{
		delay(100);        //去抖
		if(cord_h!=0x0f)
		{
			cord_h=P3&0x0f;  //读入列线值
			P3=cord_h|0xf0;  //输出当前列线值
			cord_l=P3&0xf0;  //读入行线值
			return(cord_h+cord_l);//键盘最后组合码值
		}
	}
	return(0xff);     //返回该值
}
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

3.4 Pulsante Prosegue simulazione

Pulsante indipendente per visualizzare il risultato, interruttore DIP, collegare un'estremità del pulsante a terra

Simulazione dei tasti della tastiera a matrice:

4 Riepilogo delle principali operazioni

Nelle applicazioni con microcontrollore, la progettazione dell'affidabilità del rilevamento dei tasti è fondamentale per garantire l'input corretto e il funzionamento stabile del sistema. Ecco alcuni principi di progettazione per migliorare l'affidabilità del rilevamento delle chiavi:

1. Elimina il jitter dei tasti: il jitter dei tasti si riferisce al breve segnale instabile generato quando un pulsante viene premuto o rilasciato. Per eliminare il jitter, è possibile utilizzare metodi di eliminazione del jitter hardware o software. Dal punto di vista hardware, è possibile utilizzare condensatori esterni o reti RC per filtrare il jitter. In termini di software, è possibile utilizzare ritardi software o macchine a stati per stabilizzare i segnali chiave.
2. Utilizzare resistori pull-up/pull-down esterni: utilizzando un resistore pull-up o pull-down esterno collegato al pin del tasto, è possibile garantire che il tasto rimanga stabile quando non viene premuto. In questo modo si evitano segnali fluttuanti quando i tasti non vengono premuti.
3. Algoritmi di ritardo e antirimbalzo: l'implementazione di algoritmi di ritardo e antirimbalzo appropriati nel software può migliorare l'affidabilità del rilevamento della pressione dei tasti. Il ritardo può garantire uno stato della chiave stabile ed evitare false attivazioni. L'algoritmo antirimbalzo può filtrare il jitter durante la pressione dei tasti per garantire che vengano rilevate solo le operazioni di pressione dei tasti valide.
4. Rilevamento e conferma multipli: per migliorare l'affidabilità, è possibile utilizzare più meccanismi di rilevamento e conferma delle chiavi. Ad esempio, è possibile utilizzare un timer o un'interruzione software per rilevare periodicamente lo stato della chiave e si possono utilizzare più conferme per garantire l'attivazione effettiva della chiave.
5. Buffer di input e macchine a stati: utilizzare i buffer di input per memorizzare l'input digitato, quindi utilizzare una macchina a stati per elaborare l'input. La macchina a stati può tenere traccia dello stato delle chiavi e gestire gli eventi chiave per garantire la correttezza e la stabilità delle operazioni chiave.
6. Isolamento delle interferenze dell'alimentazione e del filo di terra: per prevenire l'influenza delle interferenze dell'alimentazione e del ritorno del filo di terra sul segnale chiave, è possibile adottare misure di isolamento adeguate. Ad esempio, utilizzare piani di alimentazione e di terra separati oppure utilizzare filtri per ridurre le interferenze.
7. Meccanismi di tolleranza agli errori per hardware e software: progettare meccanismi di tolleranza agli errori per proteggere l'affidabilità dell'input chiave quando si verificano errori o condizioni anomale. Ad esempio, è possibile utilizzare il rilevamento della ridondanza, il rilevamento del checksum, la gestione degli errori e i meccanismi di ripristino, ecc.
   In generale, una progettazione affidabile del rilevamento delle chiavi deve considerare in modo completo vari fattori hardware e software e apportare ottimizzazioni e aggiustamenti appropriati in base a scenari applicativi specifici. Attraverso una corretta progettazione e implementazione, è possibile garantire la stabilità, la precisione e l'affidabilità delle chiavi.