Technologieaustausch

51 Mikrocontroller-Embedded-Entwicklung: 5. Tasten-, Matrixtastenbedienung und Protues-Simulation

2024-07-12

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


提示

1 Tasteneinführung

1.1 Schlüsseltypen

Ein Schlüssel ist eine Taste oder ein Schalter, mit dem das Anschließen und Trennen eines elektronischen Geräts oder Stromkreises gesteuert wird. Sie haben normalerweise zwei Zustände: offen und geschlossen. Im Folgenden finden Sie eine Einführung in einige gängige Schaltertasten:

  1. Druckknopfschalter: Hierbei handelt es sich um einen einfachen Knopf, der beim Drücken einen Stromkreis verbindet und beim Loslassen den Stromkreis unterbricht. Sie werden häufig verwendet, um den Ein-/Ausschalter eines Geräts zu steuern oder eine bestimmte Funktion auszulösen.
  2. Kippschalter: Ein Kippschalter ist ein Schalter mit fester Position, der manuell umgeschaltet werden kann. Sie haben normalerweise zwei oder mehr feste Positionen (z. B. offen und geschlossen), und durch Ändern der Schalterposition wird ein Stromkreis verbunden oder getrennt.
  3. Schiebeschalter: Ein Schiebeschalter ist ein Schalter, der seinen Zustand durch Betätigen einer Taste ändert. Sie haben normalerweise zwei Positionen, und der Stromkreis wird verbunden oder getrennt, indem der Schieber von einer Position in die andere geschoben wird.
  4. Kippschalter: Ein Kippschalter ist ein Schalter, der seinen Zustand durch Drehen einer Taste ändert. Sie haben normalerweise eine Mittelstellung und zwei Extremstellungen, wobei der Stromkreis durch Umlegen des Knopfes von einer Stellung in die andere verbunden oder getrennt wird.
  5. Knopfschalter: Ein Druckknopfschalter ähnelt einem Druckschalter, verfügt jedoch normalerweise über einen Federmechanismus, der beim Loslassen der Taste automatisch in seine ursprüngliche Position zurückkehrt. Sie werden häufig in Anwendungen eingesetzt, bei denen Sie eine Taste gedrückt halten müssen, um eine Verbindung aufrechtzuerhalten, und die Taste loslassen müssen, um den Stromkreis zu unterbrechen.
  6. Elektronischer Schalter: Ein elektronischer Schalter ist ein Schalter, der elektronische Komponenten (wie Transistoren oder Relais) verwendet, um das Verbinden und Trennen eines Stromkreises zu steuern.Sie können den Schaltzustand durch elektrische Signale oder andere Auslösemethoden steuern

1.2 Anwendungsszenarien für Tasten

Einige Anwendungsszenarien mechanischer Tasten:

  1. Computertastatur: Mechanische Tastaturen sind im Computerbereich weit verbreitet. Da mechanische Tasten ein besseres Tastgefühl und einen besseren Tastenhub bieten, ist das Tipp- und Spielerlebnis komfortabler und präziser.
  2. Spielausrüstung: Mechanische Tasten werden häufig in Spielekonsolen, Gamecontrollern und mechanischen Spieltastaturen verwendet. Das taktile Feedback und die schnelle Reaktionszeit mechanischer Tasten tragen dazu bei, die Leistung der Spielsteuerung zu verbessern.
  3. Industrielle Steuerungsgeräte: Mechanische Tasten weisen eine hohe Haltbarkeit auf und eignen sich für Szenarien, die häufige Betätigungen in industriellen Steuerungsgeräten erfordern, wie z. B. mechanische Bedienfelder, Roboterkonsolen usw.
  4. Kommunikationsgeräte: Mechanische Tasten können in Kommunikationsgeräten wie Mobiltelefonen, Telefonen und Walkie-Talkies verwendet werden, um eine bessere Tastenberührung und Zuverlässigkeit zu gewährleisten.
  5. Audiogeräte: Mechanische Tasten werden häufig in Audiogeräten wie Mischpulten, Audio-Bedienfeldern, Musiktastaturen usw. verwendet.
  6. Medizinische Geräte: Mechanische Tasten werden häufig in medizinischen Geräten wie medizinischen Instrumenten, Bedienfeldern für Operationstische usw. verwendet. Die Stabilität und Zuverlässigkeit mechanischer Tasten ist für den normalen Betrieb medizinischer Geräte von entscheidender Bedeutung.
  7. Automobil- und Luftfahrtausrüstung: Mechanische Tasten können in Automobil-Bedientafeln, Flugzeuginstrumententafeln und anderen Szenarien verwendet werden, die eine hohe Zuverlässigkeit und Haltbarkeit erfordern.
    Die Haltbarkeit, Haptik und Zuverlässigkeit mechanischer Tasten machen sie in vielen Bereichen zur bevorzugten Wahl. Ob zur Verbesserung der Arbeitseffizienz oder zur Bereitstellung eines besseren Benutzererlebnisses: Mechanische Tasten werden in vielen Anwendungsszenarien häufig verwendet.

2-Tasten-Schaltung

Das schematische Diagramm der Tastenschaltung auf der Entwicklungsplatine sieht wie folgt aus: J11 wird verwendet, um zu steuern, ob sich die 0/4/8/-Tasten in der Matrixtastatur oder unabhängigen Tasten befinden. Die 16 Tasten werden von einem Satz P3X-Ports gesteuert.

Fügen Sie hier eine Bildbeschreibung ein

Die tatsächlichen Tasten des Entwicklungsboards sind in der Abbildung dargestellt
Fügen Sie hier eine Bildbeschreibung ein

Fügen Sie hier eine Bildbeschreibung ein

3-Tasten-Softwaredesign

3.1 Button-Implementierung

Zuerst implementieren wir unabhängige Tasten. Schließen Sie J11 und 2.3 mit einer Brückenkappe kurz, sodass die Tasten 0/4/8/C unabhängig voneinander verwendet werden können.
1. Software-Engineering: Wir erstellen zwei neue Dateien, c51_key.c und c51_key.h, wenden Includes.h in c51_key.c an, schließen c51_key.h in Includes.h ein und fügen die beiden Dateien dem Projekt hinzu, wie das Bild zeigt.

Fügen Sie hier eine Bildbeschreibung ein

Da wir den Tastenwert anzeigen möchten, verwenden wir die vordere digitale Röhre, um die Daten anzuzeigen.
Die Anzeigefunktion ist unten dargestellt.

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

Implementieren Sie in c51_key.c die Schlüsselerkennung

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

Zitiert im Hauptprogramm 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 Schaltflächenfiltermethode

/********************************************************
函数名称: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 Design der Matrix-Tastensoftware

//Zeige den Segmentcodewert 01234567 an, der entsprechend dem Schaltplan angezeigt werden kann, und zeige den Pin-High-Point-Level-Konfigurationsstatus entsprechend verschiedenen Grafiken an.

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 Button Protues-Simulation

Unabhängige Taste zur Anzeige des Ergebnisses, DIP-Schalter, verbinden Sie ein Ende der Taste mit Masse

Fügen Sie hier eine Bildbeschreibung ein

Tastensimulation der Matrix-Tastatur:Fügen Sie hier eine Bildbeschreibung ein

4 Zusammenfassung der wichtigsten Operationen

Bei Mikrocontroller-Anwendungen ist die Zuverlässigkeit der Schlüsselerkennung von entscheidender Bedeutung, um eine korrekte Eingabe und einen stabilen Systembetrieb sicherzustellen. Hier sind einige Designprinzipien zur Verbesserung der Schlüsselerkennungszuverlässigkeit:

  1. Beseitigen Sie Tastenzittern: Tastenzittern bezieht sich auf das kurzzeitige instabile Signal, das beim Drücken oder Loslassen einer Taste erzeugt wird. Um Jitter zu eliminieren, können Hardware- oder Software-Jitter-Eliminierungsmethoden verwendet werden. Hardwareseitig können externe Kondensatoren oder RC-Netzwerke zur Jitter-Filterung eingesetzt werden. Softwareseitig können Software-Verzögerungen oder Zustandsmaschinen zur Stabilisierung wichtiger Signale eingesetzt werden.
  2. Verwenden Sie externe Pull-Up-/Pull-Down-Widerstände: Durch die Verwendung eines externen Pull-Up- oder Pull-Down-Widerstands, der an den Tastenstift angeschlossen wird, können Sie sicherstellen, dass die Taste stabil bleibt, wenn sie nicht gedrückt wird. Dadurch werden schwebende Signale verhindert, wenn Tasten nicht gedrückt werden.
  3. Verzögerungs- und Entprellungsalgorithmen: Die Implementierung geeigneter Verzögerungs- und Entprellungsalgorithmen in Software kann die Zuverlässigkeit der Tastenanschlagserkennung verbessern. Eine Verzögerung kann einen stabilen Schlüsselstatus gewährleisten und Fehlauslösungen vermeiden. Der Entprellalgorithmus kann Tastendruck-Jitter herausfiltern, um sicherzustellen, dass nur gültige Tastendruckvorgänge erkannt werden.
  4. Mehrfacherkennung und -bestätigung: Um die Zuverlässigkeit zu verbessern, können mehrere Schlüsselerkennungs- und -bestätigungsmechanismen verwendet werden. Beispielsweise kann ein Software-Timer oder Interrupt verwendet werden, um den Schlüsselstatus regelmäßig zu erkennen, und mehrere Bestätigungen können verwendet werden, um die effektive Auslösung des Schlüssels sicherzustellen.
  5. Eingabepuffer und Zustandsautomaten: Verwenden Sie Eingabepuffer, um Tasteneingaben zu speichern, und verwenden Sie dann einen Zustandsautomaten, um die Eingaben zu verarbeiten. Die Zustandsmaschine kann den Schlüsselstatus verfolgen und Schlüsselereignisse verarbeiten, um die Korrektheit und Stabilität der Schlüsseloperationen sicherzustellen.
  6. Störungsisolierung von Stromversorgung und Erdungskabel: Um den Einfluss von Stromversorgungsstörungen und Erdungsleitungsrückführung auf das Schlüsselsignal zu verhindern, können geeignete Isolationsmaßnahmen ergriffen werden. Verwenden Sie beispielsweise separate Strom- und Masseebenen oder verwenden Sie Filter, um Störungen zu reduzieren.
  7. Fehlertoleranzmechanismen für Hardware und Software: Entwerfen Sie Fehlertoleranzmechanismen, um die Zuverlässigkeit der Tasteneingabe zu schützen, wenn Fehler oder ungewöhnliche Bedingungen auftreten. Beispielsweise können Redundanzerkennung, Prüfsummenerkennung, Fehlerbehandlungs- und Wiederherstellungsmechanismen usw. verwendet werden.
    Im Allgemeinen muss ein zuverlässiges Schlüsselerkennungsdesign verschiedene Faktoren in Hardware und Software umfassend berücksichtigen und entsprechend spezifische Anwendungsszenarien entsprechende Optimierungen und Anpassungen vornehmen. Durch die richtige Gestaltung und Implementierung kann die Stabilität, Genauigkeit und Zuverlässigkeit der Schlüssel gewährleistet werden.