¿Por qué usar un puntero que se interconecta con LCD HD44780

1

Estoy intentando conectar con una pantalla LCD (HD44780). Encontré un tutorial en Internet para enviar caracteres y cadenas a la pantalla. Todo salió bien y funciona bien, pero no tengo idea de por qué se usa un puntero. No estoy muy familiarizado con el puntero en C. Sé que pueden contener direcciones de variables, etc.

¿Alguien puede explicarme por qué se utiliza para enviar datos a la pantalla LCD y qué hace exactamente en el código a continuación?

#define lcdE    0x04
#define lcdRW   0x02
#define lcdRS   0x01
#define lcdport PORTC       //port where LCD is connected
#define lcdDIR  DDRC

void lcd_init(void);                                //initialize
void cmd_to_lcd(unsigned char cmd);                 //send command to LCD display
void char_to_lcd(unsigned char character);          //send character to LCD display
void set_cursor_to_1st_line(void);                  //set cursor at the beginning of the first line
void set_cursor_to_2nd_line(void);                  //set cursos at the beginning of the second line
void clear_display(void);                           //clear display and return to home position
void string_to_lcd(unsigned char *ptr);             //send a string to LCD display

void cmd_to_lcd(unsigned char cmd)
{
    unsigned char temp = 0;
    temp = cmd;                         //store cmd in temp
    cmd &= 0xF0;                        // clear lower nibble
    lcdport &= ~(lcdRS|lcdRW);          //pull RS and RW low
    lcdport |= lcdE;                    //pull E high
    lcdport = cmd | lcdE;               //output cmd and hold E high
    _delay_us(10);
    lcdport &= ~(lcdE);                 //pull E low
    _delay_us(10);
    cmd = ((temp << 4) & 0xF0);         //shift command 4 left and clear lower nibble (send lower nibble of cmd)
    lcdport |= lcdE;                    //pull E high
    lcdport = cmd | lcdE;               //output cmd and hold E high
    _delay_us(10);
    lcdport &= ~(lcdE);                 //pull E low
    _delay_us(50);
}

void lcd_init(void)
{
    lcdDIR = 0xFF;                      //port C as output
    _delay_ms(30);                      //wait for lcd internal init
    cmd_to_lcd(0x28);                   //4-bits, 2 lines, 5x8 dots
    _delay_us(10);
    cmd_to_lcd(0x0C);                   //turn on display, cursor, cursor blink
    _delay_us(10);
    cmd_to_lcd(0x06);                   //increment AC on operation and move set cursor move to right
    _delay_us(10);
    cmd_to_lcd(0x01);                   //clear screen and move to home position
    _delay_ms(2);
}

void char_to_lcd(unsigned char character)
{
    unsigned char temp = 0;
    temp = character;
    character &= 0xF0;
    lcdport |= lcdRS;                   //RS = 1: data register
    lcdport &= ~(lcdRW);                //RW = 0: write operation
    lcdport |= lcdE;
    lcdport = character | (lcdRS | lcdE);
    _delay_us(10);
    lcdport &= ~(lcdE);
    character = ((temp << 4) & 0xF0);
    lcdport |= lcdE;
    lcdport = character | (lcdRS | lcdE);
    _delay_us(10);
    lcdport &= ~(lcdE);
    _delay_us(50);
}

void string_to_lcd(unsigned char *ptr)
{
    while(*ptr)
    {
        char_to_lcd(*ptr);
        ptr++;
    }
}
    
pregunta maikel

2 respuestas

6

El lenguaje C no tiene un formato de cadena nativo, por lo tanto, las cadenas se implementan como matrices de caracteres. La función string_to_lcd recibe un puntero a la ubicación de la memoria donde se encuentra el primer carácter de la cadena.

Por convenciones en C, las cadenas terminan con un carácter nulo (0x00).

Editar

La instrucción while primero verifica si llegó al final de la cadena (el carácter actual es diferente de nulo), si es así, el carácter se imprime y el puntero se incrementa para apuntar al siguiente carácter. El ciclo se detiene cuando se alcanza el carácter nulo.

    
respondido por el Bruno Ferreira
4

Este es un código fuente bien comentado, al menos ya da una breve función principal de las funciones.

En el lenguaje C, hay un tipo de datos "matriz", cuando necesita mostrar algunas "palabras" o "cadenas de caracteres" en la pantalla, puede presentar esto en el lenguaje C como una "matriz de caracteres". Y puede usar un "puntero" para apuntar la matriz y usarla. El puntero es solo la dirección del primer carácter de la matriz, y "puntero + 1" es el segundo carácter de la matriz, "puntero + 2" es el tercero, ... Pasando este puntero a

  

string_to_lcd

función, puede citar todos los caracteres de la matriz en esta función y enviarlos uno por uno a la pantalla LCD. Y mostrarlos en la pantalla.

    
respondido por el diverger

Lea otras preguntas en las etiquetas