LCD eigene Zeichen

[Lokus P. (derschatten)]

Das Thema wurde hier ja zwar schon mehrmals angesprochen, hab aber 
trotzdem leider nichts passendes gefunden.
Habe jetzt 2 Stunden so ziemlich jeden beitrag durchgeackert und auch 
Google befragt, konnta aber keine hilfreiche Anleitung finden wie man 
die 8 frei definierten Zeichen für ein LCD programmiert.

Soviel ich herausfinden konnte geht das ganze mittels einer Tabelle, in 
der man seine Pixel definiert.

Mit einer Funktion definiert man dann in welche Adresse des Displays 
welches Zeichen geschrieben wird

void write_lcd_cg(byte lcd_addr, byte *lcd_zeichen)
{
  byte lcd_i;
  for(lcd_i = 0; lcd_i < 8; lcd_i++)
  {
    lcd_puts(0x40 + lcd_addr * 8 + lcd_i,1); // CG RAM Adresse Set (01aa azzz)
    lcd_puts(*lcd_zeichen,0);  // Data Write 8x Pixelzeile
    lcd_zeichen++;
  }
}

Und das gibt man dann irgendwie aus.

Nur komm ichd amit überhaupt nicht klar.
Ich verwende die LCD-Library von Peter Fleury.

[Plan (Gast)]

Ich habe eine EADOG und mir eine eigene LIB geschrieben. Da schreibe ich 
sowas raus:

  // neues Zeichen:
  LCD_WR(0, 0x78);  // RAM Umschalten
  LCD_WR(1, 0x14);  // Zeichen Addr 7: "KHz"
  LCD_WR(1, 0x18);
  LCD_WR(1, 0x14);
  LCD_WR(1, 0x00);
  LCD_WR(1, 0x13);
  LCD_WR(1, 0x19);
  LCD_WR(1, 0x16);
  LCD_WR(1, 0x17);
  LCD_WR(0, 0x80);  // Zeichenanzeige wieder aktivieren

Mit
LCD_Char(7);  // LCD Zeichen "KHz"
rufe ich das Zeichen auf.

PS: Die Definition:
void LCD_WR(unsigned char RS, unsigned char Dat);
void LCD_Char(char Dat);

[komische idee (Gast)]

im datenblatt gibt es startadressen  für die eigenen zeichen

 ab dieser startadresse werden 8 byte reingeschrieben
diese stellen die pixel dar

also

1. byte: xxx00000
2. byte: xxx00000
3. byte: xxx00000
4. byte: xxx00000
5. byte: xxx00000
6. byte: xxx00000
7. byte: xxx00000
8. byte: xxx00000

da es nur 5x8 pixel sind werden nur die untersten bits genutzt

aufrufen kann man das zeichen ganz einfach in dem man die normale 
lcd_puts( ) mit  0x00 bis 0x07  aufruft


grob nochmal ..

also ein array mit 8 byte die pixelweise das zeichen darstellen
const   char symbol[]  PROGMEM= {130,130,130,130,130,130,130,130};

das läd man ab adresse 0x40 in den RAM des LCDs
also ab
adresse 0x40  ( lcd_puts ( 0x00)  )
adresse 0x48  ( lcd_puts ( 0x01)  )
adresse 0x4F  ( lcd_puts ( 0x02)  )

[Lokus P. (derschatten)]

Also das mit der Tabelle hab ich ja hinbekommen.
Das schreiben in den LCD-RAM ist mir noch nicht ganz klar.

Wie genau funktioniert das?

[Chris M. (shortie)]

ich hab das so gelöst:

static const PROGMEM unsigned char cHddChar[] =  //  Acht selbstdefinierte Symbole fuer das LCD
{
  0x00, 0x0A, 0x1B, 0x1B, 0x18, 0x1F, 0x0E, 0x00,  // Uhrensymbol 3 Uhr
  0x00, 0x0A, 0x1B, 0x1B, 0x03, 0x1F, 0x0E, 0x00,  // Uhrensymbol 9 Uhr
  0x1F, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1F,  // Ein/Aus Symbol
  0x00, 0x0A, 0x1F, 0x1F, 0x1F, 0x0E, 0x04, 0x00,  // Herz
  0x15, 0x0E, 0x15, 0x0E, 0x04, 0x04, 0x04, 0x00,  // Sendeturm
  0x04, 0x0E, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x00,  // Haus
  0x04, 0x0E, 0x1F, 0x04, 0x04, 0x04, 0x04, 0x00,  // Pfeil nach oben
  0x04, 0x04, 0x04, 0x04, 0x1F, 0x0E, 0x04, 0x00    // Pfeil nach unten
//  0x0E, 0x1F, 0x0E, 0x11, 0x0E, 0x11, 0x0E, 0x00,    // Festplattensymbol
};

und in lcd_init nach dem Wechsel in den 4Bit-Modus kommt dann eine 
Schleife die die Zeichen ins Display überträgt:

    lcd_write (0x22,0);      //Init in 4 Bit Mode
    for(int i=0; i<64; i++)  // Die benutzerdefinierten Zeichen 
    {                        // in das Display schreiben
      lcd_write(i+64,0);     // 64 = 0x40 = CG-RAM Adresse 0
      lcd_write(pgm_read_byte_near(&cHddChar[i]),1);
    }
    lcd_write (0x80,0);      //Set DD-Ram Adresse = 0

[Lokus P. (derschatten)]

Hi, das hatte ich schon versucht.

Kannst du mir sagen an welche Stelle genau die beiden Codeschnippsel hin 
müssen?
Ich nehme mal an beide ins die lcd.c

Und wie gibt man diese Zeichen dann aus?

[Chris M. (shortie)]

ich hab das ganze in lcd.c drin - das ist richtig. Die Tabelle oben nach 
den #include Zeilen und der Rest in der Funktion lcd_init. Allerdings 
nutze ich die LCD-Routine von Ulrich Radig.

[Lokus P. (derschatten)]

Ich habs jetzt mal so versucht:

static const unsigned char symbol[] PROGMEM =    // Acht selbstdefinierte Symbole fuer das LCD
{
  0x90, 0x98, 0x9C, 0x9E, 0x9C, 0x98, 0x90, 0x80,  //
  0x00, 0x0A, 0x1B, 0x1B, 0x03, 0x1F, 0x0E, 0x00,  //
  0x1F, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1F,  //
  0x00, 0x0A, 0x1F, 0x1F, 0x1F, 0x0E, 0x04, 0x00,  //
  0x15, 0x0E, 0x15, 0x0E, 0x04, 0x04, 0x04, 0x00,  //
  0x04, 0x0E, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x00,  //
  0x04, 0x0E, 0x1F, 0x04, 0x04, 0x04, 0x04, 0x00,  //
  0x04, 0x04, 0x04, 0x04, 0x1F, 0x0E, 0x04, 0x00  //
};

Und bei der Display Initialisierung dann:

    lcd_write(0x22,0);                  // Init in 4 Bit Mode
  for(int i=0; i<64; i++)
  {
    lcd_write(i+64,0);                // CG RAM Adresse Set (01aa azzz)
    lcd_write(pgm_read_byte_near(&symbol[i]),1);  // Data Write 8x Pixelzeile
  }
    lcd_write(0x80,0);                  // Set DD-Ram Adresse = 0

Wenn ich jetzt allerdings mit

  lcd_gotoxy(0,0);
  lcd_putc(0x00);
  lcd_gotoxy(1,0);
  lcd_putc(0x01);
  lcd_gotoxy(2,0);
  lcd_putc(0x02);
  lcd_gotoxy(3,0);
  lcd_putc(0x03);
  lcd_gotoxy(4,0);
  lcd_putc(0x04);
  lcd_gotoxy(5,0);
  lcd_putc(0x05);
  lcd_gotoxy(6,0);
  lcd_putc(0x06);
  lcd_gotoxy(7,0);
  lcd_putc(0x07);

meine Zeichen anzeigen möchte bekomme ich nur verstümmelte Symbole.

[Jens K. (jjk)]

Manfred W. schrieb:
> Ich habs jetzt mal so versucht:
>
>

> static const unsigned char symbol[] PROGMEM =    // Acht
> selbstdefinierte Symbole fuer das LCD
> {
>   0x90, 0x98, 0x9C, 0x9E, 0x9C, 0x98, 0x90, 0x80,  //
>   0x00, 0x0A, 0x1B, 0x1B, 0x03, 0x1F, 0x0E, 0x00,  //
>   0x1F, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1F,  //
>   0x00, 0x0A, 0x1F, 0x1F, 0x1F, 0x0E, 0x04, 0x00,  //
>   0x15, 0x0E, 0x15, 0x0E, 0x04, 0x04, 0x04, 0x00,  //
>   0x04, 0x0E, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x00,  //
>   0x04, 0x0E, 0x1F, 0x04, 0x04, 0x04, 0x04, 0x00,  //
>   0x04, 0x04, 0x04, 0x04, 0x1F, 0x0E, 0x04, 0x00  //
> };
>

Also das höchste was pro Zeile an Hex Wert geht ist 0x1F (alles an) ... 
wie kommen Deine 0x90 oder 0x98 zustande? Die 8 HEX Werte geben ja die 8 
Zeilen eines Zeichens an, mit jeweils 5 bit ...

Als kleine Hilfe fand ich diese Seite immer praktisch: 
http://www.quinapalus.com/hd44780udg.html

Mal damit mal Deine Zeichen und nimm das Ergebnis für den symbol[] ...

Gruß
 Jens

[Kay V. (kay1971)]

Chris M. schrieb:
> nutze ich die LCD-Routine von Ulrich Radig.

Hallo Chris,

ich setzte dieselbe Routine ein und mir stellt sich jetzt noch die 
Frage, wie du die Zeichen aufrufst.
LCD_PRINT scheint je nur Ascii zu nehmen, wenn ich das richtig lese?

MfG
Kay

[Chris M. (shortie)]

lcd_print nimmt auch andere Zeichen.
Hier mal ein Beispiel wie alle 8 Zeichen ausgegeben werden können:

uint8_t udc;
for (udc=0;udc<8;udc++) {
  lcd_print(1,udc,"%c",udc);  // Die 8 benutzerdefinierten Zeichen
}                             // in Zeile 2 des Displays anzeigen