Partage de technologie

51 développement intégré du microcontrôleur : 5. Bouton, fonctionnement du bouton matriciel et simulation des protues

2024-07-12

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


提示

Présentation à 1 bouton

1.1 Types de clés

Une clé est un bouton ou un interrupteur utilisé pour contrôler la connexion et la déconnexion d'un appareil ou d'un circuit électronique. Ils ont généralement deux états : ouvert et fermé. Ce qui suit est une introduction à certains boutons de commutation courants :

  1. Interrupteur à bouton-poussoir : Il s'agit d'un simple bouton qui connecte un circuit lorsqu'il est enfoncé et coupe le circuit lorsqu'il est relâché. Ils sont souvent utilisés pour contrôler l'interrupteur marche/arrêt d'un appareil ou déclencher une fonction spécifique.
  2. Interrupteur à bascule : un interrupteur à bascule est un interrupteur à position fixe qui peut être commuté manuellement. Ils ont généralement deux positions fixes ou plus (telles que ouverte et fermée), et la commutation de la position de l'interrupteur connecte ou déconnecte un circuit.
  3. Interrupteur à glissière : Un interrupteur à glissière est un interrupteur qui change d'état en faisant glisser un bouton. Ils ont généralement deux positions et le circuit est connecté ou déconnecté en faisant glisser le curseur d'une position à l'autre.
  4. Interrupteur à bascule : Un interrupteur à bascule est un interrupteur qui change d'état en tournant un bouton. Ils ont généralement une position médiane et deux positions extrêmes, le circuit étant connecté ou déconnecté en basculant le bouton d'une position à l'autre.
  5. Bouton-poussoir : Un bouton-poussoir est similaire à un bouton-poussoir, mais il est généralement doté d'un mécanisme à ressort qui revient automatiquement à sa position d'origine lorsque le bouton est relâché. Ils sont souvent utilisés dans les applications où vous devez maintenir un bouton enfoncé pour maintenir une connexion et relâcher le bouton pour couper le circuit.
  6. Commutateur électronique : Un commutateur électronique est un commutateur qui utilise des composants électroniques (tels que des transistors ou des relais) pour contrôler la connexion et la déconnexion d'un circuit.Ils peuvent contrôler l'état de commutation via des signaux électriques ou d'autres méthodes de déclenchement

1.2 Scénarios d'application des boutons

Quelques scénarios d'application de boutons mécaniques :

  1. Clavier d'ordinateur : Les claviers mécaniques sont largement utilisés dans le domaine informatique. Étant donné que les touches mécaniques offrent une meilleure sensation tactile et une meilleure course des touches, l'expérience de frappe et de jeu est plus confortable et précise.
  2. Équipement de jeu : les touches mécaniques sont largement utilisées dans les consoles de jeux, les contrôleurs de jeux et les claviers mécaniques de jeux. Le retour tactile et le temps de réponse rapide des boutons mécaniques contribuent à améliorer les performances de contrôle du jeu.
  3. Équipement de contrôle industriel : les boutons mécaniques ont une forte durabilité et conviennent aux scénarios nécessitant des opérations fréquentes dans les équipements de contrôle industriel, tels que les panneaux de commande mécaniques, les consoles de robots, etc.
  4. Équipement de communication : les boutons mécaniques peuvent être utilisés dans les équipements de communication tels que les téléphones mobiles, les téléphones et les talkies-walkies pour offrir une meilleure touche et une meilleure fiabilité.
  5. Équipement audio : les touches mécaniques sont largement utilisées dans les équipements audio, tels que les mixeurs, les panneaux de commande audio, les claviers musicaux, etc.
  6. Équipement médical : les boutons mécaniques sont couramment utilisés dans les équipements médicaux, tels que les instruments médicaux, les panneaux de commande des tables d'opération, etc. La stabilité et la fiabilité des boutons mécaniques sont cruciales pour le fonctionnement normal de l'équipement médical.
  7. Équipement automobile et aéronautique : les boutons mécaniques peuvent être utilisés dans les panneaux de commande automobiles, les tableaux de bord des avions et d'autres scénarios nécessitant une fiabilité et une durabilité élevées.
    La durabilité, la sensation et la fiabilité des clés mécaniques en font le choix privilégié dans de nombreux domaines. Qu'il s'agisse d'améliorer l'efficacité du travail ou d'offrir une meilleure expérience utilisateur, les boutons mécaniques sont largement utilisés dans de nombreux scénarios d'application.

Circuit à 2 boutons

Le schéma de principe du circuit des touches sur la carte de développement est le suivant. J11 est utilisé pour contrôler si les boutons 0/4/8/ sont dans le clavier matriciel ou des touches indépendantes. Les 16 touches sont contrôlées par un ensemble de ports P3X.

Insérer la description de l'image ici

Les boutons réels de la carte de développement sont comme indiqué sur la figure
Insérer la description de l'image ici

Insérer la description de l'image ici

Conception de logiciel à 3 boutons

3.1 Implémentation du bouton

Tout d'abord, nous implémentons des boutons indépendants. Utilisez un cavalier pour court-circuiter J11 et 2.3, afin que les boutons 0/4/8/C puissent être utilisés indépendamment.
1. Génie logiciel, nous créons deux nouveaux fichiers, c51_key.c et c51_key.h, appliquons include.h dans c51_key.c, incluons c51_key.h dans include.h et ajoutons les deux fichiers au projet comme le montre l'image.

Insérer la description de l'image ici

Parce que nous voulons afficher la valeur du bouton, nous utilisons le tube numérique avant pour afficher les données.
La fonction d'affichage est illustrée ci-dessous.

/********************************************************
函数名称: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

Dans c51_key.c, implémentez la détection de clé

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

Cité dans le programme principal principal :

#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 Méthode de filtrage des boutons

/********************************************************
函数名称: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 Conception du logiciel du bouton matriciel

//Affiche la valeur du code de segment 01234567, qui peut être visualisée correspondant au diagramme schématique et affiche l'état de configuration du niveau de point haut de la broche correspondant à différents graphiques.

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 Simulation du bouton Protues

Bouton indépendant pour afficher le résultat, commutateur DIP, connecter une extrémité du bouton à la terre

Insérer la description de l'image ici

Simulation des touches du clavier matriciel :Insérer la description de l'image ici

4 Résumé des opérations clés

Dans les applications de microcontrôleurs, la conception fiable de la détection des clés est cruciale pour garantir une entrée correcte et un fonctionnement stable du système. Voici quelques principes de conception pour améliorer la fiabilité de la détection des clés :

  1. Élimine la gigue des touches : la gigue des touches fait référence au bref signal instable généré lorsqu'un bouton est enfoncé ou relâché. Pour éliminer la gigue, des méthodes d'élimination de la gigue matérielle ou logicielle peuvent être utilisées. Côté matériel, des condensateurs externes ou des réseaux RC peuvent être utilisés pour filtrer la gigue. En termes de logiciel, des retards logiciels ou des machines à états peuvent être utilisés pour stabiliser les signaux clés.
  2. Utilisez des résistances externes pull-up/pull-down : En utilisant une résistance externe pull-up ou pull-down connectée à la broche de la clé, vous pouvez vous assurer que la touche reste stable lorsqu'elle n'est pas enfoncée. Cela évite les signaux flottants lorsque les touches ne sont pas enfoncées.
  3. Algorithmes de retard et anti-rebond : la mise en œuvre d'algorithmes de retard et anti-rebond appropriés dans le logiciel peut améliorer la fiabilité de la détection des frappes. Le retard peut garantir un statut de clé stable et éviter un faux déclenchement. L'algorithme anti-rebond peut filtrer la gigue des touches pour garantir que seules les opérations d'appui sur les touches valides sont détectées.
  4. Détection et confirmation multiples : afin d'améliorer la fiabilité, plusieurs mécanismes de détection et de confirmation de clé peuvent être utilisés. Par exemple, une minuterie ou une interruption logicielle peut être utilisée pour détecter périodiquement l'état de la clé, et plusieurs confirmations peuvent être utilisées pour garantir le déclenchement efficace de la clé.
  5. Tampons d'entrée et machines à états : utilisez des tampons d'entrée pour stocker les entrées au clavier, puis utilisez une machine à états pour traiter l'entrée. La machine d'état peut suivre l'état des clés et gérer les événements clés pour garantir l'exactitude et la stabilité des opérations clés.
  6. Isolation des interférences de l'alimentation et du fil de terre : Afin d'éviter l'influence des interférences de l'alimentation et du retour du fil de terre sur le signal clé, des mesures d'isolation appropriées peuvent être prises. Par exemple, utilisez des plans d'alimentation et de masse séparés, ou utilisez des filtres pour réduire les interférences.
  7. Mécanismes de tolérance aux pannes pour le matériel et les logiciels : concevez des mécanismes de tolérance aux pannes pour protéger la fiabilité des entrées clés lorsque des erreurs ou des conditions anormales se produisent. Par exemple, la détection de redondance, la détection de somme de contrôle, les mécanismes de gestion des erreurs et de récupération, etc. peuvent être utilisés.
    En général, une conception fiable de détection de clé doit prendre en compte de manière exhaustive divers facteurs matériels et logiciels, et procéder à l'optimisation et aux ajustements appropriés en fonction de scénarios d'application spécifiques. Grâce à une conception et une mise en œuvre appropriées, la stabilité, la précision et la fiabilité des clés peuvent être garanties.