Comunicazione Uart tramite microcontrollore pic

In questo tutorial impariamo ad abilitare la comunicazione UART con il microcontrollore PIC e come trasferire i dati da e verso il tuo computer. Finora, abbiamo coperto tutti i moduli di base come ADC, timer, PWM e abbiamo anche imparato come interfacciare LCD e display a 7 segmenti. Ora, doteremo noi stessi di un nuovo strumento di comunicazione chiamato UART, ampiamente utilizzato nella maggior parte dei progetti di microcontrollori. Controlla qui i nostri tutorial completi sui microcontrollori PIC utilizzando MPLAB e XC8.

Qui abbiamo usato l' MCU PIC16F877A, ha un modulo chiamato "Ricevitore e trasmettitore asincrono sincrono universale indirizzabile", brevemente noto come USART. USART è un sistema di comunicazione a due fili in cui i dati fluiscono in modo seriale. USART è anche una comunicazione full-duplex, significa che puoi inviare e ricevere dati contemporaneamente che possono essere utilizzati per comunicare con dispositivi periferici, come terminali CRT e personal computer.

L' USART può essere configurato nelle seguenti modalità:

• Asincrono (full-duplex)
• Sincrono - Master (half-duplex)
• Sincrono - Slave (half-duplex)

Esistono anche due diverse modalità ovvero la modalità 8 bit e la modalità 9 bit, in questo tutorial configureremo il modulo USART per funzionare in modalità Asincrona con sistema di comunicazione a 8 bit, poiché è il tipo di comunicazione più utilizzato. Poiché è asincrono, non è necessario inviare il segnale di clock insieme ai segnali di dati. UART utilizza due linee dati per inviare (Tx) e ricevere (Rx) dati. Anche la massa di entrambi i dispositivi dovrebbe essere resa comune. Questo tipo di comunicazione non condivide un orologio comune, quindi un terreno comune è molto importante per il funzionamento del sistema.

Alla fine di questo tutorial sarai in grado di stabilire una comunicazione (UART) tra il tuo computer e il tuo microcontrollore PIC e attivare un LED sulla scheda PIC dal tuo laptop. Lo stato del LED verrà inviato al laptop dall'MCU PIC. Testeremo l'output utilizzando Hyper Terminal nel computer. Alla fine di questo tutorial viene fornito anche un video dettagliato.

Requisiti:

Hardware:

• Scheda PIC16F877A Perf
• Modulo convertitore da RS232 a USB
• Computer
• Programmatore PICkit 3

Software:

• MPLABX
• HyperTerminal

È necessario un convertitore da RS232 a USB per convertire i dati seriali in un formato leggibile dal computer. Esistono modi per progettare il proprio circuito invece di acquistare il proprio modulo, ma non sono affidabili in quanto soggetti a rumore. Quello che stiamo usando è mostrato sotto

Nota: ogni convertitore da RS232 a USB richiede l'installazione di un driver speciale; la maggior parte di essi dovrebbe essere installata automaticamente non appena si collega il dispositivo. Ma se non si rilassa !!! Usa la sezione commenti e ti aiuterò.

Programmazione del microcontrollore PIC per la comunicazione UART:

Come tutti i moduli (ADC, Timer, PWM) dovremmo anche inizializzare il nostro modulo USART del nostro MCU PIC16F877A e istruirlo a funzionare in modalità di comunicazione UART a 8 bit. Definiamo i bit di configurazione e iniziamo con la funzione di inizializzazione UART.

Inizializzazione del modulo UART del microcontrollore PIC:

I pin Tx e Rx sono fisicamente presenti sui pin RC6 e RC7. Secondo il datasheet dichiariamo TX come output e RX come input.

// **** Impostazione dei pin I / O per UART **** // TRISC6 = 0; // Pin TX impostato come uscita TRISC7 = 1; // Pin RX impostato come ingresso // ________ Pin I / O impostati __________ //

Ora è necessario impostare la velocità di trasmissione. La velocità in baud è la velocità con cui le informazioni vengono trasferite in un canale di comunicazione. Questo può essere uno dei tanti valori predefiniti, ma in questo programma stiamo usando 9600 poiché è il baud rate più utilizzato.

/ ** Inizializza il registro SPBRG per la velocità di trasmissione richiesta e imposta BRGH per la velocità di trasmissione veloce ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // per baud_rate alto // _________ Fine dell'impostazione baud_rate _________ //

Il valore del baud rate deve essere impostato tramite il registro SPBRG, il valore dipende dal valore della frequenza del cristallo esterno, di seguito sono riportate le formule per calcolare il baud rate:

SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1;

Il bit BRGH deve essere alto per abilitare il bit rate ad alta velocità. Secondo il datasheet (pagina 13) è sempre vantaggioso abilitarlo, in quanto può eliminare gli errori durante la comunicazione.

Come detto in precedenza lavoreremo in modalità Asincrona, quindi il bit SYNC dovrebbe essere azzerato e il bit SPEM deve essere alto per abilitare i pin seriali (TRISC6 e TRICSC5)

// **** Abilita porta seriale asincrona ******* // SYNC = 0; // SPEN asincrono = 1; // Abilita i pin della porta seriale // _____ Porta seriale asincrona abilitata _______ //

In questo tutorial invieremo e riceveremo dati tra MCU e computer, quindi dobbiamo abilitare sia i bit TXEN che CREN.

// ** Prepariamo la trasmissione e la ricezione ** // TXEN = 1; // abilita la trasmissione CREN = 1; // abilita la ricezione // __ Modulo UART attivo e pronto per la trasmissione e la ricezione __ //

I bit TX9 e RX9 devono essere azzerati in modo da operare in modalità 8 bit. Se deve essere stabilita un'elevata affidabilità, è possibile selezionare la modalità a 9 bit.

// ** Seleziona la modalità a 8 bit ** // TX9 = 0; // Ricezione a 8 bit selezionata RX9 = 0; // Modalità di ricezione a 8 bit selezionata // __ Modalità a 8 bit selezionata __ //

Con questo completiamo la nostra configurazione di inizializzazione. ed è pronto per il funzionamento.

Trasmissione dei dati tramite UART:

La funzione seguente può essere utilizzata per trasmettere dati tramite il modulo UART:

// ** Funzione per inviare un byte di data a UART ** // void UART_send_char (char bt) {while (! TXIF); // tiene il programma finché il buffer TX è libero TXREG = bt; // Carica il buffer del trasmettitore con il valore ricevuto} // _____________ Fine della funzione ________________ //

Una volta che il modulo è stato inizializzato, qualsiasi valore caricato nel registro TXREG verrà trasmesso tramite UART, ma la trasmissione potrebbe sovrapporsi. Quindi dovremmo sempre verificare la presenza del flag TXIF di interruzione della trasmissione . Solo se questo bit è basso possiamo procedere con il bit successivo per la trasmissione altrimenti dovremmo aspettare che questo flag si abbassi.

Tuttavia, la funzione sopra può essere utilizzata solo per inviare un solo byte di dati, per inviare una stringa completa dovrebbe essere utilizzata la funzione seguente

// ** Funzione per convertire la stringa in byte ** // void UART_send_string (char * st_pt) {while (* st_pt) // if there is a char UART_send_char (* st_pt ++); // elaboralo come un dato byte} // ___________ Fine della funzione ______________ //

Questa funzione potrebbe essere un po 'complicata da capire poiché ha puntatori, ma credetemi i puntatori sono meravigliosi e rendono la programmazione più semplice e questo è un buon esempio della stessa cosa.

Come puoi notare, abbiamo nuovamente chiamato UART_send_char () ma ora all'interno del ciclo while. Abbiamo diviso la stringa in singoli caratteri, ogni volta che viene chiamata questa funzione, un carattere verrà inviato al TXREG e verrà trasmesso.

Ricezione di dati tramite UART:

La seguente funzione può essere utilizzata per ricevere dati dal modulo UART:

// ** Funzione per ottenere un byte di data da UART ** // char UART_get_char () {if (OERR) // controlla l'errore {CREN = 0; // Se errore -> Reimposta CREN = 1; // If error -> Reset} while (! RCIF); // tiene il programma fino a quando il buffer RX è free return RCREG; // riceve il valore e lo invia alla funzione principale} // _____________ Fine della funzione ________________ //

Quando un dato viene ricevuto dal modulo UART, lo raccoglie e lo memorizza nel registro RCREG. Possiamo semplicemente trasferire il valore a qualsiasi variabile e usarlo. Ma potrebbe esserci un errore di sovrapposizione o l'utente potrebbe inviare dati in modo continuo e non li abbiamo ancora trasferiti a una variabile.

In tal caso, il bit di flag di ricezione RCIF viene in soccorso. Questo bit diminuirà ogni volta che un dato viene ricevuto e non è ancora elaborato. Quindi lo usiamo nel ciclo while creando un ritardo per mantenere il programma finché non abbiamo a che fare con quel valore.

Commutazione del LED utilizzando il modulo UART del microcontrollore PIC:

Veniamo ora alla parte finale del programma, la funzione void main (void) , dove attiveremo un LED attraverso il computer usando la comunicazione UART tra PIC e computer.

Quando inviamo un carattere "1" (dal computer) il LED si accenderà e il messaggio di stato "LED ROSSO -> ON" verrà rispedito (da PIC MCU) al computer.

Allo stesso modo inviamo un carattere "0" (dal computer) il LED si spegnerà e il messaggio di stato "LED ROSSO -> OFF" verrà rispedito (da PIC MCU) al computer.

while (1) // Ciclo infinito {get_value = UART_get_char (); if (get_value == '1') // Se l'utente invia "1" {RB3 = 1; // Attiva il LED UART_send_string ("LED ROSSO -> ON"); // Invia una notifica al computer UART_send_char (10); // Il valore ASCII 10 viene utilizzato per il ritorno a capo (per stampare in una nuova riga)} if (get_value == '0') // Se l'utente invia "0" {RB3 = 0; // Spegni il LED UART_send_string ("RED -> OFF"); // Invia la notifica al computer UART_send_char (10); // Il valore ASCII 10 viene utilizzato per il ritorno a capo (per stampare in una nuova riga)}}

Simulazione del nostro programma:

Come al solito simuliamo il nostro programma usando proteus e scopriamo se funziona come previsto.

L'immagine sopra mostra un terminale virtuale in cui mostra un messaggio di benvenuto e lo stato del LED. Si può notare che il LED di colore rosso è collegato al pin RB3. Il funzionamento dettagliato della simulazione può essere trovato nel video alla fine.

Configurazione hardware e test dell'output:

La connessione per questo circuito è davvero semplice, usiamo la nostra scheda PIC Perf e colleghiamo i tre fili al convertitore da RS232 a USB e colleghiamo il modulo al nostro computer usando il cavo dati USB come mostrato di seguito.

Successivamente installiamo l' applicazione Hyper Terminal (scaricala da qui) e apriamola. Dovrebbe mostrare qualcosa di simile

Ora apri Gestione dispositivi sul tuo computer e controlla a quale porta Com è collegato il tuo modulo, il mio è connesso alla porta COM 17 come mostrato di seguito

Nota: il nome della porta COM per il modulo potrebbe cambiare in base al fornitore, non è un problema.

Ora torna all'applicazione Hyper Terminal e vai a Set Up -> Port Configuration o premi Alt + C, per ottenere la seguente finestra a comparsa e seleziona la porta desiderata (COM17 nel mio caso) nella finestra a comparsa e fai clic su Connetti.

Una volta stabilita la connessione, accendi la tua scheda PIC perf e dovresti vedere qualcosa di simile sotto

Mantieni il cursore nella finestra dei comandi e inserisci 1, quindi premi Invio. Il LED si accenderà e lo stato verrà visualizzato come mostrato di seguito.

Allo stesso modo, mantieni il cursore nella finestra dei comandi e inserisci 0, quindi premi Invio. Il LED si spegnerà e lo stato verrà visualizzato come mostrato di seguito.

Di seguito viene fornito il codice completo e il video dettagliato, che mostrerà come il LED risponde in tempo reale per “1” e “0”.

Questo è tutto ragazzi, abbiamo interfacciato PIC UART con il nostro computer e trasferito i dati per accendere il LED utilizzando Hyper terminal. Spero che tu abbia capito, in caso contrario, usa la sezione dei commenti per porre la tua domanda. Nel nostro prossimo tutorial useremo nuovamente l'UART ma lo renderemo più interessante utilizzando un modulo Bluetooth e trasmettiamo i dati via etere.

Controlla anche la comunicazione UART tra due microcontrollori ATmega8 e la comunicazione UART tra ATmega8 e Arduino Uno.