LCD zeigt nichts an

[Snayer I. (Firma: Audi GmbH) (snayer2311)]

Hallo :-)

stehe seit tagen vor einem Problem bei dem ich nicht mehr weiter komme. 
Simple Aufgabe ich möchte das mein display i-was anzeigen soll. Deswegen 
habe ich mal zur Sicherheit das Testbeispiel im AtmegaStudio Projekt 
übernommen. Die libery also lcd-routine.h habe ich natürlich geändert: 
einmal die Taktfrequenz und die Pinbelegung. Dennoch wenn ich dieses 
Programm ausführe zeigt mir nur mein Display das standard initialisierte 
Balkenbild:( Jezt weiss ich nicht wo und was ich jetzt falsch gemacht 
habe, ob es jetzt am programm liegt oder an der Verdrahtung selber. Ich 
habe mein Atmel Addon Board V1.0 am Atmel Evaluation-Board Version 2.0.1 
angeschlossen.
Zusätzlich hänge ich noch oben mein Programm mit den beiden library und 
meine verdrahtung am board. Leider war mir der Schaltplan von diesem 
board nicht so einleuchtend und weiss jetzt nicht ob ich alles so 
richtig mit jedem pin verbunden habe, die betonnung liegt auf richtig!
hoffe ihr könnt mir helfen,

vielen dank im voraus :-)

Ps: hier ist der Schaltplan
http://www.pollin.de/shop/downloads/D810053B.PDF

[Felix (Gast)]

hi,
deine Belegung passt nicht.
Die Datenleitung leigen bei dir von PA0 - PA3
Auf PA3 liegt aber auch gleichzeitig 'RS' und auf PA1 auf 'EN'.

mfg

[Snayer I. (Firma: Audi GmbH) (snayer2311)]

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 ?

[Karl H. (kbuchegg)]

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.

[Udo S. (urschmitt)]

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

[Snayer I. (Firma: Audi GmbH) (snayer2311)]

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

[Karl H. (kbuchegg)]

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 (Gast)]

wie mache ich das dass endlich zugriff auf dem 2 port bekomme?
im moment muss ich ja nur hier in diesem folgenden Code was ändern:

#ifndef LCD_PORTS
#define LCD_PORTS

#define LCD_PORT      PORTD
#define LCD_DDR       DDRD

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

//  LCD DB4-DB7 <-->  PORTC Bit PC0-PC3
#define LCD_DB        PD0

// LCD Steuersignale RS und EN

//  LCD RS      <-->  PORTC Bit PC4     (RS: 0=Data, 1=Command)
#define LCD_RS        PD4

//  LCD EN      <-->  PORTC Bit PC5     (EN: 1-Impuls für Daten)
#define LCD_EN        PD5

#endif // LCD_PORTS

laut dem hier zufolge 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung

muss bei diesem display PD4 auf RS sein und PD5 auf EN.

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

[Karl H. (kbuchegg)]

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 ...

static void lcd_enable( void )
{
  LCD_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen
  _delay_us( LCD_ENABLE_US );  // kurze Pause
  LCD_PORT &= ~(1<<LED_EN);    // Enable auf 0 setzen
}

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

#ifndef LCD_PORTS
#define LCD_PORTS

#define LCD_PORT      PORTA
#define LCD_DDR       DDRA

#define LCD_CTRL_PORT PORTB
#define LCD_CTRL_DDR  DDRB

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

//  LCD DB4-DB7 <-->  PORTC Bit PC0-PC3
#define LCD_DB        PA0

// LCD Steuersignale RS und EN am Control Port

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

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

#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.

static void lcd_enable( void )
{
  LCD_CTRL_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen
  _delay_us( LCD_ENABLE_US );  // kurze Pause
  LCD_CTRL_PORT &= ~(1<<LED_EN);    // Enable auf 0 setzen
}

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 (Gast)]

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

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar

#include <avr/io.h>
#include "lcd.h"
#include <util/delay.h>

////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls
static void lcd_enable( void )
{
  LCD_CTRL_PORT |= (1<<LCD_EN);        // Enable auf 1 setzen
  _delay_us( LCD_ENABLE_US );       // kurze Pause
  LCD_CTRL_PORT &= ~(1<<LCD_EN);      // Enable auf 0 setzen
}

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
  data &= 0xF0;                       // obere 4 Bit maskieren
  
  LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
  LCD_PORT |= (data>>(4-LCD_DB));     // Bits setzen
  lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
  DDRA = 0xff;
  PORTA = (1<<LCD_PORT);
  DDRB = 0xff;
  PORTB = (1<<LCD_CTRL_PORT);
  
  // 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;
  
  // initial alle Ausgänge auf Null
  LCD_PORT &= ~pins;
  
  // warten auf die Bereitschaft des LCD
  _delay_ms( LCD_BOOTUP_MS );
  
  // Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
  lcd_out( LCD_SOFT_RESET );
  _delay_ms( LCD_SOFT_RESET_MS1 );
  
  lcd_enable();
  _delay_ms( LCD_SOFT_RESET_MS2 );
  
  lcd_enable();
  _delay_ms( LCD_SOFT_RESET_MS3 );
  
  // 4-bit Modus aktivieren
  lcd_out( LCD_SET_FUNCTION |
  LCD_FUNCTION_4BIT );
  _delay_ms( LCD_SET_4BITMODE_MS );
  
  // 4-bit Modus / 2 Zeilen / 5x7
  lcd_command( LCD_SET_FUNCTION |
  LCD_FUNCTION_4BIT |
  LCD_FUNCTION_2LINE |
  LCD_FUNCTION_5X7 );
  
  // Display ein / Cursor aus / Blinken aus
  lcd_command( LCD_SET_DISPLAY |
  LCD_DISPLAY_ON |
  LCD_CURSOR_OFF |
  LCD_BLINKING_OFF);
  
  // Cursor inkrement / kein Scrollen
  lcd_command( LCD_SET_ENTRY |
  LCD_ENTRY_INCREASE |
  LCD_ENTRY_NOSHIFT );
  
  lcd_clear();
}

////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
  LCD_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 );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data )
{
  LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen
  
  lcd_out( data );             // zuerst die oberen,
  lcd_out( data<<4 );           // dann die unteren 4 Bit senden
  
  _delay_us( LCD_COMMAND_US );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void )
{
  lcd_command( LCD_CLEAR_DISPLAY );
  _delay_ms( LCD_CLEAR_DISPLAY_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void )
{
  lcd_command( LCD_CURSOR_HOME );
  _delay_ms( LCD_CURSOR_HOME_MS );
}

////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)

void lcd_setcursor( uint8_t x, uint8_t y )
{
  uint8_t data;
  
  switch (y)
  {
    case 1:    // 1. Zeile
    data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
    break;
    
    case 2:    // 2. Zeile
    data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
    break;
    
    case 3:    // 3. Zeile
    data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
    break;
    
    case 4:    // 4. Zeile
    data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
    break;
    
    default:
    return;                                   // für den Fall einer falschen Zeile
  }
  
  lcd_command( data );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD

void lcd_string( const char *data )
{
  while( *data != '\0' )
  lcd_data( *data++ );
}

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM

void lcd_generatechar( uint8_t code, const uint8_t *data )
{
  // Startposition des Zeichens einstellen
  lcd_command( LCD_SET_CGADR | (code<<3) );
  
  // Bitmuster übertragen
  for ( uint8_t i=0; i<8; i++ )
  {
    lcd_data( data[i] );
  }
}

[Karl H. (kbuchegg)]

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

[Karl H. (kbuchegg)]

Das hier

// LCD Steuersignale RS und EN am Control Port

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

//  LCD EN      <-->  PORTC Bit PB0     (EN: 1-Impuls für Daten)
#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.

[snayer2311 (Gast)]

Ich hab mal alles nochmal von neu begonnen und mir selber jetzt einzelne 
Codes geschrieben. Bei der Initialisierung war ich mir nicht sicher. 
Dafür hab ich hoffe mal darauf geachtet das die die Pinne RS und EN 
nicht über den Datenbus PORTA laufen. Ich stelle dies mal als 
worddokument mit rein. Noch weissi ich nicht ob es funktioniert werde es 
mal morgen testen.

[holger (Gast)]

>Ich hab mal alles nochmal von neu begonnen und mir selber jetzt einzelne
>Codes geschrieben.

Also mein Compiler frisst keine Word Dokumente.

[snayer2311 (Gast)]

ich weiss hab mom kein atmel wegen windows 8. mein system hat gerade 
gestreikt bei der installation von avr studio -.-

[Karl H. (kbuchegg)]

?
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.

[snayer2311 (Gast)]

okay bin schon dabei^^

[snayer2311 (Gast)]

bitte die dateien^^

[snayer2311 (Gast)]

diese datei ist falsch initialisiert werde es überarbeiten
hab jetzt meine fehler soweit selber heraus gebessert. Werde es dann 
komplett wieder hochlasen^^

[Karl H. (kbuchegg)]

Die Funktion hier

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out(uint8_t data)
{
  data &= 0xF0;
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB1)); //obere 4 Bit maskieren

  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB2)); //Maske löschen
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB3));
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB4));
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB5));
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB6));
  LCD_PORT &= ~(0xF0 >> (4 - LCD_DB7));

  LCD_PORT &= (data >> (4 - LCD_DB1)); //Bits setezn
  LCD_PORT &= (data >> (4 - LCD_DB2));
  LCD_PORT &= (data >> (4 - LCD_DB3));
  LCD_PORT &= (data >> (4 - LCD_DB4));
  LCD_PORT &= (data >> (4 - LCD_DB5));
  LCD_PORT &= (data >> (4 - LCD_DB6));
  LCD_PORT &= (data >> (4 - LCD_DB7));
  

}

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

void lcd_init(void)
{
  //verwendete Pins auf Ausgang schalten

  LCD_DDR = 0xff;
  LCD_PORT = 0x00;
  
  LCD_CTRL_PORT = 0x00;
  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!

  LCD_CTRL_PORT &= ~( (1<<LCD_RS) | (1<<LCD_EN));
  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.

[snayer2311 (Gast)]

Im moment bekomme ich die richtigen Signale die ich für das schreiben 
und Empfangen bekommen möchte. Also die funktion enable funktioniert 
schonmal.
Auch sehe ich dass daten verschickt werden nach dem das Enable gesetzt 
wurden ist. Jedoch wenn ich das schreiben möchte kommmt es tdem nicht 
bis zum display an

void lcd_init(void)
{
  //verwendete Pins auf Ausgang schalten

  LCD_DDR =0xf0;// PORTA Pin 4-7 auf Ausgang gestellt
  LCD_CTRL_PORT = LCD_CTRL_PORT & ~( (1<<LCD_RS) | (1<<LCD_EN));
 // An PortB wird RS und EN zur Sichherheit auf Low geschaltet
  LCD_CTRL_DDR=0x05;      }

static void lcd_out(uint8_t data)
{
  LCD_PORT = data & 0xf;
  #ifndef _mydebug
  _delay_us(LCD_WRITEDATA_US);      //kurze Pause
  #endif
}
static void lcd_enable(void)
{
  LCD_CTRL_PORT |= (1 << LCD_EN);  //Enable auf 1 setzen
  _delay_us(LCD_ENABLE_US);       //kurze Pause
  LCD_CTRL_PORT &= ~(1 << LCD_EN); //Enable auf 0 setzen

void lcd_data(uint8_t data)
{
  LCD_CTRL_PORT |= ~(1 << LCD_RS);   //RS auf 0 setzen
  lcd_out(data & 0xf0);             //zuerst die oberen 0b11110000
  _delay_us(LCD_COMMAND_US);
  lcd_enable();
  lcd_out(data << 4);             //dann die unteren
  _delay_us(LCD_COMMAND_US);
  lcd_enable();
}
void lcd_command(uint8_t data)
{
  LCD_CTRL_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen

  lcd_out( data & 0xf0);              // zuerst die oberen, 0b11110000
  lcd_enable();
  lcd_out( data << 4);           // dann die unteren 4 Bit senden
  lcd_enable();
}
void lcd_string(const char *data)
{
  while (*data != '\0')
  lcd_data(*data++);

}

[Hubert G. (hubertg)]

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

[snayer2311 (Gast)]

nee atmega32pu16

[snayer2311 (Gast)]

ich hab das jetzt mal versucht einfacher zu schreiben jedoch wenn ich 
dieses programm debuggen möchte hängt er in der delay.h fest und macht 
gar nichts mehr
jetzt weiss ich nicht mehr wo da der fehler jetzt sein könnte

[snayer2311 (Gast)]

snayer2311 schrieb:
> ich hab das jetzt mal versucht einfacher zu schreiben jedoch wenn
> ich
> dieses programm debuggen möchte hängt er in der delay.h fest und macht
> gar nichts mehr
> jetzt weiss ich nicht mehr wo da der fehler jetzt sein könnte

verwerden das display hd44780

[Karl H. (kbuchegg)]

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.

[snayer2311 (Gast)]

von wegen wegwerfen-.- der code ist um einiges einfacher zu verstehen 
als das was im internet zu verstehen ist!

Ich bin fertig mit mein Projekt und siehe da es funktiert. Es lag 
hauptsächlich an die falsche Initialisierung des Displays. Aber ich 
leugne nicht dass es nicht nur der eine Fehler gewesen ist. Ich glaube 
dass besonders du Karl Heinz das eine oder andere mal mit dem Kopf 
schütteln musstest. Sorry im Vorfeld AVR Programmierung ist für mich was 
neu ich programmiere selten hardware spezifisch deswegen musste ich oft 
hier um hilfe fragen. Manches hat mir geholfen manches naja ging so eher 
weniger:(
Ich möchte mich auch dafür entschuldigen dass ich einfach zu viele 
Datein reingestellt haben die das Maß an Grenzen deutlich überschritten. 
Ich wusste das gerade nicht.

Nun gut, das wollte ich nochmal kurz loswerden. Jetz zu meinem Projekt. 
Als Hilfe für andere die dann das selbe Problem wie ich hatte stelle ich 
mein Projekt hier rein. Es Funktioniert für das Display HD448780! Bei 
den anderen Displays weiss ich es leider nicht. Denke mal da muss man 
nur die Initialisierung ändern. Findet man alles im Handbuch.

Was nicht gerade funktioniert ist dass ich keine Umlaute ausgeben kann. 
Er erkennt z.B kein ä oder ein ß. Ich weiss i-was mit dem Ascii-Code 
programmiert werden muss. Wie genau das funktionieren soll weiss ich 
momentan nicht. Wäre cool wenn mir da einer eine Lösung dafür hätte.

lg
snayer2311

[Hubert G. (hubertg)]

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 (Gast)]

Hubert G. schrieb:
> 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.

bei ä kommt dann ein mikcro zeichen
sowie auch jeweils bei den anderen Umlaute wie ö ü oder ß.

wie kann man das best möglich programmieren?

[holger (Gast)]

>sowie auch jeweils bei den anderen Umlaute wie ö ü oder ß.

Dann vermeide Umlaute oder bau dir eine Übersetzungstabelle.

#if DEFAULT_TABLE
 // Standard conversion table used by most displays
 switch(ps)
  {
   case 'ä' : ps = 0xE1; break;
   case 'ö' : ps = 0xEF; break;
   case 'ü' : ps = 0xF5; break;
   case 'ß' : ps = 0xE2; break;
   case '°' : ps = 0xDF; break;
   case 'µ' : ps = 0xE4; break;
   case 'Ä' : ps = 0x00; break;  // Point to CG-RAM
   case 'Ö' : ps = 0x01; break; // self defined characters
   case 'Ü' : ps = 0x02; break;
  }
#endif

 return ps;

[snayer2311 (Gast)]

wie setze ich diese Tabelle in meiner Funktion ein direkt bei 
lcd_string?

[Karl H. (kbuchegg)]

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

////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen aufs LCD

void lcd_char( char ps )
{
  switch(ps)
  {
   case 'ä' : ps = 0xE1; break;
   case 'ö' : ps = 0xEF; break;
   case 'ü' : ps = 0xF5; break;
   case 'ß' : ps = 0xE2; break;
   case '°' : ps = 0xDF; break;
   case 'µ' : ps = 0xE4; break;
   case 'Ä' : ps = 0x00; break;  // Point to CG-RAM
   case 'Ö' : ps = 0x01; break; // self defined characters
   case 'Ü' : ps = 0x02; break;
  }
  lcd_data(ps);
}

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

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

void lcd_string(const char *data)
{
  while (*data != '\0')
    lcd_char(*data++);
}

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.

[Karl H. (kbuchegg)]

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

[snayer2311 (Gast)]

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();

[snayer2311 (Gast)]

danke hat funktionier :-)

[snayer2311 (Gast)]

>
> void lcd_char( char ps )
> {
>   switch(ps)
>   {
>    case 'ä' : ps = 0xE1; break;
>
>
kurz zur tabelle ich verstehe gerade nicht wie du
auf den code bei ä auf 0xE1 kamst?
hast du den hexadezimal code zunächst als binär code umgewandelt also 
für ä schreibst du dann 11100001?
und diesen code lieste dann von der tabelle ab?

[Karl H. (kbuchegg)]

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

#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

  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

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

#define LCD_PORT PORTD

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

[snayer2311 (Gast)]

#define  LCD_PORT  PORTC
#define  LCD_DDR  DDRC

#define  LCD_CTRL_PORT    PORTB
#define  LCD_CTRL_DDR    DDRB

habe ich schon definiert :)

[Karl H. (kbuchegg)]

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.

[snayer2311 (Gast)]

achso ah jetzt habe ich verstanden was du meintest jaaa hast recht
stimmt dass ist mir gerade in meinem projekt nicht aufgefallen werde das 
selbstverständlich überarbeiten.


Hoffe mal dann ist alles komplett und das Kapitel lcd-Display und vorab 
endgültig abgeschlossen^^

[snayer2311 (Gast)]

Hier ist mein projekt:)


gerne würde ich wissen ob es auch möglich wenn ich ein langen text in 
der ersten spalte ausgeben möchte dass mir das display auch diesen 
anzeigt:)

[snayer2311 (Gast)]

Nun zeigt meine LCD-Anzeige auch den kompletten Text für einige Sekunden 
wie bei einer Werbung. Jedoch zeigt er nicht alles bis zu einer 
bestimmten Anzahl von Zeichen. Dies liegt an dem Display da dieser nicht 
so viele Zeichen aufnhemen kann wie mans gerne hätte.

lg