Receptor/probador de datos UART portátil

El receptor/transmisor asíncrono universal (UART) es la interfaz de comunicación serie punto a punto (peer) más común utilizada en microcontroladores. Es una interfaz simple de dos cables que no requiere una señal de reloj ni ningún dispositivo maestro para la transmisión de datos en serie entre dos dispositivos integrados. Puede transmitir paquetes de datos de longitud variable (de 5 a 9 bits) con la provisión de un bit de paridad para la detección de errores. Es por eso que casi todos los microcontroladores tienen USART incorporado o al menos periféricos UART.

En la comunicación UART, dos dispositivos comunican datos directamente entre sí. Esta comunicación de datos puede ser simplex (donde un dispositivo es el receptor y otro es el transmisor), full duplex (donde ambos dispositivos reciben y transmiten datos entre sí simultáneamente) o half duplex (ambos dispositivos transmiten y reciben datos entre sí, pero uno a la vez). Un dispositivo con un periférico UART puede comunicarse con otro dispositivo con un periférico UART, ya sea directamente (si ambos dispositivos operan en niveles lógicos TTL) o a través de un chip controlador en serie (si uno o ambos dispositivos operan en otros niveles lógicos TTL). señal distinta a TTL). Se desarrollaron protocolos de controlador en serie para facilitar la comunicación de datos de largo alcance. Hay tres protocolos de controlador serie UART más utilizados:

1) RS-232: en el protocolo del controlador serie RS-232, se utiliza una señal de voltaje en el rango de -25 V a +25 V para la comunicación de datos donde la señal de -25 V a -3 V es equivalente a la lógica ALTA. (estado del bit 1) y la señal de +3 V a +25 V es equivalente a la lógica BAJA (estado del bit 0). El chip controlador RS-232 (como MAX232) convierte estos niveles de voltaje (como los de una PC) en niveles de voltaje TTL (0 a 5 V) para la transmisión de datos a un dispositivo TTL con un periférico UART (como un microcontrolador). El chip controlador (como MAX-232) recibe de manera similar bits en niveles lógicos TTL de un dispositivo TTL con periférico UART (como un microcontrolador) y los convierte a niveles de señal RS-232 estándar para transmitirlos al dispositivo con interfaz RS-232. (como computadora personal). RS-232 permite la comunicación UART full-duplex punto a punto entre dos dispositivos. El chip controlador RS-232 utiliza al menos tres cables (Tx, RX y tierra común) para interactuar con el puerto RS-232 o la interfaz de un dispositivo. En el protocolo RS-232, un transmisor UART puede comunicar datos sólo a un receptor UART.

2) RS-422: en el protocolo del controlador serie RS-422, las señales de voltaje en el rango de -6 V a +6 V se utilizan para la comunicación de datos, donde la señal de -6 V a -2 V es equivalente a la lógica ALTA (estado de bit 1) y La señal de +2 V a +6 V es equivalente a la lógica BAJA (estado del bit 0). El chip controlador RS-422 convierte estos niveles de voltaje en niveles de voltaje TTL (0 a 5 V) para su transmisión al dispositivo TTL con periférico UART. El chip controlador convierte de manera similar bits en niveles lógicos TTL desde el dispositivo TTL con periférico UART a niveles de señal RS-422 estándar para su transmisión al dispositivo con interfaz RS-422. RS-422 permite la comunicación UART full-duplex y half-duplex entre dos dispositivos. El protocolo RS-422 utiliza señales diferenciales (dos señales invertidas en dos líneas para transmitir y recibir datos en el dispositivo final) para proporcionar datos de largo alcance con mejores características de relación señal-ruido. Por lo tanto, el chip controlador RS-422 utiliza al menos 5 cables para conectarse al puerto RS-422 de un dispositivo (dos Tx, dos Rx y tierra común). En el protocolo RS-422, un transmisor UART puede comunicar datos a dos receptores UART.

3) RS-485: RS-485 es una versión semidúplex del protocolo RS-422. Generalmente, los chips controladores RS-422 también pueden funcionar en modo RS-485. En el protocolo RS-485, un transmisor UART puede comunicar datos a múltiples receptores UART.

Los dispositivos con un periférico UART comunican datos de forma asíncrona. En lugar de utilizar cualquier señal de reloj, los dispositivos con datos de trama periférica UART (de 5 bits a 9 bits de longitud) en un paquete de datos que comienza con un bit de inicio y termina con un bit de parada. Cuando el receptor UART detecta el bit de inicio, comienza a buscar paquetes de datos a una frecuencia predeterminada llamada velocidad en baudios. La velocidad de transmisión se expresa en baudios por segundo, es decir, paquetes de datos o palabras comunicadas por segundo. Idealmente, dos dispositivos que comunican datos a través de periféricos UART deberían tener la misma velocidad en baudios. Los periféricos UART pueden gestionar una tolerancia máxima del 10% en las velocidades de transmisión. Se puede enviar un bit de paridad opcional en el paquete de datos UART para detectar errores en la comunicación de datos. Los paquetes de datos se enmarcan como se muestra en la siguiente figura mediante dispositivos UART:

En este proyecto, se diseñó un dispositivo portátil que puede leer datos (hasta 500 bytes) de un transmisor UART y permitir al usuario inspeccionar los datos transmitidos en una pantalla LCD de caracteres. El usuario puede configurar la velocidad en baudios, la cantidad de bits de datos, la paridad y el bit de parada en el dispositivo para que coincida con el transmisor UART. El usuario puede ajustar estos parámetros en el dispositivo hasta que se observen los paquetes de datos correctos en la pantalla. De esta manera, un usuario puede identificar la velocidad en baudios, la cantidad de bits de datos, la paridad y el bit de parada del transmisor UART y configurar los mismos parámetros en un receptor UART no configurado.

Normalmente, para comprobar la transmisión USART de un dispositivo integrado basado en un microcontrolador, los pines Rx y Tx del controlador se conectan al PUERTO COM de una PC a través de un chip controlador en serie (como MAX232 para el protocolo RS-232). Luego se utilizan programas como HyperTerminal para verificar la transmisión de datos. Con este método, todavía es difícil comprobar/identificar los caracteres no imprimibles en la pantalla de la computadora. El dispositivo desarrollado en este proyecto muestra paquetes de datos leídos en caracteres LCD en formatos de texto, hexadecimal, decimal y octal para una fácil identificación de caracteres no imprimibles. Este dispositivo también es capaz de comunicar un flujo fijo de paquetes de datos (una secuencia de prueba que contiene caracteres de la A a la Z y dígitos del 0 al 9) a un receptor UART para determinar si el dispositivo receptor está funcionando correctamente o no.

Este dispositivo está diseñado con el microcontrolador AVR ATMega8. ATMega8 tiene USART serial programable por lo que puede comunicarse fácilmente con UART o periférico USART de cualquier otro microcontrolador. ATMega8 tiene una EEPROM interna de 512 bytes que se utiliza para recuperar hasta 500 bytes de datos en serie de un transmisor UART para su inspección. Se conectó una pantalla LCD de 20X4 caracteres al ATMega8 para mostrar e inspeccionar los paquetes de datos UART obtenidos.

Este dispositivo fue diseñado para ser utilizado en un entorno industrial, por lo que el ATMega8 se conectó al chip controlador serie MAX485. MAX485 es un chip controlador serie UART que se puede utilizar para la comunicación UART con dispositivos con interfaz RS-422 o RS-485. El dispositivo también puede comunicarse directamente con la interfaz USART/UART de un dispositivo TTL (como otros microcontroladores). Para leer datos de dispositivos con una interfaz RS-232, el MAX-232 debe tener una interfaz externa con este dispositivo.

Componentes necesarios –

Nombre del componente	Cantidad
Microcontrolador IC ATMega8 o ATMega8A	1
IC MAX485	1
LCD de 20 x 4 caracteres	1
Cristal de 11,0592 MHz	1
olla de recorte 5K	1
LED de 3 mm	3
Interruptores de botón	6
Capacitores de disco de 22pF	dos
Condensador de disco de 0,1 uF	1
Resistencias de 10K ohmios 0,25W	7
Resistencia de 4,7 K ohmios y 0,25 W	1
Resistencia de 3,3 K ohmios y 0,25 W	1
Resistencias de 2,2 K ohmios y 0,25 W	dos
Resistencia de 470 ohmios 0,25 W	1
Resistencia de 100 ohmios 0,5 W	1
Base CI de 28 pines	1
Base CI de 8 pines	1
conector de 6 pines	1
Cinturón Berg – Hombre	1
Cinturón Berg – Mujer	1
PCB adecuado	1
Programador AVR	1

Diagrama de circuito -

Conexiones de circuito –

Este dispositivo está basado en el AVR ATMega8. ATMega8 es un microcontrolador de 8 bits que puede operar hasta 16 MIPS de velocidad de transferencia a 16 MHz. ATMega8 está interconectado con una pantalla LCD de 20X4 caracteres y un chip controlador serie MAX485 para crear el dispositivo. Hay un Trimpot (que se muestra como VR1 en el diagrama del circuito) que se utiliza para ajustar el contraste de la pantalla LCD. Hay un LED amarillo conectado en paralelo a todo el circuito que se utiliza para indicar que el dispositivo está funcionando. Hay un LED rojo conectado al bit 2 del puerto D del Atmega8 que se utiliza para indicar que el dispositivo está enviando datos de prueba a un receptor UART. Hay un LED blanco conectado al bit 7 del puerto D del ATMega8 que indica que el microcontrolador está activo y esperando que se presione un botón de menú parpadeante.

Hay interruptores de 6 botones entrelazados en el puerto B del ATMega8 para entrada del usuario. El dispositivo puede funcionar en dos modos: 1) Modo de menú que muestra la velocidad en baudios, bits de datos, paridad y bit de parada y 2) Modo de vista previa que muestra los paquetes de datos obtenidos de su búfer de un transmisor UART. Los interruptores de botón se utilizan para cambiar el modo y operar el dispositivo en ambos modos. Los botones están conectados a los pines del microcontrolador a través de seis resistencias pull-up.

La configuración y el control de datos en serie se pueden operar usando estos seis botones (que se muestran como SW1 a SW6 en el diagrama del circuito). El botón conectado al bit 5 del puerto B (que se muestra como SW6 en el diagrama del circuito) es un interruptor de palanca que se utiliza para cambiar entre el modo Ver y el modo Menú. Los botones SW2, SW3, SW4 y SW5 tienen funciones diferentes en ambos modos. El SW1 funciona en MODO VER solo para enviar datos de prueba a un receptor UART.

Los pines Rx y Tx del ATmega8 se pueden utilizar para recibir paquetes de datos de transmisión de datos USART/UART desde cualquier microcontrolador. Los pines Rx y Tx del ATmega8 también interactúan con el IC del controlador serial MAX485. MAX485 puede recibir datos UART desde cualquier dispositivo con interfaz RS-485 o RS422. RS-485 y RS-422 son los protocolos de comunicación serie más utilizados en las industrias. Para recibir datos UART desde la interfaz RS-232, este dispositivo debe tener una interfaz externa con IC MAX232.

Todo el circuito funciona con 5 V CC que se puede obtener de un banco de energía de 5 V o de una batería de 9 V con una fuente de alimentación regulada de 5 V utilizando 7805 IC. Se utiliza un cristal de frecuencia de 11,0592 MHz con ATmega8 para obtener una velocidad de transmisión precisa durante las pruebas.

Cómo funciona el circuito –

Después de ensamblar el circuito, el puerto ISP del ATmega8 debe conectarse a cualquier programador AVR y el archivo SerialDataTester.HEX debe actualizarse en el microcontrolador. Luego desconecte el circuito del programador AVR. Ahora el dispositivo está listo para funcionar.

Cuando el dispositivo está encendido, el LED intermitente y los LED RX-MODE se encienden por un momento y la pantalla LCD comienza a mostrar el título del proyecto y la configuración USART actual. Después de unos segundos, la pantalla LCD muestra el mensaje SIN DATOS o BÚFER VACÍO si no se reciben datos de un transmisor UART.

El dispositivo ahora se puede utilizar para probar datos en serie desde un transmisor UART o para probar un receptor UART enviando paquetes de datos de muestra. Los botones SW1 a SW6 se pueden utilizar para navegar por el modo Ver y el modo Menú. El modo Ver muestra los datos en serie recibidos desde un transmisor UART, mientras que el modo Menú le permite ajustar la configuración de UART.

1) Modo de menú : para probar los datos en serie de un transmisor UART, el usuario primero debe realizar la configuración UART en el dispositivo. La velocidad en baudios, el número de bits de datos, la paridad y la configuración de bits de parada del dispositivo deben ser los mismos que los del transmisor UART para recibir paquetes de datos correctamente. La velocidad en baudios esperada, el número de bits de datos, la paridad y el bit de parada se deben configurar navegando al modo de menú. El usuario puede ingresar al modo de menú presionando el botón SW6. Al presionar la tecla, la pantalla LCD muestra el menú USART que contiene parámetros (velocidad en baudios, bits de datos, paridad y bits de parada) con los valores actuales. Para seleccionar un parámetro se debe presionar el botón SW4. El parámetro seleccionado se indica mediante el cursor parpadeante. Para cambiar el valor del parámetro, se debe presionar el botón SW5 contra el parámetro seleccionado. Los parámetros se pueden configurar en los valores requeridos usando los botones SW4 y SW5. Una vez configurados los parámetros se pueden guardar sus valores pulsando el botón SW3. Estos valores se guardan permanentemente en la EEPROM interna del microcontrolador. Para cambiar los valores, si es necesario, el usuario debe regresar al modo de menú presionando el botón SW6. Las configuraciones de parámetros predeterminadas para velocidad en baudios, bits de datos, paridad y bit de parada son 9600, 8, 0 y 1, respectivamente. El usuario puede restablecer la configuración predeterminada de USART (9600, 8, 0, 1) presionando el botón SW2.

2) Modo de visualización : este es el modo predeterminado para ver los datos seriales recibidos. Para cambiar del modo Menú al modo Ver, el usuario debe presionar el botón SW6 una vez más o esperar 10 segundos sin operar ningún botón. En el modo Vista previa, cuatro paquetes de datos recibidos se muestran en líneas LCD de cuatro caracteres. Cada línea consta de la posición, el carácter, el código hexadecimal, el código decimal y el código octal del paquete de datos en serie recibido en el búfer. Si el paquete de datos recibido no es un carácter imprimible, se mostrará un punto en lugar del carácter. El tamaño máximo del búfer se establece en 500 bytes ya que el ATmega8 tiene 512 bytes de EEPROM incorporada. El número total de bytes recibidos (en el búfer) se muestra en la esquina inferior izquierda de la pantalla LCD.

En el modo Vista previa, los paquetes de datos recibidos se pueden desplazar hacia arriba y hacia abajo presionando los botones SW5 y SW4. Al presionar el botón SW3, la pantalla muestra los datos del primer paquete de datos recibido en el buffer. Si se presiona el botón SW2, el buffer recibido se borrará y la pantalla LCD mostrará el mensaje "SIN DATOS o BUFFER VACÍO".

3) Prueba de un receptor UART : para probar un receptor UART, el usuario debe presionar el botón SW1. Al presionar este botón, se transmite una cadena de prueba que contiene los caracteres de la A a la Z y del 0 al 9 a través del pin Tx, así como de los pines A y B del MAX485. Al presionar esta tecla, el buffer recibido también se borra para recibir nuevos datos. El LED rojo se ilumina durante un breve período, lo que indica que se están transmitiendo datos desde el microcontrolador al receptor UART.

Fig. 3: Imagen que muestra el modo de menú del probador de datos en serie UART basado en ATmega8

Guía de programación-

Este dispositivo está basado en AVR ATmega8 y está programado con C integrado usando AVR Studio 4. También se pueden usar otras herramientas de programación como Atmel Studio o Notepad++ para escribir y compilar el código. El ATmega8 está programado para recibir configuraciones UART del usuario mediante botones y recibir datos en serie desde un transmisor UART en consecuencia. El búfer de datos recibidos se muestra en una pantalla LCD de 20X4 caracteres, donde los paquetes de datos recibidos se pueden desplazar hacia arriba y hacia abajo. El ATmega8 también está programado para probar cualquier receptor UART enviándole una cadena de prueba.

Constantes utilizadas en el código.

#define F_CPU 11059200L: – Constante utilizada para definir la frecuencia de reloj de la MCU

#define F_CPU_BY_100 F_CPU/100: - Frecuencia dividida por 100 para calcular la velocidad de transmisión.

#define UMS 500: – Inicialización del tamaño del mensaje USART para la matriz

#define LCD_P PORTC: – Puerto C para interfaz con LCD

#define LCD_EN 0b00010000: - En pin de la pantalla LCD conectado al cuarto pin del puerto C

#define LCD_RS 0b00100000: - Pin LCD Rs conectado al quinto pin del puerto C

#define BTN_SW6 0b00100000: - Switch 6 conectado al quinto pin del puerto B

#define BTN_SW1 0b00000001: – Switch 1 conectado al pin 0 del puerto B

#define BTN_SWS 0b00011110: - Interruptor para 4 pines 2,3,4,5

#define BTN_SW5 0b00010000: - Switch 5 conectado al cuarto pin del puerto B

#define BTN_SW4 0b00001000: - Switch 4 conectado al tercer pin del puerto B

#define BTN_SW3 0b00000100: - Switch 3 conectado al segundo pin del puerto B

#define BTN_SW2 0b00000010: - Switch 2 conectado al primer pin del puerto B

#define TX_L 0b00000100: - LED Tx conectado al segundo pin del puerto D

#define TX_C 0b00001000: – Modo RX o TX habilitado en MAX485

#define BLK 0b10000000: - LED parpadeante conectado al séptimo pin del puerto D que indica que la MCU está funcionando.

Variable utilizada en el código.

carácter sin firmar URD(UMS+1); : – Esta matriz se utiliza para leer datos de USART

carácter USD = “ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”; :-Esta matriz se utiliza para enviar datos en USART

char HEX (16) = {'0′,'1′,'2′,'3′,'4′,'5′,'6′,'7′,'8′,'9', 'A' ,'B','C','D','E','F'}; : – Esta matriz se utiliza para convertir los datos recibidos a hexadecimal.

intUBRL(12)={ 3, 6, 12, 24, 48, 96, 144, 192, 288, 384, 576, 768}; //X 100: - se cambiarán las velocidades en baudios

uint8_t U_B=5; : – typedef unsigned char 8 bits para velocidad en baudios

uint8_t U_D=8; : – typedef unsigned char 8 bits para bits de datos

uint8_t U_P=1; : – typedef carácter sin firmar de 8 bits para paridad

uint8_t U_S=1; : – typedef carácter sin firmar de 8 bits para bit de parada

carácter sin firmar USART_RXD=0; :- propósito variable de recibir datos

intURDP = 0; : – Con el fin de leer datos de PIN

intUSDP = 0; :- Con el fin de enviar datos de PIN

uint8_tUSCH = 1; :- para actualizar los datos de USART

uint8_t VCCH = 1; :- para actualizar el modo de visualización

Archivo de encabezado y bibliotecas utilizadas en el código –

#incluir : – Cabecera AVR estándar para entrada/salida

#incluir : – Encabezado AVR estándar para proporcionar retrasos de tiempo

#incluir : – Encabezado AVR estándar para interrupciones

#incluir : – Encabezado AVR estándar para manejar datos EEPROM

Función utilizada en el código.

getString: manipula la cadena para imprimirla en la pantalla LCD.

rdE: – Leer datos de EEPROM

wrE: – Escribe datos desde EEPROM

P_init: – inicializando puertos para su uso

LCD_E: – habilita el pin E del LCD

LCD_WN: – para activar y desactivar el modo RS

LCD_WCM: – Para conectar comandos

LCD_init: – Para inicializar la pantalla LCD

LCD_WC: – Escribir carácter

LCD_WS: – Escribir cadena

LCD_CS: – Para limpiar la pantalla

LCD_POS: – Pausa el cursor

USART_init: – inicializa USART

USART_SC: – Para enviar caracteres

USART_SM: -Para configurar el modo Menú

ISR: – Para recibir datos

VUSCR: – Ver configuración de pantalla

USART_UPD: – Actualización de datos USART

USART_SD: -Enviando datos USART

USART_MN: – El menú USART se puede cambiar mediante el interruptor

VWL: – controla los datos del buffer mediante interruptores

Algoritmo:

El código para este receptor/probador de datos UART portátil funciona de la siguiente manera:

1) Cuando se enciende el circuito del probador de datos en serie, en primer lugar, se inicializan los puertos que definen el puerto B como entrada, el puerto C como salida y los 7 pines del puerto D como salida. También pasa el bit cero a "TX_C, TX_L, LCD_RS, LCD_EN" para ponerlos en BAJO.

 vacío P_init ()

 {

 DDRB = 0x00;

 DDRC = 0xFF;

 DDRD = 0xFE;

 PUERTO &= (~TX_C);

 PUERTO &= (~TX_L);

 LCD_P &= (~LCD_RS);

 LCD_P &= (~LCD_ES);

 }

2) Después de inicializar los puertos, el LED TX_L y el LED BLK se encienden durante 2000 milisegundos y se apagan, lo que indica que el programa se ha iniciado.

 PUERTO = NEGRO;

 PUERTO = TX_L;

 _delay_ms (2000);

 PUERTO &= ~BLK;

 PUERTO &= (~TX_L);

3) La pantalla LCD se inicializa e imprime un mensaje de bienvenida que se muestra para verificar que la pantalla LCD esté funcionando correctamente.

 LCD_init( );

 LCD_CS ();

 LCD_POS (1,1);

 LCD_WS ("PROBADOR DE DATOS EN SERIE");

 LCD_POS (2,1);

 LCD_WS ( "=====================");

 LCD_POS (3,1);

 LCD_WS ("para USART y MAX485");

 LCD_POS (4,1);

 LCD_WS ("comunicaciones");

4) Ahora lee los valores actuales de EEPROM para actualizar el modo de menú y luego establece el valor del búfer recibido en USART.

 _delay_ms (3000);

 rdE ( );

 _delay_ms (100);

 USART_SM ( );

 saber ;

 _delay_ms (2000);

5) En un bucle while, el LED parpadeante permanece encendido para indicar que está listo para funcionar. Aquí se actualizan los datos USART y el modo de visualización también se actualiza en la pantalla LCD. Ahora el usuario puede ver los datos del búfer y los datos de comunicación en serie guardados en EEPROM.

 si (USCH)

 USART_UPD ( );


 si (VCCH)

 {

 VUSCR ( );

 _delay_ms (200);

 }

6) Cuando se presiona la tecla 1 en el modo de vista previa, envía datos a USART. El usuario puede ver los datos en la pantalla LCD así como en el receptor UART como terminal serie de una PC conectada.

 si ((PINB y BTN_SW1) == 0)

 USART_SD ( );

7) Cuando se presiona el interruptor 6, muestra el modo de menú para que el usuario pueda cambiar la velocidad en baudios, los bits de datos, la paridad y la configuración del bit de parada. Si se presiona nuevamente el interruptor 6, el dispositivo cambia del modo de menú al modo de vista previa, donde se muestran los datos del búfer.

 si ((PINB y BTN_SW6) == 0)

 estáMenuPresionado = 1;


 si (isMenuPressed)

 {
 
USART_MN ( );

 LCD_WCM (0x0C);

 }

 demás

 VWL ( );

Consulte el código completo y comience rápidamente a construir este apasionante proyecto.

 //Programa para

 /*

 nombre de archivo: SerialDataTester.C

 autor: fhn

 Día: 22-mar-2018

 MCU : ATmega8 (A) a 11,0592 MHz

 mostrar; LCD 4 filas

 otros: controlados por menú

 botones: 6

 */


 #definir F_CPU 11059200L

 #definir F_CPU_BY_100 F_CPU/100


 #incluir

 #incluir

 #incluir

 #incluir


 #definir UMS 500



 #definir LCD_P PORTC


 #definir LCD_EN  0b00010000 

#definir LCD_RS  0b00100000


 #definir BTN_SW6 0b00100000

 #definir BTN_SW1 0b00000001

 #definir BTN_SWS 0b00011110


 #definir BTN_SW5 0b00010000

 #definir BTN_SW4 0b00001000

 #definir BTN_SW3 0b00000100

 #definir BTN_SW2 0b00000010


 #definir TX_L 0b00000100

 #definir TX_C 0b00001000
 
#definir NEGRO 0b10000000



 //================================================== ==============================


 carácter sin firmar URD(UMS+1);

 carácter USD = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";


 carácter HEX(16) = {'0','1','2','3','4','5','6','7','8','9', 'A' ,'B','C','D','E','F'};

 intUBRL(12)={3, 6, 12, 24, 48, 96, 144, 192, 288, 384, 576, 768}; //X 100


 uint8_t U_B=5;

 uint8_t U_D=8;

 uint8_t U_P=1;

 uint8_t U_S=1;

 carácter sin firmar USART_RXD=0;

 intURDP = 0;

 intUSDP = 0;

 uint8_t USCH = 1;

 uint8_t VCCH = 1;


 //================================================== ==============================

 void getString (long val, char *str, char fc, int ancho)

 {

 largo v=val,i=0;

 intnst=0, p=0;

 largo hvl=1;

 para (int w=0; w =1; yo=yo/10 )

 {

 si ((v/i)>=1 && nst==0)

 nst = 1;

 si (nst==1)

 {

 cadena(p++) = (v/i) + '0';

 }

 demás

 {

 cadena(p++) = fc;

 }

 v = v%i;

 }

 cadena(p)=0;

 si (cadena(p-1)==' ')

 { cadena(p-1)='0'; }

 }

 //================================================== ==============================

 rdE nulo ( )

 {

 intervalo int = 0;

 rval = eeprom_read_byte ((void *)1);
 
si ( rval<1 rval>2 )

 devolver;

 U_S = rval;

 rval = eeprom_read_byte ((void *)2);

 si ( rval<0 rval>2 )

 devolver;

 U_P = valor;

 rval = eeprom_read_byte ((void *)3);

 si (rval<5 rval>8)

 devolver;

 U_D = rval;

 rval = eeprom_read_byte ((void *)4);

 si ( rval<0 rval>13 )

 devolver;

 U_B = rval;

 }

 //================================================== ==============================

 vacío wrE ()

 {

 eeprom_write_byte ((void *)1, U_S);

 _delay_ms(10);

 eeprom_write_byte ((void *)2, U_P);

 _delay_ms(10);

 eeprom_write_byte ((void *)3, U_D);

 _delay_ms(10);

 eeprom_write_byte ( (void *)4, U_B);;

 _delay_ms(10);


 }

 //================================================== ==============================

 vacío P_init ()

 {

 DDRB = 0x00;

 DDRC = 0xFF;

 DDRD = 0xFE;

 PUERTO &= (~TX_C);

 PUERTO &= (~TX_L);

 LCD_P &= (~LCD_RS);

 LCD_P &= (~LCD_ES);

 }

 //================================================== ==============================

 anular LCD_E ( )

 {

 LCD_P = LCD_ES;

 _delay_us(10);

 LCD_P &= (~LCD_ES);

 _delay_us(15);

 }
 
//================================================== ==============================

 void LCD_WN (carácter sin firmar nibl, carbón sin firmar RS)

 {


 LCD_P &= 0xF0;

 _delay_us(5);


 si ( nibl > 0b00001111)

 LCD_P = ((nibl>>4) & 0x0F);

 demás

 LCD_P = (nibl y 0x0F);


 si (RS)

 LCD_P = LCD_RS;

 demás

 LCD_P &= (~LCD_RS);


 LCD_E ();

 }

 //================================================== ==============================

 anular LCD_WCM (cmd de carácter sin firmar)

 {

 LCD_WN (cmd y 0xF0, 0);

 LCD_WN (cmd y 0x0F, 0);

 _delay_us(2);

 }

 //================================================== ==============================

 anular LCD_init()

 {

 inicial de carácter sin firmar = 0x20;


 _delay_ms (50);

 LCD_WN (0x30, 0);

 _delay_ms (20);

 LCD_WN (0x30, 0);

 _delay_us (200);

 LCD_WN (0x30, 0);

 _delay_ms (100);

 LCD_WN (0x20, 0);

 _delay_ms (25);

 valor inicial = 0b00001000;

 valor inicial = 0b00000100;

 LCD_WCM (valor inicial);

 _delay_ms (25);

 LCD_WCM (0x0C);

 _delay_ms (25);

 LCD_WCM (0x06);

 _delay_ms (250);

 }
 
//================================================== ==============================

 anular LCD_WC (carácter c sin firmar)

 {

 LCD_WN ( c & 0xF0 , 1);

 LCD_WN (c & 0x0F, 1);

 _delay_us(1);

 }

 //================================================== =

 anular LCD_WS ( caracteres )

 {

 para (int i=0; s(i)!=0; i++)

 {

 LCD_WC (s(i));

 _delay_us (5);

 }

 }

 //================================================== ==============================

 anular LCD_CS ()

 {

 LCD_WCM (0x01);

 _delay_ms(3);

 }

 //================================================== =

 void LCD_POS (carácter R sin firmar, carácter C sin firmar)

 {

 interruptor (R)

 {

 caso 3: LCD_WCM (0x94 + C-1); romper;

 caso 4: LCD_WCM (0xD4 + C-1); romper;

 caso 2: LCD_WCM (0xC0 + C-1); romper;

 caso 1:

 por defecto: LCD_WCM (0x80 + C-1); romper;

 }

 _delay_ms (3);

 }

 //================================================== ==============================

 int USART_init (int bd, int db, int prt, int stb)

 {


 int ubrr = 0;

 int bd_rate=bd;
 
sin firmar int ucsrc = (1< =0)

 {

 UBRRL = ubrr;

 UBRRH = (ubrr>>8);

 }

 demás

 devolver (-1);

 UCSRB = (1< romper;

 caso 6: ucsrc = (1< romper;

 caso 7: ucsrc = (2< romper;

 caso 8: ucsrc = (3< romper;

 por defecto: devolver (-1);

 }

 si (stb==2)

 ucsrc = (1< 

 getString(UBRL(U_B), cadena,'', 3); 

LCD_WS (cadena); LCD_WS ("00");

 LCD_POS (2,1); 

LCD_WS("Bits de datos: "); 

LCD_POS (2.12);

 LCD_WC (U_D+'0');

 LCD_POS (3,1);

 LCD_WS ("Paridad:");

 LCD_POS (3.12);

 cambiar(U_P)

 {

 caso 1: LCD_WS ("ODD"); romper;

 caso 2: LCD_WS ("PARO"); romper;

 predeterminado:LCD_WS ("NINGUNO"); romper;


 }

 LCD_POS (4,1);

 LCD_WS ("Bits de parada: ");

 LCD_POS (4.12);

 LCD_WC (U_S+'0');

 LCD_POS (1.12);


 }

 //================================================== ==============================

 ISR (USART_RXC_vect)

 {

 USART_RXD = UDR;


 si (URDP <UMS)

 {

 URD(URDP++) = USART_RXD;

 }


 }

 //================================================== ==============================
 
anular VUSCR ( )

 {

 cadena de caracteres (10);

 LCD_CS ();

 si (URDP<=0)

 {

 LCD_POS (2,1);

 LCD_WS ("SIN DATOS o");

 LCD_POS (3,1);

 LCD_WS ("BUFFER VACÍO");

 devolver;

 }

 para ( int i=0; i<4 && URDP>(USDP+i); i++ )

 {

 LCD_POS (i+1, 1);

 LCD_WC ('@');

 getString(USDP+i, cadena,'0',3); 

LCD_WS (cadena);


 LCD_WS("=");


 si (URD(USDP+i)<32

 URD(USDP+i)>126 )

 LCD_WC ('.');

 demás 

LCD_WC (URD(USDP+i));

 LCD_WC (' ');

 LCD_WC ( HEX(URD(USDP+i)/16) ); 

LCD_WC ( HEX(URD(USDP+i)%16) ); 

LCD_WS ("h");

 getString(URD(USDP+i), str,'0',3); 

LCD_WS (cadena);

 LCD_WS ("d");

 int n = URD(USDP+i);

 LCD_WC (n/64 + '0'); 

n = n%64;

 LCD_WC (n/8 + '0'); 

LCD_WC (n%8 + '0'); 

}

 LCD_POS(4,1);

 LCD_WC ('(');

 getString(URDP, cadena,'0', 3); 

LCD_WS (cadena);

 LCD_WC(')');

 }

 //================================================== ==============================

 anular USART_UPD ()

 {

 USART_init (UBRL(U_B),

 U_D,

 ARRIBA,

 A NOSOTROS );

 URDP=0;

 USDP = 0;

 VCCH = 1;

 wre ( );
 
rdE ( );

 }

 //================================================== ==============================

 anular USART_SD ()

 {

 LCD_CS ();

 PUERTO = NEGRO;

 LCD_POS (1,1);

 LCD_WS ("ENVIANDO.... ");

 PUERTO = TX_C;

 PUERTO = TX_L;

 _delay_ms(10);

 LCD_POS (2,1);

 para (int i=0; USD(i)!=0 ;i++)

 {

 si (yo==18)

 LCD_POS (3,1);

 LCD_WC (USD(i));

 USART_SC (USD(i));

 _delay_ms(1);

 }

 _delay_ms(50);

 PUERTO &= (~TX_C);

 LCD_POS (4,1);

 LCD_WS ("ENVIADO (Verificar LSB)");

 _delay_ms(50);

 PUERTO &= (~TX_L);

 _delay_ms(1500);

 VCCH = 1;

 }

 //================================================== ==============================

 anular USART_MN ()

 {

 uint8_t peso = 100;

 uint8_t btn_sws = 0;

 uint8_t editarpos = 0;

 cadena de caracteres (10);

 uint8_t sU_B = U_B;

 uint8_t su_D = U_D;

 uint8_t su_P = U_P;

 uint8_t su_S = Estados Unidos;


 USART_SM ( );

 _delay_ms (300);


 LCD_WCM (0x0F);


 mientras (wtl > 0)

 {

 PUERTO ^= NEGRO;

 LCD_POS (editar pos+1,12);

 btn_sws = PINB y BTN_SWS;

 si (btn_sws! = BTN_SWS)

 {

 peso = 100;

 _delay_ms (300);


 si ((btn_sws y BTN_SW4) ==0)

 {

 editarpos++;
 
si (editarpos>3)

 posedit = 0;

 _delay_ms (300);

 }

 de lo contrario si ((btn_sws y BTN_SW5) ==0)

 {

 cambiar (ediciones)

 {

 caso 0:

 su_B++;

 si (sU_B>11)

 su_B=0;

 LCD_POS (1.12); 

getString(UBRL(sU_B), cadena, ' ', 3); 

LCD_WS (cadena); LCD_WS ("00");

 romper;

 caso 1:

 su_D ++;

 si (sU_D>8)

 su_D=5;

 LCD_POS (2.12);

 LCD_WC ( su_D +'0' );

 romper;

 caso 2:

 su_P++;

 si (sU_P>2)

 su_P=0;

 LCD_POS (3.12);

 cambiar(sU_P)

 {

 caso 1: LCD_WS ("ODD"); romper;

 caso 2: LCD_WS ("PARO"); romper;

 predeterminado:LCD_WS ("NINGUNO"); romper;

 }

 romper;

 caso 3:

 su_S++;

 si (sU_S>2)

 sU_S=1;

 LCD_POS (4.12);

 LCD_WC (sU_S +'0');

 romper;

 por defecto:

 romper;


 }

 }

 de lo contrario si ((btn_sws y BTN_SW3) ==0)

 {

 U_B = su_B;

 U_D = su_D;

 ARRIBA = su_P;

 A NOSOTROS = su_S;

 USCH = 1;

 USART_SM ( );

 LCD_POS (4.15);

 LCD_WS ("GUARDADO");

 _delay_ms (2000);

 devolver;

 }

 de lo contrario si ((btn_sws y BTN_SW2) ==0)

 {

 U_B = 5;

 U_D = 8;

 ARRIBA = 1;

 A NOSOTROS = 1;

 USCH = 1;

 USART_SM ( );

 LCD_POS (4.15);
 
LCD_WS ("RESETABLECER");

 _delay_ms (2000);

 devolver;

 }

 }

 demás

 {

 wtl--;

 }

 si ((PINB y BTN_SW6) == 0)

 {

 peso = 0;

 _delay_ms (300);

 }

 _delay_ms (100);

 }


 VCCH = 1;

 }

 //================================================== ==============================

 anular VWL ( )

 {

 int btn_sws = 0;

 PUERTO ^= NEGRO;


 btn_sws = PINB y BTN_SWS;

 si ((btn_sws y BTN_SW2) == 0)

 {

 URDP=0;

 USDP = 0;

 VCCH = 1;

 _delay_ms (100);

 }

 de lo contrario si ((btn_sws y BTN_SW4) == 0)

 {

 USDP += 3;

 si (USDP>=URDP)

 USDP = URDP-1;

 VCCH = 1;

 _delay_ms (100);

 }

 de lo contrario si ((btn_sws y BTN_SW5) == 0)

 {

 USDP -= 3;

 si (USDP<0)

 USDP = 0;

 VCCH = 1;

 _delay_ms (100);

 }

 de lo contrario si ((btn_sws y BTN_SW3) == 0)

 {

 USDP = 0;

 VCCH = 1;

 _delay_ms (100);

 }

 }

 //================================================== ==============================

 int principal()

 {

 int isMenuPressed = 0;

 int usuario_recd_data_pos = -1;



 P_inicio ( );

 PUERTO = NEGRO;

 PUERTO = TX_L;

 _delay_ms (2000);

 PUERTO &= ~BLK;

 PUERTO &= (~TX_L);

 LCD_init( );

 LCD_CS ();

 LCD_POS (1,1);

 LCD_WS ("PROBADOR DE DATOS EN SERIE");

 LCD_POS (2,1);
 
LCD_WS ( "=====================");

 LCD_POS (3,1);

 LCD_WS ("para USART y MAX485");

 LCD_POS (4,1);

 LCD_WS ("comunicaciones");


 _delay_ms (3000);

 rdE ( );

 _delay_ms (100);

 USART_SM ( );


 USCH = 1;

 VCCH = 1;


 saber ;


 _delay_ms (2000); 


mientras(1)

 {

 PUERTO ^= NEGRO;

 si (usart_recd_data_pos! = URDP)

 VCCH = 1;


 usert_recd_data_pos = URDP;


 si (USCH)

 USART_UPD ( );


 si (VCCH)

 {

 VUSCR ( );

 _delay_ms (200);

 }

 estáMenuPresionado = 0;

 USCH = 0;

 VCCH = 0;

 _delay_ms (50); 


si ((PINB y BTN_SW1) == 0)

 USART_SD ( ); 


si ((PINB y BTN_SW6) == 0)

 estáMenuPresionado = 1;


 si (isMenuPressed)

 {

 USART_MN ( );

 LCD_WCM (0x0C);

 }

 demás

 VWL ( );

 }

 devolver 0;

 }

 //================================================== ==============================




 ### 

AVR-ATmega8-Universal-UART-Data-Tester-1