LCD ansteuerung mit einem ATMega16 und I2C

[arget (Gast)]

Hallo,
Ich habe hier auf mikrocontroller.net die Beschreibung zur ansteuerung 
für LCD Bildschirme gelesen und möchte nun einen solchen mithilfe eines 
MCP23017 (I2C GPIO erweiterung) ansteuern. Hierfür habe ich die Library 
die hich hier gefunden habe verwendet und sie erweitert. Jedoch scheine 
ich bereits beim initialiesieren einen Fehler zu haben da nur schwarze 
Balken angezeigt werden. Die Schaltung ist als Anhang zu finden, ich 
verwende das Panelolu2 von meinem 3D Drucker! Zum Display selber kann 
ich sagen das er funktioniert, da er mit dem Arduino und der 
dazugehörigen Software für den 3D Drucker ohne Probleme funktioniert.

Da es anscheinend nur möglich ist Bilder als Anhang zu posten ist hier 
der Code den ich zum ansprechen des Displays verwende.

lcd-routines.h

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//

#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H

////////////////////////////////////////////////////////////////////////////////
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!

#ifndef F_CPU
#define F_CPU 15000000UL
#endif

////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// Alle LCD Pins müssen an einem Port angeschlossen sein und die 4
// Datenleitungen müssen auf aufeinanderfolgenden Pins liegen

//Adresse des Slave Devices MCP23017
//Die ersten 4 Bit sind laut Datenblatt definiert(0100)
//Die letzten 3 Bit werden über die Pins A0-A2 definiert
#define  SLAVE 0b0100000

//  LCD DB4-DB7 <-->  PORTB an MCP23017 Bit GPB1-GPB4
#define LCD_PORT      0x13 //GPIOB Register Addresse des MCP23017
#define LCD_DDR       0x01 // IODIRB Register addresse des MCP23017
#define LCD_DB        1 // GPB1 

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

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

////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)

#define LCD_BOOTUP_MS           15
#define LCD_ENABLE_US           20
#define LCD_WRITEDATA_US        46
#define LCD_COMMAND_US          42

#define LCD_SOFT_RESET_MS1      5
#define LCD_SOFT_RESET_MS2      1
#define LCD_SOFT_RESET_MS3      1
#define LCD_SET_4BITMODE_MS     5

#define LCD_CLEAR_DISPLAY_MS    2
#define LCD_CURSOR_HOME_MS      2

////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// Die Einträge hier sollten für ein LCD mit einer Zeilenlänge von 16 Zeichen passen
// Bei anderen Zeilenlängen müssen diese Einträge angepasst werden

#define LCD_DDADR_LINE1         0x00
#define LCD_DDADR_LINE2         0x40
#define LCD_DDADR_LINE3         0x14
#define LCD_DDADR_LINE4         0x54

uint_fast8_t _data;
uint_fast8_t _ddr;
uint_fast8_t _port;
static const unsigned char BitReverseTable16[] =
{
  0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F
};
////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void );

////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home( void );

////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t spalte, uint8_t zeile );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
void lcd_string( const char *data );

////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[8] mit den Zeilencodes des zu definierenden Zeichens
// zeigen
void lcd_generatechar( uint8_t code, const uint8_t *data );

////////////////////////////////////////////////////////////////////////////////
//Schreiben eines Registers des MCP23017
void writeOut(uint8_t reg, uint_fast8_t value);

////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );





////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// Zur Verwendung in lcd_command

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

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

// Set Display ---------------- 0b00001xxx
#define LCD_SET_DISPLAY         0x08

#define LCD_DISPLAY_OFF         0x00
#define LCD_DISPLAY_ON          0x04
#define LCD_CURSOR_OFF          0x00
#define LCD_CURSOR_ON           0x02
#define LCD_BLINKING_OFF        0x00
#define LCD_BLINKING_ON         0x01

// Set Shift ------------------ 0b0001xxxx
#define LCD_SET_SHIFT           0x10

#define LCD_CURSOR_MOVE         0x00
#define LCD_DISPLAY_SHIFT       0x08
#define LCD_SHIFT_LEFT          0x00
#define LCD_SHIFT_RIGHT         0x04

// Set Function --------------- 0b001xxxxx
#define LCD_SET_FUNCTION        0x20

#define LCD_FUNCTION_4BIT       0x00
#define LCD_FUNCTION_8BIT       0x10
#define LCD_FUNCTION_1LINE      0x00
#define LCD_FUNCTION_2LINE      0x08
#define LCD_FUNCTION_5x8    0x04
#define LCD_FUNCTION_5x11    0x00

#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

#endif

lcd-routines.c

// 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-routines.h"
#include "TWI_Master.h"
#include <util/delay.h>

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

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
  data &= 0xF0;
  data = data >> 4;
  data = BitReverseTable16[data];
     data = data << 4; 
  
  _data &= ~(0xF0 >> (4-LCD_DB));
  writeOut(LCD_PORT, _data);
  
  _data |= (data>>(4-LCD_DB));
  writeOut(LCD_PORT, _data);
  
  lcd_enable();
}

////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init( void )
{
  _data = 0x01; // 0b00000001 schaltet LED des Panelolu 2 aus
  
  _ddr = 0b00000000;
  _port = 0x00;
  
  writeOut(LCD_DDR, _ddr);//Alle benötigten Pins als Ausgang definieren
  
  writeOut(LCD_PORT, _port);//Alle Ausgänge auf 0 setzen
  
  // warten auf die Bereitschaft des LCD
  _delay_ms( LCD_BOOTUP_MS );  
  
  // Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
  _data = LCD_SOFT_RESET;
  lcd_out( _data );
  _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
  _data = (LCD_SET_FUNCTION |  LCD_FUNCTION_4BIT);
  lcd_out( _data );
  _delay_ms( LCD_SET_4BITMODE_MS );
  
  // 4-bit Modus / 2 Zeilen / 5x7
  _data = (LCD_SET_FUNCTION |  LCD_FUNCTION_4BIT |  LCD_FUNCTION_2LINE |LCD_FUNCTION_5x8);
  lcd_command( _data);
  
  // Display ein / Cursor aus / Blinken aus
  _data = (LCD_SET_DISPLAY |LCD_DISPLAY_ON |LCD_CURSOR_OFF |LCD_BLINKING_OFF);
  lcd_command( _data );
  
  // Cursor inkrement / kein Scrollen
  _data = ( LCD_SET_ENTRY |LCD_ENTRY_INCREASE |LCD_ENTRY_NOSHIFT);
  lcd_command(_data);
  
  lcd_clear();  
}

////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
  _port |= (1<<LCD_RS);
  
  writeOut(LCD_PORT, _port);
  
  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 )
{
  _port &= ~(1<<LCD_RS);
  writeOut(LCD_PORT, _port);
  
  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] );
}
}

void writeOut(uint8_t reg, uint_fast8_t value)
{  
  if(!TWIM_Start(SLAVE, TWIM_WRITE))
  {
    TWIM_Stop();
  }
  else
  {
    TWIM_Write(reg);
    TWIM_Write(value);
    TWIM_Stop();
  }
}

Hoffentlich kann mir jemand helfen!
mit freundlichen Grüßen
Markus

[Schlaumeier (Gast)]

Man kann auch C-Dateien anhängen. Hat den Vorteil, dass es eine echte 
Codeansicht gibt.

[Schlaumeier (Gast)]

und ... (geht auch beides gleichzeitig)

[arget (Gast)]

Danke, hat bei mir nicht funktioniert, habe immer die Meldung bekommen 
das es eine PNG oder JPG datei sein muss :/

[Mitlesa (Gast)]

arget schrieb:
> habe immer die Meldung bekommen
> das es eine PNG oder JPG datei sein muss

Von einer Einschränkung des Uploads auf Grafik-Dateien ist nicht die 
Rede.

Auch ist es immer hilfreich sich den Hinweistext durchzulesen
und zu verstehen

----------------------------------------------
Formatierung (mehr Informationen...)

[c]C-Code[/c]
[avrasm]AVR-Assembler-Code[/avrasm]
[code]Code in anderen Sprachen, ASCII-Zeichnungen
[math]Formel in LaTeX-Syntax[/math]
[[Titel]] - Link zu Artikel

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

[Forist (Gast)]

arget schrieb:
> Danke, hat bei mir nicht funktioniert, habe immer die Meldung bekommen
> das es eine PNG oder JPG datei sein muss :/

Dann lies den Text mal genau.

[Schlaumeier (Gast)]

arget schrieb:
> Jedoch scheine
> ich bereits beim initialiesieren einen Fehler zu haben da nur schwarze
> Balken angezeigt werden.

Am Kontrastregler hast Du mal gedreht?

[arget (Gast)]

Ja habe ich. Am Kontrast liegt es nicht, ich habe versucht verschiedene 
Sachen auszugeben und dann denn Kontrast neu einzustellen aber das hat 
auch nichts gebracht

[Schlaumeier (Gast)]

Ich bin kein Programmierprofi, aber bei der Pinzuordnung stimmt was 
nicht. E und RS liegen lt. Schaltplan auch auf PortB des MCP23017.

//  LCD DB4-DB7 <-->  PORTB an MCP23017 Bit GPB1-GPB4
#define LCD_PORT      0x13 //GPIOB Register Addresse des MCP23017
#define LCD_DDR       0x01 // IODIRB Register addresse des MCP23017
#define LCD_DB        1 // GPB1 

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

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

[Schlaumeier (Gast)]

Ah, ok, da ist nur der Kommentar falsch

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

[arget (Gast)]

Schlaumeier schrieb:
> Ich bin kein Programmierprofi, aber bei der Pinzuordnung stimmt
> was
> nicht. E und RS liegen lt. Schaltplan auch auf PortB des MCP23017.
> //  LCD DB4-DB7 <-->  PORTB an MCP23017 Bit GPB1-GPB4
> #define LCD_PORT      0x13 //GPIOB Register Addresse des MCP23017
> #define LCD_DDR       0x01 // IODIRB Register addresse des MCP23017
> #define LCD_DB        1 // GPB1
>
> //  LCD RS      <-->  PORTD Bit PD4     (RS: 1=Data, 0=Command)
> #define LCD_RS        7
>
> //  LCD EN      <-->  PORTD Bit PD5     (EN: 1-Impuls für Daten)
> #define LCD_EN        5

Ja das stimmt, die Kommentaren sind noch vom Originalfile, RS liegt am 
Pin 7 des PORTB and und EN an Pin 5 des PORTB. Demnach sollten die 
definitionen stimmen

[Schlaumeier (Gast)]

Taktfrequenz 15 MHz stimmt?

[arget (Gast)]

Ja ich verwende für den Mega16 einen externen 15MHz Quarz

[Schlaumeier (Gast)]

Zeig mal bitte Dein vollständiges Test-Programm, denn das sehen wir 
bisher noch nicht.

[arget (Gast)]

Hier bitte

[Schlaumeier (Gast)]

lcd_clear nach lcd_init ist überflüssig, weil lcd_init das mitmacht, 
aber das ist nicht das Problem.

lcd_init();
lcd_clear();

Kannst Du mit Oszi, Logikanalysator oder ähnlichem nachgucken, ob auf 
dem TWI/i2c was passiert?

Ich kenne den MCP23017 nicht. Stimmt die Adresse und die Ansprache gemäß 
Beschaltung und Datenblatt?

Kannst Du ein kleines Testprogramm schreiben, das nur die LED auf PortB 
des MCP23017 blinken läßt? Dann könnte man sicherstellen, dass i2c 
funktioniert.

[arget (Gast)]

Also die Kommunikation funktioniert, die LED am PORT B0 kann ich blinken 
lassen!

[Schlaumeier (Gast)]

Beschaltung geprüft? Fuses stimmen auch?

Dann bin ich mit meinem Latein am Ende. Vielleicht sieht jemand anders 
mehr.

[Schlaumeier (Gast)]

Schlaumeier schrieb:
> Beschaltung geprüft?

Quatsch, ist ja eine fertige Platine ...

[arget (Gast)]

Ja die Fuses stimmen auch, habe jz einen Fehler gefunden, ich muss bei 
lcd_out() die gedrehten Bits auch schreiben, dass habe ich nicht getan 
die funktion muss wie folgt aussehen:

static void lcd_out( uint8_t data )
{
  data &= 0xF0;
  data = data >> 4;
  data = BitReverseTable16[data];
     _data = data << 4; 
  
  _data &= ~(0xF0 >> (4-LCD_DB));
  _data |= (0b00000001);
  writeOut(LCD_PORT, _data);
  
  _data |= (data>>(4-LCD_DB));
  _data |= (0b00000001);
  writeOut(LCD_PORT, _data);
  
  lcd_enable();
}

Jetz wird mir etwas angezeigt, jedoch nur sehr komische zeichen!

[holger (Gast)]

Versuch das mal so:

////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
  data = data >> 4;
  data = BitReverseTable16[data];
     _data = data << 4; 
  
  _data = (_data>>(4-LCD_DB));
  _data |= (0b00000001);
  writeOut(LCD_PORT, _data);
  
  lcd_enable();
}

[arget (Gast)]

holger schrieb:
> Versuch das mal so:
> //////////////////////////////////////////////////////////////////////// 
////////
> // Sendet eine 4-bit Ausgabeoperation an das LCD
> static void lcd_out( uint8_t data )
> {
>   data = data >> 4;
>   data = BitReverseTable16[data];
>      _data = data << 4;
>
>   _data = (_data>>(4-LCD_DB));
>   _data |= (0b00000001);
>   writeOut(LCD_PORT, _data);
>
>   lcd_enable();
> }

Mit dem Code scheint die Initialisierung zwar zu funktionieren, jedoch 
bekomme ich nichts angezeigt

[arget (Gast)]

Ok der Code zeigt mir doch etwas an aber nur die selben komischen 
Symbole wie vorher

[Schlaumeier (Gast)]

arget schrieb:
> Ok der Code zeigt mir doch etwas an aber nur die selben komischen
> Symbole wie vorher

Zuordnung der Datenbits überprüfen ...

[arget (Gast)]

Schlaumeier schrieb:
> arget schrieb:
>> Ok der Code zeigt mir doch etwas an aber nur die selben komischen
>> Symbole wie vorher
>
> Zuordnung der Datenbits überprüfen ...

Wie kann ich die überprüfen ohne Logicanalyzer?

[Schlaumeier (Gast)]

Wirre Zeichen sind bei normalem Anschluss (also ohne i2c) meist ein 
Indiz für Vertauschung der Datenleitungen o. ä., deswegen war das mein 
erster Impuls.

Ist die Reihenfolge Highnibble, lownibble so, wie es das LCD erwartet? 
Ich hab jetzt nicht geguckt, wie Du das machst.

[holger (Gast)]

>Ok der Code zeigt mir doch etwas an aber nur die selben komischen
>Symbole wie vorher

Dss liegt daran das dir z.B. RS kaputt gemacht wird.
Du musst bei jedem  writeOut(LCD_PORT, _data);
darauf achten das alle Bits in _data gültig sind.
Also auch RS, E, RW.

[arget (Gast)]

holger schrieb:
>>Ok der Code zeigt mir doch etwas an aber nur die selben komischen
>>Symbole wie vorher
>
> Dss liegt daran das dir z.B. RS kaputt gemacht wird.
> Du musst bei jedem  writeOut(LCD_PORT, _data);
> darauf achten das alle Bits in _data gültig sind.
> Also auch RS, E, RW.

Soll heißen, RS, E und RW müssen 0 sein?

[holger (Gast)]

>Soll heißen, RS, E und RW müssen 0 sein?

Die müssen so stehen wie sie stehen müssen.
void lcd_out( uint8_t data ) berücksichtigt den Zustand
von RS nicht. Es ist immer 0 und deshalb kannst du
keine Zeichen schreiben.

Du kannst immer nur alle 8 Bits gleichzeitig schreiben.
Daran musst du denken wenn du den Port beschreibst.
Also sieh zu das auch die Steuerleitungen in lcd_out()
richtig gesetzt bleiben.

[arget (Gast)]

Ok ich verstehe auf was du hinauswillst, ich habe jetzt die Funktion so 
umgeschrieben das wirklich nur die 4 Datenbits umgeschrieben werden die 
ich benötige und die restlichen Bits unbeeinflusst von dem 
schreibvorgang selbst sind. Die Funktion sieht jz so aus:

static void lcd_out( uint8_t data )
{
  data &= 0xF0;
  data = data >> 4;
  data = (BitReverseTable16[(data>>4)] << 4);
  
  _data &= ~(0xF0 >> (4-LCD_DB));
  writeOut(LCD_PORT, _data);
  
  _data |= (data>>(4-LCD_DB));
  writeOut(LCD_PORT, _data);
  
  lcd_enable();
}

Nun sollten die Bits passen da RS und E je nachdem wo die Funktion 
aufgerufen wird vorher oder nachher gesetzt/gelöscht werden.

Die ausgabe hat sich nicht geändert obwohl sie die richtigen Bits 
eigentlich jz nur verändern sollte

[holger (Gast)]

>Nun sollten die Bits passen da RS und E je nachdem wo die Funktion
>aufgerufen wird vorher oder nachher gesetzt/gelöscht werden.

Ja, die alte Routine hatte doch Sinn.
Dummerweise setzt du RS in _port und nicht in _data;)

[arget (Gast)]

holger schrieb:
>>Nun sollten die Bits passen da RS und E je nachdem wo die
> Funktion
>>aufgerufen wird vorher oder nachher gesetzt/gelöscht werden.
>
> Ja, die alte Routine hatte doch Sinn.
> Dummerweise setzt du RS in _port und nicht in _data;)

ja das habe ich auch schon gesehen, die Variable _port gibt es nicht 
mehr ich habe sie entfernt und alles durch _data ersetzt, somit habe ich 
den Zustand des Registers immer in der Variable _data drinnen

[arget (Gast)]

Danke an alle die mir geholfen haben, habe den Fehler nun gefunden. Ich 
habe in der Funktion lcd_out zweimal das Byte um 4 Bit nach links 
verschoben somit wurde das ganze byte gelöscht, nun funktioniert es! 
Falls jemand an den Dateien interessiert sein sollte, findet ihr diese 
im Anhang