Simulation des 4-Bit Modus beim HD44780

[Christian S. (chrisstra84)]

Hallo Zusammen,

ich habe hier mal ein Programm geschrieben, welches Simuliert, wie ein 
Zeichen im 4-Bit Modus an mein HD44780 kompatibles LCD (EA W204B-NLW) 
von Electronic Assembly übertragen wird. Zur Hilfe habe ich hier die 
Routine von der Seite genommen 
(http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung).
Ich habe halt versucht zu verstehen, wie der Kontroller angesteuert 
wird. Betrachtet habe ich hierbei erst mal nur die Datenübertragung an 
sich.

Mit der Funktion „lcd_data()“ wird hier ein Datenwert (253) an den 
Kontroller geschickt. Dies passiert wie folgt. Zuerst wird das gesamte 
Byte an die Funktion „lcd_out()“ geschickt. Dabei werden die oberen Bits 
mit 1111 und die unteren mit 0000 maskiert. So das mit „data &= 0xF0“ 
dafür gesorgt wird, dass nur noch die Daten an sich (4 oben Bits) 
vorhanden sind. Dann wird in der eigentlichen Funktion mit „Port &= 
~(0xF0>>(4-0))“ dafür gesorgt, dass erst mal die Pins am Port, welche 
zur Übertragung genutzt werden auf 0000 gesetzt werden. Dann wird mit 
„LCD_PORT |= (data>>(4-LCD_DB)“ dafür gesorgt, dass nur noch die 4 
Bit-Daten an die Pins gelegt werden. Der restliche Port bleibt also wie 
es ist.

Dann kommen auf die gleiche Weise die restlichen 4-Bits (unteren) 
hinterher. Nur wurde vorher mit einem linksshift (data<<4) dafür 
gesorgt, dass die untern 4-Bits jetzt an der Position der 4 oberen Bits 
liegen und auf gleiche Art und Weise wie die eigentlichen oberen Bits 
übertragen werden.

Wenn ich also von dem Zeichen 253 ausgehe (0b11111101), dann wird zuerst 
die obere Hälfte (1111) und dann die untere Hälfte (1101) übertragen. So 
das im gesamten Ergebnis die 253 (11111101) übertragen wurde. Man sieht 
auch, dass zu jedem Zeitpunkt (T1 & T2) die 4 anderen (hier oberen) Pins 
vom Port unverändert bleiben.

Ich hoffe ich habe es so richtig verstanden.

Gruß
Christian

/*
 * LCD.c
 *
 * Created: 06.09.2014 17:45:44
 *  Author: Christian
 */ 

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

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

// Es wird das Zeichen 253 übertragen

//Virtuelle Port (mit dem Zustand 0b10010000)
static uint8_t Port =  0b10010000;


// Sendet ein Datenbyte an das LCD (lcd_out( uint8_t data ))

  static uint8_t test(uint8_t daten)
  {    
    //obere 4 Bit maskieren
    daten &= 0xF0;
    
    //Maske löschen
    Port &= ~(0xF0>>(4-0));
    //Bits setzen
    Port |= (daten>>(4-0));    
    return(Port);    
  };


//Simulation lcd_data( uint8_t data )
int main(void)
{
   
  lcd_init(); 
  
  

  uint8_t test_daten = 0b11111101;  
  uint8_t gesamt = 0;  
  uint8_t test_Port = 0;
    char buffer[33];
    
  
  // Oberen 4 Bits  
  //Ablauf in der Funktion (hier nur für Hilfszwecke)
  uint8_t D1 = test_daten;
  D1 &= 0xF0;
  D1 = (D1>>(4-0));  
  
  //obern Bits an Funktion
  test_Port = test( test_daten );   
  gesamt |= (test_Port<<4);  
  
  //Zeitpunkt 1 am Port
  lcd_setcursor(0, 1);
  lcd_string("T1:");         
  
  lcd_setcursor(5, 1);
  itoa(test_Port,buffer,2);
  lcd_string(buffer);
  
  //Übertragende Bits
  lcd_setcursor(14, 1);
  itoa(D1,buffer,2);
  lcd_string(buffer);
  
  //Unteren 4 Bits  
  //Ablauf in der Funktion (hier nur für Hilfszwecke)
  uint8_t D2 = test_daten;
  D2 = ( D2<<4 );
  D2 &= 0xF0;
  D2 = (D2>>(4-0));  
    
  //unteren Bits an Funktion
  test_Port = test( test_daten<<4 ); 
  gesamt |= (test_Port);
  
  //Zeitpunkt 2 am Port
  lcd_setcursor(0, 2);
  lcd_string("T2:");
          
  lcd_setcursor(5, 2);  
  itoa(test_Port,buffer,2);
  lcd_string(buffer);
  
  //Übertragende Bits
  lcd_setcursor(14, 2);
  itoa(D2,buffer,2);
  lcd_string(buffer);
   
  
    lcd_setcursor(0, 3);    
  lcd_string("-------------");
  
  
  //Gesamt übertragende Daten an HD44780
  lcd_setcursor(0, 4); 
  lcd_string("Data:");
  
  
  lcd_setcursor(5, 4);
  itoa(gesamt,buffer,2);
  lcd_string(buffer);
  
  lcd_setcursor(14, 4);
  itoa(gesamt,buffer,10);
  lcd_string(buffer);
  
  lcd_setcursor(18, 4);
  lcd_data(gesamt);
  
  
  
  return 0;
}

[Karl H. (kbuchegg)]

Na ja. Von einer 'Simulation' bist du noch weit entfernt.
Dein Programm zeigt eigentlich nur an, wie ein 8 Bit Wert in 2 4 Bit 
Teile zerlegt wird. Das ist zwar ein integraler Teil, der 
notwendigerweise bei der Kommunikation mit einem HD44780 im 4 Bit Modus 
anfällt, aber es ist nur ein kleiner Teil davon. Da fehlt zb noch das 
ganze Geklimpere mit den Steuerleitungen, denn die Übertragung ist ja 
nicht einfach nach dem Muster: erst leg ich die ersten 4 Bit an, dann 
leg ich die 2.ten 4 Bit an und schwupdiwupp ist das Byte im 
LCD-Controller.

Wenn dir da was unklar ist, dann frag bitte im Forum. Aber zu einem 
Eintrag in der Codesammlung reicht das gezeigte meiner Meinung nach 
nicht wirklich.