Comunicación Uart mediante microcontrolador pic

En este tutorial aprendemos a habilitar la comunicación UART con el microcontrolador PIC y cómo transferir datos hacia y desde su computadora. Hasta ahora, hemos cubierto todos los módulos básicos como ADC, Timers, PWM y también hemos aprendido cómo interconectar LCD y pantallas de 7 segmentos. Ahora, nos equiparemos con una nueva herramienta de comunicación llamada UART que se usa ampliamente en la mayoría de los proyectos de microcontroladores. Consulte aquí nuestros tutoriales completos de microcontroladores PIC utilizando MPLAB y XC8.

Aquí hemos utilizado PIC16F877A MCU, tiene un módulo llamado "Receptor y transmisor asíncrono síncrono universal direccionable", conocido brevemente como USART. USART es un sistema de comunicación de dos cables en el que los datos fluyen en serie. USART también es una comunicación full-duplex, lo que significa que puede enviar y recibir datos al mismo tiempo que se pueden usar para comunicarse con dispositivos periféricos, como terminales CRT y computadoras personales.

El USART se puede configurar en los siguientes modos:

• Asíncrono (dúplex completo)
• Sincrónico - Maestro (semidúplex)
• Sincrónico - Esclavo (semidúplex)

También hay dos modos diferentes a saber el modo de 8 bits y el de 9 bits, en este tutorial configuraremos el módulo USART para que funcione en modo Asíncrono con sistema de comunicación de 8 bits, ya que es el tipo de comunicación más utilizado. Como es asíncrono, no necesita enviar señales de reloj junto con las señales de datos. UART utiliza dos líneas de datos para enviar (Tx) y recibir (Rx) datos. La tierra de ambos dispositivos también debe hacerse común. Este tipo de comunicación no comparte un reloj común, por lo que un terreno común es muy importante para que el sistema funcione.

Al final de este tutorial, podrá establecer una comunicación (UART) entre su computadora y su microcontrolador PIC y alternar un LED en la placa PIC de su computadora portátil. El estado del LED se enviará a su computadora portátil desde el PIC MCU. Probaremos la salida usando Hyper Terminal en la computadora. También se ofrece un video detallado al final de este tutorial.

Requisitos:

Hardware:

• Tablero de perforación PIC16F877A
• Módulo convertidor RS232 a USB
• Computadora
• Programador PICkit 3

Software:

• MPLABX
• Hiper terminal

Se requiere un convertidor de RS232 a USB para convertir los datos en serie en un formato legible por computadora. Hay formas de diseñar su propio circuito en lugar de comprar su propio módulo, pero no son confiables ya que están sometidas a ruido. El que estamos usando se muestra a continuación.

Nota: Cada convertidor de RS232 a USB requeriría la instalación de un controlador especial; la mayoría de ellos deberían instalarse automáticamente tan pronto como conecte el dispositivo. Pero, si no se relaja !!! Usa la sección de comentarios y te ayudaré.

Programación del microcontrolador PIC para comunicación UART:

Como todos los módulos (ADC, Timer, PWM), también debemos inicializar nuestro módulo USART de nuestra MCU PIC16F877A e indicarle que funcione en el modo de comunicación UART de 8 bits. Definamos los bits de configuración y comencemos con la función de inicialización de UART.

Inicializando el módulo UART del microcontrolador PIC:

Los pines Tx y Rx están físicamente presentes en los pines RC6 y RC7. De acuerdo con la hoja de datos, declaremos TX como salida y RX como entrada.

// **** Configuración de pines de E / S para UART **** // TRISC6 = 0; // Pin TX configurado como salida TRISC7 = 1; // Pin RX establecido como entrada // ________ Conjunto de pines de E / S __________ //

Ahora se debe configurar la velocidad en baudios. La velocidad en baudios es la velocidad a la que se transfiere la información en un canal de comunicación. Este puede ser uno de los muchos valores predeterminados, pero en este programa estamos usando 9600 ya que es la velocidad en baudios más utilizada.

/ ** Inicialice el registro SPBRG para la velocidad en baudios requerida y configure BRGH para velocidad en baudios rápida ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // para alta velocidad en baudios // _________ Fin de la configuración de velocidad en baudios _________ //

El valor de la velocidad en baudios debe establecerse utilizando el registro SPBRG, el valor depende del valor de la frecuencia del cristal externo, las fórmulas para calcular la velocidad en baudios se muestran a continuación:

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

El bit BRGH debe hacerse alto para permitir una tasa de bits de alta velocidad. Según la hoja de datos (página 13), siempre es ventajoso habilitarlo, ya que puede eliminar errores durante la comunicación.

Como se dijo anteriormente, estaremos trabajando en modo asíncrono, por lo tanto, el bit SYNC debe hacerse cero y el bit SPEM debe ser alto para habilitar los pines seriales (TRISC6 y TRICSC5)

// **** Habilitar puerto serie asincrónico ******* // SYNC = 0; // SPEN asincrónico = 1; // Habilitar los pines del puerto serie // _____ Puerto serie asincrónico habilitado _______ //

En este tutorial enviaremos y recibiremos datos entre la MCU y la computadora, por lo tanto, debemos habilitar los bits TXEN y CREN.

// ** Vamos a prepararnos para la transmisión y recepción ** // TXEN = 1; // habilita la transmisión CREN = 1; // habilita la recepción // __ Módulo UART arriba y listo para transmisión y recepción __ //

Los bits TX9 y RX9 deben ponerse a cero para que podamos operar en modo de 8 bits. Si tiene que establecerse una alta fiabilidad, se puede seleccionar el modo de 9 bits.

// ** Seleccione el modo de 8 bits ** // TX9 = 0; // Recepción de 8 bits seleccionada RX9 = 0; // Modo de recepción de 8 bits seleccionado // __ Modo de 8 bits seleccionado __ //

Con esto completamos nuestra configuración de inicialización. y está listo para funcionar.

Transmisión de datos mediante UART:

La siguiente función se puede utilizar para transmitir datos a través del módulo UART:

// ** Función para enviar un byte de fecha a UART ** // void UART_send_char (char bt) {while (! TXIF); // mantenga el programa hasta que el búfer de TX esté libre TXREG = bt; // Cargar el búfer del transmisor con el valor recibido} // _____________ Fin de la función ________________ //

Una vez que se inicializa el módulo, cualquier valor que se cargue en el registro TXREG se transmitirá a través de UART, pero la transmisión podría superponerse. Por tanto, siempre deberíamos comprobar el indicador de interrupción de transmisión TXIF. Solo si este bit es bajo, podemos continuar con el siguiente bit para la transmisión; de lo contrario, debemos esperar a que este indicador baje.

Sin embargo, la función anterior se puede usar solo para enviar solo un byte de datos; para enviar una cadena completa, se debe usar la función siguiente

// ** Función para convertir cadena en byte ** // void UART_send_string (char * st_pt) {while (* st_pt) // si hay un char UART_send_char (* st_pt ++); // procesarlo como un byte de datos} // ___________ Fin de la función ______________ //

Esta función puede ser un poco complicada de entender ya que tiene punteros, pero créanme, los punteros son maravillosos y facilitan la programación y este es un buen ejemplo de lo mismo.

Como puede notar, hemos llamado nuevamente a UART_send_char () pero ahora dentro del ciclo while. Hemos dividido la cadena en caracteres individuales, cada vez que se llama a esta función, se enviará un carácter al TXREG y se transmitirá.

Recibir datos usando UART:

La siguiente función se puede utilizar para recibir datos del módulo UART:

// ** Función para obtener un byte de fecha de UART ** // char UART_get_char () {if (OERR) // buscar Error {CREN = 0; // Si hay error -> Reset CREN = 1; // Si hay error -> Reset} while (! RCIF); // mantener el programa hasta que el búfer RX esté libre return RCREG; // recibir el valor y enviarlo a la función principal} // _____________ Fin de la función ________________ //

Cuando el módulo UART recibe un dato, lo recoge y lo almacena en el registro RCREG. Simplemente podemos transferir el valor a cualquier variable y usarlo. Pero puede haber un error de superposición o el usuario puede estar enviando datos continuamente y aún no los hemos transferido a una variable.

En ese caso, el bit de bandera de recepción RCIF viene al rescate. Este bit se reducirá siempre que se reciba un dato y aún no se procese. Por lo tanto, lo usamos en el ciclo while creando un retraso para mantener el programa hasta que manejemos ese valor.

Cambio de LED usando el módulo UART del microcontrolador PIC:

Ahora vayamos a la parte final del Programa, la función void main (void) , donde cambiaremos un LED a través de la computadora usando la comunicación UART entre PIC y la computadora.

Cuando enviamos un carácter “1” (desde la computadora), el LED se encenderá y el mensaje de estado “LED ROJO -> ENCENDIDO” se enviará de regreso (desde PIC MCU) a la computadora.

De manera similar, enviamos un carácter “0” (desde la computadora), el LED se apagará y el mensaje de estado “LED ROJO -> APAGADO” se enviará de regreso (desde PIC MCU) a la computadora.

while (1) // Bucle infinito {get_value = UART_get_char (); if (get_value == '1') // Si el usuario envía "1" {RB3 = 1; // Enciende el LED UART_send_string ("LED ROJO -> ENCENDIDO"); // Enviar notificación a la computadora UART_send_char (10); // El valor ASCII 10 se usa para el retorno de carro (para imprimir en una nueva línea)} if (get_value == '0') // Si el usuario envía "0" {RB3 = 0; // Apague el LED UART_send_string ("RED -> OFF"); // Enviar notificación a la computadora UART_send_char (10); // El valor ASCII 10 se usa para el retorno de carro (para imprimir en una nueva línea)}}

Simulando nuestro programa:

Como de costumbre, simulemos nuestro programa usando proteus y averigüemos si funciona como se esperaba.

La imagen de arriba muestra un terminal virtual en el que muestra un mensaje de bienvenida y el estado del LED. Se puede notar que el LED de color rojo está conectado al pin RB3. El funcionamiento detallado de la simulación se puede encontrar en el video al final.

Configuración de hardware y prueba de la salida:

La conexión para este circuito es realmente simple, usamos nuestra placa PIC Perf y simplemente conectamos los tres cables al convertidor RS232 a USB y conectamos el módulo a nuestra computadora usando un cable de datos USB como se muestra a continuación.

A continuación, instalamos la aplicación Hyper Terminal (descárguela desde aquí) y la abrimos. Debería mostrar algo como esto

Ahora abra el Administrador de dispositivos en su computadora y verifique a qué puerto Com está conectado su módulo, el mío está conectado al puerto COM 17 como se muestra a continuación

Nota: El nombre del puerto COM para su módulo puede cambiar según su proveedor, no es un problema.

Ahora regrese a la aplicación Hyper Terminal y navegue hasta Configurar -> Configuración del puerto o presione Alt + C, para obtener el siguiente cuadro emergente y seleccione el puerto deseado (COM17 en mi caso) en la ventana emergente y haga clic en conectar.

Una vez que se establece la conexión, encienda su placa PIC perf y debería ver algo como esto a continuación

Mantenga el cursor en la ventana de comandos e ingrese 1 y luego presione enter. El LED se encenderá y el estado se mostrará como se muestra a continuación.

De la misma manera, mantenga el cursor en la ventana de comandos e ingrese 0 y luego presione enter. El LED se apagará y el estado se mostrará como se muestra a continuación.

A continuación se muestra el código completo y el video detallado, que mostrará cómo responde el LED en tiempo real para "1" y "0".

Eso es todo chicos, hemos interconectado PIC UART con nuestra computadora y transferimos los datos para alternar el LED usando Hyper terminal. Espero que lo hayas entendido, si no, usa la sección de comentarios para hacer tu consulta. En nuestro próximo tutorial usaremos de nuevo UART pero lo haremos más interesante usando un módulo Bluetooth y transmitiendo los datos por aire.

También verifique la comunicación UART entre dos microcontroladores ATmega8 y la comunicación UART entre ATmega8 y Arduino Uno.