- Requisitos:
- Microcontrolador PIC de programação para comunicação UART:
- Simulando nosso programa:
- Configuração de hardware e teste de saída:
Neste tutorial, aprendemos a ativar a comunicação UART com o microcontrolador PIC e como transferir dados de e para o seu computador. Até agora, cobrimos todos os módulos básicos como ADC, Timers, PWM e também aprendemos como fazer a interface de LCDs e monitores de 7 segmentos. Agora, vamos nos equipar com uma nova ferramenta de comunicação chamada UART, amplamente utilizada na maioria dos projetos de Microcontroladores. Confira aqui nossos tutoriais completos de microcontroladores PIC usando MPLAB e XC8.
Aqui, usamos o MCU PIC16F877A, que possui um módulo denominado “Receptor e transmissor assíncrono síncrono universal endereçável”, também conhecido como USART. USART é um sistema de comunicação de dois fios no qual os dados fluem em série. O USART também é uma comunicação full-duplex, o que significa que você pode enviar e receber dados ao mesmo tempo, que podem ser usados para se comunicar com dispositivos periféricos, como terminais CRT e computadores pessoais.
O USART pode ser configurado nos seguintes modos:
- Assíncrono (full-duplex)
- Síncrono - Mestre (half-duplex)
- Síncrono - Slave (half-duplex)
Existem também dois modos diferentes, nomeadamente o modo de 8 bits e o modo de 9 bits, neste tutorial iremos configurar o módulo USART para funcionar em modo Assíncrono com sistema de comunicação de 8 bits, visto ser o tipo de comunicação mais utilizado. Por ser assíncrono, não precisa enviar sinal de clock junto com os sinais de dados. O UART usa duas linhas de dados para enviar (Tx) e receber (Rx) dados. O aterramento de ambos os dispositivos também deve ser comum. Este tipo de comunicação não compartilha um relógio comum, portanto, um terreno comum é muito importante para o sistema funcionar.
No final deste tutorial, você será capaz de estabelecer uma comunicação (UART) entre seu computador e seu microcontrolador PIC e alternar um LED na placa PIC de seu laptop. O status do LED será enviado ao seu laptop do PIC MCU. Vamos testar a saída usando o Hyper Terminal no computador. Vídeo detalhado também é fornecido no final deste tutorial.
Requisitos:
Hardware:
- PIC16F877A Perf Board
- Módulo conversor RS232 para USB
- Computador
- Programador PICkit 3
Programas:
- MPLABX
- Hiper terminal
Um conversor RS232 para USB é necessário para converter os dados seriais em formato legível por computador. Existem maneiras de projetar seu próprio circuito em vez de comprar seu próprio módulo, mas elas não são confiáveis, pois estão sujeitas a ruídos. O que estamos usando é mostrado abaixo
Nota: Cada conversor RS232 para USB requer a instalação de um driver especial; a maioria deles deve ser instalada automaticamente assim que você conectar o dispositivo. Mas, se não relaxar !!! Use a seção de comentários e eu irei te ajudar.
Microcontrolador PIC de programação para comunicação UART:
Como todos os módulos (ADC, Timer, PWM), também devemos inicializar nosso módulo USART de nosso MCU PIC16F877A e instruí-lo a trabalhar no modo de comunicação UART de 8 bits. Vamos definir os bits de configuração e começar com a função de inicialização do UART.
Inicializando o módulo UART do microcontrolador PIC:
Os pinos Tx e Rx estão fisicamente presentes nos pinos RC6 e RC7. De acordo com o datasheet, vamos declarar TX como saída e RX como entrada.
// **** Definindo pinos de I / O para UART **** // TRISC6 = 0; // Pino TX definido como saída TRISC7 = 1; // Pino RX definido como entrada // ________ Pinos I / O definidos __________ //
Agora a taxa de transmissão deve ser definida. A taxa de transmissão é a taxa na qual as informações são transferidas em um canal de comunicação. Este pode ser um dos muitos valores padrão, mas neste programa estamos usando 9600 por ser a taxa de transmissão mais usada.
/ ** Inicializar o registro SPBRG para a taxa de baud exigida e definir BRGH para taxa de baud rápida ** / SPBRG = ((_XTAL_FREQ / 16) / Taxa de Baud) - 1; BRGH = 1; // para baud_rate alta // _________ Fim da configuração da baud_rate _________ //
O valor da taxa de baud deve ser definido usando o registro SPBRG, o valor depende do valor da frequência do cristal externo, as fórmulas para calcular a taxa de baud são mostradas abaixo:
SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1;
O bit BRGH deve ser alto para permitir a taxa de bits de alta velocidade. De acordo com a ficha técnica (página 13) é sempre vantajoso habilitá-la, pois pode eliminar erros durante a comunicação.
Como dito anteriormente, estaremos trabalhando em modo assíncrono, portanto, o bit SYNC deve ser zerado e o bit SPEM deve ser elevado para habilitar os pinos seriais (TRISC6 e TRICSC5)
// **** Ativar porta serial assíncrona ******* // SYNC = 0; // SPEN assíncrono = 1; // Habilita os pinos da porta serial // _____ Porta serial assíncrona habilitada _______ //
Neste tutorial, estaremos enviando e recebendo dados entre o MCU e o computador, portanto, temos que habilitar os bits TXEN e CREN.
// ** Vamos nos preparar para a transmissão e recepção ** // TXEN = 1; // habilita a transmissão CREN = 1; // habilita a recepção // __ módulo UART ativo e pronto para transmissão e recepção __ //
Os bits TX9 e RX9 devem ser zerados para que possamos operar no modo de 8 bits. Se for necessário estabelecer uma alta confiabilidade, o modo de 9 bits pode ser selecionado.
// ** Selecione o modo de 8 bits ** // TX9 = 0; // Recepção de 8 bits selecionada RX9 = 0; // modo de recepção de 8 bits selecionado // __ modo de 8 bits selecionado __ //
Com isso, concluímos nossa configuração de inicialização. e está pronto para operação.
Transmitindo dados usando UART:
A função abaixo pode ser usada para transmitir dados através do módulo UART:
// ** Função para enviar um byte de data para UART ** // void UART_send_char (char bt) {while (! TXIF); // mantenha o programa até que o buffer TX esteja livre TXREG = bt; // Carregar o buffer do transmissor com o valor recebido} // _____________ Fim da função ________________ //
Assim que o módulo for inicializado, qualquer valor carregado no registrador TXREG será transmitido através do UART, mas a transmissão pode se sobrepor. Portanto, devemos sempre verificar o sinalizador de interrupção de transmissão TXIF. Somente se esse bit for baixo, podemos prosseguir com o próximo bit para transmissão, caso contrário, devemos esperar que esse sinalizador fique baixo.
No entanto, a função acima pode ser usada apenas para enviar apenas um byte de dados, para enviar uma string completa a função abaixo deve ser usada
// ** Função para converter string em byte ** // void UART_send_string (char * st_pt) {while (* st_pt) // se houver um char UART_send_char (* st_pt ++); // processá-lo como um dado de byte} // ___________ Fim da função ______________ //
Esta função pode ser um pouco complicada de entender, pois tem ponteiros, mas acredite em mim, os ponteiros são maravilhosos e tornam a programação mais fácil e este é um bom exemplo do mesmo.
Como você pode notar, chamamos novamente UART_send_char (), mas agora dentro do loop while. Dividimos a string em caracteres individuais, cada vez que esta função é chamada, um caractere será enviado ao TXREG e será transmitido.
Recebendo dados usando UART:
A seguinte função pode ser usada para receber dados do módulo UART:
// ** Função para obter um byte de data de UART ** // char UART_get_char () {if (OERR) // verificar o erro {CREN = 0; // Se houver erro -> Reset CREN = 1; // Se houver erro -> Reinicializar} while (! RCIF); // mantenha o programa até que o buffer RX esteja livre return RCREG; // receber o valor e enviá-lo para a função principal} // _____________ Fim da função ________________ //
Quando um dado é recebido pelo módulo UART, ele o pega e armazena no registro RCREG. Podemos simplesmente transferir o valor para qualquer variável e usá-lo. Mas pode haver erro de sobreposição ou o usuário pode estar enviando dados continuamente e ainda não os transferimos para uma variável.
Nesse caso, o bit RCIF da bandeira de recepção vem para resgatar. Este bit será reduzido sempre que um dado for recebido e ainda não tiver sido processado. Portanto, nós o usamos no loop while criando um atraso para segurar o programa até que lidemos com aquele valor.
Alternando LED usando o módulo UART do microcontrolador PIC:
Agora vamos para a parte final do Programa, a função void main (void) , onde iremos alternar um LED através do computador usando a comunicação UART entre o PIC e o computador.
Quando enviamos um caractere “1” (do computador), o LED se acende e a mensagem de status “LED VERMELHO -> ON” é enviada de volta (do PIC MCU) para o computador.
Da mesma forma, enviamos um caractere “0” (do computador), o LED será DESLIGADO e a mensagem de status “LED VERMELHO -> DESLIGADO” será enviada de volta (do PIC MCU) para o computador.
while (1) // Loop infinito {get_value = UART_get_char (); if (get_value == '1') // Se o usuário enviar "1" {RB3 = 1; // Liga o LED UART_send_string ("RED LED -> ON"); // Enviar notificação para o computador UART_send_char (10); // valor ASCII 10 é usado para retorno de carro (para imprimir em nova linha)} if (get_value == '0') // Se o usuário enviar "0" {RB3 = 0; // Apaga o LED UART_send_string ("RED -> OFF"); // Enviar notificação para o computador UART_send_char (10); // valor ASCII 10 é usado para retorno de carro (para imprimir em uma nova linha)}}
Simulando nosso programa:
Como sempre vamos simular nosso programa usando proteus e descobrir se funciona como esperado.
A imagem acima mostra um terminal virtual no qual mostra uma mensagem de boas-vindas e o status do LED. Nota-se que o LED de cor vermelha está conectado ao pino RB3. O funcionamento detalhado da simulação pode ser encontrado no Vídeo ao final.
Configuração de hardware e teste de saída:
A conexão para este circuito é muito simples, usamos nossa placa PIC Perf e basta conectar os três fios ao conversor RS232 para USB e conectar o módulo ao nosso computador usando o cabo de dados USB conforme mostrado abaixo.
Em seguida, instalamos o aplicativo Hyper Terminal (baixe-o aqui) e o abrimos. Deve mostrar algo assim
Agora abra o Gerenciador de Dispositivos no seu computador e verifique em qual porta Com o seu módulo está conectado, o meu está conectado à porta COM 17, conforme mostrado abaixo
Nota: O nome da porta COM para seu módulo pode mudar de acordo com seu fornecedor, não é um problema.
Agora volte para o Hyper Terminal Application e navegue até Set Up -> Port Configuration ou pressione Alt + C, para obter a seguinte caixa pop-up e selecione a porta desejada (COM17 no meu caso) na janela pop-up e clique em conectar.
Assim que a conexão for estabelecida, ligue sua placa de desempenho PIC e você deverá ver algo assim abaixo
Mantenha o cursor na janela de comando e digite 1 e pressione enter. O LED será ligado e o status será exibido conforme mostrado abaixo.
Da mesma forma, mantenha o cursor na Janela de Comando e insira 0 e pressione Enter. O LED será desligado e o status será exibido conforme mostrado abaixo.
Abaixo é fornecido o código completo e vídeo detalhado, que irá mostrar como o LED responde em tempo real para “1” e “0”.
É isso, pessoal, fizemos a interface do PIC UART com nosso computador e transferimos os dados para alternar o LED usando o terminal Hyper. Espero que você tenha entendido, se não, use a seção de comentários para fazer sua consulta. Em nosso próximo tutorial, usaremos novamente o UART, mas o tornaremos mais interessante usando um módulo Bluetooth e transmitiremos os dados pelo ar.
Verifique também a comunicação UART entre dois microcontroladores ATmega8 e a comunicação UART entre ATmega8 e o Arduino Uno.