Por qué utilizar un puntero de interfaz LCD HD44780

Question

Estoy tratando de interactuar con una pantalla LCD (HD44780). Me encontré con un tutorial en Internet para enviar caracteres y cadenas a la pantalla. Todo fue bien y funciona bien, pero no tengo ni idea de por qué se utiliza un puntero. No estoy muy familiarizado con los punteros en C. Sé que pueden contener direcciones de variables, etc.

¿Puede alguien explicarme por qué se utiliza para enviar datos a la pantalla LCD y qué hace exactamente en el código siguiente?

#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++;
    }
}

Answer 1

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

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

Editar

La sentencia while comprueba primero si ha llegado al final de la cadena (el carácter actual es diferente de null), si es así, se imprime el carácter y se incrementa el puntero para apuntar al siguiente carácter. El ciclo se detiene cuando se alcanza el carácter nulo.

Answer 2

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

En lenguaje C, hay un tipo de datos "array", cuando necesitas mostrar algunas "palabras" o "cadenas de caracteres" en la pantalla, puedes presentar esto en lenguaje C como un "array de caracteres". Y puedes usar un "puntero" para apuntar al array y usarlo. El puntero es sólo 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,.... Al pasar este puntero a la

cadena_a_lcd

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