Comunicazione seriale uart su stm8 utilizzando cosmic c e stvd

La programmazione di un nuovo microcontrollore spesso richiede più tempo a causa dei nuovi metodi di gestione dei registri e non si sa quale bit fa esattamente cosa. Lo stesso vale anche per il debug senza dirlo. Questo è il motivo per cui i programmatori utilizzano abbastanza spesso i punti di interruzione nel loro codice e li eseguono utilizzando un debugger. Ma l'utilizzo di un debugger potrebbe richiedere hardware aggiuntivo (il più delle volte costoso) e anche tempo aggiuntivo. Essendo un fan boy di Arduino, una cosa su cui possiamo essere tutti d'accordo è usare le dichiarazioni di stampa seriale per il debug e comprendere il nostro codice rende la vita molto più semplice. Cosa possiamo replicare lo stesso su STM8 con il compilatore C cosmico e le librerie SPL? Bene, è assolutamente possibile, ed è esattamente ciò che faremo in questo terzo tutorial della nostra serie di tutorial.Se sei completamente nuovo qui, controlli anche la guida introduttiva a STM8S (tutorial 1) e al controllo GPIO STM8S (tutorial 2). Inoltre, abbiamo anche esplorato la possibilità di programmare STM8S con Arduino per un rapido avvio. Detto questo, entriamo nel tutorial.

Comunicazione seriale su STM8S103F3P6

Dalla scheda tecnica di STM8S103F3P6, possiamo vedere che il nostro controller a 8 bit supporta la comunicazione UART in molte modalità diverse. Il controller dispone anche di un pin di uscita del clock per la comunicazione UART sincrona e può supportare anche SmarCard, IrDA e LIN. Ma non esploreremo nulla di tutto ciò in questo tutorial solo per stare lontano dalla complessità. Impareremo come leggere e scrivere semplici UART.

Il tutorial fornisce anche un file di intestazione chiamato stm8s103 serial.h che consente di eseguire semplici comandi UART come Serial begin, Serial read, serial print, ecc. Fondamentalmente, sarai in grado di stampare char, int e string sul monitor seriale e legge anche char dal monitor seriale. Alla fine di questo tutorial, sarai in grado di controllare un LED dal monitor seriale e ottenere un feedback sullo stato del LED. Il file di intestazione menzionato sopra dipende dalle librerie SPL, quindi assicurati di aver seguito il tutorial introduttivo.

Pin di comunicazione seriale su STM8S103F3P6

Partiamo dal lato hardware. Dando una rapida occhiata ai pin sul microcontrollore STM8S103F3P6 di seguito, possiamo vedere che i pin 1, 2 e 3 verranno utilizzati per la comunicazione UART.

Tra i tre, il pin 1 è il pin del clock UART che verrà utilizzato solo durante la comunicazione UART sincrona, quindi non ne avremo bisogno qui. Il pin 2 è il pin del trasmettitore UART e il pin 3 è il pin del ricevitore UART. Tieni presente che questi pin possono anche raddoppiare come un pin analogico o un normale pin GPIO.

Schema del circuito per la comunicazione seriale STM8S

Lo schema del circuito è molto semplice qui, dobbiamo collegare il nostro ST-LINK 2 per la programmazione e un convertitore da USB a TTL per la lettura dei dati seriali. Tieni presente che il nostro controller STM8S funziona a livello logico 3,3 V, quindi assicurati che il tuo convertitore da USB a TTL supporti anche la logica 3,3 V. Lo schema elettrico completo è mostrato di seguito.

Devi collegare il tuo ST-link a una porta USB e il convertitore da USB a TTL a un'altra porta USB del tuo laptop, in modo da poter programmare e monitorare i dati allo stesso tempo. La connessione UART è semplice, basta collegare la massa e il pin Rx / Tx del microcontrollore STM8S ai pin Tx / Rx del convertitore da USB a TTL. Qui ho alimentato il controller con il pin Vcc di ST-Link e ho lasciato aperto il pin vss del convertitore TTL, puoi anche farlo al contrario. Esistono molti tipi di convertitori da USB a TTL sul mercato, ma assicurati che possa funzionare con segnali logici a 3,3 V e cerca semplicemente i pin Tx, Rx e GND ed effettua la connessione mostrata sopra. La mia configurazione hardware è mostrata di seguito.

Per creare un modo di comunicazione seriale, abbiamo fornito il file di intestazione STM8S_Serial.h . Utilizzando questo file di intestazione, è possibile eseguire semplici funzioni simili ad Arduino per la comunicazione seriale.

Puoi trovare tutti i file richiesti per questo progetto sulla nostra pagina Github STM8S103F3_SPL. Se hai solo bisogno di questo particolare file di intestazione, puoi scaricarlo dal link sottostante.

Scarica STM8S_Serial.h

Configurazione di STVD per la comunicazione seriale

Per lavorare con la comunicazione seriale, ne useremo molti usando la funzione del file di intestazione STM8S_Serial.h di cui abbiamo discusso in precedenza. Ma la libreria ha altre dipendenze, molte delle intestazioni relative a SPL UART e Clock e file C. Quindi da questo punto è meglio includere tutti i file di intestazione e C nel nostro progetto per evitare un errore di compilazione. Il mio ambiente di lavoro STVD è simile a questo.

Assicurati di aver incluso tutti i file sorgente SPL e Includi file come abbiamo fatto nel nostro primo tutorial. E assicurati anche di aver aggiunto il file di intestazione stm8s103_serial.h . Non esiste un file C per questa intestazione.

Programmazione STM8S per comunicazione seriale

Una volta che la configurazione del progetto STVD è pronta, possiamo iniziare a scrivere il nostro codice nel file main.c. Il codice completo per questo tutorial può essere trovato in fondo a questa pagina. La spiegazione è la seguente.

Il primo passo è includere i file di intestazione richiesti, qui ho aggiunto il file di intestazione principale (stm8s) e il file di intestazione stm8s_103_serial che abbiamo appena scaricato.

// Intestazioni obbligatorie #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h

Successivamente, utilizziamo le macro di progettazione per specificare i pin di input e output. Qui controlleremo solo il LED di bordo che è collegato al pin5 della porta B, quindi gli diamo un nome come test_LED .

#define test_LED GPIOB, GPIO_PIN_5 // Il LED di test è collegato a PB5

Spostandoci all'interno della funzione principale, definiremo il pin come un'uscita. Se non hai familiarità con le funzioni GPIO di base, torna al tutorial GPIO di STM8S.

// Definizioni dei pin // Dichiara PB5 come pin di uscita push pull GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);

Quindi inizializziamo le nostre porte di comunicazione seriale a 9600 baud rate. Per coloro che sono nuovi, 9600 è la velocità con cui i bit di dati verranno trasferiti durante la comunicazione. Se si imposta 9600 qui, è necessario impostare lo stesso anche sul software di monitoraggio. Quindi stampiamo anche una stringa "Enter command" e passiamo alla riga successiva.

Serial_begin (9600); // Inizializza la comunicazione seriale a 9600 baud rate Serial_print_string ("Enter command"); // stampa una stringa Serial_newline (); // passa alla riga successiva

Passando al ciclo while infinito, utilizziamo la funzione Serial_available per verificare se sono presenti dati seriali in entrata. Se sì, lo leggiamo e lo salviamo in una variabile chiamata ch e stampiamo lo stesso anche usando Serial_print . Quindi se il valore ricevuto è 0, spegneremo il LED e se è 1, accenderemo il LED

if (Serial_available ()) {Serial_print_string ("Hai premuto:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED SPENTO se (ch == '1') GPIO_WriteLow (test_LED); // LED ACCESO}

Con questo, la programmazione di questo tutorial è completa, basta caricare il codice fornito in fondo a questa pagina e dovresti essere in grado di controllare il LED dal monitor seriale.

Controllo del LED dal monitor seriale

Una volta caricato il codice, è possibile aprire qualsiasi monitor seriale a 9600 baud rate. Ho usato il monitor seriale di Arduino stesso per la facilità d'uso. Premi il pulsante di ripristino e dovresti vedere il messaggio "Inserisci un comando". Quindi se inserisci 1 e premi invio, il led di bordo dovrebbe accendersi, analogamente per 0, dovrebbe spegnersi.

La lavorazione completa si trova nel video linkato in fondo a questa pagina. Se hai domande, lasciale nella sezione commenti. Puoi anche utilizzare i nostri forum per pubblicare altre domande tecniche.

Analisi approfondita della libreria seriale STM8S

Per quelle menti curiose che vogliono sapere cosa succede effettivamente all'interno del file di intestazione STM8S103F3_Serial continua a leggere….

Questo file di intestazione funziona bene per la programmazione a livello principiante, ma se stai utilizzando una versione diversa del controller STM8S o stai cercando alcune opzioni avanzate, potresti voler modificare leggermente questa intestazione o lavorare direttamente con le librerie SPL. Ho scritto questo file di intestazione proprio come un maturo dal file di intestazione UART1, la spiegazione del mio file di intestazione è la seguente.

Leggere un personaggio da Serial Monitor

Questa funzione aiuta a leggere un singolo carattere che è stato inviato al microcontrollore dal monitor seriale.

char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); return (UART1_ReceiveData8 ()); }

Attendiamo che il flag RXE sia impostato per completare la ricezione, quindi azzeriamo il flag per confermare la ricezione. Infine, inviamo i dati a 8 bit ricevuti come risultato di questa funzione.

Stampa di un carattere su Serial Monitor

Questa funzione trasmette un singolo carattere da un microcontrollore al monitor seriale.

void Serial_print_char (char value) {UART1_SendData8 (value); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aspetta l'invio}

La funzione scrive semplicemente il valore a 8 bit e attende il completamento della trasmissione controllando UART1_FLAG_TXE su SET

Inizializzazione della comunicazione seriale

Questa funzione inizializza la comunicazione seriale alla velocità di trasmissione richiesta.

void Serial_begin (uint32_t baud_rate) {GPIO_Init (GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_PP_HIGH_FAST); GPIO_Init (GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_NO_IT); UART1_DeInit (); // Deinizializza le periferiche UART UART1_Init (baud_rate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE); // (BaudRate, Wordlegth, StopBits, Parity, SyncMode, Mode) UART1_Cmd (ENABLE); }

Oltre al baud rate, ci sono altri parametri che devono essere impostati per la comunicazione seriale, come il numero di bit di dati, numero di bit di stop, parità, ecc. Il più comune (simile ad Arduino) è il dato a 8 bit con un bit di stop e nessuna parità e quindi questa sarà l'impostazione predefinita. Puoi cambiarlo se necessario.

Stampa di un numero intero su Serial Monitor

La maggior parte delle volte, se stiamo usando un monitor seriale per il debug o il monitoraggio, potremmo voler stampare una variabile di tipo int sul monitor seriale. Questa funzione fa esattamente questo

void Serial_print_int (int number) // Funzione per stampare il valore int sul monitor seriale {char count = 0; char digit = ""; while (number! = 0) // divide l'array int in char {digit = number% 10; count ++; numero = numero / 10; } while (count! = 0) // stampa l'array di caratteri nella direzione corretta {UART1_SendData8 (digit + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aspetta l'invio di count--; }}

Prende un valore intero e lo converte in un array di caratteri nel primo ciclo while, quindi nel secondo ciclo while, invieremo ciascuno dei caratteri in modo simile alla nostra funzione print char.

Stampa una nuova riga

Questa è una semplice funzione per stampare una nuova riga. Il valore esadecimale per farlo è "0x0a", lo stiamo semplicemente inviando utilizzando il comando di trasmissione a 8 bit.

void Serial_newline (void) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aspetta l'invio}

Stampa di una stringa sul monitor seriale

Un'altra funzione utile è stampare effettivamente le stringhe sul monitor seriale.

void Serial_print_string (char string) {. char i = 0; while (stringa! = 0x00) {UART1_SendData8 (stringa); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}

Anche in questo caso, questa funzione converte anche la stringa in char array e invia ogni carattere. Come sappiamo tutte le stringhe finiranno nulle. Quindi dobbiamo solo continuare ad attraversare e trasmettere i caratteri fino a raggiungere il 0x00 nullo.

Verificare se i dati seriali sono disponibili per la lettura

Questa funzione controlla se ci sono dati seriali nel buffer pronti per la lettura.

bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) return TRUE; altrimenti restituisce FALSE; }

Controlla il flag UART1_FLAG_RXNE , se è vero, restituisce vero e se non lo è, restituisce falso.