Embedded C ist die beliebteste Programmiersprache im Softwarebereich für die Entwicklung elektronischer Geräte. Jeder Prozessor ist eingebetteter Software zugeordnet. Embedded C-Programmierung spielt eine wichtige Rolle bei der Ausführung bestimmter Funktionen durch den Prozessor. In unserem täglichen Leben verwenden wir häufig viele elektronische Geräte wie Waschmaschinen, Mobiltelefone, Digitalkameras usw., die auf Mikrocontrollern basieren, die von Embedded C programmiert werden.
Programmierung eingebetteter Systeme
Der geschriebene C-Code ist zuverlässiger, portabler und skalierbarer und in der Tat viel einfacher zu verstehen. Das erste und wichtigste Tool ist die eingebettete Software, die über den Betrieb eines eingebetteten Systems entscheidet. Die Programmiersprache Embedded C wird am häufigsten zum Programmieren der Mikrocontroller verwendet.
Tutorial zur Embedded C-Programmierung (8051)
Zum Schreiben des Programms müssen die eingebetteten Entwickler über ausreichende Kenntnisse der Hardware bestimmter Prozessoren oder Controller verfügen, da die eingebettete C-Programmierung eine vollständige hardwarebezogene Programmiertechnik ist.
Programmier-Tutorial
Zuvor wurden viele eingebettete Anwendungen mithilfe der Programmierung auf Baugruppenebene entwickelt. Sie boten jedoch keine Portabilität, um dieses Problem mit dem Aufkommen verschiedener Hochsprachen wie C, COBOL und Pascal zu überwinden. Es war jedoch die C-Sprache, die breite Akzeptanz fand Anwendungsentwicklung für eingebettete Systeme und das tut es auch weiterhin.
Eingebettetes System
Das eingebettete System ist definiert als die Kombination aus eingebetteter C-Programmiersoftware und Hardwareteil, die hauptsächlich aus Mikrocontrollern besteht und die spezifische Aufgabe ausführen soll. Diese Arten von eingebetteten Systemen werden in unserem täglichen Leben verwendet, wie Waschmaschinen und Videorecorder, Kühlschränke und so weiter. Das eingebettete System wurde erstmals von den 8051-Mikrocontrollern eingeführt.
Eingebettetes System
Einführung in den 8051 Microcontroller
Der 8051-Mikrocontroller ist ein grundlegender Mikrocontroller. Er wird erstmals seit 1970 von der Intel Corporation eingeführt. Er wird von der 8086-Prozessorarchitektur entwickelt. Der 8051 ist eine Familie des Mikrocontrollers, der von verschiedenen Herstellern wie Philips, Atmel, Dalls usw. entwickelt wurde. Die 8051 Mikrocontroller wurde in vielen eingebetteten Produkten verwendet, von kleinen Kinderspielzeugen bis zu großen Automobilsystemen.
8051 Mikrocontroller
Der 8051-Mikrocontroller ist der 8-Bit CISC-Architektur . Es besteht aus Speichern, serieller Kommunikation, Interrupts, Eingangs- / Ausgangsanschlüssen und Zeitgebern / Zählern, die in einen einzigen integrierten Chip eingebaut sind, der so programmiert ist, dass er die mit ihm verbundenen Peripheriegeräte steuert. Das Programm ist im RAM des Mikrocontrollers gespeichert, aber bevor wir das Programm schreiben, müssen wir den RAM kennen Organisation des Mikrocontrollers.
Programmierung eingebetteter Systeme: Grundlegende Erklärung
Jede Funktion ist eine Sammlung von Anweisungen, die eine bestimmte Aufgabe ausführen, und die Sammlung einer oder mehrerer Funktionen wird als Programmiersprache bezeichnet. Jede Sprache besteht aus einigen Grundelementen und grammatikalischen Regeln. Die C-Sprachprogrammierung funktioniert mit dem Zeichensatz. Variablen, Datentypen, Konstanten, Schlüsselwörter, Ausdrücke usw. werden zum Schreiben eines C-Programms verwendet. All dies wird unter der Header- oder Bibliotheksdatei betrachtet und als dargestellt
#einschließen
Embedded C-Programmierentwicklung
Die Erweiterung der C-Sprache wird als Embedded C-Programmiersprache bezeichnet. Im Vergleich zu oben bietet die eingebettete Programmierung in C-Sprache einige zusätzliche Funktionen wie Datentypen und Schlüsselwörter, und die Header- oder Bibliotheksdatei wird als dargestellt
#einschließen
Embedded C Zusätzliche Schlüsselwörter
- sbit
- bisschen
- SFR
- flüchtig
- Makros definieren
Das 'sbit' wird zum Deklarieren der einzelnen PIN des Mikrocontrollers verwendet. Zum Beispiel ist die LED mit dem P0.1-Pin verbunden. Es wird nicht empfohlen, den Wert direkt an den Port-Pin zu senden. Zuerst müssen wir den Pin mit einer anderen Variablen deklarieren und dann, nachdem wir ihn irgendwo im Programm verwenden können.
Syntax: sbit a = P0 ^ 1 // deklariert den jeweiligen Pin mit einer Variablen //
a = 0x01 // Sende den Wert an den Port Pin //
Das „Bit“ dient zur Überprüfung des Status der Variablen.
Syntax: Bit c // deklariert die Bitvariable //
c = a // der c-Variablen // wird ein Wert zugewiesen
if (c == 1) // überprüfe die Bedingung wahr oder falsch //
{
… ..
……
}}
Das Schlüsselwort 'SFR' wird verwendet, um unter einem anderen Namen auf die SFR-Register zuzugreifen. Das SFR-Register definiert als Sonderfunktionsregister enthält es alle peripher verwandten Register durch Angabe der Adresse. Das SFR-Register wird durch das Schlüsselwort SFR deklariert. Das SFR-Schlüsselwort muss in Großbuchstaben geschrieben werden.
Syntax: SFR port = 0x00 // 0x00 ist eine Port0-Adresse, die von der Portvariablen // deklariert wird
Port = 0x01 // dann sende den Wert an port0 //
verzögern()
Port = 0x00
verzögern()
Das Schlüsselwort 'volatile' ist das wichtigste in der Entwicklung eingebetteter Systeme. Die Variable, die mit dem flüchtigen Schlüsselwortwert deklariert wird, konnte nicht unerwartet geändert werden. Es kann in speicherabgebildeten Peripherieregistern verwendet werden, globalen Variablen, die von den ISRs modifiziert werden. Ohne die Verwendung des flüchtigen Schlüsselworts zum Senden und Empfangen der Daten tritt ein Codefehler oder ein Optimierungsfehler auf.
Syntax: volatile int k
Das Makro ist ein Name, mit dem der Anweisungsblock als Vorprozessor-Direktive deklariert wird. Immer wenn der Name verwendet wird, wird er durch den Inhalt des Makros ersetzt. Die Makros repräsentieren die #define. Die gesamten Port-Pins werden durch die Makros definiert.
Syntax: #define dat Po // Der gesamte Port wird durch eine Variable // deklariert
dat = 0x01 // Daten an Port0 senden //
Grundlegende eingebettete C-Programme
Die Programmierung des Mikrocontrollers ist für jeden unterschiedlich Art des Betriebssystems . Obwohl es viele Betriebssysteme gibt, wie Linux, Windows, RTOS und so weiter. RTOS bietet jedoch mehrere Vorteile für die Entwicklung eingebetteter Systeme. Dieser Artikel beschreibt die grundlegende Embedded C-Programmierung zur Entwicklung der Embedded C-Programmierung mit einem 8051-Mikrocontroller.
Embedded C-Programmierschritte
- LED blinkt mit 8051 Mikrocontroller
- Nummernanzeige auf 7-Segment-Anzeige mit 8051-Mikrocontroller
- Timer / Zähler-Berechnungen und Programmierung mit dem 8051-Mikrocontroller
- Berechnungen und Programme für die serielle Kommunikation mit dem 8051-Mikrocontroller
- Unterbrechen Sie Programme mit dem 8051-Mikrocontroller
- Tastaturprogrammierung mit 8051 Mikrocontroller
- LCD-Programmierung mit 8051 Mikrocontroller
LED blinkt mit 8051 Mikrocontroller
Die LED ist ein Halbleiterbauelement, das in vielen Anwendungen verwendet wird, hauptsächlich zu Anzeigezwecken. Während des Tests wird eine Vielzahl von Anwendungen als Indikatoren gefunden, um die Gültigkeit der Ergebnisse in verschiedenen Phasen zu überprüfen. Sie sind sehr billig und leicht in einer Vielzahl von Formen, Farben und Größen erhältlich. Die LEDs werden zum Entwerfen verwendet Nachrichtenanzeigetafeln und Verkehrssteuerungssignallampen usw. Hier sind die LEDs mit dem PORT0 der 8051-Mikrocontroller verbunden.
LED blinkt mit 8051 Mikrocontroller
1. 01010101
10101010
#include // Header-Datei //
void main () // der Statistikpunkt für die Programmausführung //
{
unsigned int i // Datentyp //
while (1) // für Endlosschleife //
{
P0 = 0x55 // sende den Hexa-Wert an port0 //
für (i = 0i<30000i++) //normal delay//
P0 = 0x3AA // sende den Hexa-Wert an port0 //
für (i = 0i<30000i++) //normal delay//
}}
}}
2. 00000001
00000010
00000100
.
.
10.000.000
#einschließen
void main ()
{
unsignedint i
vorzeichenloses Zeichen j, b
während (1)
{
P0 = 0x01
b = P0
für (j-0j<3000j++)
für (j = 0j<8j++)
{
b = b<<1
P0 = b
für (j-0j<3000j++)
}}
}}
}}
3. 00001111
11110000
#einschließen
void main ()
{
unsignedint i
während (1)
{
P0 = 0x0F
für (j-0j<3000j++)
P0 = 0xF0
für (j-0j<3000j++)
}}
}}
4. 00000001
00000011
00000111
.
.
11111111
#einschließen
void main ()
{
unsignedint i
vorzeichenloses Zeichen j, b
während (1)
{
P0 = 0x01
b = P0
für (j-0j<3000j++)
für (j = 0j<8j++)
0x01
P0 = b
für (j-0j<3000j++)
}}
}}
Anzeigen von Zahlen auf einer 7-Segment-Anzeige mit dem 8051 Microcontroller
Das 7-Segment-Anzeigen ist die grundlegende elektronische Anzeige, die in vielen Systemen zur Anzeige der numerischen Informationen verwendet wird. Es besteht aus acht LEDs, die nacheinander angeschlossen werden, um Ziffern von 0 bis 9 anzuzeigen, wenn die richtigen LED-Kombinationen eingeschaltet sind. Sie können jeweils nur eine Ziffer anzeigen.
Anzeigen von Zahlen auf einer 7-Segment-Anzeige mit dem 8051 Microcontroller
1. WAP, um die Zahlen von „0 bis F“ auf vier 7-Segment-Anzeigen anzuzeigen?
#einschließen
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
void main ()
{
unsignedchar n [10] = {0 × 40,0xF9,0 × 24,0 × 30,0 × 19,0 × 12,0 × 02,0xF8,0xE00,0 × 10}
unsigniert, j
a = b = c = d = 1
während (1)
{
für (i = 0i<10i++)
{
P2 = n [i]
für (j = 0j<60000j++)
}}
}}
}}
2. WAP, um die Zahlen von '00 bis 10' auf 7-Segment-Displays anzuzeigen?
#einschließen
sbit a = P3 ^ 0
sbit b = P3 ^ 1
void display1 ()
void display2 ()
void delay ()
void main ()
{
unsignedchar n [10] = {0 × 40,0xF9,0 × 24,0 × 30,0 × 19,0 × 12,0 × 02,0xF8,0xE00,0 × 10}
unsigniert, j
ds1 = ds2 = 0
während (1)
{
für (i = 0, i<20i++)
display1 ()
display2 ()
}}
}}
void display1 ()
{
a = 1
b = 0
P2 = s [ds1]
verzögern()
a = 1
b = 0
P2 = s [ds1]
verzögern()
}}
void display2 ()
{
ds1 ++
if (ds1> = 10)
{
ds1 = 0
ds2 ++
if (ds2> = 10)
{
ds1 = ds2 = 0
}}
}}
}}
void delay ()
{
unsignedint k
für (k = 0k<30000k++)
}}
Timer- / Zählerberechnungen und Programmierung mit dem 8051-Mikrocontroller
Die Verzögerung ist einer der wichtigsten Faktoren bei der Entwicklung von Anwendungssoftware. Die normale Verzögerung liefert jedoch nicht das wertvolle Ergebnis, um dieses Problem bei der Implementierung der Zeitgeberverzögerung zu überwinden. Das Timer und Zähler sind Hardwarekomponenten des Mikrocontrollers, der in vielen Anwendungen verwendet wird, um die kostbare Zeitverzögerung mit Zählimpulsen bereitzustellen. Beide Aufgaben werden durch die Softwaretechnik implementiert.
Timer-Verzögerung
WAP zur Erzeugung der 500us-Zeitverzögerung mit T1M2 (Timer1 und Modus2)?
#einschließen
void main ()
{
vorzeichenloses Zeichen i
TMOD = 0x20 // Timer-Modus einstellen //
für (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // Zeitverzögerung einstellen //
TH1 = 0x00
TR1 = 1 // Timer auf //
Während (TF1 == 0) // das Flagbit prüfen //
TF1 = 0
}}
TR1 = 0 // Timer aus //
}}
Normale Schleifenverzögerung
void delay ()
{
unsignedint k
für (k = 0k<30000k++)
}}
Berechnungen und Programme für die serielle Kommunikation mit dem 8051 Microcontroller
Serielle Kommunikation wird üblicherweise zum Senden und Empfangen des Signals verwendet. Der 8051 Mikrocontroller besteht aus Serielle UART-Kommunikation die von den Rx- und Tx-Pins gesendeten und empfangenen Signale. Der UART nimmt Datenbytes auf und sendet die einzelnen Bits nacheinander. Die Register sind eine Möglichkeit, die Daten zu sammeln und im Speicher zu speichern. UART ist ein Halbduplex-Protokoll. Halbduplex bedeutet das Senden und Empfangen der Daten, jedoch nicht gleichzeitig.
Berechnungen und Programme für die serielle Kommunikation mit dem 8051 Microcontroller
1. WAP, um das Zeichen 'S' an das serielle Fenster zu übertragen, verwenden Sie 9600 als Baudrate?
28800 ist die maximale Baudrate des 8051-Mikrocontrollers
28800/9600 = 3
Diese Baudrate „3“ wird in den Timern gespeichert
#einschließen
void main ()
{
SCON = 0x50 // Starten Sie die serielle Kommunikation //
TNOD = 0x20 // Timer-Modus ausgewählt //
TH1 = 3 // Baudrate laden //
TR1 = 1 // Timer EIN //
SBUF = 'S' // speichere das Zeichen im Register //
while (TI == 0) // Interrupt-Register prüfen //
TI = 0
TR1 = 0 // Timer ausschalten //
while (1) // Endlosschleife //
}}
2. WAP, um die Daten vom Hyperterminal zu empfangen und diese Daten mit 9600 Baud an den PORT 0 des Mikrocontrollers zu senden?
28800 ist die maximale Baudrate des 8051-Mikrocontrollers
28800/9600 = 3
Diese Baudrate „3“ wird in den Timern gespeichert
#einschließen
void main ()
{
SCON = 0x50 // Starten Sie die serielle Kommunikation //
TMOD = 0x20 // Timer-Modus ausgewählt //
TH1 = 3 // Baudrate laden //
TR1 = 1 // Timer EIN //
PORT0 = SBUF // Sende die Daten von SBUF an Port0 //
while (RI == 0) // Interrupt-Register prüfen //
RI = 0
TR1 = 0 // Timer ausschalten //
while (1) // Programm stoppen, wenn Zeichen empfangen werden //
}}
Unterbrechen Sie Programme mit dem 8051 Microcontroller
Der Interrupt ist ein Signal, das zwingt, das aktuelle Programm anzuhalten und das andere Programm sofort auszuführen. Der 8051-Mikrocontroller bietet 6 Interrupts, die intern und extern sind Interruptquellen . Wenn der Interrupt auftritt, pausiert der Mikrocontroller die aktuelle Aufgabe und kümmert sich um den Interrupt, indem er den ISR ausführt. Dann kehrt der Mikrocontroller zur letzten Aufgabe zurück.
WAP, um eine Linksverschiebungsoperation durchzuführen, wenn Timer 0-Interrupts auftreten, und dann die Interruptoperation für den P0 in der Hauptfunktion auszuführen?
#einschließen
vorzeichenloses Zeichen b
void timer0 () Interrupt 2 // ausgewählter Timer0 Interrupt //
{
b = 0x10
P1 = b<<2
}}
void main ()
{
vorzeichenloses Zeichen a, i
IE = 0x82 // Timer0 Interrupt aktivieren //
TMOD = 0x01
TLo = 0xFC // Interrupt-Timer //
TH1 = 0xFB
TR0 = 1
a = 0x00
während (1)
{
für (i = 0i<255i++)
{
a ++
Po = a
}}
}}
}}
Tastaturprogrammierung mit 8051 Microcontroller
Die Matrixtastatur ist ein analoges Schaltgerät, das in vielen eingebetteten Anwendungen verwendet wird, damit der Benutzer die erforderlichen Aufgaben ausführen kann. EIN Matrixtastatur besteht aus einer Anordnung von Schaltern im Matrixformat in Zeilen und Spalten. Die Zeilen und Spalten sind so mit dem Mikrocontroller verbunden, dass die Reihe der Schalter mit einem Pin verbunden ist und die Schalter in jeder Spalte mit einem anderen Pin verbunden sind, und führen dann die Operationen aus.
Tastaturprogrammierung mit 8051 Microcontroller
1. WAP, um die LED durch Drücken des Schalters umzuschalten
#einschließen
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
void delay ()
void main ()
{
während (1)
{
a = 0
b = 1
c = 1
d = 1
verzögern()
a = 1
b = 0
c = 1
d = 1
void delay ()
{
vorzeichenloses Zeichen i
TMOD = 0x20 // Timer-Modus einstellen //
für (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // Zeitverzögerung einstellen //
TH1 = 0x00
TR1 = 1 // Timer auf //
Während (TF1 == 0) // das Flagbit prüfen //
TF1 = 0
}}
TR1 = 0 // Timer aus //
}}
2. WAP zum Einschalten der LED durch Drücken der Taste '1' auf der Tastatur?
#einschließen
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
sbit LED = P0 ^ 1
void main ()
{
r1 = 0
if (c1 == 0)
{
LED = 0xff
}}
}}
3. WAP, um die Nummer 0,1,2,3,4,5 auf dem Siebensegment anzuzeigen, indem Sie die entsprechende Taste auf der Tastatur drücken?
#einschließen
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
sbit r2 = P2 ^ 0
sbit c2 = P3 ^ 0
sbit a = P0 ^ 1
void main ()
{
r1 = 0 a = 1
if (c1 == 0)
{
a = 0xFC
}}
Wenn (c2 == 0)
{
a = 0x60
}}
if (c3 == 0)
{
a = 0xDA
}}
Wenn (c4 == 0)
{
a = 0xF2
}}
}}
LCD-Programmierung mit 8051 Mikrocontroller
Das LCD Bildschirm ist ein elektronisches Gerät, das in vielen Anwendungen häufig zur Anzeige von Informationen in einem Text- oder Bildformat verwendet wird. Das LCD ist ein Display, auf dem leicht Zeichen auf dem Bildschirm angezeigt werden können. Das LCD-Display besteht aus 8 Datenleitungen und 3 Steuerleitungen, die als Schnittstelle zum Mikrocontroller verwendet werden.
LCD-Programmierung mit 8051 Mikrocontroller
WAP zur Anzeige der „EDGEFX KITS“ auf der LED-Anzeige?
#einschließen
#define kam P0
voidlcd_initi ()
voidlcd_dat (vorzeichenloses Zeichen)
voidlcd_cmd (vorzeichenloses Zeichen)
void delay ()
void display (vorzeichenlose Zeichen, vorzeichenlose Zeichen)
sbitrs = P2 ^ 0
sbitrw = P2 ^ 1
sbit bei = P2 ^ 2
void main ()
{
lcd_initi ()
lcd_cmd (0x80)
Verzögerung (100)
lcd_cmd (0xc0)
Anzeige ('edgefx Kits', 11)
während (1)
}}
void display (vorzeichenlose Zeichen, vorzeichenlose Zeichen)
{
unsignedint w
für (w = 0w
lcd_data (s [w])
}}
}}
voidlcd_initi ()
{
lcd_cmd (0 × 01)
Verzögerung (100)
lcd_cmd (0 × 38)
Verzögerung (100)
lcd_cmd (0 × 06)
Verzögerung (100)
lcd_cmd (0x0c)
Verzögerung (100)
}}
voidlcd_dat (vorzeichenloses char dat)
{
Kamm = das
rs = 1
rw = 0
in = 1
Verzögerung (100)
in = 0
}}
}}
voidlcd_cmd (vorzeichenloses Zeichen cmd)
{
kam=cmd
rs = 0
rw = 0
in = 1
Verzögerung (100)
in = 0
}}
ungültige Verzögerung (unsigned int n)
{
unsignedint a
für (a = 0a
Hoffe, dieser Artikel enthält grundlegende Informationen zur Programmierung eingebetteter Systeme mit dem 8051-Mikrocontroller mit einigen Beispielprogrammen. Für ein detailliertes Tutorial zur Embedded C-Programmierung veröffentlichen Sie bitte Ihre Kommentare und Fragen im Kommentarbereich unten.
