Módulo de pantalla LCD con desplazamiento – (Parte 30/46)

Un microcontrolador es un dispositivo que tiene un procesador incorporado rodeado por algunos módulos de hardware dedicados. Una vez que el microcontrolador los inicializa, comienzan a funcionar por sí solos. En el caso de un ADC, realizará el muestreo y la conversión de digital a analógico por sí mismo y mantendrá los datos convertidos en su búfer para que el microcontrolador pueda leerlos más tarde. La ventaja de este tipo de implementación es que el microcontrolador es libre de realizar otras tareas durante este período y, por tanto, aumenta la eficiencia general. Este fue el caso de los módulos de hardware o periféricos dentro de un microcontrolador que aumentan la eficiencia de procesamiento del procesador integrado. La eficiencia puede aumentar aún más si el hardware externo conectado al microcontrolador también puede realizar muchas más tareas por sí solo sin depender del microcontrolador. El hardware puede contener o no otro procesador para que pueda realizar una determinada tarea predeterminada después de que el microcontrolador lo inicialice.

Un ejemplo de un dispositivo de este tipo es la pantalla de desplazamiento LCD en serie . Una vez recibidos del microcontrolador los datos a visualizar en el desplazamiento, éste iniciará por sí solo la operación y realizará el proceso de desplazamiento. Este proyecto explica la interfaz del MÓDULO LCD con cualquier tipo de controlador utilizando un único pin de recepción en serie. En este modo sólo se utiliza un pin para enviar datos. Este modo de visualización de desplazamiento tiene la ventaja sobre el modo de 8 bits de que solo utiliza un pin. Los pines restantes del controlador están disponibles para uso normal y la valiosa potencia de procesamiento necesaria para tirar los dados se puede utilizar para cualquier otro propósito.

El proyecto se analiza en dos partes.

Parte 1: Para crear un módulo LCD

En parte, se crea un módulo LCD utilizando el controlador AVR y la pantalla LCD alfanumérica de 16×2. El controlador ATMEGA16 controla la pantalla LCD. El código programado vertido permanentemente en este atmega16 controla el módulo LCD. Un único pin receptor (RXD -14) del ATMEGA16 es la única entrada de este módulo LCD. Los datos recibidos a través de comunicación serie se muestran en el módulo LCD en forma de desplazamiento.

Fig. 2: Configuración del circuito del módulo LCD construido con un controlador AVR y una pantalla LCD alfanumérica de 16×2

Parte 2: Interconectar el módulo LCD usando cualquier otro microcontrolador.

En la segunda parte, el controlador utilizado en nuestro proyecto es otro chip AVR. Los datos se envían al módulo LCD a través del pin de transmisión en serie (TXD-15). Un interruptor demostrado en nuestro proyecto proporciona la entrada al controlador.

Fig. 3: Interfaz del módulo LCD con el segundo microcontrolador AVR para

Cada vez que se presiona el botón se transmite un texto predefinido al módulo LCD. Cualquiera que sea el texto que se envíe, los datos se desplazarán en el módulo LCD.

Fig. 4: Comunicación de datos entre el módulo LCD y el AVR configurando el circuito de transmisión en serie en la placa de pruebas.

En esta demostración se puede ver que se pueden guardar 8 pines de datos y 3 pines de control del microcontrolador. Estos pines guardados se pueden utilizar para cualquier otro propósito.

Descripción del circuito:

Las conexiones de LCD con ATmega16 se muestran en el diagrama del circuito. En modo de 4 bits, las líneas de datos deben conectarse a los pines D4, D5, D6 y D7 del módulo LCD.

Código fuente del proyecto

 ###


 #definir F_CPU 8000000

#define _USART_H #ifndef F_CPU #define F_CPU 8000000 #endif #define USART_BAUDRATE 9600 #define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1) #include #incluir #incluir anular usert_init; void usert_putch (envío de caracteres sin firmar); sin firmar int user_getch; void usert_send_string(const char* datos); int uart_print(char c, ARCHIVO *flujo); uart_out ARCHIVO = FDEV_SETUP_STREAM(uart_print, NULL, _FDEV_SETUP_WRITE); int uart_print(char c, ARCHIVO *flujo) { if (c == 'n') uart_print('r', flujo); loop_until_bit_is_set(UCSRA, UDRE); UDR = c; devolver 0; } void usert_init {UCSRB = (1< > 8); // Carga los 8 bits superiores del valor de velocidad en baudios. // en el byte alto del registro UBRR stdout = &uart_out; } void usert_putch(envío de carácter sin firmar) { while ((UCSRA & (1 << UDRE)) == 0); // No hacer nada hasta que la UDR esté lista. // para que se escriban más datos en él UDR = enviar; // Envía el byte } unsigned int gerar_getch { while ((UCSRA & (1 << RXC)) == 0); // No hacer nada hasta que los datos se hayan recibido y estén listos para leerse en la UDR return(UDR); // devuelve el byte } void gerart_send_string(const char* data) { for(; *data; data ++) use_putch(*data); } #terminara si

###

Código fuente del proyecto

 ###

 
#ifndef _LCD_H #define _LCD_H #ifndef F_CPU #define F_CPU 8000000 #endif #include<avr/io.h> #include<util/delay.h> #include<inttypes.h> #include <stdio.h> #include < string.h> #define rs PA0 #define rw PA1 #define en PA2 void lcd_init; vacío dis_cmd(char); vacío dis_data(char); vacío lcdcmd(char); void lcddata(char); vacío lcd_clear(vacío); void lcd_2nd_line(nulo); void lcd_1st_line(nulo); void lcd_string(const char *datos); int lcd_print(char c, ARCHIVO *flujo); int lcd_scroll(const char *datos); ARCHIVO lcd_out = FDEV_SETUP_STREAM(lcd_print, NULL, _FDEV_SETUP_WRITE); char disp_beg = " "; int lcd_print(char c, ARCHIVO *flujo) { if('n' == c) lcd_2nd_line; de lo contrario dis_data(c); devolver 0; } #definir F_CPU 8000000 #incluir <avr/io.h> #incluir <util/delay.h> #incluir <stdio.h> #incluir <avr/interrupt.h> #incluir "lcd.h" #incluir "usart .h" carácter A (150); carácter B (150); int principal (nulo) { int i; usuariot_init; cli; lcd_init; printf("INGENIEROS"); printf("n GARAJE"); para (i = 0; 'n'! = (A (i) = use_getch); i ++); A(yo) = '