LCD 16x2 HD44780 – jak poprawnie wyświetlić tekst na drugiej linii?

write_command(0x38); // interfejs 8-bitów, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // czyść LCD
write_command(0x06); // bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania

void lcd_init(void)
{
waitms(15); // czekaj 15ms na ustabilizowanie się napięcia zasilającego
CLR_E; // E = 0
CLR_RS; // RS = 0
char i; // zmianna licznikowa
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
  {
  SET_E; // E = 1
  LCD &= 0x3F; //
  CLR_E; // E = 0
  waitms(5); // czekaj 5ms
  }
SET_E; // E = 1
LCD &= 0x2E; //
CLR_E; // E = 0
waitms(1); // czekaj 1ms
write_command(0x38); // interfejs 8-bitów, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // czyść LCD
write_command(0x06); // bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania
}

LCD &= 0x3F;

LCD = 0x3F;

LCD &= 0x2E; //

write_command(0x38); // interfejs 8-bitów, 2-linie, znak 5x7

SET_E; // E = 1 
LCD &= 0x2E; //
CLR_E; // E = 0

SET_E; // E = 1 
LCD &= 0x2E; //
CLR_E; // E = 0

LCD = 0x2E; //
SET_E; // E = 1
//Dodatkowe opuźnienie 
CLR_E; // E = 0

#include <avr/io.h>
//
#define LCD  PORTA
#define E  7
#define RW 6                     
#define RS  5
//
#define SET_E   PORTC |= _BV(E)
#define CLR_E   PORTC &= ~_BV(E)

#define SET_RS  PORTC |= _BV(RS)
#define CLR_RS  PORTC &= ~_BV(RS)

#define SET_RW  PORTC |= _BV(RW)
#define CLR_RW  PORTC &= ~_BV(RW) 

// funkcja opóźniająca o x*1ms
void waitms(char x)
{
unsigned char a, b; // zmnienne licznikowe
for( ; x > 0; --x) // ta pętla zostanie wykonana x-razy
  for(b = 10; b > 0; --b) // a ta 10 razy
	for(a = 100; a > 0; --a) // natomiast ta 100 razy
	__asm("nop"); // dodatkowa instrukcja opóźniająca o 1 cykl
	// razem to da opóźnienie ok. x * 1ms
	// x od 0 do 255
}
// pcodedura zapisu bajtu do wyświetlacza LCD
// bez rozróżnienia instrukcja/dana
void write_to_lcd(char x)
{
SET_E; // ustaw na E stan wysoki
asm("nop");
LCD = x;
CLR_E;
waitms(1); // czekaj 1ms
}

// procedura zapisu instrukcji do wyświetlacza LCD
void write_command(char x)
{
CLR_RS; // niski stan na RS -> zapis instrukcji
write_to_lcd(x); // zapis do LCD
}

// procedura zapisu danej do wyświetlacza LCD
void write_char(char x)
{
SET_RS; // wysoki stan na RS -> zapis danej
write_to_lcd(x); // zapis do LCD
}

// procedura zapisu tekstu do wyświetlacza LCD
void write_text(char * s)
{
while(*s) // do napotkania 0
  {
  write_char(*s); // zapisz znak wskazywany przez s na LCD
  s++; // zwiększ s (przygotuj nastepny znak)
  }
}

// procedura inicjalizacji wyświetlacza LCD
void lcd_init(void)
{
waitms(15); // czekaj 15ms na ustabilizowanie się napięcia zasilającego
CLR_E; // E = 0
CLR_RS; // RS = 0
char i; // zmianna licznikowa
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
  {
  SET_E; // E = 1
  LCD = 0x3F; //
  CLR_E; // E = 0
  waitms(5); // czekaj 5ms
  }

LCD = 0x2E; //
SET_E; // E = 1
CLR_E; // E = 0
waitms(1); // czekaj 1ms
write_command(0x38); // interfejs 8-bitow, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // czyść LCD
write_command(0x06); // bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania
}

int main(void)
{
// konfiguracja portów we/wy
DDRA = 0xFF;
DDRC = 0xFF;
PORTA = 0xFF;
PORTC = 0xFF;

CLR_RW;

lcd_init();

write_text("Hello ");
write_command(0x40);
write_text("World");

while(1);
return 0;
}

write_command(0x40);

write_command(0xC0);

#include <avr/io.h> 
// 
#define LCD  PORTA 
#define E  7 
#define RW 6                      
#define RS  5 
// 
#define SET_E   PORTC |= _BV(E) 
#define CLR_E   PORTC &= ~_BV(E) 

#define SET_RS  PORTC |= _BV(RS) 
#define CLR_RS  PORTC &= ~_BV(RS) 

#define SET_RW  PORTC |= _BV(RW) 
#define CLR_RW  PORTC &= ~_BV(RW) 

// funkcja opóźniająca o x*1ms 
void waitms(char x) 
{ 
unsigned char a, b; // zmnienne licznikowe 
for( ; x > 0; --x) // ta pętla zostanie wykonana x-razy 
  for(b = 10; b > 0; --b) // a ta 10 razy 
   for(a = 100; a > 0; --a) // natomiast ta 100 razy 
   __asm("nop"); // dodatkowa instrukcja opóźniająca o 1 cykl 
   // razem to da opóźnienie ok. x * 1ms 
   // x od 0 do 255 
} 
// pcodedura zapisu bajtu do wyświetlacza LCD 
// bez rozróżnienia instrukcja/dana 
void write_to_lcd(char x) 
{ 
LCD = x; 
SET_E; // ustaw na E stan wysoki 
waitms(10); // czekaj 10ms 
CLR_E; 
waitms(10); // czekaj 10ms 
} 

// procedura zapisu instrukcji do wyświetlacza LCD 
void write_command(char x) 
{ 
CLR_RS; // niski stan na RS -> zapis instrukcji 
write_to_lcd(x); // zapis do LCD 
} 

// procedura zapisu danej do wyświetlacza LCD 
void write_char(char x) 
{ 
SET_RS; // wysoki stan na RS -> zapis danej 
write_to_lcd(x); // zapis do LCD 
} 

// procedura zapisu tekstu do wyświetlacza LCD 
void write_text(char * s) 
{ 
while(*s) // do napotkania 0 
  { 
  write_char(*s); // zapisz znak wskazywany przez s na LCD 
  s++; // zwiększ s (przygotuj nastepny znak) 
  } 
} 

// procedura inicjalizacji wyświetlacza LCD 
void lcd_init(void) 
{ 
waitms(100); // czekaj 100ms na ustabilizowanie się napięcia zasilającego 
CLR_RS; // RS = 0 
char i; // zmianna licznikowa 
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji 
  { 
  SET_E; // E = 1 
  LCD = 0x30; // 
waitms(10); // czekaj 10ms 
  CLR_E; // E = 0 
waitms(10); // czekaj 10ms 
  } 

SET_E; // E = 1 
waitms(10); // czekaj 10ms 
write_command(0x3C); // interfejs 8-bitow, 2-linie, znak 5x7 
write_command(0x08); // wyłącz LCD, kursor i miganie 
write_command(0x01); // czyść LCD 
write_command(0x06); // bez przesuwania w prawo 
write_command(0x0C); // włącz LCD, bez kursora i mrugania 
} 

int main(void) 
{ 
// konfiguracja portów we/wy 
DDRA = 0xFF; 
DDRC = 0xFF; 
PORTA = 0xFF; 
PORTC = 0xFF; 

CLR_RW; 

lcd_init(); 

write_text("Hello "); 
write_command(0xC0); 
write_text("World"); 

while(1); 
return 0; 
}

#include <avr/io.h>
//
#define LCD  PORTC
#define E  4
#define RS  5
//
#define SET_E   LCD |= _BV(E)
#define CLR_E   LCD &= ~_BV(E)
//
#define SET_RS  LCD |= _BV(RS)
#define CLR_RS  LCD &= ~_BV(RS)

// funkcja opóźniająca o x*1ms
void waitms(char x)
{
unsigned char a, b; // zmnienne licznikowe
for( ; x > 0; --x) // ta pętla zostanie wykonana x-razy
  for(b = 10; b > 0; --b) // a ta 10 razy
	for(a = 100; a > 0; --a) // natomiast ta 100 razy
	__asm("nop"); // dodatkowa instrukcja opóźniająca o 1 cykl
	// razem to da opóźnienie ok. x * 1ms
	// x od 0 do 255
}

// pcodedura zapisu bajtu do wyświetlacza LCD
// bez rozróżnienia instrukcja/dana
void write_to_lcd(char x)
{
SET_E;
LCD=(LCD & 0xF0) | (x >>4);
CLR_E;
SET_E;
LCD=(LCD & 0xF0) | (x & 0x0F);
CLR_E;
waitms(1); // czekaj 1ms
}

// procedura zapisu instrukcji do wyświetlacza LCD
void write_command(char x)
{
CLR_RS; // niski stan na RS -> zapis instrukcji
write_to_lcd(x); // zapis do LCD
}

// procedura zapisu danej do wyświetlacza LCD
void write_char(char x)
{
SET_RS; // wysoki stan na RS -> zapis danej
write_to_lcd(x); // zapis do LCD
}

// procedura zapisu tekstu do wyświetlacza LCD
void write_text(char * s)
{
while(*s) // do napotkania 0
  {
  write_char(*s); // zapisz znak wskazywany przez s na LCD
  s++; // zwiększ s (przygotuj nastepny znak)
  }
}

}
// procedura inicjalizacji wyświetlacza LCD
void lcd_init(void)
{
waitms(15); // czekaj 15ms na ustabilizowanie się napięcia zasilającego
CLR_E; // E = 0
CLR_RS; // RS = 0
char i; // zmianna licznikowa
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
  {
  
  LCD =0x3F;//&= 0x3F; //
  SET_E; // E = 1
  waitms(5);
  CLR_E; // E = 0
  waitms(5); // czekaj 5ms
  }
LCD = 0x2E; //
SET_E; // E = 1

waitms(5);
CLR_E; // E = 0
waitms(1); // czekaj 1ms
write_command(0x28); // interfejs 4-bity, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // czyść LCD
write_command(0x06); // bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania
}

// program główny
int main(void)
{
DDRC = 0xFF;
PORTC = 0xFF;
lcd_init();
write_text("Ala ma kota :D");
write_command(0xc0);
write_text("Kot ma AIDS");
while(1);
return 0;
}

#include <avr/io.h>
#include <util/delay.h>
#define LCD_RS_DIR		 DDRC
#define LCD_RS_PORT     	PORTC
#define LCD_RS			    (1 << PC0)

#define LCD_E_DIR		  DDRD
#define LCD_E_PORT		 PORTD
#define LCD_E			     (1 << PD5)

#define LCD_DB4_DIR		DDRD
#define LCD_DB4_PORT	       PORTD
#define LCD_DB4			   (1 << PD6)

#define LCD_DB5_DIR		DDRD
#define LCD_DB5_PORT	       PORTD
#define LCD_DB5			   (1 << PD7)

#define LCD_DB6_DIR		DDRG
#define LCD_DB6_PORT	       PORTG
#define LCD_DB6			   (1 << PG0)

#define LCD_DB7_DIR		DDRG
#define LCD_DB7_PORT	       PORTG
#define LCD_DB7			   (1 << PG1)


#define HD44780_CLEAR					0x01

#define HD44780_HOME					0x02

#define HD44780_ENTRY_MODE				0x04
	#define HD44780_EM_SHIFT_CURSOR		0
	#define HD44780_EM_SHIFT_DISPLAY	1
	#define HD44780_EM_DECREMENT		0
	#define HD44780_EM_INCREMENT		2

#define HD44780_DISPLAY_ONOFF			0x08
	#define HD44780_DISPLAY_OFF			0
	#define HD44780_DISPLAY_ON			4
	#define HD44780_CURSOR_OFF			0
	#define HD44780_CURSOR_ON			2
	#define HD44780_CURSOR_NOBLINK		0
	#define HD44780_CURSOR_BLINK		1

#define HD44780_DISPLAY_CURSOR_SHIFT	0x10
	#define HD44780_SHIFT_CURSOR		0
	#define HD44780_SHIFT_DISPLAY		8
	#define HD44780_SHIFT_LEFT			0
	#define HD44780_SHIFT_RIGHT			4

#define HD44780_FUNCTION_SET			0x20
	#define HD44780_FONT5x7				0
	#define HD44780_FONT5x10			4
	#define HD44780_ONE_LINE			0
	#define HD44780_TWO_LINE			8
	#define HD44780_4_BIT				0
	#define HD44780_8_BIT				16

#define HD44780_CGRAM_SET				0x40

#define HD44780_DDRAM_SET				0x80

void LCD_WriteCommand(unsigned char);
void LCD_WriteData(unsigned char);
void LCD_WriteText(char *);
void LCD_GoTo(unsigned char, unsigned char);
void LCD_Clear(void);
void LCD_Home(void);
void LCD_Initalize(void);
int  wysrodkuj(char* text);
void LCD_WriteTextXY(unsigned char x, unsigned char y, char * text);

#include <String.h>
#include "HD44780.h"

//-------------------------------------------------------------------------------------------------
//
// Funkcja wystawiająca półbajt na magistralę danych
//
//-------------------------------------------------------------------------------------------------
void _LCD_OutNibble(unsigned char nibbleToWrite)
{
	if(nibbleToWrite & 0x01)
		LCD_DB4_PORT |= LCD_DB4;//ustawienie portu na 1??
	else
		LCD_DB4_PORT  &= ~LCD_DB4;//ustawienie portu na 0??

	if(nibbleToWrite & 0x02)
		LCD_DB5_PORT |= LCD_DB5;
	else
		LCD_DB5_PORT  &= ~LCD_DB5;

	if(nibbleToWrite & 0x04)
		LCD_DB6_PORT |= LCD_DB6;
	else
		LCD_DB6_PORT  &= ~LCD_DB6;

	if(nibbleToWrite & 0x08)
		LCD_DB7_PORT |= LCD_DB7;
	else
		LCD_DB7_PORT  &= ~LCD_DB7;
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja zapisu bajtu do wyświetacza (bez rozróżnienia instrukcja/dane).
//
//-------------------------------------------------------------------------------------------------
void _LCD_Write(unsigned char dataToWrite)
{

	LCD_E_PORT |= LCD_E;//1
	_LCD_OutNibble(dataToWrite >> 4);
	LCD_E_PORT &= ~LCD_E;//0
	LCD_E_PORT |= LCD_E;//1
	_LCD_OutNibble(dataToWrite);
	LCD_E_PORT &= ~LCD_E;//0
	_delay_us(50);
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja zapisu rozkazu do wyświetlacza
//
//-------------------------------------------------------------------------------------------------
void LCD_WriteCommand(unsigned char commandToWrite)
{
	LCD_RS_PORT &= ~LCD_RS;//0
	_LCD_Write(commandToWrite);
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja zapisu danych do pamięci wyświetlacza
//
//-------------------------------------------------------------------------------------------------
void LCD_WriteData(unsigned char dataToWrite)
{
	LCD_RS_PORT |= LCD_RS;//1
	_LCD_Write(dataToWrite);
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja wyświetlenia napisu na wyswietlaczu.
//
//-------------------------------------------------------------------------------------------------
void LCD_WriteText(char * text)
{
 	while(*text) LCD_WriteData(*text++);
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja ustawienia współrzędnych ekranowych
//
//-------------------------------------------------------------------------------------------------
void LCD_GoTo(unsigned char x, unsigned char y)
{
	LCD_WriteCommand(HD44780_DDRAM_SET | (x + (0x40 * y)));
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja czyszczenia ekranu wyświetlacza.
//
//-------------------------------------------------------------------------------------------------
void LCD_Clear(void)
{
	LCD_WriteCommand(HD44780_CLEAR);
	_delay_ms(2);
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja przywrócenia początkowych współrzędnych wyświetlacza.
//
//-------------------------------------------------------------------------------------------------
void LCD_Home(void)
{
	LCD_WriteCommand(HD44780_HOME);
	_delay_ms(2);
}
//-------------------------------------------------------------------------------------------------
//
// Procedura inicjalizacji kontrolera HD44780.
//
//-------------------------------------------------------------------------------------------------
void LCD_Initalize(void)
{
	unsigned char i;
	LCD_DB4_DIR |= LCD_DB4; // Konfiguracja kierunku pracy wyprowadzeń
	LCD_DB5_DIR |= LCD_DB5; //czyli wyjscie z atmegi
	LCD_DB6_DIR |= LCD_DB6; //
	LCD_DB7_DIR |= LCD_DB7; //
	LCD_E_DIR 	|= LCD_E;   //
	LCD_RS_DIR 	|= LCD_RS;  //
	KEY_ENA_DIR |= KEY_ENA;
	KEY_ROW0_DIR|= KEY_ROW0;
	_delay_ms(15); // oczekiwanie na ustalibizowanie się napiecia zasilajacego
	KEY_ENA_PORT  |= KEY_ENA;//ENABLE i ROW0 na 1 czyli blokada odczytu z klawiatury
	KEY_ROW0_PORT |= KEY_ROW0;
	LCD_RS_PORT &= ~LCD_RS; // wyzerowanie linii RS
	LCD_E_PORT &= ~LCD_E;  // wyzerowanie linii E

	for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
	{
		LCD_E_PORT |= LCD_E; //  E = 1
		_LCD_OutNibble(0x03); // tryb 8-bitowy
		LCD_E_PORT &= ~LCD_E; // E = 0
		_delay_ms(5); // czekaj 5ms
	}

	LCD_E_PORT |= LCD_E; // E = 1
	_LCD_OutNibble(0x02); // tryb 4-bitowy
	LCD_E_PORT &= ~LCD_E; // E = 0

	_delay_ms(1); // czekaj 1ms 
	LCD_WriteCommand(HD44780_FUNCTION_SET | HD44780_FONT5x7 | HD44780_TWO_LINE | HD44780_4_BIT); // interfejs 4-bity, 2-linie, znak 5x7
	LCD_WriteCommand(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_OFF); // wyłączenie wyswietlacza
	LCD_WriteCommand(HD44780_CLEAR); // czyszczenie zawartosći pamieci DDRAM
	_delay_ms(2);
	LCD_WriteCommand(HD44780_ENTRY_MODE | HD44780_EM_SHIFT_CURSOR | HD44780_EM_INCREMENT);// inkrementaja adresu i przesuwanie kursora
	LCD_WriteCommand(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_ON | HD44780_CURSOR_OFF | HD44780_CURSOR_NOBLINK); // włącz LCD, bez kursora i mrugania
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja zwraca wartosc pola x tak aby tekst byl wysrodkowany.
//
//-------------------------------------------------------------------------------------------------
int wysrodkuj(char* text)
{
	int ilosc=strlen(text);
	
	if ((ilosc % 2)==0) return (16-ilosc)/2; else
	return (15-ilosc)/2;
}
//-------------------------------------------------------------------------------------------------
//
// Funkcja wyświetlenia napisu na wyswietlaczu o wspolrzednych ekranowych(dla x>15 tekst wysrodkowany).
//
//-------------------------------------------------------------------------------------------------
void LCD_WriteTextXY(unsigned char x, unsigned char y, char * text)
{
	if (x>15) LCD_GoTo(wysrodkuj(text),y); else LCD_GoTo(x,y);
	LCD_WriteText(text);
}

write_command(0x40);

write_command(0xC0);

void locate(char w, char k)
{
write_command((w*0x40+k)|0x80); 
}

#define F_CPU 4000000

#include <avr/io.h>
#include <avr/delay.h>

#define DDR_DB4  DDRD
#define PORT_DB4 PORTD
#define DB4      PD4

#define DDR_DB5  DDRD
#define PORT_DB5 PORTD
#define DB5      PD5

#define DDR_DB6  DDRD
#define PORT_DB6 PORTD
#define DB6      PD6

#define DDR_DB7  DDRD
#define PORT_DB7 PORTD
#define DB7      PD7


#define DDR_RS   DDRD
#define PORT_RS  PORTD
#define RS       PD2

#define DDR_E    DDRD
#define PORT_E   PORTD
#define E        PD3

#define SET_DB4 PORT_DB4 |= _BV(DB4)
#define CLR_DB4 PORT_DB4 &= ~_BV(DB4)

#define SET_DB5 PORT_DB5 |= _BV(DB5)
#define CLR_DB5 PORT_DB5 &= ~_BV(DB5)

#define SET_DB6 PORT_DB6 |= _BV(DB6)
#define CLR_DB6 PORT_DB6 &= ~_BV(DB6)

#define SET_DB7 PORT_DB7 |= _BV(DB7)
#define CLR_DB7 PORT_DB7 &= ~_BV(DB7)

#define SET_E PORT_E |= _BV(E)
#define CLR_E PORT_E &= ~_BV(E)

#define SET_RS PORT_RS |= _BV(RS)
#define CLR_RS PORT_RS &= ~_BV(RS)

// funkcja wystawiająca na szynę danych połówkę bajtu
// pod uwagę brana jest młodsza połówka parametru
void out_nibble(char x)
{
if(x & _BV(0)) SET_DB4; else  CLR_DB4;
if(x & _BV(1)) SET_DB5; else  CLR_DB5;
if(x & _BV(2)) SET_DB6; else  CLR_DB6;
if(x & _BV(3)) SET_DB7; else  CLR_DB7;
}

// funkcja zapisująca do LCD bajt danych
void write_to_lcd(char x)
{
SET_E;
out_nibble(x >> 4); // wystawienie na szynę danych starszej połówki bajtu
CLR_E; // opadające zbocze na E powoduje zapis do wyświetlacza
SET_E;
out_nibble(x); // wystawienie na szynę danych młodszej połówki bajtu
CLR_E; // opadające zbocze na E powoduje zapis do wyświetlacza
_delay_ms(1); // opóźnienie ok 1 ms
}

// funkcja zapisująca do LCD rozkaz
void write_command(char x)
{
CLR_RS; // niski stan na RS -> zapis instrukcji
write_to_lcd(x); // zapis do LCD
}

// funkcja zapisujaca do LCD znak
void write_char(char x)
{
SET_RS; // wysoki stan na RS -> zapis danej
write_to_lcd(x); // zapis do LCD
}

// funkcja zapisu tekstu do wyświetlacza LCD
void write_text(char * s)
{
while(*s) // do napotkania 0
  {
  write_char(*s); // zapisz znak wskazywany przez s na LCD
  s++; // zwiększ s (przygotuj nastepny znak)
  }
}

// funkcja inicjująca LCD
void lcd_init(void)
{
// ustawienie wszystkich linii sterujących LCD jako wyjścia
DDR_DB4 |= _BV(DB4);
DDR_DB5 |= _BV(DB5);
DDR_DB6 |= _BV(DB6);
DDR_DB7 |= _BV(DB7);
DDR_E |= _BV(E);
DDR_RS |= _BV(RS);
//
_delay_ms(15); // czekaj 15ms na ustabilizowanie się napięcia zasilającego
CLR_E; // E = 0
CLR_RS; // RS = 0
char i; // zmianna licznikowa
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
  {
  SET_E; // E = 1
  out_nibble(0x03);
  CLR_E; // E = 0
  _delay_ms(5); // czekaj 5ms
  }
SET_E; // E = 1
out_nibble(0x02);
CLR_E; // E = 0
_delay_ms(1); // czekaj 1ms
write_command(0x28); // interfejs 4-bity, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // czyść LCD
write_command(0x06); // bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania
}

void LCDxy(char x,char y)
{
   unsigned char com=0x80;
   com|=(x|(y<<6));
   write_command(com);
} 
int main(void)
{
// inicjalizacja LCD
lcd_init();
// zapisz na LCD przykładowy tekst
write_text("1234");
LCDxy(0,1);
write_text("ABCD");
// petla nieskończona
while(1);
return 0;
}