- Comunicação serial em STM8S103F3P6
- Pinos de comunicação serial em STM8S103F3P6
- Diagrama de circuito para comunicação serial STM8S
- Configurando STVD para comunicação serial
- Programando STM8S para comunicação serial
- Controle de LED do monitor serial
- Análise mais detalhada da biblioteca serial STM8S
Programar um novo microcontrolador geralmente leva mais tempo devido aos novos métodos de tratamento de registro e não saber que bit faz exatamente o quê. O mesmo vale para depuração, sem dizer. É por isso que os programadores costumam usar pontos de interrupção em seu código e percorrê-los usando um depurador. Mas usar um depurador pode exigir hardware adicional (na maioria das vezes caro) e também tempo adicional. Sendo um fã do Arduino, uma coisa que todos podemos concordar é que usar instruções de impressão serial para depurar e entender nosso código torna a vida muito mais fácil. O que é que podemos replicar o mesmo em STM8s com compilador C cósmico e bibliotecas SPL? Bem, é muito possível, e é exatamente isso que faremos neste terceiro tutorial de nossa série de tutoriais.Você também verifica os primeiros passos com STM8S (tutorial 1) e controle STM8S GPIO (tutorial 2) se você é completamente novo aqui. Além disso, também exploramos a possibilidade de Programar STM8S com Arduino para iniciantes rápidos. Com tudo isso dito, vamos entrar no tutorial.
Comunicação serial em STM8S103F3P6
Na folha de dados de STM8S103F3P6, podemos ver que nosso controlador de 8 bits suporta comunicação UART em muitos modos diferentes. O controlador também possui um pino de saída de clock para comunicação UART síncrona e também pode suportar SmarCard, IrDA e LIN. Mas não exploraremos nada disso neste tutorial apenas para ficar longe da complexidade. Aprenderemos como fazer uma leitura e escrita UART simples.
O tutorial também fornece um arquivo de cabeçalho chamado stm8s103 serial.h, com o qual você pode executar comandos UART simples, como Serial begin, Serial read, serial print, etc. Basicamente, você será capaz de imprimir char, int e string no monitor serial e também ler char no monitor serial. No final deste tutorial, você será capaz de controlar um LED a partir do monitor serial e obter feedback sobre o status do LED. O arquivo de cabeçalho mencionado acima depende das bibliotecas SPL, portanto, certifique-se de seguir o tutorial de introdução.
Pinos de comunicação serial em STM8S103F3P6
Vamos começar pelo lado do hardware. Dando uma olhada rápida na pinagem do microcontrolador STM8S103F3P6 fornecido abaixo, podemos ver que os pinos 1, 2 e 3 serão usados para comunicação UART.
Entre os três, o pino 1 é o pino do relógio UART que será usado apenas durante a comunicação UART síncrona, portanto, não o precisaremos aqui. O pino 2 é o pino do transmissor UART e o pino 3 é o pino do receptor UART. Observe que esses pinos também podem dobrar como um pino analógico ou pino GPIO normal.
Diagrama de circuito para comunicação serial STM8S
O diagrama do circuito é muito simples aqui, precisamos conectar nosso ST-LINK 2 para programação e um conversor USB para TTL para leitura de dados seriais. Observe que nosso controlador STM8S funciona no nível lógico de 3,3 V, portanto, certifique-se de que seu conversor USB para TTL também suporte a lógica de 3,3 V. O diagrama completo do circuito é mostrado abaixo.
Você deve conectar o seu ST-link em uma porta USB e o conversor USB para TTL em outra porta USB do seu laptop, para que você possa programar e monitorar os dados ao mesmo tempo. A conexão UART é simples, basta conectar o aterramento e o pino Rx / Tx do seu microcontrolador STM8S aos pinos Tx / Rx do conversor USB para TTL. Aqui eu alimentei o controlador com o pino Vcc do ST-Link e deixei o pino vss do conversor TTL aberto, você também pode fazer isso ao contrário. Existem muitos tipos de conversor de USB para TTL no mercado, apenas certifique-se de que ele pode operar em sinais lógicos de 3,3 V e procure pelos pinos Tx, Rx e GND e faça a conexão mostrada acima. Minha configuração de hardware é mostrada abaixo.
Para fazer uma comunicação serial, fornecemos o arquivo de cabeçalho STM8S_Serial.h . Usando este arquivo de cabeçalho, você pode executar funções simples do tipo Arduino para comunicação serial.
Você pode encontrar todos os arquivos necessários para este projeto em nossa página STM8S103F3_SPL no Github. Se você só precisa desse arquivo de cabeçalho específico, pode baixá-lo no link abaixo.
Baixe STM8S_Serial.h
Configurando STVD para comunicação serial
Para trabalhar com comunicação serial, usaremos muitos usando a função de arquivo de cabeçalho STM8S_Serial.h que discutimos anteriormente. Mas a biblioteca tem outras dependências, muitos dos arquivos C de cabeçalho e C relacionados ao SPL UART e Clock. Portanto, a partir deste ponto, é melhor incluir todos os arquivos de cabeçalho e C em nosso projeto para evitar um erro de compilação. Meu ambiente de trabalho STVD é assim.
Certifique-se de incluir todos os arquivos de origem SPL e Incluir arquivo como fizemos em nosso primeiro tutorial. E também certifique-se de ter adicionado o arquivo de cabeçalho stm8s103_serial.h . Não há arquivo C para este cabeçalho.
Programando STM8S para comunicação serial
Assim que a configuração do projeto STVD estiver pronta, podemos começar a escrever nosso código no arquivo main.c. O código completo para este tutorial pode ser encontrado na parte inferior desta página. A explicação é a seguinte.
A primeira etapa é incluir os arquivos de cabeçalho necessários, aqui adicionei o arquivo de cabeçalho principal (stm8s) e o arquivo de cabeçalho stm8s_103_serial que acabamos de baixar.
// Cabeçalhos obrigatórios #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Em seguida, estamos usando as macros de design para especificar os pinos de entrada e saída. Aqui estará controlando apenas o LED on-board que está conectado ao pino 5 da porta B, então damos a ele o nome de test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // LED de teste está conectado ao PB5
Continuando na função principal, definiremos o pino como uma saída. Se você não estiver familiarizado com as funções básicas do GPIO, volte para o tutorial do STM8S GPIO.
// Definição dos pinos // Declara PB5 como push pull Output pin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Em seguida, inicializamos nossas portas de comunicação serial a taxas de 9600 baud. Para quem é novo, 9600 é a velocidade com que os bits de dados serão transferidos durante a comunicação. Se você definir 9600 aqui, também terá que definir o mesmo no software de monitoramento. Em seguida, também imprimimos uma string “Enter command” e passamos para a próxima linha.
Serial_begin (9600); // Inicializa a comunicação serial na taxa de transmissão de 9600 Serial_print_string ("Enter command"); // imprime uma string Serial_newline (); // mover para a próxima linha
Passando para o loop while infinito, usamos a função Serial_available para verificar se há dados seriais de entrada. Se sim, lemos e salvamos em uma variável chamada ch e também imprimimos a mesma usando Serial_print . Então se o valor recebido for 0, vamos desligar o LED e se for 1, vamos ligar o LED
if (Serial_available ()) {Serial_print_string ("Você pressionou:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED desligado if (ch == '1') GPIO_WriteLow (test_LED); // LED ON}
Com isso, a programação deste tutorial está completa, basta fazer o upload do código fornecido no final desta página e você poderá controlar o LED a partir do monitor serial.
Controle de LED do monitor serial
Depois de carregar o código, você pode abrir qualquer monitor serial a taxas de transmissão de 9600. Usei o próprio monitor serial do Arduino para facilitar o uso. Pressione o botão de reset e você deverá ver a mensagem “Enter a command”. Então, se você digitar 1 e pressionar enter, o led on-board deve acender, da mesma forma que para 0, ele deve desligar.
O trabalho completo pode ser encontrado no link do vídeo no final desta página. Se você tiver alguma dúvida, deixe-as na seção de comentários. Você também pode usar nossos fóruns para postar outras questões técnicas.
Análise mais detalhada da biblioteca serial STM8S
Para aquelas mentes curiosas que querem saber o que realmente acontece dentro do arquivo de cabeçalho STM8S103F3_Serial, continue lendo….
Este arquivo de cabeçalho funciona bem para programação de nível iniciante, mas se você estiver usando uma versão diferente do controlador STM8S ou procurando algumas opções avançadas, você pode querer ajustar este cabeçalho um pouco ou trabalhar diretamente com bibliotecas SPL. Eu escrevi este arquivo de cabeçalho apenas como um exemplo do arquivo de cabeçalho UART1, a explicação do meu arquivo de cabeçalho é a seguinte.
Lendo um personagem do Serial Monitor
Esta função ajuda a ler um único caractere que foi enviado para o microcontrolador do monitor serial.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); return (UART1_ReceiveData8 ()); }
Esperamos até que o sinalizador RXE esteja DEFINIDO para concluir a recepção e, em seguida, apagamos o sinalizador para reconhecer a recepção. Finalmente, enviamos os dados de 8 bits recebidos como resultado desta função.
Imprimindo um caractere no Monitor Serial
Esta função transmite um único caractere de um microcontrolador para o monitor serial.
void Serial_print_char (valor char) {UART1_SendData8 (valor); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aguarde o envio}
A função simplesmente escreve o valor de 8 bits e espera até que a transmissão seja concluída verificando o UART1_FLAG_TXE para SET
Inicializando a comunicação serial
Esta função inicializa a comunicação serial na taxa de transmissão necessária.
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 (); // Desinicializar periféricos 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); }
Além da taxa de bauds, existem outros parâmetros que devem ser configurados para comunicação serial, como o número de bits de dados, número de bits de parada, paridade, etc. O mais comum (semelhante ao Arduino) são os dados de 8 bits com um bit de parada e sem paridade e, portanto, essa será a configuração padrão. Você pode alterá-lo, se necessário.
Impressão de um inteiro no monitor serial
Na maioria das vezes, se estivermos usando um monitor serial para depuração ou monitoramento, podemos querer imprimir uma variável do tipo int no monitor serial. Esta função faz exatamente isso
void Serial_print_int (int number) // Função para imprimir o valor int no monitor serial {char count = 0; dígito char = ""; while (number! = 0) // divide o int em char array {digit = number% 10; contagem ++; número = número / 10; } while (count! = 0) // imprime a matriz de caracteres na direção correta {UART1_SendData8 (dígito + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aguarde o envio de contagem--; }}
Ele recebe um valor inteiro e o converte em um array de caracteres no primeiro loop while, depois no segundo loop while, enviaremos cada um dos caracteres de maneira semelhante à nossa função print char.
Imprimindo uma nova linha
Esta é uma função simples para imprimir uma nova linha. O hexvalue para fazer isso é “0x0a”, estamos apenas enviando usando o comando de transmissão de 8 bits.
void Serial_newline (void) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // aguarde o envio}
Imprimir uma string no monitor serial
Outra função útil é realmente imprimir strings no monitor serial.
void Serial_print_string (string de caracteres) {. char i = 0; while (string! = 0x00) {UART1_SendData8 (string); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Novamente, essa função também converte a string em uma matriz char e envia cada caractere. Como sabemos, todas as strings terminarão em null. Portanto, só temos que continuar cruzando e transmitindo os caracteres até chegarmos ao 0x00 nulo.
Verificar se os dados seriais estão disponíveis para leitura
Esta função verifica se há algum dado serial no buffer pronto para ler.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) return TRUE; senão retorna FALSE; }
Ele verifica o sinalizador UART1_FLAG_RXNE , se for verdadeiro, retorna verdadeiro e se não for, retorna falso.