Klasse für HD44780 LCDs

[Tim (Gast)]

Hallo, ich versuche gerade, aus diesem 
(http://www.mikrocontroller.net/articles/AVR-Tutorial:_LCD) Tutorial 
eine Klasse für einen ATMEGA88 zu Entwickeln. Mein LCD scheint jedoch 
nicht darauf zu reagieren. Es schreibt nur einen Schwarzen Balken in das 
Feld ganz links und dann sieht man den Cursor im 2ten Feld blinken.

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

#define nop() \
asm volatile ("nop")

LCD_HD44780_4Bit::LCD_HD44780_4Bit (
    volatile uint8_t *Port, // Der Port, an dem das LCD angeschlossen ist
    int DB4, // Der Pin, der mit ... verbunden ist.
    int DB5,
    int DB6,
    int DB7,

    int RS,
    int E,

    Lines ZeilenZahl,
    Pixel PunkteProPixel,
    Scrolling Scrollverhalten,
    Cursor cursor,
    Display display,
    CursorFlashing CursorBlinkverhalten,
    WritingBehavior Schreibverhalten
)
{
    
    this->_Port = Port;
  this->_DB4 = DB4;
  this->_DB5 = DB5;
  this->_DB6 = DB6;
  this->_DB7 = DB7;
    
  this->_RS = RS;
  this->_E = E; 
    
    this->_lines = ZeilenZahl;
    this->_pixel = PunkteProPixel;
    this->_scrolling = Scrollverhalten;
    this->_cursor = cursor;
    this->_display = display;
    this->_cursorFlashing = CursorBlinkverhalten;
    this->_writingBehavior = Schreibverhalten;
   
}
  
void LCD_HD44780_4Bit::init()
{
  
  // LCD-Kontroller Zeit für seine eigene Initialisierung zu geben
  Pause_ms(250);
  // 3 muss zur Initialisierung 3mal hintereinander gesendet werden
  Write4BitToPort(3, 0); // 0b00000011
  // 1
  enable();             
  Pause_ms(5);
  // 2
  enable();                 
  Pause_ms(5);
  // und 3!
     enable();            
  Pause_ms(5);
  // 4bit-Modus einstellen
  Write4BitToPort(2, 0); // 0b00000010
  enable();
  Pause_ms(5);
    
     
  uint8_t Konfiguration = 
        (1<<5) | // Bit gibt die Konfigurations-Art an
        (0<<4) | // 4-Bit Interface
        (this->_lines<<3) | // Wird durch this->_lines = 1- oder 2-Zeilig bestimmt. Der enum wert wird in einen Int-konvertiert (0 oder 1)
        (this->_pixel<<2);  // Wie this->_lines
    this->command(Konfiguration);
        
    
    uint8_t On_Off_control =
        (1<<3) | // Bit gibt die Konfigurations-Art an
        (this->_display<<2) | // Wird durch this->_display = On oder Off bestimmt. Der enum wert wird in einen Int-konvertiert (1 oder 0)
        (this->_cursor<<1) | // Wird durch this->_cursor = On oder Off bestimmt. Der enum wert wird in einen Int-konvertiert (1 oder 0)
        (this->_cursorFlashing<<0);  // Wird durch this->_cursorFlashingy = Yes oder No bestimmt. Der enum wert wird in einen Int-konvertiert (1 oder 0)
  this->command(On_Off_control);
        
      uint8_t Entry_mode = 
        (1<<2) | // Bit gibt die Konfigurations-Art an
        (this->_writingBehavior<<1) | // Wird durch this->_writingBehavior = decrement oder increment bestimmt. Der enum wert wird in einen Int-konvertiert (0 oder 1)
        (this->_scrolling<<0); // Wird durch this->_scrolling = No oder Yes bestimmt. Der enum wert wird in einen Int-konvertiert (0 oder 1)
    this->command(Entry_mode);

  return;
}

uint8_t LCD_HD44780_4Bit::SWAP(uint8_t val)
{
  // Trennen der Bits und setzen der passenden Nibbles auf 0
  uint8_t upper = val & 0xF0; // 0b11110000 -> Oberes Nibble bleibt erhalten
  uint8_t lower = val & 0x0F; // 0b00001111 -> Unteres Nibble bleibt erhalten
    
  // Verschieben der Bits um 4 stellen durch Addition sind die Nibbles dann vertauscht
  upper >>= 4;
  lower <<= 4;
    
  // Rückgben der Summe
  return upper | lower;
}

void LCD_HD44780_4Bit::enable()
{
  // Enable high
  *this->_Port = (1<<this->_E);
  // mindestens 3 Taktzyklen warten
  nop();
  nop();
  nop();
  nop();
  // Enable wieder low
  *this->_Port = (0<<this->_E);
  // Und wieder zurück
  return;
}



void LCD_HD44780_4Bit::Write4BitToPort(uint8_t val, bool RS )
{
  // Filtern der Passenden Bits...
    /* Durch die UND-Verknüpfung zwischen val und dem Bit wird geprüft, ob das jeweilige Bit gesetzt ist. Wenn es
     * gesetzt ist, ist der Wert >= 1. Dieser bool-Wert wird dann auf den Jeweiligen Pin geschoben. */
    uint8_t b1 = (((val & (1 << 0)) >= 1) << this->_DB4); // Normalerweise: 0000|0001
    uint8_t b2 = (((val & (1 << 1)) >= 1) << this->_DB5); // Normalerweise: 0000|0010
    uint8_t b3 = (((val & (1 << 2)) >= 1) << this->_DB6); // Normalerweise: 0000|0100
    uint8_t b4 = (((val & (1 << 3)) >= 1) << this->_DB7); // Normalerweise: 0000|1000
  *this->_Port = (b1 | b2 | b3 | b4 | (RS<<this->_RS));
    
    return;
}

void LCD_HD44780_4Bit::command(uint8_t command)
{
   // wie lcd_data, nur RS=0
     
   // Beide Nibble-Blöcke werden in Zwei Variablen zerlegt
   // Oberes Nibble
   uint8_t upper = SWAP(command);
   // Unteres Nibble
   uint8_t lower = (command);
   // Oberes Nibble übertragen
   Write4BitToPort(upper, 0);
   enable();
   // Unteres Nibble übertragen
   Write4BitToPort(lower, 0);
   enable();
   // Kurze Pause
   Pause_us(50);
   return;
}
  
void LCD_HD44780_4Bit::WriteChar( unsigned char val)
{
    // Trennen der Nibbles
    uint8_t upper = SWAP(val); 
    uint8_t lower = val; 
    
    // Über RS wird ausgewählt, ob man einen Befehl oder ein Datenbyte an das LCD schicken möchte.
    // Beim Schreiben gilt: ist RS Low, dann wird das ankommende Byte als Befehl interpretiert;
    // Ist RS high, wird das Byte auf dem LCD angezeigt (genauer: ins Data-Register geschrieben, kann auch für den CG bestimmt sein).
    
    // Oberes Nibble ausgeben
    Write4BitToPort(upper, 1);
    // Enable, damit das LCD das Datenbyte interpretiert
  enable();          
       
  // Unteres Nibble ausgeben
    Write4BitToPort(lower, 1);
    // Enable, damit das LCD das Datenbyte interpretiert
    enable();
    
    // 50µs warten
    Pause_us(50);
    
  return;
}

void LCD_HD44780_4Bit::Clear()
{
    command(1);
    Pause_ms(5);
    return;
}



void * LCD_HD44780_4Bit::operator new( size_t size )
{
    return malloc(size);
}

void LCD_HD44780_4Bit::operator delete( void * ptr )
{
    free(ptr);
}

void LCD_HD44780_4Bit::Pause_us(double duration)
{
    for (int i = 0; i < duration; i++)
    _delay_us(1);
}
void LCD_HD44780_4Bit::Pause_ms(double duration)
{
    for (int i = 0; i < duration; i++)
    _delay_ms(1);
}

[Tim (Gast)]

DDRD = 0xFF;
    LCD_HD44780_4Bit lcdController(
        &PORTD,
        PIND0,
        PIND1,
        PIND2,
        PIND3,
    
        PIND4,
        PIND5,

        LCD_HD44780_4Bit::Lines_1Line,
        LCD_HD44780_4Bit::Pixel_5x7Pixel,
        LCD_HD44780_4Bit::Scrolling_No,
        LCD_HD44780_4Bit::Cursor_Off,
        LCD_HD44780_4Bit::Display_On,
        LCD_HD44780_4Bit::CursorFlashing_No,
        LCD_HD44780_4Bit::WritingBehavior_increment);
    
    lcdController.init();
    
    lcdController.Clear();
    lcdController.WriteChar(65);
    lcdController.WriteChar(66);
    lcdController.WriteChar(67);
    lcdController.WriteChar(68);

[Klaus W. (mfgkw)]

Das hier hat bei mir schon regelmäßig funktioniert:
Beitrag "Re: LCD Library gesucht für HD44780"

[Peter D. (peda)]

Zwar kein C++, dafür aber sehr einfach und sehr kleiner Code:

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=102296


Peter

[Karl H. (kbuchegg)]

void LCD_HD44780_4Bit::enable()
{
  // Enable high
  *this->_Port = (1<<this->_E);
  // mindestens 3 Taktzyklen warten
  nop();
  nop();
  nop();
  nop();
  // Enable wieder low
  *this->_Port = (0<<this->_E);
  // Und wieder zurück
  return;
}

Du bist ein wenig sehr optimistisch, was Bit setzen und löschen an einem 
Port anbelangt.

> *this->_Port = (1<<this->_E);
Gratuliere: Du hast soeben alle anderen Bits am Port auf 0 gesetzt

>   *this->_Port = (0<<this->_E);
Gratuliere, du hast soeben möglichst kompliziert
   *_Port = 0;
geschrieben.


(Warum das stört? Weil am besagten Port ja auch noch das R/S Signal bzw. 
die Datenbits liegen. Und das wird nicht gut kommen, wenn du die alle 
auf 0 zwingst, nur weil du E toggeln willst)

Bitmanipulation

Das funktioniert in C++ auch nicht anders als in C.


(und spar dir das ewige this. Deine Member Variablen hast du ohnehin 
eindeutig bezeichnet [wenn auch schlecht], so dass du dir das this-> 
sparen kannst.)