Ansteuern eines LCD über ATmega16

Hallo,
ich schreibe kurz nieder was ich wo angeschlossen habe:

VSS -> GND
VDD -> 5V
VO -> nicht angeschlossen
RS -> PD5
R/W -> PD6
E -> PD7
DB0-DB7 -> PA0-PA7
A -> nicht angeschlossen
K -> nicht angeschlossen

Ich lese mir mal die Tutorials durch und hoffe daraus schlauer zu 
werden.. danke schonmal :)

Das Problem ist das ich den Controller in C programmiere und mit den 
Codebeispielen nicht anfangen kann.. =/

VO -> nicht angeschlossen

Ohne Kontrastspannung ist die Programmiersprache auch egal.
Zeigt sowieso nix an;)

Oh, ich habe den zweiten Link total vergessen gehabt. Dort ist das 
Tutorial mit C-Code Beispielen.. sorry.. Ich arbeite mich mal durch.

Nur eine kleine Frage.. ist V0 = Vee?

So, also ich habe jetzt alles wie im Tutorial angeschlossen, die lcd 
routinen .h und .c erstellt und es wie folgt in mein Makefile 
eingetragen:

CC= avr-gcc

CFLAGS= -Wall -mmcu=atmega16 -Os
LDFLAGS=-mmcu=atmega16

all: $(f)

$(f): $(f).o lcd-routines.o

$(f).hex: $(f)
        avr-objcopy -j .text -j .data -O ihex $^ $@

brennen: $(f).hex
        avrdude -u -e -c avrispmkII -P usb -p m16 -U flash:w:$^

clean:
        $(RM) *.o $(f) *.hex

//////////////////////////////////7

Er kompiliert zwar ohne Probleme, jedoch wird nichts auf dem Bildschirm 
angezeigt. Habe das LCD Beispiel 1 gebrannt.

Ich glaube das ich es irgendwie im Makefile falsch eingetragen habe, das 
er als SRC die lcd-routine.c verwenden soll. Oder?

also habe ich es im Makefile richtig eingetragen?

Mein Display verwendet ja auch den HD44780. Du meinst also das ich die 
Initialisierung in der lcd-routine.h anpassen soll?

Tobias Neumann schrieb:
> Mein Display verwendet ja auch den HD44780. Du meinst also das ich die
> Initialisierung in der lcd-routine.h anpassen soll?

Datenblatt!!! Datenblatt!!! Datenblatt!!! Datenblatt!!!

Nochmal: Schau bitte ins Datenblatt und vergleiche selber, ob die 
initialisierung im Code dazu passt.

Sorry wenn ich mich dumm anstelle.. bin nunmal ein totaler Newbie in 
Sachen LCD. Ich habe ja das Datenblatt angehange.. kann mir einer sagen 
wo diese Initialisierungsdaten stehen?.. Ich nehme an auf Seite 6 aber 
ich werde daraus nicht so wirklich schlau :(

Leider fehlt der Anhang, bzw. das Datenblatt noch immer.

Aus leidvoller (Zeitverschwendung) Erfahrung weiß ich,
daß es sehr sinnvoll ist sich an die Init-Routine
des Datenblatt zu halten, und nicht blind der vom
Displayhersteller zu vertrauen. Glücklicherweise sind
die Namen der Steuerleitungen bei (fast) allen die gleichen.

Achte auf die Position der Steuerbits im Datenbyte!!
Hier fand ich schon Unterschiede, aus der Erklärung
der Steuerbits habe ich dann Unterschiede (fast 100% kompatibel)
gefunden.

Mach die Wartezeiten ruhig etwas größer, so 50% stören für
den Beginn keinen, ich nehme nach der Init immer den Busy-
Flag-Test, ist zuverlässiger, und schneller.

James schrieb:
> Leider fehlt der Anhang, bzw. das Datenblatt noch immer.

Möge er im ersten Post schauen.

Hallo Leute,
ich hab es leider immer noch nicht zum Laufen gebracht.. langsam 
verzweifele ich. Ich weiß nicht wo ich aus dem Datenblatt sehe welche 
Daten is wo in der lcd-routine.h reinschreiben muss. Ich denke mal das 
ihr meint das ich folgnde Initialisierungsgeschichten anpassen muss wie 
z.B:

// Clear Display -------------- 0b00000001
#define LCD_CLEAR_DISPLAY       0x02

// Cursor Home ---------------- 0b0000001x
#define LCD_CURSOR_HOME         0x02

// Set Entry Mode ------------- 0b000001xx
#define LCD_SET_ENTRY           0x04

#define LCD_ENTRY_DECREASE      0x00
#define LCD_ENTRY_INCREASE      0x02
#define LCD_ENTRY_NOSHIFT       0x00
#define LCD_ENTRY_SHIFT         0x01

Jedoch weiß ich nicht woher ich die richtigen Daten aus dem Datenblatt 
entnehmen soll..

Ja ich habe schon viele Sachen mit meinem Mikrocontroller gemacht. Es 
ist nicht so das ich gerade mit Mikrokontrollern angefangen habe.. und 
mit C arbeite ich auch schon seit 2 Jahren.

Ich habe jetzt wieder alle 8 Datenpins angeschlossen und versuche jetzt 
mit hilfe von Tutorial und Datenblatt mein eigenes kleines 
Beispielprogramm zu schreiben wo einfach nur einen Char auf dem 
Bildschirm ausgibt und es danach wieder cleared. Mal schauen ob ich das 
hin kriegen ;)

Also ich habe nun ein Beispielprogramm geschrieben was leider nicth 
funktioniert. Ich habe auch eine lcd-routine.h geschrieben. Ich habe 
dabei alles berücksichtigt was auch in der lcd-routine.h vom Tutorial 
steht, außer diesen Teil:

#define LCD_SOFT_RESET          0x30

//Set CG RAM Address --------- 0b01xxxxxx  (Character Generator RAM)
#define LCD_SET_CGADR           0x40

#define LCD_GC_CHAR0            0
#define LCD_GC_CHAR1            1
#define LCD_GC_CHAR2            2
#define LCD_GC_CHAR3            3
#define LCD_GC_CHAR4            4
#define LCD_GC_CHAR5            5
#define LCD_GC_CHAR6            6
#define LCD_GC_CHAR7            7

// Set DD RAM Address --------- 0b1xxxxxxx  (Display Data RAM)
#define LCD_SET_DDADR           0x80

Diesen Teil kann ich aus meinem Datenblatt nicht wirklich entnehmen.. 
hat einer ne Idee was ich da laut Datenblatt angeben muss?

Mein Programm sollte den String "Hello World!" über die funktion 
lcd_string() ausgeben. Aber er er leuchtet nur jede einzelne Zelle des 
Displays mit verschiedenen grau stufen auf.. also es sind keine Zeichen 
auf dem Display zu sehen aber irgendwas passiert schonmal.. wenigstens 
was!

Hm, ich versteh nicht ganz wie mir das bei meinem Problem helfen soll.. 
:)

Ich wollte mal meine Eigene lcd init posten und euch fragen ob ich das 
denn so richtig mache, weil mein Programm funktioniert immer noch nicht 
und ich hab immernoch nur die zwei Balken auf dem Display:

Also laut Datenblatt soll meine Initialisierung so aussehen:

----------------------------------------------------------------

- POWER On
- Wait for more then 15ms
- RS=0, R/W=0, DB7=0, DB6=0, DB5=1, DB4=1
- Wait for more then 4,1ms
- RS=0, R/W=0, DB7=0, DB6=0, DB5=1, DB4=1
- Wait for more then 100us
- RS=0, R/W=0, DB7=0, DB6=0, DB5=1, DB4=1
- RS=0, R/W=0, DB7=0, DB6=0, DB5=1, DB4=1, DB3=N, DB2=F
- RS=0, R/W=0, DB7=0, DB6=0, DB5=0, DB4=0, DB3=1, DB2=0 (Display off)
- RS=0, R/W=0, DB7=0, DB6=0, DB5=0, DB4=0, DB3=0, DB2=0,DB1=0, DB0=1
 (Clear)
-RS=0, R/W=0, DB7=0, DB6=0, DB5=0, DB4=0, DB3=0, DB2=1, DB1=I/D, DB0=Sh
 (Entry mode set)
- Initialisation Ends.

------------------------------------------------------------------

Programmtechnisch habe ich das so geloest:

------------------------------------------------------------------

void lcd_init( void )
{
        DATA_DDR = 0xFF;
        SET_DDR = 0xE0;

//-----Enable Display-------//
        _delay_ms(5000);
        lcd_enable();
        _delay_ms(200);

//--------1--Fset------------------//
        DATA_PORT |= (1<<PA4);
        DATA_PORT |= (1<<PA5);
        _delay_ms(500);

        DATA_PORT &= ~(1<<PA4);
        DATA_PORT &= ~(1<<PA5);
        _delay_ms(500);
//---------2-----Fset-----------------//
        DATA_PORT |= (1<<PA4);
        DATA_PORT |= (1<<PA5);
        _delay_ms(500);

        DATA_PORT &= ~(1<<PA4);
        DATA_PORT &= ~(1<<PA5);
        _delay_ms(500);
//---------3-----Fset-----------------//
        DATA_PORT |= (1<<PA4);
        DATA_PORT |= (1<<PA5);
        _delay_ms(500);

        DATA_PORT &= ~(1<<PA4);
        DATA_PORT &= ~(1<<PA5);
        _delay_ms(500);
//------------SET Funktion-------------//
        DATA_PORT |= (1<<PA3);
        DATA_PORT |= (1<<PA4);
        DATA_PORT |= (1<<PA5);
        _delay_ms(500);
        DATA_PORT &= ~(1<<PA3);
        DATA_PORT &= ~(1<<PA4);
        DATA_PORT &= ~(1<<PA5);
        _delay_ms(500);
//---------------Display Off-------------------------//
        DATA_PORT |= (1<<PA3);
        _delay_ms(15);
        DATA_PORT &= ~(1<<PA3);
        _delay_ms(15);
//--------Display on------//
        DATA_PORT |= (1<<PA0);
        DATA_PORT |= (1<<PA1);
        DATA_PORT |= (1<<PA2);
        DATA_PORT |= (1<<PA3);
        _delay_ms(15);
        DATA_PORT &= ~(1<<PA0);
        DATA_PORT &= ~(1<<PA1);
        DATA_PORT &= ~(1<<PA2);
        DATA_PORT &= ~(1<<PA3);
        _delay_ms(15);
//-----------Display clear------------//

        DATA_PORT |= (1<<PA0);
        _delay_ms(15);
        DATA_PORT &= ~(1<<PA0);
        _delay_ms(15);

//----------Entrymode set-------//
        DATA_PORT |= (1<<PA2);
        DATA_PORT |= (1<<PA1);
        DATA_PORT &= ~(1<<PA0);
        _delay_ms(15);
        DATA_PORT &= ~(1<<PA2);
        DATA_PORT &= ~(1<<PA1);
        DATA_PORT |= (1<<PA0);
        _delay_ms(15);

//--------Display on------//
        DATA_PORT |= (1<<PA0);
        DATA_PORT |= (1<<PA1);
        DATA_PORT |= (1<<PA2);
        DATA_PORT |= (1<<PA3);
        _delay_ms(15);
        DATA_PORT &= ~(1<<PA0);
        DATA_PORT &= ~(1<<PA1);
        DATA_PORT &= ~(1<<PA2);
        DATA_PORT &= ~(1<<PA3);
        _delay_ms(15);
}

----------------------------------------------------------------

In meinem Programm gebe ich einfach den String "Hello World!" an die 
Funktion lcd_string.

Die Syntax der Funktionen:

-----------------------------------------------------------------

//////////////////////////////////////////////////////////////////////// 
////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
        data &= 0xFF;                       // Bits maskieren

        DATA_PORT |= data;
        lcd_enable();
}
//////////////////////////////////////////////////////////////////////// 
////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
    SET_PORT |= (1<<LCD_RS);    // RS auf 1 setzen

    lcd_out( data );            // zuerst die oberen,
    lcd_out( data<<4 );         // dann die unteren 4 Bit senden

    _delay_us( LCD_WRITEDATA_US );
}

void lcd_string( const char *data )
{
    while( *data != '\0' )
        lcd_data( *data++ );
}
//////////////////////////////////////////////////////////////////////// 
////////
// Erzeugt einen Enable-Puls
static void lcd_enable( void )
{
    SET_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen
    _delay_us( LCD_ENABLE_US );  // kurze Pause
    SET_PORT &= ~(1<<LCD_EN);    // Enable auf 0 setzen
}

-----------------------------------------------------------------

Ich glaube das das Problem entweder an der Initialisierung liegt, oder 
daran das ich vielleicht mit 8 Datenpins arbeite und die Funktions 
lcd_data() angepasst werden muss. Ich hoffe ihr könnt mir dabei helfen.

Danke schonma und entschuldigt den extrem langen Post!

> VO -> nicht angeschlossen


Da bist du recht lapidar drüber hinweggegangen.

So lange VO (VEE) nicht richtig bedient wird,

normalerweise also per Poti die passende Spannung zwischen 0V und 5V 
gefunden wird,
bei manchen Displays sogar eine negative Spannung (bei deinem nicht)
kannst du initialisieren wie du willst und nichts ist zu sehen.

Ganz abgesehen von den Problemen die die Anderen im Programm gefunden 
haben.

Hallo,
habe die Initialisierung von diesem Beitrag hier und an meine 
Pinbelegung angepasst: Beitrag "Hilfe bei KS0076B"

MaWin schrieb:
>> VO -> nicht angeschlossen
>
>
> Da bist du recht lapidar drüber hinweggegangen.
>
> So lange VO (VEE) nicht richtig bedient wird,
>
> normalerweise also per Poti die passende Spannung zwischen 0V und 5V
> gefunden wird,
> bei manchen Displays sogar eine negative Spannung (bei deinem nicht)
> kannst du initialisieren wie du willst und nichts ist zu sehen.
>
> Ganz abgesehen von den Problemen die die Anderen im Programm gefunden
> haben.

V0 hab ich über einen Poti an 5V angeschlossen. Ich sehe zwei Balken, 
also müsste der Kontrast soin ordnung sein.

Karl heinz Buchegger schrieb:
> Der Enable Pin heißt nicht 'Enable', weil er das LCD einschaltet.
> Er ist das Signal an das LCD, dass die restlichen Leitungen jetzt einen
> stabilen Zustand angenommen haben und daher vom LCD als gültig anzusehen
> sind. Wenn man will, kann man das so sagen: 'Jetzt gilts. Das was jetzt
> an den Leitungen anliegt, sind gültige Werte'

Das mit lcd_enable habe ich jetzt verstanden, habe es jetzt aus der 
initialisierung genommen.

Karl heinz Buchegger schrieb:
> Warum denkst du, verweisen wir dich immer auf anderen Code? Damit du den
> ignorierst? Woher soll denn dein LCD wissen, dass genau jetzt die an PA4
> und PA5 anliegende 1 schon der endgültige Zustand ist? Weil dein
> Programm eine halbe Sekunde wartet?
>
> Du musst schon mit den Steuer-Pins wackeln (konkret dem Enable) um dem
> LCD mitzuteilen: Jetzt gilts!

Ich versteh nicht ganz was du damit meinst.. soll ich jetzt nach jeder 
Fset anweisung noch ein lcd_enable machen??

Karl heinz Buchegger schrieb:
> Deine Funktion lcd_data + lcd_out ist ein einziger Schmarrn. Ein
> Mischmasch aus 4Bit und 8 Bit Anteuerung, wobei weder das eine noch das
> andere sauber durchgezogen ist.

Ja, ich bin in diesen Bitverknüpfungsgeschichten noch sehr unsicher.. 
könntest du mir denn eine funktionierende lcd_data+lcd_out für eine 8 
Bit Datenübertragung schreiben?

Karl heinz Buchegger schrieb:
>> Ja ich habe schon viele Sachen mit meinem Mikrocontroller gemacht.
>> Es ist nicht so das ich gerade mit Mikrokontrollern angefangen habe..
>> und mit C arbeite ich auch schon seit 2 Jahren.
>
> Wenn ich deinen Code so ansehe: Ich mag es kaum glauben.

Ja ich habe davor mit den ganzen Interrupts gearbeitet und LEDs 
geschaltet, ein Zaehlrohr angeschlossen und solche Dinge. Ich arbeite 
jetzt vielleicht seit ung. 8 Wochen mit dem ATmega8. Mit C arbeite ich 
seit knapp 2 Jahren. Wobei ich erst vor kurzem mit diesen Bitoperationen 
angefangen habe... entschuldige bitte.

Karl heinz Buchegger schrieb:
> Ist PA4 PA5 jetzt eine Steuerleitung oder sind das Datenleitungen?

PA0 - PA 7 sind meine Datenleitungen. Diese habe ich in meinem init 
direkt reingeschrieben.

RS = PD5
R/W = PD6
E = PD7

//  LCD RS      <-->  PORTD Bit PD5     (RS: 0=Data, 1=Command)
#define LCD_RS        PD5

//  LCD EN      <-->  PORTD Bit PD7     (EN: 1-Impuls für Daten)
#define LCD_EN        PD7

Sorry für meine Verwirrende schreibweise

Also Leute,
ich habe mein Programm jetzt nochmal komplett überarbeitet und den 
Quelltext nun leserlich gestalltet (hoffentlich :)). Ich habe im Anhang 
mein .c file angehängt. Ich habe immernoch ein Initialisierungsproblem, 
da die schwarzen Balken auf meinem Display nicht verschwinen. Irgendwas 
mach ich noch falsch. Wäre nett wenn einer mal meine Initialisiesung mit 
dem Datenblatt welches ich auch nochmal angehangen habe durchgeht und 
mir sagt was ich falsch mache.

Danke, Tobias.

der TE sollte sich langsam darüber gedanken machen ob er programmieren 
WILL
das ist jetzt quasi eine grundsatzfrage ...

ohne weitere C kenntnisse und wie so ein µC sowie solche signale 
funktionieren kommt man hier nicht weiter
bzw ist es ein absoluter frust sich unwissend durch Code zu wühlen
ohne nur ansatzweise zu verstehen wie es funzt


wenn er will .. dann muss er lernen ...
wenn er nicht will ... kann er sich maximal projekte nachbauen die 
seinem anspruch genügen

alles andere führt nur dazu das hier elend lange threads entstehen wo zu 
90% geflamed wird ..

Ganz ruhig bleiben.. Diejenigen die meinen mich hier beleidigen zu 
müssen sollen lieber mal garnichts schreiben. Ich versuche mein bestes 
und habe nunmal gerade erst mit LCD Displays angefangen und habe mich in 
der hinsicht vielleicht etwas schwer getan.

An diejenigen die mich unterstützen, wie z.B Karl Heinz:

Ich habe nun die Initialisierung ENDLICH hinbekommen.. nachdem du mir so 
anschaulich beschrieben hast wozu das ENABLE wirklich dient :). Danke 
schonmal dafür!

Meine Initialisierung sieht nun wie folgt aus:

void out_stat_reg (unsigned char command)
{
        PORTA=0;
        PORTD &= ~(1<<PD6);
        _delay_ms(5);
        PORTD |= (1<<PD7);              // Enable auf 1 setzen
        PORTA=command;
        PORTD &= ~(1<<PD7);             // Enable auf 0 setzen
        _delay_ms(70);
}

// Initialisierung:
void lcd_init( void )
{
//Pins auf schreiben schalten (PA0-PA7) (PD5-PD7)
        DDRA = 0xFF;
        DDRD = 0xE0;

//Pins alle low setzen
        PORTA = 0;
        PORTD = 0;

//Wait untill VDD rises to 4,5V
        _delay_ms(2000);
//Function Set 1
        PORTD |= (1<<PD7);              // Enable auf 1 setzen
        PORTA = 0x30;                   //Set PA4 und PA5 high
        PORTD &= ~(1<<PD7);             // Enable auf 0 setzen
        _delay_ms(2000);
//Function Set 2
        PORTD |= (1<<PD7);              // Enable auf 1 setzen
        PORTA = 0x30;                   //Set PA4 und PA5 high
        PORTD &= ~(1<<PD7);             // Enable auf 0 setzen
        _delay_ms(2000);
//Function Set 3
        PORTD |= (1<<PD7);              // Enable auf 1 setzen
        PORTA = 0x30;                   //Set PA4 und PA5 high
        PORTD &= ~(1<<PD7);             // Enable auf 0 setzen
        _delay_ms(2000);

        out_stat_reg(0x3c);                             //set Display 
lines
        out_stat_reg(0x08);                             //Display off
        out_stat_reg(0x01);                             //Display clear
        out_stat_reg(0x06);                             //cursor 
increase
        out_stat_reg(0x0c);                             //Display on
}

Ich hoffe das ist nun verständlicher und sieht mal n bisschen besser aus 
als das was ich vorher fabriziert habe ;)

Also es erscheinen nun die Zeichen "Lo<-" anstatt "Hello World!" auf dem 
Display. Aber wenigstens hat die Initialisierung schonmal funktioniert. 
Jetzt muss ich nurnoch rausfinden warum er nicht meinen gewünschten 
String ausgibt. Ich probier mal ein paar Dinge aus, wenn jemand n 
Vorschlag hat woran es liegen könnte kann er es ruhig hier posten.

Danke erstmal an die jenigen die so Geduldig mit mir waren.

Hallo,
also ich kann jetzt einen beliebigen char an das Display übergeben.. 
weiß aber nicht wie ich den Curser bewege. Wie kann ich dem Display denn 
sagen, das er, nachdem er einen char geschickt bekommen hat eine 
curserposition nach rechts rücken soll?

Gruß, Tobias.

Ok.

Ich habe nur ein ganz einfaches Programm erstellt wo direkt in der main 
den char sendet. Wenn ich genau weiß wie das richtig funktioniert will 
ich dann meine eigene putchar funktion erstellen.

Meine init() kennst du ja.

Meine main:

int main(void)
{
        lcd_init();

        PORTD |= (1<<PD5); //RS auf 1
        PORTA = 0x54;      //send char 'T'
        lcd_enable();      //Jetzt gilts

        while(1)
        {
        }

        return 0;
}

Naja, ich frage mich halt grade wie das genau Funktioniert.

Ich habe jetzt versucht so zwei char nebeneinander zu senden:

int main(void)
{
        lcd_init();

        PORTD |= (1<<PD5);
        PORTA = 0x54;
        lcd_enable();

        PORTD |= (1<<PD5);
        PORTA = 0x4F;
        lcd_enable();

        while(1)
        {
        }

        return 0;
}

Ok.. vielen dank!

Er zeigt mir aber nur ein 'H' an, wenn ich es so mache :/

Ich habe grad irgend n kleinen bug drinnen, Nachdem ich die ganzen 
defines gemacht habe. Brauche noch kurz um den zu fixen.

JAAAAAAAAAAAAAAAAAAAAA!

Ich habs endlich geschafft!!!! DANKE Karl Heinz ich LIEBE DICH :D

Das Problem war das ich mal wieder zu "copy&paste" geil war und ich 
deine defines rauskopiert habe, wobei du RS = PD6 und RW = PD5 definiert 
hattest. Diese sind aber genau umgedreht.. das hat mich grad zur 
verzweiflung gebrahct.. aber jetzt gehts! DANKE DANKE DANKE

Ich hab mein Programm mal in den Anhang gemacht, falls du es dir nochmal 
anschauen willst.

Gruß, Tobias.

Ok. Ich werde in Zukunft darauf achten. Danke nochmal für alles.