// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
void lcd_data(unsigned char temp1);
void lcd_string(char *data);
void lcd_running_string(char *data,int zeile);
void lcd_command(unsigned char temp1);
void lcd_enable(void);
void lcd_init(void);
void lcd_home(void);
void lcd_clear(void);
void set_cursor(uint8_t x, uint8_t y);

 
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!
 
#define F_CPU 8000000
 
// LCD Befehle
 
#define CLEAR_DISPLAY 0x01
#define CURSOR_HOME   0x02
 
// Pinbelegung für das LCD, an verwendete Pins anpassen
 
#define LCD_PORT      PORTC
#define LCD_DDR       DDRC
#define LCD_RS        PC4
#define LCD_EN        PC5
// DB4 bis DB7 des LCD sind mit PC0 bis PC3 des AVR verbunden 






// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar
 
#include <avr/io.h>
#include <string.h>
#include "lcd-routines.h"
#include <util/delay.h>
 
// sendet ein Datenbyte an das LCD

void lcd_data(unsigned char temp1)
{
   unsigned char temp2 = temp1;
 
   LCD_PORT |= (1<<LCD_RS);        // RS auf 1 setzen
 
   temp1 = temp1 >> 4;
   temp1 = temp1 & 0x0F;
   LCD_PORT &= 0xF0;
   LCD_PORT |= temp1;               // setzen
   lcd_enable();
 
   temp2 = temp2 & 0x0F;
   LCD_PORT &= 0xF0;
   LCD_PORT |= temp2;               // setzen
   lcd_enable();
   
   _delay_us(42);
}
 
// sendet einen Befehl an das LCD
 
void lcd_command(unsigned char temp1)
{
   unsigned char temp2 = temp1;
 
   LCD_PORT &= ~(1<<LCD_RS);        // RS auf 0 setzen
 
   temp1 = temp1 >> 4;              // oberes Nibble holen
   temp1 = temp1 & 0x0F;            // maskieren
   LCD_PORT &= 0xF0;
   LCD_PORT |= temp1;               // setzen
   lcd_enable();
 
   temp2 = temp2 & 0x0F;            // unteres Nibble holen und maskieren
   LCD_PORT &= 0xF0;
   LCD_PORT |= temp2;               // setzen
   lcd_enable();
   
   _delay_us(42);
}
 
// erzeugt den Enable-Puls
void lcd_enable(void)
{
   // Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers einfügen
   // http://www.mikrocontroller.net/topic/81974#685882
   LCD_PORT |= (1<<LCD_EN);
    _delay_us(1);                   // kurze Pause
   // Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
   // http://www.mikrocontroller.net/topic/80900
   LCD_PORT &= ~(1<<LCD_EN);
}
 
// Initialisierung: 
// Muss ganz am Anfang des Programms aufgerufen werden.
 
void lcd_init(void)
{
   LCD_DDR = LCD_DDR | 0x0F | (1<<LCD_RS) | (1<<LCD_EN);   // Port auf Ausgang schalten
 
   // muss 3mal hintereinander gesendet werden zur Initialisierung
 
   _delay_ms(15);
   LCD_PORT &= 0xF0;
   LCD_PORT |= 0x03;            
   LCD_PORT &= ~(1<<LCD_RS);      // RS auf 0
   lcd_enable();
 
   _delay_ms(5);
   lcd_enable();
 
   _delay_ms(1);
   lcd_enable();
   _delay_ms(1);
 
   // 4 Bit Modus aktivieren 
   LCD_PORT &= 0xF0;
   LCD_PORT |= 0x02;
   lcd_enable();
   _delay_ms(1);
 
   // 4Bit / 2 Zeilen / 5x7
   lcd_command(0x28);
    
   // Display ein / Cursor aus / kein Blinken
   lcd_command(0x0C); 
 
   // inkrement / kein Scrollen
   lcd_command(0x06);
 
   lcd_clear();
}
 
// Sendet den Befehl zur Löschung des Displays
 
void lcd_clear(void)
{
   lcd_command(CLEAR_DISPLAY);
   _delay_ms(5);
}
 
// Sendet den Befehl: Cursor Home
 
void lcd_home(void)
{
   lcd_command(CURSOR_HOME);
   _delay_ms(5);
}
 
// setzt den Cursor in Zeile y (1..4) Spalte x (0..15)
 
void set_cursor(uint8_t x, uint8_t y)
{
  uint8_t tmp;
 
  switch (y) {
    case 1: tmp=0x80+0x00+x; break;    // 1. Zeile
    case 2: tmp=0x80+0x40+x; break;    // 2. Zeile
    case 3: tmp=0x80+0x10+x; break;    // 3. Zeile
    case 4: tmp=0x80+0x50+x; break;    // 4. Zeile
    default: return;                   // für den Fall einer falschen Zeile
  }
  lcd_command(tmp);
}
 
// Schreibt einen String auf das LCD
 
void lcd_string(char *data)
{
	int i,max=0;
	int size=strlen(data);//gibt die Länge des String ohne 0 ende
	char *data_2;

	data_2=data;//String merken

// Schreibt die ersten 16 zeichen des Strings
	
	while(*data) 
	{
		lcd_data(*data);
    data++;
		max++;
			if(max>=16)
			{
				break;
			}
	}
	
//Ist der String größer als 16 Zeichen wird der Rest
//in Laufschrift angezeigt alle 0,5 Sekunden  	

	if(size>16)
	{
		_delay_ms(500);
		for(i=0;i<(size-16);i++)
		{
			max=0;
			lcd_home();
			lcd_clear();
			data_2++;
			data=data_2;
			while(*data) 
			{
				lcd_data(*data);
				data++;
				max++;
				if(max>=16)
					{
						break;
					}
			}
			_delay_ms(500);
		}
	}
}			

// Schreibt einen String in Laufschrift auf das LCD

void lcd_running_string(char *data,int zeile)
{
	int max,i=0;
	int pos=16;
	char *data_2;
	int size=strlen(data);//gibt die Länge des String ohne 0 ende
	for(;;)
	{
	pos=16;
	max=0;
	i=0;
	
	data_2=data;
	set_cursor(pos,zeile);

// Schreibt die ersten 16 zeichen des Strings
	
	for(i=0;i<=16;i++)
	{	
		while(*data) 
			{
				lcd_data(*data);
				data++;
				max++;
				if(max>=16)
				{
					break;
				}
			}
		data=data_2;	
		pos--;
		max=0;
		_delay_ms(250);	
		lcd_clear();
		set_cursor(pos,zeile);
	}
	for(i=0;i<size;i++)
		{
			max=0;
			lcd_home();
			lcd_clear();
			data_2++;
			data=data_2;
			while(*data) 
			{
				lcd_data(*data);
				data++;
				max++;
				if(max>=16)
					{
						break;
					}
			}
			_delay_ms(250);
		}
	}
}			





#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>//Für sei(); cli(); ISR()
#include "lcd-routines.h"
#include <util/delay.h>



int main(void)
{	

	
	DDRD |= (1<<PD4);//LED1 Ausgang
	lcd_init();
	for(;;)
	{
		_delay_ms(500);
		PORTD ^= (1<<PD4);
	}

	
//Ende des Programms
	for(;;){
	}
}



###############################################################################
# Makefile for the project FirststepAtmega64
###############################################################################

## General Flags
PROJECT = FirststepAtmega64
MCU = atmega64
TARGET = FirststepAtmega64.elf
CC = avr-gcc.exe

## Options common to compile, link and assembly rules
COMMON = -mmcu=$(MCU)

## Compile options common for all C compilation units.
CFLAGS = $(COMMON)
CFLAGS += -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d 

## Assembly specific flags
ASMFLAGS = $(COMMON)
ASMFLAGS += $(CFLAGS)
ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2

## Linker flags
LDFLAGS = $(COMMON)
LDFLAGS +=  -Wl,-Map=FirststepAtmega64.map


## Intel Hex file production flags
HEX_FLASH_FLAGS = -R .eeprom

HEX_EEPROM_FLAGS = -j .eeprom
HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"
HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0 --no-change-warnings


## Objects that must be built in order to link
OBJECTS = FirststepAtmega64.o lcd-routines.o 

## Objects explicitly added by the user
LINKONLYOBJECTS = 

## Build
all: $(TARGET) FirststepAtmega64.hex FirststepAtmega64.eep FirststepAtmega64.lss size

## Compile
FirststepAtmega64.o: ../FirststepAtmega64.c
	$(CC) $(INCLUDES) $(CFLAGS) -c  $<

lcd-routines.o: ../lcd-routines.c
	$(CC) $(INCLUDES) $(CFLAGS) -c  $<

##Link
$(TARGET): $(OBJECTS)
	 $(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)

%.hex: $(TARGET)
	avr-objcopy -O ihex $(HEX_FLASH_FLAGS)  $< $@

%.eep: $(TARGET)
	-avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0

%.lss: $(TARGET)
	avr-objdump -h -S $< > $@

size: ${TARGET}
	@echo
	@avr-size -C --mcu=${MCU} ${TARGET}

## Clean target
.PHONY: clean
clean:
	-rm -rf $(OBJECTS) FirststepAtmega64.elf dep/* FirststepAtmega64.hex FirststepAtmega64.eep FirststepAtmega64.lss FirststepAtmega64.map


## Other dependencies
-include $(shell mkdir dep 2>/dev/null) $(wildcard dep/*)