Embedded C è il linguaggio di programmazione più diffuso nel campo del software per lo sviluppo di gadget elettronici. Ogni processore è associato al software incorporato. Programmazione C incorporata svolge un ruolo importante nell'esecuzione di funzioni specifiche da parte del processore. Nella nostra vita quotidiana, usiamo spesso molti dispositivi elettronici come lavatrici, telefoni cellulari, fotocamere digitali e così via funzioneranno sulla base di microcontrollori programmati da C.
Programmazione del sistema integrato
Il codice C scritto è più affidabile, portabile e scalabile e, di fatto, molto più facile da capire. Il primo e più importante strumento è il software embedded che decide il funzionamento di un sistema embedded. Il linguaggio di programmazione C incorporato viene utilizzato più frequentemente per programmare i microcontrollori.
Tutorial di programmazione C integrato (8051)
Per scrivere il programma, i progettisti incorporati devono avere una conoscenza sufficiente dell'hardware di particolari processori o controller poiché la programmazione C incorporata è una tecnica di programmazione completa correlata all'hardware.
Tutorial di programmazione
In precedenza, molte applicazioni incorporate venivano sviluppate utilizzando la programmazione a livello di assembly. Tuttavia, non hanno fornito la portabilità per superare questo problema con l'avvento di vari linguaggi di alto livello come C, COBOL e Pascal. Tuttavia, è stato il linguaggio C che ha ottenuto un'ampia accettazione sviluppo di applicazioni per sistemi embedded e continua a farlo.
Sistema incorporato
Il sistema embedded è definito come la combinazione del software di programmazione C incorporato e della parte hardware costituita principalmente da microcontrollori ed è destinata a svolgere il compito specifico. Questi tipi di sistemi embedded vengono utilizzati nella nostra vita quotidiana come lavatrici e videoregistratori, frigoriferi e così via. Il sistema embedded è stato introdotto per la prima volta dai microcontrollori 8051.
Sistema incorporato
Introduzione al microcontrollore 8051
Il microcontrollore 8051 è un microcontrollore di base, è stato introdotto per la prima volta dalla 'Intel Corporation' dal 1970. È sviluppato dall'architettura del processore 8086. L'8051 è una famiglia di microcontrollori, che è stata sviluppata da diversi produttori come Philips, Atmel, dalls e così via. I microcontrollori 8051 è stato utilizzato in molti prodotti incorporati, dai giocattoli per bambini piccoli ai grandi sistemi automobilistici.
8051 Microcontrollore
Il microcontrollore 8051 è a 8 bit Architettura 'CISC' . Consiste di memorie, comunicazione seriale, interrupt, porte di ingresso / uscita e timer / contatori, incorporati in un unico chip integrato, che è programmato per controllare le periferiche che si interfacciano con esso. Il programma è memorizzato nella RAM del microcontrollore ma prima di scrivere il programma, dobbiamo essere a conoscenza della RAM organizzazione del microcontrollore.
Programmazione del sistema integrato: dichiarazione di base
Ogni funzione è una raccolta di istruzioni che eseguono un'attività specifica e la raccolta di una o più funzioni è chiamata linguaggio di programmazione. Ogni lingua è composta da alcuni elementi di base e regole grammaticali. La programmazione in linguaggio C è progettata per funzionare con il set di caratteri, variabili, tipi di dati, costanti, parole chiave, espressioni e così via vengono utilizzati per scrivere un programma C. Tutti questi sono considerati sotto il file di intestazione o il file di libreria ed è rappresentato come
#includere
Sviluppo della programmazione C integrato
L'estensione del linguaggio C è chiamata linguaggio di programmazione C incorporato. Rispetto a quanto sopra, la programmazione incorporata in linguaggio C ha alcune funzionalità aggiuntive come tipi di dati e parole chiave e il file di intestazione o il file di libreria è rappresentato come
#includere
Parole chiave aggiuntive C incorporate
- sbit
- po
- SFR
- volatile
- le macro definiscono
Lo “sbit” viene utilizzato per dichiarare il singolo PIN del microcontrollore. Ad esempio, il LED è collegato al pin P0.1, non è consigliabile inviare il valore direttamente al pin della porta, prima dobbiamo dichiarare il pin con un'altra variabile, quindi dopo possiamo usarlo ovunque nel programma.
Sintassi: sbit a = P0 ^ 1 // dichiara il rispettivo pin con una variabile //
a = 0x01 // invia il valore al pin della porta //
Il “bit” viene utilizzato per controllare lo stato della variabile.
Sintassi: bit c // dichiara la variabile bit //
c = a // viene assegnato un valore alla variabile c //
if (c == 1) // controlla la condizione true o false //
{
… ..
……
}
La parola chiave 'SFR' viene utilizzata per accedere ai registri SFR con un altro nome. Il registro SFR definito come a registro delle funzioni speciali , contiene tutti i registri relativi alla periferia indicando l'indirizzo. Il registro SFR è dichiarato dalla parola chiave SFR. La parola chiave SFR deve essere in lettere maiuscole.
Sintassi: SFR port = 0x00 // 0x00 è un indirizzo port0 dichiarato dalla variabile port //
Port = 0x01 // quindi invia il valore a port0 //
ritardo()
porta = 0x00
ritardo()
La parola chiave 'volatile' è la più importante nello sviluppo di sistemi embedded. La variabile che dichiara con il valore della parola chiave volatile non può essere modificata in modo imprevisto. Può essere utilizzato nei registri periferici mappati in memoria, variabili globali modificate dagli ISR. Senza utilizzare la parola chiave volatile per la trasmissione e la ricezione dei dati, si verificherà un errore di codice o un errore di ottimizzazione.
Sintassi: volatile int k
La macro è un nome che viene utilizzato per dichiarare il blocco di istruzioni come direttiva pre-processore. Ogni volta che viene utilizzato il nome, viene sostituito dal contenuto della macro. Le macro rappresentano il #define. Tutti i pin della porta sono definiti dalle macro.
Sintassi: #define dat Po // l'intera porta è dichiarata da una variabile //
dat = 0x01 // dati inviati alla porta0 //
Programmi C integrati di base
La programmazione del microcontrollore sarà diversa per ciascuno tipo di sistema operativo . Anche se esistono molti sistemi operativi come Linux, Windows, RTOS e così via. Tuttavia, RTOS presenta diversi vantaggi per lo sviluppo di sistemi embedded. Questo articolo discute la programmazione C embedded di base per sviluppare la programmazione C embedded utilizzando un microcontrollore 8051.
Fasi di programmazione C integrate
- LED lampeggiante con microcontrollore 8051
- Numero Visualizzazione su display a 7 segmenti utilizzando il microcontrollore 8051
- Calcolo del timer / contatore e programma utilizzando il microcontrollore 8051
- Calcoli di comunicazione seriale e programma utilizzando il microcontrollore 8051
- Interrompere i programmi utilizzando il microcontrollore 8051
- Programmazione da tastiera tramite microcontrollore 8051
- Programmazione LCD con microcontrollore 8051
LED lampeggiante utilizzando il microcontrollore 8051
Il LED è un dispositivo a semiconduttore che viene utilizzato in molte applicazioni, principalmente a scopo di indicazione. Sta trovando una vasta gamma di applicazioni come indicatori durante il test per verificare la validità dei risultati nelle diverse fasi. Sono molto economici e facilmente disponibili in una varietà di forme, colori e dimensioni. I LED servono per progettare tabelloni per messaggi e luci di segnalazione del controllo del traffico ecc. Qui i LED sono interfacciati con la PORT0 dei microcontrollori 8051.
LED lampeggiante utilizzando il microcontrollore 8051
1. 01010101
10101010
#include // file di intestazione //
void main () // lo stat point di esecuzione del programma //
{
unsigned int i // tipo di dati //
while (1) // per ciclo continuo //
{
P0 = 0x55 // invia il valore hexa a port0 //
per (i = 0i<30000i++) //normal delay//
P0 = 0x3AA // invia il valore hexa a port0 //
per (i = 0i<30000i++) //normal delay//
}
}
2. 00000001
00000010
00000100
.
.
10.000.000
#includere
void main ()
{
unsignedint i
carattere non firmato j, b
mentre (1)
{
P0 = 0x01
b = P0
per (j-0j<3000j++)
per (j = 0j<8j++)
{
b = b<<1
P0 = b
per (j-0j<3000j++)
}
}
}
3. 00001111
11110000
#includere
void main ()
{
unsignedint i
mentre (1)
{
P0 = 0x0F
per (j-0j<3000j++)
P0 = 0xF0
per (j-0j<3000j++)
}
}
4. 00000001
00000011
00000111
.
.
11111111
#includere
void main ()
{
unsignedint i
carattere non firmato j, b
mentre (1)
{
P0 = 0x01
b = P0
per (j-0j<3000j++)
per (j = 0j<8j++)
0x01
P0 = b
per (j-0j<3000j++)
}
}
Visualizzazione dei numeri sul display a 7 segmenti utilizzando il microcontrollore 8051
Il Display a 7 segmenti sono i display elettronici di base, utilizzati in molti sistemi per visualizzare le informazioni numeriche. Consiste di otto led che vengono collegati in modo sequenziale in modo da visualizzare le cifre da 0 a 9, quando si accendono opportune combinazioni di led. Possono visualizzare solo una cifra alla volta.
Visualizzazione dei numeri sul display a 7 segmenti utilizzando il microcontrollore 8051
1. WAP per visualizzare i numeri da '0 a F' su quattro display a 7 segmenti?
#includere
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}
non firmato, j
a = b = c = d = 1
mentre (1)
{
per (i = 0i<10i++)
{
P2 = n [i]
per (j = 0j<60000j++)
}
}
}
2. WAP per visualizzare i numeri da '00 a 10 'sui display a 7 segmenti?
#includere
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}
non firmato, j
ds1 = ds2 = 0
mentre (1)
{
per (i = 0, i<20i++)
display1 ()
display2 ()
}
}
void display1 ()
{
a = 1
b = 0
P2 = s [ds1]
ritardo()
a = 1
b = 0
P2 = s [ds1]
ritardo()
}
void display2 ()
{
ds1 ++
se (ds1> = 10)
{
ds1 = 0
ds2 ++
se (ds2> = 10)
{
ds1 = ds2 = 0
}
}
}
void delay ()
{
unsignedint k
per (k = 0k<30000k++)
}
Calcoli con timer / contatore e programmazione utilizzando il microcontrollore 8051
Il ritardo è uno dei fattori importanti nello sviluppo del software applicativo. Tuttavia, il normale ritardo non darà il prezioso risultato per superare questo problema per l'implementazione del ritardo del timer. Il timer e contatori sono componenti hardware del microcontrollore, che viene utilizzato in molte applicazioni per fornire il prezioso ritardo di tempo con impulsi di conteggio. Entrambi i compiti sono implementati dalla tecnica software.
Ritardo del timer
WAP per generare il ritardo di 500us utilizzando T1M2 (timer1 e mode2)?
#includere
void main ()
{
carattere non firmato i
TMOD = 0x20 // imposta la modalità timer //
per (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // imposta il ritardo //
TH1 = 0x00
TR1 = 1 // timer oN //
While (TF1 == 0) // controlla il bit flag //
TF1 = 0
}
TR1 = 0 // timer disattivato //
}
Normal Loop Delay
void delay ()
{
unsignedint k
per (k = 0k<30000k++)
}
Calcoli e programma di comunicazione seriale utilizzando il microcontrollore 8051
La comunicazione seriale è comunemente usata per trasmettere e ricevere il segnale. Il microcontrollore 8051 è composto Comunicazione seriale UART i segnali trasmessi e ricevuti dai pin Rx e Tx. L'UART prende byte di dati e invia i singoli bit in modo sequenziale. I registri sono un modo per raccogliere e archiviare i dati nella memoria. UART è un protocollo half-duplex. Half-duplex significa trasferire e ricevere i dati, ma non allo stesso tempo.
Calcoli e programma di comunicazione seriale utilizzando il microcontrollore 8051
1. WAP per trasmettere il carattere 'S' alla finestra seriale usa 9600 come baud rate?
28800 è il baud rate massimo del microcontrollore 8051
28800/9600 = 3
La velocità di trasmissione '3' viene memorizzata nei timer
#includere
void main ()
{
SCON = 0x50 // avvia la comunicazione seriale //
TNOD = 0x20 // ha selezionato la modalità timer //
TH1 = 3 // carica il baud rate //
TR1 = 1 // Timer ON //
SBUF = ’S’ // memorizza il carattere nel registro //
while (TI == 0) // controlla il registro degli interrupt //
TI = 0
TR1 = 0 // OFF il timer //
while (1) // loop continuo //
}
2. WAP per ricevere i dati dall'iperterminale e inviarli alla PORTA 0 del microcontrollore utilizzando 9600 baud?
28800 è il baud rate massimo del microcontrollore 8051
28800/9600 = 3
La velocità di trasmissione '3' viene memorizzata nei timer
#includere
void main ()
{
SCON = 0x50 // avvia la comunicazione seriale //
TMOD = 0x20 // ha selezionato la modalità timer //
TH1 = 3 // carica il baud rate //
TR1 = 1 // Timer ON //
PORT0 = SBUF // invia i dati da SBUF a port0 //
while (RI == 0) // controlla il registro degli interrupt //
RI = 0
TR1 = 0 // OFF il timer //
while (1) // ferma il programma quando viene ricevuto il carattere //
}
Interrompere i programmi utilizzando il microcontrollore 8051
L'interrupt è un segnale che costringe a fermare il programma corrente ed eseguire immediatamente l'altro programma. Il microcontrollore 8051 fornisce 6 interrupt, interni ed esterni sorgenti di interruzione . Quando si verifica l'interruzione, il microcontrollore mette in pausa l'attività corrente e si occupa dell'interruzione eseguendo l'ISR, quindi il microcontrollore torna all'attività recente.
WAP per eseguire l'operazione di spostamento a sinistra quando si verifica l'interruzione del timer 0, quindi eseguire l'operazione di interruzione per P0 nella funzione principale?
#includere
carattere non firmato b
void timer0 () interrupt 2 // selezionato timer0 interrupt //
{
b = 0x10
P1 = b<<2
}
void main ()
{
carattere non firmato a, i
IE = 0x82 // abilita l'interrupt timer0 //
TMOD = 0x01
TLo = 0xFC // timer di interrupt //
TH1 = 0xFB
TR0 = 1
a = 0x00
mentre (1)
{
per (i = 0i<255i++)
{
a ++
Po = a
}
}
}
Programmazione da tastiera utilizzando il microcontrollore 8051
La tastiera a matrice è un dispositivo di commutazione analogico, utilizzato in molte applicazioni integrate per consentire all'utente di eseguire le attività necessarie. UN tastiera a matrice consiste in una disposizione di interruttori in formato matrice in righe e colonne. Le righe e le colonne sono collegate al microcontrollore in modo tale che la fila di interruttori sia collegata a un pin e gli interruttori in ciascuna colonna siano collegati a un altro pin, quindi eseguono le operazioni.
Programmazione da tastiera utilizzando il microcontrollore 8051
1. WAP per attivare o disattivare il LED premendo l'interruttore
#includere
sbit a = P3 ^ 0
sbit b = P3 ^ 1
sbit c = P3 ^ 2
sbit d = P3 ^ 3
void delay ()
void main ()
{
mentre (1)
{
a = 0
b = 1
c = 1
d = 1
ritardo()
a = 1
b = 0
c = 1
d = 1
void delay ()
{
carattere non firmato i
TMOD = 0x20 // imposta la modalità timer //
per (i = 0i<2i++) //double the time daly//
{
TL1 = 0x19 // imposta il ritardo //
TH1 = 0x00
TR1 = 1 // timer oN //
While (TF1 == 0) // controlla il bit flag //
TF1 = 0
}
TR1 = 0 // timer disattivato //
}
2. WAP per accendere il LED premendo il tasto '1' sulla tastiera?
#includere
sbit r1 = P2 ^ 0
sbit c1 = P3 ^ 0
LED sbit = P0 ^ 1
void main ()
{
r1 = 0
se (c1 == 0)
{
LED = 0xff
}
}
3. WAP per visualizzare il numero 0,1,2,3,4,5 sui sette segmenti premendo il rispettivo tasto sulla tastiera?
#includere
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
se (c1 == 0)
{
a = 0xFC
}
Se (c2 == 0)
{
a = 0x60
}
se (c3 == 0)
{
a = 0xDA
}
Se (c4 == 0)
{
a = 0xF2
}
}
Programmazione LCD con microcontrollore 8051
Il display LCD è un dispositivo elettronico, che viene spesso utilizzato in molte applicazioni per visualizzare le informazioni in un formato di testo o immagine. Il display LCD è un display che può facilmente mostrare i caratteri sul suo schermo. Il display LCD è composto da 8 linee di dati e 3 linee di controllo che vengono utilizzate per interfacciarsi con il microcontrollore.
Programmazione LCD con microcontrollore 8051
WAP per visualizzare i 'KIT EDGEFX' sul display a LED?
#includere
#define kam P0
voidlcd_initi ()
voidlcd_dat (carattere non firmato)
voidlcd_cmd (carattere non firmato)
void delay ()
void display (unsigned char * s, unsigned char r)
sbitrs = P2 ^ 0
sbitrw = P2 ^ 1
sbit a = P2 ^ 2
void main ()
{
lcd_initi ()
lcd_cmd (0x80)
ritardo (100)
lcd_cmd (0xc0)
display ('kit edgefx', 11)
mentre (1)
}
void display (unsigned char * s, unsigned char r)
{
unsignedint w
per (w = 0w
lcd_data (s [w])
}
}
voidlcd_initi ()
{
lcd_cmd (0 × 01)
ritardo (100)
lcd_cmd (0 × 38)
ritardo (100)
lcd_cmd (0 × 06)
ritardo (100)
lcd_cmd (0x0c)
ritardo (100)
}
voidlcd_dat (dat char non firmato)
{
pettine = quello
rs = 1
rw = 0
in = 1
ritardo (100)
in = 0
}
}
voidlcd_cmd (char cmd non firmato)
{
came = cmd
rs = 0
rw = 0
in = 1
ritardo (100)
in = 0
}
void delay (unsigned int n)
{
unsignedint a
per (a = 0a
Spero che questo articolo fornisca informazioni di base sulla programmazione del sistema embedded utilizzando il microcontrollore 8051 con alcuni programmi di esempio. Per un tutorial dettagliato sulla programmazione C incorporata, pubblica i tuoi commenti e le tue domande nella sezione commenti qui sotto.
