Jak zdefiniować i sterować LCD przez 4-bitową szynę w C?

/*
* Funkcje obslugi wyswietlaczy LCD. Funkcje proste dostepne wszystkie,
* dostep do funkcji zlozonych po zadeklarowniau odpowiednich stalych
* (patrz plik def.h). LCD podlaczony do uC interfejsem 4 bitowym, do
* starszej polowki zadeklarowanego portu:
*     LCD_D7  -  PORTx.7
*     LCD_D6  -  PORTx.6
*     LCD_D5  -  PORTx.5
*     LCD_D4  -  PORTx.4
* Sygnaly sterujace EN (enable), RS i R/W podlaczenie dowolne (nalezy
* wlasciwie zadeklarowac porty uC).
* W przypadku koniecznosci podlaczenie wyswietlacza do mlodszej czesci
* portu nalezy odpowiednio zmodyfikowac funkcje.
* Makra rozpoczynajace sie od VFD sluza do ustawiania jasnosci
* wyswietlaczy tego typu (UWAGA:nie wszystkie wyswietlacze VFD maja
* sterowanie zgodne z wyswietlaczami LCD).
* Przy korzystaniu z funkcji wyswietlania liczb 8, 16 i 32 bitowych
* na wyswietlaczu jest zawsze rezerwowana maksymalna ilosc cyfr, a
* podawane wpolzedne dotycza pierwszego znaku np. dla in16xy uklad
* na wyswietlczu (wyswietlane -32000, -120, 16501, -1, 0) będzie:
* -32000
*   -120
*  16501
*     -1
*      0
* Jak widac nieznaczace zera nie sa wyswietlane. Liczby zajmuja:
*  8 bit  uint8_t  3 znaki LCD;
* 16 bit  uint16_t 5 znakow LCD;
* 32 bit  uint32_t 10 znakow LCD;
* Liczby ze znakiem (signed) zajmuja o jedno pole wiecej niz ich
* odpowiendiki bez znaku.
*/

#define LCD  PORTB
#define E  3
#define RS  2

#include <avr/io.h>

#define DDR_DB4  DDRC
#define PORT_DB4 PORTC
#define DB4      PC4

#define DDR_DB5  DDRC
#define PORT_DB5 PORTC
#define DB5      PC5

#define DDR_DB6  DDRD
#define PORT_DB6 PORTD
#define DB6      PD7

#define DDR_DB7  DDRA
#define PORT_DB7 PORTA
#define DB7      PA7


#define DDR_RS   DDRC
#define PORT_RS  PORTC
#define RS       PC2

#define DDR_E    DDRC
#define PORT_E   PORTC
#define E        PC3

#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)

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 = 200; 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
}


void write_to_lcd(char x)
{
SET_E;
if(x & _BV(4)) SET_DB4; else  CLR_DB4;
if(x & _BV(5)) SET_DB5; else  CLR_DB5;
if(x & _BV(6)) SET_DB6; else  CLR_DB6;
if(x & _BV(7)) SET_DB7; else  CLR_DB7;
CLR_E;
SET_E;
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;
CLR_E;
waitms(1);
}

void write_command(char x)
{
CLR_RS; // niski stan na RS -> zapis instrukcji
write_to_lcd(x); // zapis do 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)
  }
}

void lcd_init(void)
{
DDR_DB4 |= _BV(DB4);
DDR_DB5 |= _BV(DB5);
DDR_DB6 |= _BV(DB6);
DDR_DB7 |= _BV(DB7);

DDR_E |= _BV(E);
DDR_RS |= _BV(RS);

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
  SET_DB4;
  SET_DB5;
  CLR_DB6;
  CLR_DB7;
  CLR_E; // E = 0
  waitms(5); // czekaj 5ms
  }
SET_E; // E = 1
CLR_DB4;
SET_DB5;
CLR_DB6;
CLR_DB7; //
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
} 


int main(void)
{
DDRB= 0xFF;
// inicjalizacja LCD
lcd_init();
// zapisz na LCD przykładowy tekst
write_text("Pitus Bajtus");
// petla nieskończona
while(1);
return 0;
}

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


//Tu należy zdefiniować piny , używane do sterowania wyśw. LCD 
//Sygnał R/W podpięty na stałe do GND
#define RSPIN PC2  //numer bitu dla linii RS
#define EPIN  PC3
#define D4PIN PC4
#define D5PIN PC5
#define D6PIN PD7
#define D7PIN PA7

#define RSPORT PORTC  //port do którego podłączono linię RS 
#define EPORT  PORTC
#define D4PORT PORTC
#define D5PORT PORTC
#define D6PORT PORTD
#define D7PORT PORTA

#define RSDDR DDRC  //port konfiguracyjny linii RS
#define EDDR DDRC
#define D4DDR DDRC
#define D5DDR DDRC
#define D6DDR DDRD
#define D7DDR DDRA
//koniec definicji pinów LCD


//jeśli używamy danych umieszczonych w pamięci programu
//#define PGMTXT
//Takie sobie uproszczenia ;)
#define SET_D4 D4PORT|=(1<<D4PIN)
#define SET_D5 D5PORT|=(1<<D5PIN)
#define SET_D6 D6PORT|=(1<<D6PIN)
#define SET_D7 D7PORT|=(1<<D7PIN)

#define CLR_D4 D4PORT&=~(1<<D4PIN)
#define CLR_D5 D5PORT&=~(1<<D5PIN)
#define CLR_D6 D6PORT&=~(1<<D6PIN)
#define CLR_D7 D7PORT&=~(1<<D7PIN)

#define SET_E EPORT|=(1<<EPIN)
#define CLR_E EPORT&=~(1<<EPIN)
#define SET_RS RSPORT|=(1<<RSPIN)
#define CLR_RS RSPORT&=~(1<<RSPIN)
#define CLRDISP 0x01
#define HOMEDISP 0x02
//koniec uproszczeń

void LCDresetdata(void) //wyzeruj szynę danych LCD
{
	CLR_D4;
	CLR_D5;
	CLR_D6;
	CLR_D7;
}
void LCDwrite(char d) //zapis bajtu do LCD
{
	LCDresetdata();
	if(d & 0x10){SET_D4;} 
	if(d & 0x20){SET_D5;} 
	if(d & 0x40){SET_D6;} 
	if(d & 0x80){SET_D7;} 
	SET_E;CLR_E;
	LCDresetdata();
	if(d & 0x01){SET_D4;} 
	if(d & 0x02){SET_D5;} 
	if(d & 0x04){SET_D6;} 
	if(d & 0x08){SET_D7;} 
	SET_E;CLR_E;
	_delay_ms(2);
}
void LCDconfigIO(void) //wszystkie piny do których podłączony jest LCD jako wyjście
{
	RSDDR|=(1<<RSPIN);EDDR|=(1<<EPIN);D4DDR|=(1<<D4PIN);
	D5DDR|=(1<<D5PIN);D6DDR|=(1<<D6PIN);D7DDR|=(1<<D7PIN);
}
void LCDcmd(char d) //Wyślij komendę do LCD
{
	CLR_RS;
	LCDwrite(d);
}
void LCDchr(char d) //Wyślij 1 znak do LCD
{
	SET_RS;
	LCDwrite(d);
}
void LCDinit(void) //inicjalizacja LCD
{
	LCDconfigIO();
	CLR_RS;
	CLR_E;
	_delay_ms(20);
	CLR_D7;
	CLR_D6;
	SET_D4;
	SET_D5;
	unsigned char i;
	for(i=0;i<3;i++) {SET_E;CLR_E;_delay_ms(5);}
	CLR_D4;
	SET_E;
	CLR_E;
	_delay_ms(5);
	LCDcmd(0x28); //function set - interface=4 bit,line=2,font=5x7 
	LCDcmd(0x0c); //display ctrl - display on
	LCDcmd(0x06); //entry mode set - increment
	LCDcmd(0x01); //clear display

}
//wyczyść wyśw.
void LCDcls(void) {LCDcmd(CLRDISP);}
//ustaw kursor na pozycji 0,0
void LCDhome(void) {LCDcmd(HOMEDISP);}
//wyślij tekst z RAM na wyśw.
void LCDtext(char *txt) {while(*txt) {LCDchr(*txt++);}}
//umieść kursor na pozycji x,y - brak kontroli dla x i y
void LCDxy(char x,char y)
{
	unsigned char com=0x80;
	com|=(x|(y<<6));
	LCDcmd(com);
}
#ifdef PGMTXT
//wyświetlamy tekst zdefiniowany w pamięci programu
#include <avr/pgmspace.h>
void LCDtextP(const char *txtp)
{
char chr;
while ((chr = pgm_read_byte(txtp++))) {LCDchr(chr);}
}
#endif



// program główny
char fromflash[] PROGMEM ="Text from flash";
int main(void)
{
LCDinit();
LCDxy(3,0);
LCDtext("Piotrek");  //tradycyjnie
LCDxy(0,1);
LCDtextP(fromflash); //z pamięci programu
while(1){}
return 0;
}

#define F_CPU 4000000

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

#define DDR_DB4  DDRB
#define PORT_DB4 PORTB
#define DB4      PB4

#define DDR_DB5  DDRB
#define PORT_DB5 PORTB
#define DB5      PB5

#define DDR_DB6  DDRB
#define PORT_DB6 PORTB
#define DB6      PB6

#define DDR_DB7  DDRB
#define PORT_DB7 PORTB
#define DB7      PB7


#define DDR_RS   DDRB
#define PORT_RS  PORTB
#define RS       PB2

#define DDR_E    DDRB
#define PORT_E   PORTB
#define E        PB3

#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
} 


int main(void)
{
// inicjalizacja LCD
lcd_init();
// zapisz na LCD przykładowy tekst
write_text("Pitus Bajtus");
// petla nieskończona
while(1);
return 0;
}

void out_nibble(char x)
{
CLR_DB4;
CLR_DB5;
CLR_DB6;
CLR_DB7;
if(x & _BV(0)) SET_DB4;
if(x & _BV(1)) SET_DB5;
if(x & _BV(2)) SET_DB6;
if(x & _BV(3)) SET_DB7;
}

Cls
Lcd "Wyswietlacz zepsuty" 

LCDinit();
LCDxy(0,5);
LCDtext(majster256);

LCDinit();  //raz wystarczy ;)

while(1) {
LCDxy(0,5);
LCDtext(majster256);
}