Embedded C este cel mai popular limbaj de programare din domeniul software pentru dezvoltarea gadgeturilor electronice. Fiecare procesor este asociat cu software încorporat. Programare C încorporată joacă un rol major în îndeplinirea funcțiilor specifice de către procesor. În viața noastră de zi cu zi, folosim frecvent multe dispozitive electronice, cum ar fi mașini de spălat, telefoane mobile, camere digitale și așa mai departe, vor funcționa pe baza microcontrolerelor programate de C încorporat.
Programarea sistemului încorporat
Codul C scris este mai fiabil, portabil și scalabil și, de fapt, mult mai ușor de înțeles. Primul și cel mai important instrument este software-ul încorporat care decide funcționarea unui sistem încorporat. Limbajul de programare C încorporat este cel mai frecvent utilizat pentru programarea microcontrolerelor.
Tutorial de programare încorporat C (8051)
Pentru scrierea programului, proiectanții încorporați trebuie să aibă cunoștințe suficiente despre hardware-ul anumitor procesoare sau controlere, deoarece programarea C încorporată este o tehnică completă de programare legată de hardware.
Tutorial de programare
Anterior, multe aplicații încorporate au fost dezvoltate prin utilizarea programării la nivel de asamblare. Cu toate acestea, nu au oferit portabilitate pentru a depăși această problemă odată cu apariția diferitelor limbaje la nivel înalt, cum ar fi C, COBOL și Pascal. Cu toate acestea, limbajul C a fost acceptat pe scară largă dezvoltarea de aplicații de sisteme încorporate , și continuă să o facă.
Sistem incorporat
Sistemul încorporat este definit ca combinația dintre software-ul de programare C încorporat și partea hardware constă în mare parte din microcontrolere și este destinat să îndeplinească sarcina specifică. Aceste tipuri de sisteme încorporate sunt utilizate în viața noastră de zi cu zi, cum ar fi mașini de spălat și înregistratoare video, frigidere și așa mai departe. Sistemul încorporat a fost introdus pentru prima dată de microcontrolerele 8051.
Sistem incorporat
Introducere în microcontrolerul 8051
Microcontrolerul 8051 este un microcontroler de bază, este introdus pentru prima dată de „Intel Corporation” din 1970. Este dezvoltat de arhitectura procesorului 8086. 8051 este o familie de microcontroler, care a fost dezvoltată de diferiți producători precum Philips, Atmel, dalls și așa mai departe. Microcontrolerele 8051 a fost folosit în multe produse încorporate, de la jucării pentru copii mici la sisteme mari de automobile.
8051 Microcontroler
Microcontrolerul 8051 este pe 8 biți Arhitectura „CISC” . Se compune din memorii, comunicații seriale, întreruperi, porturi de intrare / ieșire și temporizator / contoare, încorporate într-un singur cip integrat, care este programat pentru a controla dispozitivele periferice care sunt interfațate cu acesta. Programul este stocat în memoria RAM a microcontrolerului, dar înainte de a scrie programul, trebuie să fim conștienți de memoria RAM organizare a microcontrolerului.
Programarea sistemului încorporat: Declarație de bază
Fiecare funcție este o colecție de instrucțiuni care efectuează o sarcină specifică, iar colectarea uneia sau mai multor funcții se numește limbaj de programare. Fiecare limbă constă din câteva elemente de bază și reguli gramaticale. Programarea limbajului C este concepută pentru a funcționa cu setul de caractere, variabilele, tipurile de date, constantele, cuvintele cheie, expresiile și așa mai departe sunt utilizate pentru a scrie un program C. Toate acestea sunt considerate sub fișierul antet sau fișier bibliotecă și este reprezentat ca
#include
Dezvoltarea programării Embedded C
Extensia limbajului C se numește limbaj de programare Embedded C. Comparativ cu cele de mai sus, programarea încorporată în limbajul C are câteva caracteristici suplimentare, cum ar fi tipurile de date și cuvintele cheie, iar fișierul antet sau fișierul bibliotecii este reprezentat ca
#include
Cuvinte cheie suplimentare încorporate C
- sbit
- pic
- SFR
- volatil
- macro-urile definesc
„Sbit” este utilizat pentru declararea codului PIN unic al microcontrolerului. De exemplu, LED-ul este conectat la pinul P0.1, nu este recomandat să trimiteți valoarea direct la pinul portului, mai întâi, trebuie să declarăm pinul cu o altă variabilă, apoi după ce putem folosi oriunde în program.
Sintaxă: sbit a = P0 ^ 1 // declară pinul respectiv cu o variabilă //
a = 0x01 // trimiteți valoarea la pinul portului //
„Bitul” este utilizat pentru verificarea stării variabilei.
Sintaxă: bitul c // declară variabila de bit //
c = a // o valoare este atribuită variabilei c //
if (c == 1) // verificați condiția true sau false //
{
... ..
……
}
Cuvântul cheie „SFR” este utilizat pentru a accesa registrele SFR cu un alt nume. Registrul SFR definit ca a registru de funcții speciale , conține toate registrele legate periferic prin indicarea adresei. Registrul SFR este declarat de cuvântul cheie SFR. Cuvântul cheie SFR trebuie să fie cu majuscule.
Sintaxă: port SFR = 0x00 // 0x00 este o adresă port0 este declarată de variabila de port //
Port = 0x01 // apoi trimiteți valoarea la port0 //
întârziere()
port = 0x00
întârziere()
Cuvântul cheie „volatil” este cel mai important în dezvoltarea sistemului încorporat. Variabila care declară cu valoarea volatilă a cuvântului cheie nu a putut fi modificată în mod neașteptat. Poate fi utilizat în registre periferice mapate cu memorie, variabile globale modificate de ISR-uri. Fără a utiliza cuvântul cheie volatil pentru transmiterea și primirea datelor, va avea loc o eroare de cod sau o eroare de optimizare.
Sintaxă: volatile int k
Macrocomanda este un nume folosit pentru a declara blocul de instrucțiuni ca directivă pre-procesor. Ori de câte ori este folosit numele, acesta este înlocuit cu conținutul macro-ului. Macrocomenzile reprezintă #define. Toți pinii portului sunt definiți de macro-uri.
Sintaxă: #define dat Po // întregul port este declarat de o variabilă //
dat = 0x01 // datele trimise către port0 //
Programe de bază Embedded C
Programarea microcontrolerului va fi diferită pentru fiecare tipul sistemului de operare . Chiar dacă există multe sisteme de operare, cum ar fi Linux, Windows, RTOS și așa mai departe. Cu toate acestea, RTOS are mai multe avantaje pentru dezvoltarea sistemului încorporat. Acest articol discută despre programarea C de bază încorporată pentru a dezvolta programarea C încorporată utilizând un microcontroler 8051.
Pași de programare C încorporat
- LED intermitent folosind microcontrolerul 8051
- Afișarea numărului pe afișajul pe 7 segmente utilizând microcontrolerul 8051
- Calculatoare de timp / contor și program folosind microcontrolerul 8051
- Calculele și programul comunicării seriale utilizând microcontrolerul 8051
- Întrerupeți programele folosind microcontrolerul 8051
- Programarea tastaturii folosind microcontrolerul 8051
- Programare LCD cu microcontroler 8051
LED intermitent folosind microcontrolerul 8051
LED-ul este un dispozitiv semiconductor care este utilizat în multe aplicații, în special pentru indicare. Acesta găsește o gamă largă de aplicații ca indicatori în timpul testului pentru a verifica validitatea rezultatelor în diferite etape. Sunt foarte ieftine și ușor disponibile într-o varietate de forme, culori și dimensiuni. LED-urile sunt folosite pentru proiectare panouri de afișare a mesajelor și semnalizatoarele de control al traficului etc. Aici LED-urile sunt interfațate cu PORT0 al microcontrolerelor 8051.
LED intermitent folosind microcontrolerul 8051
1. 01010101
10101010
#include // fișier antet //
void main () // Punctul statistic de execuție a programului //
{
unsigned int i // tip de date //
while (1) // pentru buclă continuă //
{
P0 = 0x55 // trimiteți valoarea hexa la port0 //
pentru (i = 0i<30000i++) //normal delay//
P0 = 0x3AA // trimiteți valoarea hexa la port0 //
pentru (i = 0i<30000i++) //normal delay//
}
}
2. 00000001
00000010
00000100
.
.
10.000.000
#include
void main ()
{
unsignedint i
char nesemnat j, b
în timp ce (1)
{
P0 = 0x01
b = P0
pentru (j-0j<3000j++)
pentru (j = 0j<8j++)
{
b = b<<1
P0 = b
pentru (j-0j<3000j++)
}
}
}
3. 00001111
11110000
#include
void main ()
{
unsignedint i
în timp ce (1)
{
P0 = 0x0F
pentru (j-0j<3000j++)
P0 = 0xF0
pentru (j-0j<3000j++)
}
}
4. 00000001
00000011
00000111
.
.
11111111
#include
void main ()
{
unsignedint i
char nesemnat j, b
în timp ce (1)
{
P0 = 0x01
b = P0
pentru (j-0j<3000j++)
pentru (j = 0j<8j++)
0x01
P0 = b
pentru (j-0j<3000j++)
}
}
Afișarea numerelor pe afișajul cu 7 segmente utilizând microcontrolerul 8051
Afișaje pe 7 segmente este afișajele electronice de bază, care sunt utilizate în multe sisteme pentru a afișa informațiile numerice. Se compune din opt LED-uri care sunt conectate în mod secvențial, astfel încât să afișeze cifre de la 0 la 9, când sunt activate combinații adecvate de LED-uri. Ele pot afișa doar o singură cifră la un moment dat.
Afișarea numerelor pe afișajul cu 7 segmente utilizând microcontrolerul 8051
1. WAP pentru a afișa numerele de la „0 la F” pe patru afișaje pe 7 segmente?
#include
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}
te-a nesemnat, j
a = b = c = d = 1
în timp ce (1)
{
pentru (i = 0i<10i++)
{
P2 = n [i]
pentru (j = 0j<60000j++)
}
}
}
2. WAP pentru a afișa numerele de la '00 la 10 'pe afișajele de 7 segmente?
#include
sbit a = P3 ^ 0
sbit b = P3 ^ 1
afișare nulă 1 ()
afișare nulă 2 ()
void delay ()
void main ()
{
unsignedchar n [10] = {0 × 40,0xF9,0 × 24,0 × 30,0 × 19,0 × 12,0 × 02,0xF8,0xE00,0 × 10}
te-a nesemnat, j
ds1 = ds2 = 0
în timp ce (1)
{
pentru (i = 0, i<20i++)
display1 ()
display2 ()
}
}
afișare nulă 1 ()
{
a = 1
b = 0
P2 = s [ds1]
întârziere()
a = 1
b = 0
P2 = s [ds1]
întârziere()
}
afișare nulă 2 ()
{
ds1 ++
dacă (ds1> = 10)
{
ds1 = 0
ds2 ++
dacă (ds2> = 10)
{
ds1 = ds2 = 0
}
}
}
void delay ()
{
unsignedint k
pentru (k = 0k<30000k++)
}
Timer / Contor Calcule și program folosind microcontrolerul 8051
Întârzierea este unul dintre factorii importanți în dezvoltarea software-ului de aplicații. Cu toate acestea, întârzierea normală nu va da rezultatul prețios pentru a depăși această problemă pentru implementarea întârzierii temporizatorului. cronometre și contoare sunt componente hardware ale microcontrolerului, care este utilizat în multe aplicații pentru a oferi prețioasa întârziere cu impulsuri de numărare. Ambele sarcini sunt implementate prin tehnica software.
Timer întârziere
WAP pentru a genera o întârziere de 500us folosind T1M2 (timer1 și mode2)?
#include
void main ()
{
nesemnat char i
TMOD = 0x20 // setați modul temporizator //
pentru (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // setează întârzierea //
TH1 = 0x00
TR1 = 1 // cronometru oN //
While (TF1 == 0) // verificați bitul de semnalizare //
TF1 = 0
}
TR1 = 0 // cronometru oprit //
}
Întârziere normală a buclei
void delay ()
{
unsignedint k
pentru (k = 0k<30000k++)
}
Calculele și programul comunicării seriale utilizând microcontrolerul 8051
Comunicarea în serie este frecvent utilizată pentru transmiterea și recepționarea semnalului. Microcontrolerul 8051 conține Comunicare serial UART semnalele transmise și recepționate de pinii Rx și Tx. UART preia octeți de date și trimite biții individuali într-o manieră secvențială. Registrele sunt o modalitate de a colecta și stoca datele în memorie. UART este un protocol semi-duplex. Half-duplex înseamnă transferul și primirea datelor, dar nu în același timp.
Calculele și programul comunicării seriale utilizând microcontrolerul 8051
1. WAP pentru a transmite caracterul „S” ferestrei seriale utilizați 9600 ca viteză de transmisie?
28800 este rata de transmisie maximă a microcontrolerului 8051
28800/9600 = 3
Această rată de transmisie „3” este stocată în temporizatoare
#include
void main ()
{
SCON = 0x50 // pornește comunicarea în serie //
TNOD = 0x20 // a selectat modul temporizator //
TH1 = 3 // încărcați viteza de transmisie //
TR1 = 1 // Temporizator PORNIT //
SBUF = ‘S’ // stochează caracterul în registru //
while (TI == 0) // verificați registrul de întrerupere //
TI = 0
TR1 = 0 // OPRIT cronometrul //
while (1) // buclă continuă //
}
2. WAP pentru a primi datele de la hyperterminal și a trimite aceste date la PORT 0 al microcontrolerului folosind 9600 baud?
28800 este rata de transmisie maximă a microcontrolerului 8051
28800/9600 = 3
Această rată de transmisie „3” este stocată în temporizatoare
#include
void main ()
{
SCON = 0x50 // pornește comunicarea în serie //
TMOD = 0x20 // a selectat modul temporizator //
TH1 = 3 // încărcați viteza de transmisie //
TR1 = 1 // Temporizator PORNIT //
PORT0 = SBUF // trimiteți datele de la SBUF la port0 //
while (RI == 0) // verificați registrul de întrerupere //
RI = 0
TR1 = 0 // OPRIT cronometrul //
while (1) // oprește programul când se primește caracter //
}
Întrerupeți programele folosind microcontrolerul 8051
Întreruperea este un semnal care forțează oprirea programului curent și executarea imediată a celuilalt program. Microcontrolerul 8051 oferă 6 întreruperi, care sunt interne și externe surse de întrerupere . Când apare întreruperea, microcontrolerul întrerupe sarcina curentă și participă la întrerupere executând ISR, atunci microcontrolerul revine la sarcina recentă.
WAP pentru a efectua operațiunea de deplasare la stânga când are loc întreruperile temporizatorului 0 apoi efectuați operația de întrerupere pentru P0 în funcția principală?
#include
char nesemnat b
void timer0 () întrerupere 2 // timer selectat0 întrerupere //
{
b = 0x10
P1 = b<<2
}
void main ()
{
nesemnat char a, i
IE = 0x82 // activați temporizatorul0 întrerupe //
TMOD = 0x01
TLo = 0xFC // temporizator de întrerupere //
TH1 = 0xFB
TR0 = 1
a = 0x00
în timp ce (1)
{
pentru (i = 0i<255i++)
{
a ++
Po = a
}
}
}
Programarea tastaturii folosind microcontrolerul 8051
Tastatura matricială este un dispozitiv de comutare analogic, care este utilizat în multe aplicații încorporate pentru a permite utilizatorului să îndeplinească sarcinile necesare. A tastatură matricială constă dintr-un aranjament de comutatoare în format matricial în rânduri și coloane. Rândurile și coloanele sunt conectate la microcontroler astfel încât rândul de comutatoare să fie conectat la un pin și comutatoarele din fiecare coloană să fie conectate la un alt pin, apoi să efectueze operațiile.
Programarea tastaturii folosind microcontrolerul 8051
1. WAP pentru a comuta LED-ul apăsând comutatorul
#include
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
void delay ()
void main ()
{
în timp ce (1)
{
a = 0
b = 1
c = 1
d = 1
întârziere()
a = 1
b = 0
c = 1
d = 1
void delay ()
{
nesemnat char i
TMOD = 0x20 // setați modul temporizator //
pentru (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // setează întârzierea //
TH1 = 0x00
TR1 = 1 // cronometru oN //
While (TF1 == 0) // verificați bitul de semnalizare //
TF1 = 0
}
TR1 = 0 // cronometru oprit //
}
2. WAP pentru a porni LED-ul apăsând tasta „1” de pe tastatură?
#include
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
LED sbit = P0 ^ 1
void main ()
{
r1 = 0
if (c1 == 0)
{
LED = 0xff
}
}
3. WAP pentru a afișa numărul 0,1,2,3,4,5 pe cel de șapte segmente apăsând tasta respectivă de pe tastatură?
#include
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
}
Dacă (c2 == 0)
{
a = 0x60
}
if (c3 == 0)
{
a = 0xDA
}
Dacă (c4 == 0)
{
a = 0xF2
}
}
Programare LCD cu microcontroler 8051
Ecran LCD este un dispozitiv electronic, care este frecvent utilizat în multe aplicații pentru afișarea informațiilor într-un format text sau imagine. LCD-ul este un afișaj care poate afișa cu ușurință caractere pe ecranul său. Afișajul LCD are 8 linii de date și 3 linii de control care sunt utilizate pentru interfața cu microcontrolerul.
Programare LCD cu microcontroler 8051
WAP pentru a afișa „KITURILE EDGEFX” pe afișajul LED?
#include
#define kam P0
voidlcd_initi ()
voidlcd_dat (caracter nesemnat)
voidlcd_cmd (caracter nesemnat)
void delay ()
afișare nulă (caractere nesemnate *, caractere nesemnate r)
sbitrs = P2 ^ 0
sbitrw = P2 ^ 1
sbit at = P2 ^ 2
void main ()
{
lcd_initi ()
lcd_cmd (0x80)
întârziere (100)
lcd_cmd (0xc0)
afișaj („kituri edgefx”, 11)
în timp ce (1)
}
afișare nulă (caractere nesemnate *, caractere nesemnate r)
{
unsignedint w
pentru (w = 0w
lcd_data (s [w])
}
}
voidlcd_initi ()
{
lcd_cmd (0 × 01)
întârziere (100)
lcd_cmd (0 × 38)
întârziere (100)
lcd_cmd (0 × 06)
întârziere (100)
lcd_cmd (0x0c)
întârziere (100)
}
voidlcd_dat (dat de caractere nesemnat)
{
pieptene = că
rs = 1
rw = 0
în = 1
întârziere (100)
în = 0
}
}
voidlcd_cmd (caractere cmd nesemnate)
{
came = cmd
rs = 0
rw = 0
în = 1
întârziere (100)
în = 0
}
întârziere nulă (nesemnat int n)
{
unsignedint a
pentru (a = 0a
Sper că acest articol oferă informații de bază despre programarea sistemului încorporat utilizând microcontrolerul 8051 cu câteva exemple de programe. Pentru un tutorial de programare C încorporat, vă rugăm să postați comentariile și întrebările dvs. în secțiunea de comentarii de mai jos.
