Enviando datos en la pantalla

1

Tengo una matriz de puntos de 132x65 LCD. Estoy utilizando el controlador STM32f303 en mi aplicación. Tuve éxito en mostrar las fuentes normales de 5x7 en LCD.  Ahora, lo que quiero hacer es mostrar las fuentes de tamaño personalizado 13x16 en la pantalla LCD. Generé el código hexadecimal apropiado para todos los 95 caracteres para el tamaño de 13x16. En 5x7 pude enviar todos los bytes usando la siguiente rutina.

void Display(uint8_t Display_Row, uint8_t Display_Column, unsigned char) 
{
  uint16_t String_Pointer_Offset;

  String_Pointer_Offset = 0;

  while( '
void Display(uint8_t Display_Row, uint8_t Display_Column, unsigned char) 
{
  uint16_t String_Pointer_Offset;

  String_Pointer_Offset = 0;

  while( '%pre%' != *(String_Pointer + String_Pointer_Offset) )
  {
#if (defined(DISPLAY_WRAP_TEXT_STRINGS) && (DISPLAY_WRAP_TEXT_STRINGS == YEP ))
    if(Display_Column > SHADOW_LAST_COLUMN) /* Check if it's the appropriate to wrap the row printing the exceeding character on the next line. */
    {
      Display_Column = 0;
      Display_Row ++;
    };
    if (Display_Row > SHADOW_LAST_LINE)
    {
      return; /* Ran out of space :( */
    };
#else /* if (not defined(DISPLAY_WRAP_TEXT_STRINGS) || (DISPLAY_WRAP_TEXT_STRINGS == NOPE )) */
    if( (Display_Column > SHADOW_LAST_COLUMN)
     || (Display_Row    > SHADOW_LAST_LINE  ) )
    {
      return; /* Ran out of space :( */
    };
#endif
    Display.Row[Display_Row].Column [Display_Column] = *(String_Pointer + String_Pointer_Offset);
    Display.Row[Display_Row].Touched[Display_Column] = TRUE;

    Display_Column ++;
    String_Pointer_Offset++;
  };

  return;
}
' != *(String_Pointer + String_Pointer_Offset) ) { #if (defined(DISPLAY_WRAP_TEXT_STRINGS) && (DISPLAY_WRAP_TEXT_STRINGS == YEP )) if(Display_Column > SHADOW_LAST_COLUMN) /* Check if it's the appropriate to wrap the row printing the exceeding character on the next line. */ { Display_Column = 0; Display_Row ++; }; if (Display_Row > SHADOW_LAST_LINE) { return; /* Ran out of space :( */ }; #else /* if (not defined(DISPLAY_WRAP_TEXT_STRINGS) || (DISPLAY_WRAP_TEXT_STRINGS == NOPE )) */ if( (Display_Column > SHADOW_LAST_COLUMN) || (Display_Row > SHADOW_LAST_LINE ) ) { return; /* Ran out of space :( */ }; #endif Display.Row[Display_Row].Column [Display_Column] = *(String_Pointer + String_Pointer_Offset); Display.Row[Display_Row].Touched[Display_Column] = TRUE; Display_Column ++; String_Pointer_Offset++; }; return; }

Y al usar la función Display_Print(1,1,"ABC %code%"); en el archivo principal, pude mostrar la cadena en mi LCD.

Pero aquí hay un número de bytes 26 en lugar de 8, por lo que no se pueden enviar simultáneamente en una pantalla LCD de interfaz paralela. ¿Puede alguien ayudarme a lograr esta gran tarea de visualización de fuentes de 13x16 píxeles?

    
pregunta spp

2 respuestas

3

Acabo de simular el carácter que agregaste a tu pregunta y me parece bien. Para referencia, escribí este código:

    unsigned char cha[] = {0x00, 0x0C, 0x00, 0x03, 0xC0, 0x01, 0x30, 0x01, 0x0C, 0x01, 0x30, 0x01, 0xC0, 0x01, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
void main(void) {
    int i;
    int j;
    for (i=0; i<sizeof(cha); i++) {
        for (j=0; j<8; j++) {
            printf("%c",(cha[i]&(1<<j)) ? '#' : '.');
        }
        i++;
        for (j=0; j<8; j++) {
            printf("%c",(cha[i]&(1<<j)) ? '#' : '.');
        }
        printf("\n");
    }
}

y se imprime:

..........##....
........##......
......###.......
....##..#.......
..##....#.......
....##..#.......
......###.......
........##......
..........##....
................
................
................
................

Parece que los datos de la fuente para el carácter "A" parecen estar bien y para escribir esto en la fila 0 de la pantalla LCD, escribiría bytes 0,2,4,6,8, ... (0x00, 0x00 , 0xc0, 0x30 ...) a la fila 0 y bytes 1,3,5,7,9 ... (0x0C, 0x03, 0x01, 0x01, ...) a la fila 1.

Solo he trabajado con pantallas LCD en un nivel de hardware directo. En caso de que sea útil para usted o alguien más que esté familiarizado con esta plataforma, puedo explicarle cómo escribir el byte B en la fila R, en la columna C utilizando la pantalla LCD que parece estar usando (NT75451):

Primero asigne el comando SET PAGE (R), que en el lenguaje c es (0xB0 | R). Luego, CONFIGURAR DIRECCIÓN DE ALTA COLUMNA, comando (0x10 | (C > > 4)) y CONFIGURAR DIRECCIÓN DE COLUMNA BAJA (0x00 | (C & 0xf)). Finalmente enviar el byte de datos (B).

Los comandos se envían con el pin A0 de la pantalla LCD bajado y los datos enviados con A0 alto, pero sospecho que ya lo sabes.

Espero que esto sea útil para usted o para otra persona.

[EDITAR]: en función de la función de sorteo agregada a la pregunta, puedes intentar algo como esto para dibujar el gran personaje:

void LCD_Draw_Char(uint8_t Line, uint8_t Column, unsigned char Char) // Bypass shadow display characters matrix to directly draw one character.
{
  Task_S_T Task;
  uint8_t Index;

  LCD_Write_Command_SetPage(Line);          // Set the virtual line index.
  LCD_Write_Command_SetColumn(Column);      // Set the column index.
  Task.Command = TASK_WRITING;
  Task.Iter    = 0;
  for( Index = 0; Index < 13; Index++ )
  {
    if( (Column + Index > DISPLAY_LAST_COLUMN)
     || (Line           > DISPLAY_LAST_LINE  ) )
    {
      return; /* Ran out of space :( */
    };
    Task.Data = Combination_Of(ACTION_WRITE_DATA_TO_RAM, Font_13x16[Char - BIG_FONT_FIRST_CHAR_CODE][Index*2]);
    LCD_FIFO_Push(Task);
  };
  Task.Data = Combination_Of(ACTION_WRITE_DATA_TO_RAM, 0x00); /* The separator column of each char is set here to prevent dirty pixels being left unerased. */
  LCD_FIFO_Push(Task);                                        /* The separator column of each char is set here to prevent dirty pixels being left unerased. */


  LCD_Write_Command_SetPage(Line+1);          // Set the virtual line index.
  LCD_Write_Command_SetColumn(Column);      // Set the column index.
  Task.Command = TASK_WRITING;
  Task.Iter    = 0;
  for( Index = 0; Index < 13; Index++ )
  {
    if( (Column + Index > DISPLAY_LAST_COLUMN)
     || (Line           > DISPLAY_LAST_LINE  ) )
    {
      return; /* Ran out of space :( */
    };
    Task.Data = Combination_Of(ACTION_WRITE_DATA_TO_RAM, Font_13x16[Char - BIG_FONT_FIRST_CHAR_CODE][Index*2+1]);
    LCD_FIFO_Push(Task);
  };
  Task.Data = Combination_Of(ACTION_WRITE_DATA_TO_RAM, 0x00); /* The separator column of each char is set here to prevent dirty pixels being left unerased. */
  LCD_FIFO_Push(Task);                                        /* The separator column of each char is set here to prevent dirty pixels being left unerased. */


  return;
}
    
respondido por el PkP
2

No dice en qué pantalla está trabajando y no muestra ningún tipo de fuente en su pregunta, por lo que no puedo decirlo con seguridad, pero generalmente estos tipos de LCD, si están en blanco y negro. Blanco, se escriben en un byte a la vez. El byte establecerá los valores de una columna vertical de 1x8 píxeles. Para una fuente de 13 anchos y 16 píxeles de alto, primero debe escribir el segmento superior de 13x8 píxeles (13 bytes de datos de píxeles), luego cambiar a la segunda fila y escribir el segmento inferior de 13x8 píxeles (otros 13 bytes de datos de píxeles).

Si la pantalla LCD es TFT, por ejemplo. una pantalla "a todo color", entonces primero deberá establecer un rectángulo de tamaño 13x16 para escribir y luego rellenar con píxeles.

    
respondido por el PkP

Lea otras preguntas en las etiquetas