LCD zeigt nichts an

Also musss ich in der headerdatei bei lcd-routine.h die Pins ändern?

Mir ist nicht klar warum  das jetzt falsch ist:( Die pins sind ja nicht 
miteinander am board verbunden.
wie sehe das denn jetzt richtig aus z.b ?

Mit den von dir gezeigten LCD-Routinen wird das nichts.
Dazu müsstest du den Port für die Steuerleitungen getrennt vom Port für 
die Datenleitungen einstellen können. Dafür sind diese Funktionen aber 
nicht vorbereitet.
Entweder du machst dir diese Modifikation selber (was nicht wirklich 
schwer ist), oder du suchst dir andere LCD-Routinen, bei denen das schon 
gemacht wurde.

3 MB für ein sinnleeres Bild einer Platine und 3 mal 200K für 
Screenshots von Programmlistings in der Größe einiger hundert Bytes.
Junge du hast den Tagespreis für die größt Platzverschwendung gewonnen.
Lese bitte mal Bildformate

Also zusammengefasst muss ich einfach die beiden headerdateien ändern 
mehr nicht dann solllte es funktionieren okay ich schau mal ob ich das 
hinkriege ^^

Danke schonmal

Adrian H, schrieb:
> Also zusammengefasst muss ich einfach die beiden headerdateien ändern

Nö.
Zusammengefasst: du müsstest DIESEN Code so umändern, dass du für den 
Zugriff auf die Steuerleitungen einen 2.ten Port benutzen kannst und 
nicht nur LCD_PORT quer durch die ganzen Funktionen verwendet wird.
Aber: so viele Verwendungen sind das dann ja auch wieder nicht, die 
umgestellte werden müssten. (Die Initialisierungen der Port-Richtung 
nicht vergessen)

snayer2311 schrieb:

> ich hab mir das Beispiel erweiterte Ansteuerung angeschaut, jedoch sah
> ich da keinen allzu großen unterschied was mir weiter bringen könnte

Dein Problem ist, dass du dich weigerst dir den Code anzusehen und 
nachzudenken.

Wenn hier ...

1

static void lcd_enable( void )

2

{

3

  LCD_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen

4

  _delay_us( LCD_ENABLE_US );  // kurze Pause

5

  LCD_PORT &= ~(1<<LED_EN);    // Enable auf 0 setzen

6

}

steht, dass der Enable Pin über den LCD_PORT geschaltet wird, bei dir 
aber der LCD_PORT der PORTA ist (wegen der Datenleitungen), die Enable 
Leitung aber auf dem Port B liegt, dann kannst du offensichtlich das 
Schalten der Enable Leitung nicht über LCD_PORT abwickeln, sondern musst 
das umprogrammieren.

Ergo wirst du dir für die Steuerleitungen etwas ähnliches wie den 
LCD_PORT einführen. Nennen wir es mal den LCD_CTRL_PORT (für Control - 
Port. Der Port an dem die Steuerleitungen vom LCD hängen.

IM Header Feil kommt also rein

1

#ifndef LCD_PORTS

2

#define LCD_PORTS

3

4

#define LCD_PORT      PORTA

5

#define LCD_DDR       DDRA

6

7

#define LCD_CTRL_PORT PORTB

8

#define LCD_CTRL_DDR  DDRB

9

10

// 4 Bit LCD Datenbus DB4-DB7, das unterste Bit DB4 kann auf den Portbits 0..4 liegen

11

12

//  LCD DB4-DB7 <-->  PORTC Bit PC0-PC3

13

#define LCD_DB        PA0

14

15

// LCD Steuersignale RS und EN am Control Port

16

17

//  LCD RS      <-->  PORTC Bit PB2     (RS: 0=Data, 1=Command)

18

#define LCD_RS        PB2

19

20

//  LCD EN      <-->  PORTC Bit PB0     (EN: 1-Impuls für Daten)

21

#define LCD_EN        PB0

22

23

#endif // LCD_PORTS

Damit hast du jetzt erst mal grundsätzlich 2 Ports benannt, über die die 
Kommunikation abgewickelt wird. Ob die Pinnummern stimmen, weiß ich 
nicht. Die kann man auf dem Photo so schlecht lesen. An der 
Steckerleiste stehen sie aber dabei, so dass du die nur kontrollieren 
brauchst.

Tja. UNd dann müssen natürlich die Routinen entsprechend geändert 
werden. Zb wird lcd_enable dann eben sein 1 bzw. 0 setzen des Enable 
Pins nicht mehr über den LCD_PORT abwickeln, sondern wird das dann eben 
über den LCD_CTRL_PORT machen.

1

static void lcd_enable( void )

2

{

3

  LCD_CTRL_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen

4

  _delay_us( LCD_ENABLE_US );  // kurze Pause

5

  LCD_CTRL_PORT &= ~(1<<LED_EN);    // Enable auf 0 setzen

6

}

Denn die Enable Leitung ist ja an den PORTB verdrahtet, dem wir den 
Namen LCD_CTRL_PORT verpasst haben.

und so geht man dann eben den Code durch, sieht sich an, was da jeweils 
passiert und überlegt, ob die Port Ausgabe auf den LCD_PORT (die 
Datenleitungen) oder den LCD_CTRL_PORT (die Steuerleitungen) gehen muss.
Auf die Initalisierung nicht vergessen, denn auch die Leitungen auf dem 
LCD_CTRL_PORT müssen mal auf Ausgang geschaltet werden ... und ... wenn 
du keinen Fehler gemacht hast, dann ist der Teil damit erst mal 
erledigt. Wenn das Timing nicht zu knapp ist, müsste sich das LCD schon 
melden.

Aber .... ohne dass du selber ein wenig umprogrammierst wird das nichts 
werden. Wenn ein Code auf eine Anforderung, hier die Trennung von Daten 
und Steuerleitungen auf verschiedene Ports, nicht vorbereitet ist, dann 
muss man eben diese Trennung selber in den Code einbauen. Mit 3 Zahlen 
in 4 #defines austauschen ist es dann nicht getan.

snayer2311 schrieb:
> nach deiner großen hilfe :) sehe dann das routinen programm etwa so aus
> also wäre es  zumindest das richtig


nein.


>   DDRA = 0xff;
>   PORTA = (1<<LCD_PORT);
>   DDRB = 0xff;
>   PORTB = (1<<LCD_CTRL_PORT);

was soll das denn sein?

>  // verwendete Pins auf Ausgang schalten
>  uint8_t pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
>  (1<<LCD_RS) |                // R/S Leitung
>  (1<<LCD_EN);                 // Enable Leitung
>  LCD_DDR |= pins;

das geht so nicht mehr. Denn LCD_RS und LCD_EN liegen ja nicht mehr am 
LCD_PORT für den LCD_DDR zuständig ist.

>  // initial alle Ausgänge auf Null
>  LCD_PORT &= ~pins;

geht auch nicht mehr.

vergiss die pins Variable. Setze die Pisn einzeln. So wie du das gelernt 
hast. Das muss nicht hoch-optimiert ablaufen.

> void lcd_command( uint8_t data )
> {
>   LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen

LCD_RS liegt nicht mehr am LCD_PORT

Das hier

1

// LCD Steuersignale RS und EN am Control Port

2

3

//  LCD RS      <-->  PORTC Bit PB2     (RS: 0=Data, 1=Command)

4

#define LCD_RS        PB2

5

6

//  LCD EN      <-->  PORTC Bit PB0     (EN: 1-Impuls für Daten)

7

#define LCD_EN        PB0

ist Ernst zu nehmen!
Überall, wo LCD_RS oder LCD_EN vorkommt, muss eingegriffen werden!
Denn die beiden Leitungen sind nicht mehr über LCD_PORT zu schalten, 
sondern über LCD_CTRL_PORT. Und das betrifft ALLE Belange! Sei es das 
Schalten auf Ausgang über das DDRx Register, sei es das setzen auf 1, 
sei es das setzen auf 0, etc. etc. Überall! Quer durch den ganzen Code.

?
Soll das heißen du hast das direkt im Word geschrieben?

Dann schau ich gar nicht erst rein (würde ich sowieso nicht tun. Bin 
doch nicht wahnsinnig und lade mir ein Word-File down).

Lass es erst mal durch den Compiler, behebe alle Probleme und DANN sehen 
wir weiter. So hat das keinen Sinn.

Die Funktion hier

1

////////////////////////////////////////////////////////////////////////////////

2

// Sendet eine 4-bit Ausgabeoperation an das LCD

3

static void lcd_out(uint8_t data)

4

{

5

  data &= 0xF0;

6

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB1)); //obere 4 Bit maskieren

7

8

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB2)); //Maske löschen

9

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB3));

10

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB4));

11

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB5));

12

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB6));

13

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB7));

14

15

  LCD_PORT &= (data >> (4 - LCD_DB1)); //Bits setezn

16

  LCD_PORT &= (data >> (4 - LCD_DB2));

17

  LCD_PORT &= (data >> (4 - LCD_DB3));

18

  LCD_PORT &= (data >> (4 - LCD_DB4));

19

  LCD_PORT &= (data >> (4 - LCD_DB5));

20

  LCD_PORT &= (data >> (4 - LCD_DB6));

21

  LCD_PORT &= (data >> (4 - LCD_DB7));

22

23

24

}

ist auch kompletter Unsinn.
Was ist ihre eigentliche Aufgabe?
Ihre AUfgabe ist es 4(!) Bit auszugeben! Warum 4? Weil in diesem Code 
das LCD im 4 Bit Modus betrieben wird. D.h. 1 Byte wird so zum LCD 
gesendet, dass die 8 Bit in 2 Teile zu je 4 Bit aufgeteilt wird und dann 
diese 4 Bit getrennt voneinander in 2 Aktionen übertragen werden.
Und genau für letzteres, das anlegen von 4 Bits an die Datenleitungen, 
ist diese Funktion zuständig.

Jetzt zähl mal deine Bit-Setz Aktionen. Wieviele sind das? Das sind 
nicht 4. Das sind interesssanterweise aber auch nicht 8, wie man es bei 
einem Byte erwarten würde. Nein, das sind 7. Wieso 7? 7 macht in diesem 
Zusammenhang überhaupt keinen Sinn.

Halte dich an die Vorlage und änder nicht gleich alles um. Wenn der Code 
erst mal für den 4 Bit Modus ausgelegt ist, dann bring ihn erst mal 
damit mit deiner Hardware zum laufen. Und erst dann, wenn er läuft, dann 
änderst du den Rest. Du änderst im Moment schon zu viel, ohne dass du 
die Änderungen testen kannst.


Das hier

1

void lcd_init(void)

2

{

3

  //verwendete Pins auf Ausgang schalten

4

5

  LCD_DDR = 0xff;

6

  LCD_PORT = 0x00;

7

8

  LCD_CTRL_PORT = 0x00;

9

  LCD_CTRL_DDR = 0xff;

ist auch schelcht. Du willst an dieser Stelle NUR und ausschliesslich 
die Bits vom jeweiligen Port bearbeiten, die du auch tatsächlich 
brauchst! Solche Rundumsdchlagzuweisungen sorgen regelmässig für Ärger. 
Am Control Port brauchst du nur 2 Bits, nicht alle 8. Die restlichen 6 
gehen dich nichts an, also lass sie in Ruhe!

1

  LCD_CTRL_PORT &= ~( (1<<LCD_RS) | (1<<LCD_EN));

2

  LCD_CTRL_DDR  |= (1<<LCD_RS) | (1<<LCD_EN);

Selbiges für die Datenleitungen.
Erstens brauchst du nur 4 (wegen dem 4 Bit Modus), zweitens lass die 
restlichen 4 Leitungen in Ruhe! Der LCD-Code kann nicht wissen, und er 
will es auch gar nicht wissen, ob da an den nicht von ihm benutzen 
Leitungen an diesem Port irgendwas angeschlossen ist oder nicht. Im 
Zweifelsfall geht er davon aus, dass da etwas angeschlossen ist, und das 
er sich von diesen Leitungen fern halten soll. Die Devise heißt: 
defensiv arbeiten! Bei Funktionsgruppen, die Standard Character haben 
(also in x Projekten eingesetzt werden) ist so etwas das um und auf zur 
Wiederverwendbarkeit.

Wollte das mal praktisch mit dem Board probieren, bin mir aber nicht 
klar welchen Kontroller du verwendest. Im *.c seht was von Mega8?

Dein Code wird immer schlimmer und immer falscher.

Wirf ihn weg und hol dir vom Peter Fleury die LCD-Routinen.
Die kannst du auf einzelne Pins konfigurieren.
In ein paar Monaten, wenn du dazu gelernt hast, kannst du es ja noch mal 
probieren. Aber im Moment sind deine Änderungen so ziemlich alle 
kontraproduktiv bis einfach nur falsch.

Was für Zeichen werden angezeigt?
Es haben nicht alle Display den gleichen ROM-Code.
Richtig ausgeben sollte es ein Display mit den ROM-Code A2.

snayer2311 schrieb:
> wie setze ich diese Tabelle in meiner Funktion ein direkt bei
> lcd_string?

Gar nicht.

Du machst dir eine Funktion lcd_char, welche 1 Zeichen ausgibt und 
gegebenfalls die Umsetzung macht

1

////////////////////////////////////////////////////////////////////////////////

2

// Schreibt ein Zeichen aufs LCD

3

4

void lcd_char( char ps )

5

{

6

  switch(ps)

7

  {

8

   case 'ä' : ps = 0xE1; break;

9

   case 'ö' : ps = 0xEF; break;

10

   case 'ü' : ps = 0xF5; break;

11

   case 'ß' : ps = 0xE2; break;

12

   case '°' : ps = 0xDF; break;

13

   case 'µ' : ps = 0xE4; break;

14

   case 'Ä' : ps = 0x00; break;  // Point to CG-RAM

15

   case 'Ö' : ps = 0x01; break; // self defined characters

16

   case 'Ü' : ps = 0x02; break;

17

  }

18

  lcd_data(ps);

19

}

und benutzt dann diese Funktion überall dort, wo ein Zeichen auszugeben 
ist

1

////////////////////////////////////////////////////////////////////////////////

2

3

void lcd_string(const char *data)

4

{

5

  while (*data != '\0')

6

    lcd_char(*data++);

7

}

der Grund warum da eine eigene Funktion fällig wird liegt darin, dass du 
die Umsetzung nicht in lcd_data machen kannst, da lcd_data auch für 
andere Ausgaben benötigt wird.

Hast du eigentlich deine lcd_init Funktion schon gesäubert?
Im letzten C-File sah die noch furchtbar aus.

snayer2311 schrieb:
> Karl Heinz schrieb:
>> Hast du eigentlich deine lcd_init Funktion schon gesäubert?
>> Im letzten C-File sah die noch furchtbar aus.
>
> das sind meine initialisierungen
> PORTA = 0x00;  // Display ON/OFF oberes Nibble
>   enable();    // Enable Funktion einfügen
>
>   PORTA = 0xf0;  // Display ON/OFF unteres Nibble >>> Display ein,
> Cursor ein, Cursor blinken
>   enable();    // Enable Funktion einfügen
>
>   PORTA = 0x00;  // Clear Display oberes Nibble
>   enable();    // Enable Funktion einfügen
>
>   PORTA = 0x10;  // Clear Display unteres Nibble >>> Display löschen,
> Cursor an 1. Stelle
>   enable();    // Enabel Funktion einfügen
>
>   PORTA = 0x00;  // Entry Mode Set oberes Nibble
>   enable();    // Enable Funktion einfügen
>
>   PORTA = 0x60;  // Entry Mode Set unteres Nibble >>> Cursor
> Auto-Increment
>   enable();    // Enable Funktion einfügen
>
>   lcd_clear();

Und warum steht da jetzt PORTA direkt drinnen?
Stell dir einfach mal vor, du hast irgendwann ein anderes Board bei dem 
das LCD nicht mehr am Port A hängt, sondern an einem anderen Port.

genau dazu gibt es die

1

#define LCD_PORT  PORTA

Ausserdem: warum setzt du da die Bits direkt? Dazu gibt es eine 
Funktion, die darüber Bescheid weiss, welche Bits auf welche Portpins zu 
verteilen sind!
Und für die Aufteilung in die beiden 4 Bit Nibbles gibt es ebenfalls 
eine Funktion. Nämlich lcd_command.

Zb. nach dem Kommando 'LCD löschen' musst du eine Wartepause einlegen, 
denn das LCD braucht dazu etwas Zeit. lcd_clear weiß das und 
berücksichtigt das. Das hier

1

  PORTA = 0x00;  // Clear Display oberes Nibble

2

>   enable();    // Enable Funktion einfügen

3

> 

4

>   PORTA = 0x10;  // Clear Display unteres Nibble >>> Display löschen, 

5

> Cursor an 1. Stelle

6

>   enable();    // Enabel Funktion einfügen

berücksichtigt gar nichts.

Kurz und gut:
Dein Code funktioniert jetzt, mit genau DIESEM Display und genau DIESEM 
Port und genau DIESER Anschlussbelegung. Verändere irgendetwas davon, 
und du musst durch deinen kompletten Code durchgehen und nach den 
notwendigen Anpassungen suchen.
Das kann es aber nicht sein.
Wird irgendwas verändert, zb ein anderer Port für die Datenleitungen, 
dann muss es reichen, dafür den

1

#define LCD_PORT PORTD

zu verändern und der Rest des Codes wird vom Compiler anhand dieses 
#define angepasst.

snayer2311 schrieb:
> #define  LCD_PORT  PORTC
> #define  LCD_DDR  DDRC
>
> #define  LCD_CTRL_PORT    PORTB
> #define  LCD_CTRL_DDR    DDRB
>
> habe ich schon definiert :)

Ja.
Aber du musst das auch in deinem Code BENUTZEN!
Das kann nicht sein, dass im Code

   PORTA = ....

steht.
Da muss

  LCD_PORT = ....

stehen!

(Jetzt mal abgesehen davon, dass das so im Code der Init Funktion 
überhaupt nicht stehen soll. Denn um 1 Nibble auszugeben gibt es die 
Funktion lcd_out für die erste Initialisierung zur Umshcaltung in den 
4-Bit Modus und ab dem Zeitpunkt ist lcd_command ALLEINIG dafür 
zuständig Kommandos an das LCD zu übergeben)


Ich scheine irgendwie ein Problem damit zu haben, dir klar zu machen, 
dass es nicht reicht, wenn ein Code so irgendwie funktioniert. 
Codequalität definiert sich auch dadurch, wie gut er wartbar bzw. an 
andere Gegebenheiten adaptierbar ist. Dazu gehört auch, dass man 
'Wissen', wie zb Portbenutzung und Belegung NICHT quer über x Funktionen 
verstreut, sondern an einer Stelle sammelt.