/*****************************************************
This program was produced by the
CodeWizardAVR V2.04.9a Evaluation
Automatic Program Generator
© Copyright 1998-2010 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : 
Version : 
Date    : 2/1/2011
Author  : Freeware, for evaluation and non-commercial use only
Company : 
Comments: 


Chip type               : ATmega32
Program type            : Application
AVR Core Clock frequency: 16.000000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 512
*****************************************************/

#include <mega32.h>
#include <delay.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 16000000
#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
 
//  LCD DB4-DB7 <-->  PORTD Bit PD0-PD3
#define LCD_PORT      PORTB
#define LCD_DDR       DDRB
#define LCD_DB        PORTB.4-PORTB.7
 
//  LCD RS      <-->  PORTD Bit PD4     (RS: 0=Data, 1=Command)
#define LCD_RS        PORTB.3

 
//  LCD EN      <-->  PORTD Bit PD5     (EN: 1-Impuls für Daten)
#define LCD_EN_1        PORTB.1
#define LCD_EN_2        PORTA.2
#define LCD_EN_3        PORTA.3
 
////////////////////////////////////////////////////////////////////////////////
// LCD Ausführungszeiten (MS=Millisekunden, US=Mikrosekunden)
 
#define LCD_BOOTUP_MS           15
#define LCD_ENABLE_US           1
#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         0x10
#define LCD_DDADR_LINE4         0x50
 
////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init_1( void );
void lcd_init_2( void );
void lcd_init_3( void );

 
////////////////////////////////////////////////////////////////////////////////
// LCD löschen
void lcd_clear_1( void );
void lcd_clear_2( void );
void lcd_clear_3( void );
 
////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home_1( void );
void lcd_home_2( void );
void lcd_home_3( void );
 
////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position 
void lcd_setcursor_1( int spalte1,  int zeile1 );
void lcd_setcursor_2( int spalte2,  int zeile2 );
void lcd_setcursor_3( int spalte3,  int zeile3 );
 
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition 
void lcd_data_1( int data1 );
void lcd_data_2( int data2 );
void lcd_data_3( int data3 );
 
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition 
void lcd_string_1( const char *data1 );
void lcd_string_2( const char *data2 );
void lcd_string_3( const char *data3 );
 
////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[5] mit den Spaltencodes des zu definierenden Zeichens
// zeigen
void lcd_generatechar_1( int code1, const int *data1 );
void lcd_generatechar_2( int code2, const int *data2 );
void lcd_generatechar_3( int code3, const int *data3 );
 
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command_1( int data1 );
void lcd_command_2( int data2 );
void lcd_command_3( int data3 );
 
 
////////////////////////////////////////////////////////////////////////////////
// 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_5X7        0x00
#define LCD_FUNCTION_5X10       0x04
 
#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 




// Declare your global variables here

void main(void)
{

PORTA=0x00;
DDRA=0x00;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;



TCCR0=0x00;
TCNT0=0x00;
OCR0=0x00;
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;
MCUCR=0x00;
MCUCSR=0x00;
TIMSK=0x00;
ACSR=0x80;
SFIOR=0x00;

   
                    
                    
                    


while (1)
      {  
      
      
      lcd_init_1();
      lcd_clear_1(); 
      delay_ms(50);
      lcd_setcursor_1(1,1); 
      lcd_string_1("test");
        
     
     lcd_init_2(); 
     delay_ms(50);
     lcd_setcursor_2(1,1); 
     lcd_string_2("test");  
     
     lcd_init_3(); 
     
     lcd_string_3("test");
     
     
                               
      

      }
}

// 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
 
 
////////////////////////////////////////////////////////////////////////////////
// Erzeugt einen Enable-Puls
static void lcd_enable_1( void )
{
    LCD_PORT |= (1<<LCD_EN_1);     // Enable auf 1 setzen
    delay_us( LCD_ENABLE_US );  // kurze Pause
    LCD_PORT &= ~(1<<LCD_EN_1);    // Enable auf 0 setzen
}
static void lcd_enable_2( void )
{
    LCD_PORT |= (1<<LCD_EN_2);     // Enable auf 1 setzen
    delay_us( LCD_ENABLE_US );  // kurze Pause
    LCD_PORT &= ~(1<<LCD_EN_2);    // Enable auf 0 setzen
}
 static void lcd_enable_3( void )
{
    LCD_PORT |= (1<<LCD_EN_3);     // Enable auf 1 setzen
    delay_us( LCD_ENABLE_US );  // kurze Pause
    LCD_PORT &= ~(1<<LCD_EN_3);    // Enable auf 0 setzen
}
 
 
////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out_1( int data1 )
{
    data1 &= 0xF0;                       // obere 4 Bit maskieren
 
    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (data1>>(4-LCD_DB));     // Bits setzen
    lcd_enable_1();
}
static void lcd_out_2( int data2 )
{
    data2 &= 0xF0;                       // obere 4 Bit maskieren
 
    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (data2>>(4-LCD_DB));     // Bits setzen
    lcd_enable_2();
}
static void lcd_out_3( int data3 )
{
    data3 &= 0xF0;                       // obere 4 Bit maskieren
 
    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (data3>>(4-LCD_DB));     // Bits setzen
    lcd_enable_3();
}
 
////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init_1( void )
{
    // verwendete Pins auf Ausgang schalten
    int pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
                   (1<<LCD_RS) |                // R/S Leitung
                   (1<<LCD_EN_1);                 // 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_1( LCD_SOFT_RESET );
    delay_ms( LCD_SOFT_RESET_MS1 );
 
    lcd_enable_1();
    delay_ms( LCD_SOFT_RESET_MS2 );
 
    lcd_enable_1();
    delay_ms( LCD_SOFT_RESET_MS3 );
 
    // 4-bit Modus aktivieren 
    lcd_out_1( LCD_SET_FUNCTION |
             LCD_FUNCTION_4BIT );
    delay_ms( LCD_SET_4BITMODE_MS );
 
    // 4-bit Modus / 2 Zeilen / 5x7
    lcd_command_1( LCD_SET_FUNCTION |
                 LCD_FUNCTION_4BIT |
                 LCD_FUNCTION_2LINE |
                 LCD_FUNCTION_5X7 );
 
    // Display ein / Cursor aus / Blinken aus
    lcd_command_1( LCD_SET_DISPLAY |
                 LCD_DISPLAY_ON |
                 LCD_CURSOR_OFF |
                 LCD_BLINKING_OFF); 
 
    // Cursor inkrement / kein Scrollen
    lcd_command_1( LCD_SET_ENTRY |
                 LCD_ENTRY_INCREASE |
                 LCD_ENTRY_NOSHIFT );
 
    lcd_clear_1();
}
void lcd_init_2( void )
{
    // verwendete Pins auf Ausgang schalten
    int pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
                   (1<<LCD_RS) |                // R/S Leitung
                   (1<<LCD_EN_2);                 // 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_2( LCD_SOFT_RESET );
    delay_ms( LCD_SOFT_RESET_MS1 );
 
    lcd_enable_2();
    delay_ms( LCD_SOFT_RESET_MS2 );
 
    lcd_enable_2();
    delay_ms( LCD_SOFT_RESET_MS3 );
 
    // 4-bit Modus aktivieren 
    lcd_out_2( LCD_SET_FUNCTION |
             LCD_FUNCTION_4BIT );
    delay_ms( LCD_SET_4BITMODE_MS );
 
    // 4-bit Modus / 2 Zeilen / 5x7
    lcd_command_2( LCD_SET_FUNCTION |
                 LCD_FUNCTION_4BIT |
                 LCD_FUNCTION_2LINE |
                 LCD_FUNCTION_5X7 );
 
    // Display ein / Cursor aus / Blinken aus
    lcd_command_2( LCD_SET_DISPLAY |
                 LCD_DISPLAY_ON |
                 LCD_CURSOR_OFF |
                 LCD_BLINKING_OFF); 
 
    // Cursor inkrement / kein Scrollen
    lcd_command_2( LCD_SET_ENTRY |
                 LCD_ENTRY_INCREASE |
                 LCD_ENTRY_NOSHIFT );
 
    lcd_clear_2();
}
void lcd_init_3( void )
{
    // verwendete Pins auf Ausgang schalten
    int pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
                   (1<<LCD_RS) |                // R/S Leitung
                   (1<<LCD_EN_3);                 // 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_3( LCD_SOFT_RESET );
    delay_ms( LCD_SOFT_RESET_MS1 );
 
    lcd_enable_3();
    delay_ms( LCD_SOFT_RESET_MS2 );
 
    lcd_enable_3();
    delay_ms( LCD_SOFT_RESET_MS3 );
 
    // 4-bit Modus aktivieren 
    lcd_out_3( LCD_SET_FUNCTION |
             LCD_FUNCTION_4BIT );
    delay_ms( LCD_SET_4BITMODE_MS );
 
    // 4-bit Modus / 2 Zeilen / 5x7
    lcd_command_3( LCD_SET_FUNCTION |
                 LCD_FUNCTION_4BIT |
                 LCD_FUNCTION_2LINE |
                 LCD_FUNCTION_5X7 );
 
    // Display ein / Cursor aus / Blinken aus
    lcd_command_3( LCD_SET_DISPLAY |
                 LCD_DISPLAY_ON |
                 LCD_CURSOR_OFF |
                 LCD_BLINKING_OFF); 
 
    // Cursor inkrement / kein Scrollen
    lcd_command_3( LCD_SET_ENTRY |
                 LCD_ENTRY_INCREASE |
                 LCD_ENTRY_NOSHIFT );
 
    lcd_clear_3();
}
  
  
////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data_1( int data1 )
{
    LCD_PORT |= (1<<LCD_RS);    // RS auf 1 setzen
 
    lcd_out_1( data1 );            // zuerst die oberen, 
    lcd_out_1( data1<<4 );         // dann die unteren 4 Bit senden
 
    delay_us( LCD_WRITEDATA_US );
}
void lcd_data_2( int data2 )
{
    LCD_PORT |= (1<<LCD_RS);    // RS auf 1 setzen
 
    lcd_out_2( data2 );            // zuerst die oberen, 
    lcd_out_2( data2<<4 );         // dann die unteren 4 Bit senden
 
    delay_us( LCD_WRITEDATA_US );
}
void lcd_data_3( int data3 )
{
    LCD_PORT |= (1<<LCD_RS);    // RS auf 1 setzen
 
    lcd_out_3( data3 );            // zuerst die oberen, 
    lcd_out_3( data3<<4 );         // dann die unteren 4 Bit senden
 
    delay_us( LCD_WRITEDATA_US );
}
 
////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command_1( int data1 )
{
    LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen
 
    lcd_out_1( data1 );             // zuerst die oberen, 
    lcd_out_1( data1<<4 );           // dann die unteren 4 Bit senden
 
    delay_us( LCD_COMMAND_US );
}
void lcd_command_2( int data2 )
{
    LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen
 
    lcd_out_2( data2 );             // zuerst die oberen, 
    lcd_out_2( data2<<4 );           // dann die unteren 4 Bit senden
 
    delay_us( LCD_COMMAND_US );
}
void lcd_command_3( int data3 )
{
    LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen
 
    lcd_out_3( data3 );             // zuerst die oberen, 
    lcd_out_3( data3<<4 );           // dann die unteren 4 Bit senden
 
    delay_us( LCD_COMMAND_US );
}
 
////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear_1( void )
{
    lcd_command_1( LCD_CLEAR_DISPLAY );
    delay_ms( LCD_CLEAR_DISPLAY_MS );
}
void lcd_clear_2( void )
{
    lcd_command_2( LCD_CLEAR_DISPLAY );
    delay_ms( LCD_CLEAR_DISPLAY_MS );
}
void lcd_clear_3( void )
{
    lcd_command_3( LCD_CLEAR_DISPLAY );
    delay_ms( LCD_CLEAR_DISPLAY_MS );
}
 
////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home_1( void )
{
    lcd_command_1( LCD_CURSOR_HOME );
    delay_ms( LCD_CURSOR_HOME_MS );
}
void lcd_home_2( void )
{
    lcd_command_2( LCD_CURSOR_HOME );
    delay_ms( LCD_CURSOR_HOME_MS );
}
void lcd_home_3( void )
{
    lcd_command_3( LCD_CURSOR_HOME );
    delay_ms( LCD_CURSOR_HOME_MS );
}
 
////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4) 
 
void lcd_setcursor_1( int spalte1, int zeile1 )
{
    int data1;
 
    switch (zeile1)
    {
        case 1:    // 1. Zeile
            data1 = LCD_SET_DDADR + LCD_DDADR_LINE1 + spalte1;
            break;
 
        case 2:    // 2. Zeile
            data1 = LCD_SET_DDADR + LCD_DDADR_LINE2 + spalte1;
            break;
 
        case 3:    // 3. Zeile
            data1 = LCD_SET_DDADR + LCD_DDADR_LINE3 + spalte1;
            break;
 
        case 4:    // 4. Zeile
            data1 = LCD_SET_DDADR + LCD_DDADR_LINE4 + spalte1;
            break;
 
        default:
            return;                                   // für den Fall einer falschen Zeile
    }
 
    lcd_command_1( data1 );
}
void lcd_setcursor_2( int spalte2, int zeile2 )
{
    int data2;
 
    switch (zeile2)
    {
        case 1:    // 1. Zeile
            data2 = LCD_SET_DDADR + LCD_DDADR_LINE1 + spalte2;
            break;
 
        case 2:    // 2. Zeile
            data2 = LCD_SET_DDADR + LCD_DDADR_LINE2 + spalte2;
            break;
 
        case 3:    // 3. Zeile
            data2 = LCD_SET_DDADR + LCD_DDADR_LINE3 + spalte2;
            break;
 
        case 4:    // 4. Zeile
            data2 = LCD_SET_DDADR + LCD_DDADR_LINE4 + spalte2;
            break;
 
        default:
            return;                                   // für den Fall einer falschen Zeile
    }
 
    lcd_command_2( data2 );
}
void lcd_setcursor_3( int spalte3, int zeile3 )
{
    int data3;
 
    switch (zeile3)
    {
        case 1:    // 1. Zeile
            data3 = LCD_SET_DDADR + LCD_DDADR_LINE1 + spalte3;
            break;
 
        case 2:    // 2. Zeile
            data3 = LCD_SET_DDADR + LCD_DDADR_LINE2 + spalte3;
            break;
 
        case 3:    // 3. Zeile
            data3 = LCD_SET_DDADR + LCD_DDADR_LINE3 + spalte3;
            break;
 
        case 4:    // 4. Zeile
            data3 = LCD_SET_DDADR + LCD_DDADR_LINE4 + spalte3;
            break;
 
        default:
            return;                                   // für den Fall einer falschen Zeile
    }
 
    lcd_command_3( data3 );
}
 
////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD
 
void lcd_string_1( const char *data1 )
{
    while( *data1 != '\0' )
        lcd_data_1( *data1++ );
}
void lcd_string_2( const char *data2 )
{
    while( *data2 != '\0' )
        lcd_data_2( *data2++ );
}
 
void lcd_string_3( const char *data3 )
{
    while( *data3 != '\0' )
        lcd_data_3( *data3++ );
}
 
 
////////////////////////////////////////////////////////////////////////////////
// Schreibt ein Zeichen in den Character Generator RAM
 
void lcd_generatechar_1( int code1, const int *data1 )
{    int i;
    // Startposition des Zeichens einstellen
    lcd_command_1( LCD_SET_CGADR | (code1<<3) );
 
    // Bitmuster übertragen
    for ( i=0; i<8; i++ )
    {
        lcd_data_1( data1[i] );
    }
}
void lcd_generatechar_2( int code2, const int *data2 )
{    int i;
    // Startposition des Zeichens einstellen
    lcd_command_2( LCD_SET_CGADR | (code2<<3) );
 
    // Bitmuster übertragen
    for ( i=0; i<8; i++ )
    {
        lcd_data_2( data2[i] );
    }
}
void lcd_generatechar_3( int code3, const int *data3 )
{    int i;
    // Startposition des Zeichens einstellen
    lcd_command_3( LCD_SET_CGADR | (code3<<3) );
 
    // Bitmuster übertragen
    for ( i=0; i<8; i++ )
    {
        lcd_data_3( data3[i] );
    }
}