Avr i C. Zapalanie diod. Jakie wartości wpisać do portu?

int main(void)
{
	DDRB=0x7c;
	PORTB = 0xff;
	_delay_loop_2(0xffff);
	PORTB = 0x04;
	_delay_loop_2(0xffff);
	PORTB = 0xff;
	_delay_loop_2(0xffff);
	PORTB = 0x18;
	_delay_loop_2(0xffff);
	PORTB = 0xff;
	_delay_loop_2(0xffff);
	PORTB = 0x2f;
	_delay_loop_2(0xffff);
	while(0);
	return 0;
}

DDRB = 0x7C; 
to to samo co
DDRB = 0b01111100; 
lub
DDRB = (1 << PB2) | (1 << PB3) | (1 << PB4) | (1 << PB5) | (1 << PB6);
lub 
DDRB |= _BV(2) | _BV(3) | _BV(4) | _BV(5) | _BV(6); 

int main(void)
{
	DDRB=0x7C;
	PORTB = 0xFB;
	_delay_loop_2(0xffff);
	PORTB = 0xF7;
	_delay_loop_2(0xffff);
	PORTB = 0xEF;
	_delay_loop_2(0xffff);
	while(0);
	return 0;
}

// Definicje dotyczace LCD 
#define RS 0                     // wybor rejestru 
#define RW 1                     // 1 - odczyt; 0 - zapis 
#define E 2                      // sygnal zezwalajacy (enable) 
#define PORTLCD PORTA            // port z podlaczanym LCD 
#define DDRLCD DDRA             // port z podlaczanym LCD 
#define PINLCD PINA             // port z podlaczanym LCD 
// Wykorzystujemy tylko cztery linie przesylowe D4-D7 portu PORTLCD 

// prodedura wytracania czasu 
void czekaj(unsigned long pt)   //procedura wytracania czasu ok. 1ms 
{ 
        for(;pt>0;pt--) 
                _delay_loop_2(1000);       // obliczone dla 4MHz 
} 
// sprawdzenie zajetosci jesli flaga zero to wolny LCD 
// funkcja bajt odpowiadajacy stanowi bitu BF 
unsigned char lcd_busy(void) 
{ 
        unsigned char flaga;            // zmienna pomocnicza 
        PORTLCD &= _BV(RS);                // dostep do rejestru instrukcji 
        PORTLCD |= _BV(RW);                // tryb odczytu  - ustaw bit RW 
        DDRLCD=0x0f;                    // bity D4 - D7 wejsciami        
        PORTLCD |= _BV(E);                 // ustawienie linii strobujacej 
        asm("nop");                     // krotka przerwa 
        flaga = PINLCD&0x80;            // zapamietanie zawartosci bitu BF(D7) 
        PORTLCD &= _BV(E); 
        PORTLCD |= _BV(E);                 // generacja pustego impulsu strobujacego 
        asm("nop");                     // krotka przerwa 
        PORTLCD &= _BV(E); 
        DDRLCD=0xff;                    // caly port wyjsciami 
        return flaga;                   // zwrocenie wartosci odczytanego bitu 
} 

// funkcja wysyla dana lub rozkaz do wyswietlenia 
// litera = 0 oznacza slowo sterujace 
void lcd_trans(unsigned char dana, char litera) 
{ 
        while (lcd_busy());             // oczekiwanie na zwolnienie wyswietlacza 
        PORTLCD &= _BV(RW);                // tryb zapisu - kasuj bit RW 
        PORTLCD |= _BV(E); 
        if (litera==0)                  // rodzaj transmisji zalezny od parametru 
                PORTLCD &= _BV(RS);        // 0 oznacza slowo sterujace 
        else 
                PORTLCD |= _BV(RS);        // 1 oznacza znak do wyswietlenia 
        PORTLCD |= _BV(E); 
        PORTLCD=(PORTLCD&0x0f)|(dana&0xf0);  //przygotuj starszy polbajt do LCD 
        asm("nop");             // krotka przerwa 
        PORTLCD &= _BV(E);         //impuls strobujacy 
        PORTLCD |= _BV(E); 
        PORTLCD=(PORTLCD&0x0f)|((dana&0x0f)<<4); 
                                // przygotuj mlodszy polbajt do LCD 
        asm("nop");             // krotka przerwa 
        PORTLCD &= _BV(E); 
 } 

// USTAWIANIE KURSORA W ZADANYM MIEJSCU 
void lcd_xy(unsigned char w, unsigned char k) 
{ 
 lcd_trans((w*0x40+k)|0x80,0); 
} 

// Pisanie tekstu na ekranie 
void lcd_tekst(char *tekst) 
{ 
        unsigned char i = 0;  while (tekst[i]) lcd_trans(tekst[i++],1); 
} 

// Inicjowanie LCD 
void lcd_init(void) 
{ 
        unsigned char i; 
        DDRLCD=0xff;            // PORTLCD - wyjsciem 
        PORTLCD &= _BV(RW); 
        czekaj(45);             // czekamy okolo 45ms - katalogowo 15ms 
   		asm("nop"); 
        for(i=0;i<3;i++)        // 3-krotne wyslanie 3- 
                { 
                PORTLCD |= _BV(E); 
                PORTLCD=(PORTLCD&0x0f)|0x30;//wyslij 3- do LCD 
                asm("nop");asm("nop");asm("nop"); 
                PORTLCD &= _BV(E); 
                czekaj(5);                      // ok. 5ms 
                } 
        PORTLCD |= _BV(E); 
        PORTLCD=(PORTLCD&0x0f)|0x20;  //wyslij 2- do LCD 
        asm("nop");asm("nop");asm("nop"); 
        PORTLCD &= _BV(E); 
        czekaj(10L);            // od tego momentu sprawdzamy gotowosc LCD 
        lcd_trans(0x28,0);      // interfejs 4-bitowy, 2 linie, znak 5x7 
        lcd_trans(0x08,0);      // wylacz LCD, wylacz kursor, wylacz mruganie 
        lcd_trans(0x01,0);      // czysc LCD nie trzeba czekac !!! 
        lcd_trans(0x06,0);      // zwiekszanie pozycji kursora po kazdym znaku 
        lcd_trans(0x0c,0);      // wlacz wyswietlacz bez kursora 
   } 


//*************************************************************** 
int main (void) 
{ 
        lcd_init();                                     // inicjujmy LCD 
        lcd_tekst('tekst1');      // wypisz *tekst1 
        lcd_xy(1,0); 
        lcd_trans('.',1);       // wyswietl kropke 
        lcd_trans(0xdf,1);      // znak stopni 
        lcd_tekst("C  ");       // duze C - "Celsjusza"  i spacja 
}

#define F_CPU        16000000
#define CYCLES_PER_US ((F_CPU+500000)/1000000) 

/****** Funkcje delay *******************************************/
void delay(unsigned int us) 
{ 
 unsigned int delay_loops;
 register unsigned int  i;

 delay_loops = (us+3)/5*CYCLES_PER_US; 
 for (i=0; i < delay_loops; i++) {};
} 

void delayms(unsigned int ms)
{
 unsigned int i;

 for (i=0;i<ms;i++) {delay(999); asm volatile ("WDR"::);}
} 
/***************************************************************/

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

#define F_CPU	12000000
#define CYCLES_PER_US ((F_CPU+500000)/1000000) 

/****** Funkcje delay *******************************************/ 
void delayus(unsigned int us) 
{ 
	unsigned int delay_loops; 
	register unsigned int  i; 
	delay_loops = (us+3)/5*CYCLES_PER_US; 
	for (i=0; i < delay_loops; i++) {}; 
}

void delayms(unsigned int ms) 
{ 
	unsigned int i; 
	for (i=0;i<ms;i++)
	{
		delayus(999);
		asm volatile ("WDR"::);
	}
}
/***************************************************************/

// Definicje dotyczace LCD 
#define LCD PORTA 				//port z LCD
#define RS 0                     // wybor rejestru 
#define RW 2                     // 1 - odczyt; 0 - zapis 
#define E 3                      // sygnal zezwalajacy (enable) 
#define SET_E LCD |= _BV(E) 
#define CLR_E LCD &= ~_BV(E) 
#define SET_RS LCD |= _BV(RS) 
#define CLR_RS LCD &= ~_BV(RS) 
#define SET_RW LCD |= _BV(RW) 
#define CLR_RW LCD &= ~_BV(RW) 
#define DDRLCD DDRA             // port z podlaczanym LCD 
#define PINLCD PINA             // port z podlaczanym LCD 
// Wykorzystujemy tylko cztery linie przesylowe D4-D7 portu PORTLCD 


// 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
LCD = ((LCD & 0x0F) | (x & 0xF0)); // zapis pierwszej połówki bajtu
CLR_E; // opadające zbocze na E -> zapis do wyświetlacza
asm("nop");
SET_E; // ustaw na E stan wysoki
LCD = ((LCD & 0x0F) | ((x & 0x0F) << 4)); // zapis drugiej połowki bajtu
CLR_E; // opadające zbocze na E -> zapis do wyświetlacza
delayms(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)
{
delayms(15); // czekaj 15ms na ustabilizowanie się napięcia zasilającego
CLR_E; // E = 0
CLR_RS; // RS = 0
char i; // zmienna licznikowa
for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
  {
  SET_E; // E = 1
  LCD &= 0x30; //
  CLR_E; // E = 0
  delayms(5); // czekaj 5ms
  }
SET_E; // E = 1
LCD &= 0x2E; //
CLR_E; // E = 0
delayms(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 lcd_xy(unsigned char w, unsigned char k) 
{ 
	write_command((w*0x40+k) | 0x80); 
}