DS18B20 z ATmega8 i LCD - dlaczego pokazuje temperaturę 0.0?

#define OW_IN DDRB &= 0b01111111		//makra do obslugi linii 1wire
#define OW_OUT DDRB |= 0b10000000
#define OW_CLR PORTB &= 0b01111111
#define OW_SET PORTB |= 0b10000000
#define OW_PIN	PINB
#define OW_PORT	PORTB

#define SKIP_ROM  			0xCC		//pominiecie rom
#define CONVERT_T 			0x44		//konwersja temp
#define READ_SCRATCHPAD 	0xBE		//odczyt pamieci termometru

char OW_RESET(void)		//reset magistrali
{
char wynik;

	OW_CLR;				//wyzerowanie pinu
	OW_IN;				//pin jako wejscie -> pin=1

	OW_OUT;				//pin jako wyjscie -> pin=0
	_delay_us(800);		//odczekaj 500us(min480us)
	OW_IN;				//pin jako wejscie -> pin=1

	_delay_us(100);		//odczekaj 70us (min60us)
	wynik = (OW_PIN & 0x80)>>7;	//wystaw odpowiedz

	_delay_us(250);
	return(wynik);
}

void OW_WBIT(char bit)		//zapis jednego bitu na magistrale
{
	OW_CLR;					//wyzerowanie pinu
	OW_IN;					//pin jako wejscie -> pin=1
	if (bit==0)				//jezeli mamy zapisac zero (argument f-ji)
	{
		OW_OUT;				//pin=0
		_delay_us(90);		//na 70us(min60us)
		OW_IN;				//pin=1
		_delay_us(15);		//na 15us
	}
	else					//jezeli mamy zapisac jedynke
	{
	OW_OUT;					//pin=0
	_delay_us(5);			//czekaj 5us
	OW_IN;					//pin=1
	_delay_us(60);			//czekaj 70us (wypelnienie slotu)
	}
}

char OW_RBIT(void)			//procedura odczytu bitu z szyny
{
	char wynik;
	OW_CLR;					//wyzerowanie pinu
	OW_IN;					//ustawienie portu jako wejscie (1 na wyj)

	OW_OUT;					//ustawienie portu jako wyjscie (0 na wyj, bo ow_clr)
	_delay_us(6);			//czekac 6us

	OW_IN;					//ustawienie pinu jako wejscie - pull-up
	_delay_us(10);			//odczekac 10us

	wynik = (OW_PIN & 0x80)>>7;
	_delay_us(60);			//60us

	return wynik;
}

void OW_SEND(char byte)		//procedura zapisu bajtu na szyne
{
char i;
for(i=0;i<8;i++)			//osmiokrotne wywolanie zapisu bitu na szyne
{
	OW_WBIT(byte & 0x01);	//wystawienie na szyne LSB
	byte >>=1;				//i przesuniecie do nastepnego bitu.
}
}

char OW_READ(void)			//procedura odczytu bajtu z szyny
{
char i,byte=0;
for(i=0;i<8;i++)			//osmiokrotne wywolanie odczytu bitu
{
	byte |= (OW_RBIT()<< (i));	//za pomoca |= tworzymy wyjsciowy bajt

}
return byte;
}

void OW_CONVTEMP()			//procedura rozkazu konwersji temperatury
{
	cli();
	OW_RESET();				//reset magistrali
	OW_SEND(SKIP_ROM);		//pominiencie sprawdzania ROM
	OW_SEND(CONVERT_T);		//rozkaz konwersji temp
	sei();
}

char OW_READTEMP(void)		//procedura odczytu temperatury
{
	cli();
	unsigned char scratchpad[9];	//deklaracja 'mapy pamieci'
	unsigned char i;				//zmienna pomocnicza
	for (i=0; i<9;i++) scratchpad[i]=0;		//zerowanie mapy pamieci
	OW_RESET();								//reset magistrali
	OW_SEND(SKIP_ROM);						//pominiecie sprawdzania ROM
	OW_SEND(READ_SCRATCHPAD);				//odczyt pamieci termometru
	for (i=0; i<9;i++) scratchpad[i] = OW_READ();

//	return  ((scratchpad[1] << 4) | (scratchpad[0] >> 4));	//obliczanie dla DS18B20
	return ((scratchpad[0]>>1)&0b01111111); // obliczanie dla DS1820 (nie B!!)
	sei();

}

void OW_RESOLUTION()	//procedura ustawiajaca rozdzielczosc na 9bit
{
	cli();
	OW_RESET();				//reset magistrali
	OW_SEND(SKIP_ROM);		//pominiecie sprawdzania ROM
	OW_SEND(0x4E);			//zapis do pamieci termometru
	OW_SEND(0);				//(nie uzywamy TH i TL)
	OW_SEND(0);

	//mozliwe ze zbedne dla ds1820 (nie B!)
	OW_SEND(0b00011111);			//ustaw rozdzielczosc na 9bit 0_R1_R0_11111
	sei();
}

unsigned char odbierz1w(void) // READ_BYTE  
{ 
   unsigned char i; 
   unsigned char value = 0; 
   for (i=0;i<8;i++) 
   { 
      if(odbierz()) 
      value|=0x01<<i;
   } 
   delay_us(119);
   return(value); 
} 

void zapisz1w(char val) // WRITE_BYTE 
{ 
   unsigned char i; 
   unsigned char temp; 
   for (i=0; i<8; i++)  
   { 
      temp = val>>i; 
      temp &= 0x01; 
      wyslij(temp); 
   }
      delay_us(119);
} 

void wyslij(char bit) //WRITE_BIT 
{    
   	PORTB |= _BV(1); //DQ = 0; 
  	if(bit==0) 
              {
              delay_us(103); // (wedlug symulatora 103,3uS)
	PORTB &= ~_BV(1); //DQ =1;
              }
   	PORTB &= ~_BV(1);//DQ = 1;
              delay_us(103); // (wedlug symulatora 103,3uS) 
} 

#define OUT DDRB|=0x02;
#define IN DDRB&=~0x02;

char odbierz1w(void) // READ_BYTE  
{ 
   unsigned char i; 
   unsigned char value = 0; 
   for (i=0;i<8;i++) 
   { 
      if(odbierz()) 
      value|=0x01<<i; 
   } 
   delay_us(150); 
   return(value); 
} 

void zapisz1w(char val) // WRITE_BYTE 
{ 
   unsigned char i; 
   unsigned char temp; 
   for (i=0; i<8; i++)  
   { 
      temp = val>>i; 
      temp &= 0x01; 
      wyslij(temp); 
   } 
      delay_us(150); 
} 

void wyslij(char bit) //WRITE_BIT 
{    
    OUT; 
    if(bit==0) 
   { 
   delay_us(100);
   IN; 
   } 
   IN; 
   delay_us(100); 
}

char odbierz(void) 
{ 
   	unsigned char presence=0; 
   	OUT; 
   	delay_us(2);
   	IN;
  	delay_us(13); 
   	if(bit_is_clear(PINB,PB1)) 
	presence=0; 
   	if(bit_is_set(PINB,PB1)) 
	presence=1; 
   	return(presence); 
} 

void reset1w(void)
	{
	stan = 0;
	OUT;
	delay_us(480);
	IN;
	delay_us(70);
	if bit_is_clear(PINB,PB1)
	stan = 1;
	delay_us(400);
	}

#define OUT DDRB|=0x02; 
#define IN DDRB&=~0x02;

#define OUT PORTB|=0x02; 
#define IN PORTB&=~0x02;

ds.nds[0]=OneWire_read_byte();
   		ds.nds[1]=OneWire_read_byte();
   		itoa(ds.tds/2,buf,10);//temper. całkowita
		write_text(buf);
		write_text(".\0");
   		itoa(abs((ds.tds*10/16)%10),buf,10);	//części dziesiętne
   		write_text(buf);
		write_text(" C");

unsigned char round2(double d1)
{
    return (d1 - floor(d1) >= 0.5) ? ((unsigned char)ceil(d1)) :((unsigned char)floor(d1));
}


    unsigned char wynik1 = ds.nds[0];
    unsigned char wynik2 = ds.nds[1];
    unsigned char TemperaturaH;
    unsigned char TemperaturaL;
    unsigned char TemperaturaZnak;
    TemperaturaH = wynik2 << 5;//przesuniecie w prawo, aby uciac 5 bitow znaku temp.
    TemperaturaH += wynik1 >> 3;//dodanie mlodszych bitow temp.
    TemperaturaH >>= 1;//powrot na odp. miejsce

    TemperaturaL = wynik1 << 4;//przesuniecie o 4 bity w prawo aby uciac 4 MSB
    TemperaturaL >>= 4;//powrot na miejsce tamtych 4. bitow
    TemperaturaL = round2((double)TemperaturaL*(double)0.625);

    if(wynik2 >= 0x80)//gdy temperatura ujemna
    {
        TemperaturaZnak = '-';
        TemperaturaH ^= (1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2) | (1 << 1) | (1 << 0);
        TemperaturaL = 10 - TemperaturaL;
        if(TemperaturaL > 9)
        {
            TemperaturaL %= 10;
            TemperaturaH++;
        }
    }
    else TemperaturaZnak = '+';

    write_text(TemperaturaZnak);
    itoa(TemperaturaH,buf,10);
    write_text(buf);
    write_text(".\0"); 
    itoa(TemperaturaL,buf,10);
    write_text(buf);

         itoa(ds.tds/2,buf,10);//temper. całkowita
      write_text(buf);
      write_text(".\0");
         itoa(abs((ds.tds*10/16)%10),buf,10);   //części dziesiętne 

itoa((ds.nds[1] << 4) | (ds.nds[0] >> 4),buf,10);
      write_text(buf);

unsigned char round2(double d1) 
{ 
    return (d1 - floor(d1) >= 0.5) ? ((unsigned char)ceil(d1)) :((unsigned char)floor(d1)); 
} 


    unsigned char wynik1 = ds.nds[0]; 
    unsigned char wynik2 = ds.nds[1]; 
    unsigned char TemperaturaH; 
    unsigned char TemperaturaL; 
    unsigned char TemperaturaZnak; 
    TemperaturaH = wynik2 << 5;//przesuniecie w prawo, aby uciac 5 bitow znaku temp. 
    TemperaturaH += wynik1 >> 3;//dodanie mlodszych bitow temp. 
    TemperaturaH >>= 1;//powrot na odp. miejsce 

    TemperaturaL = wynik1 << 4;//przesuniecie o 4 bity w prawo aby uciac 4 MSB 
    TemperaturaL >>= 4;//powrot na miejsce tamtych 4. bitow 
    TemperaturaL = round2((double)TemperaturaL*(double)0.625); 

    if(wynik2 >= 0x80)//gdy temperatura ujemna 
    { 
        TemperaturaZnak = '-'; 
        TemperaturaH ^= (1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2) | (1 << 1) | (1 << 0); 
        TemperaturaL = 10 - TemperaturaL; 
        if(TemperaturaL > 9) 
        { 
            TemperaturaL %= 10; 
            TemperaturaH++; 
        } 
    } 
    else TemperaturaZnak = '+'; 

    write_text(TemperaturaZnak); 
    itoa(TemperaturaH,buf,10); 
    write_text(buf); 
    write_text(".\0"); 
    itoa(TemperaturaL,buf,10); 
    write_text(buf);

itoa((ds.nds[1] << 4) | (ds.nds[0] >> 4),buf,10); 
      write_text(buf);

#include <math.h>

avr-gcc -mmcu=atmega88 -I. -g -O2 -Wall -pedantic -std=gnu99 "main.c" -o "main.o" -lm

avr-gcc.exe  -mmcu=atmega8 -Wall -gdwarf-2          -lm       -DF_CPU=8000000UL -O2 -fsigned-char -MD -MP -MT lcdm8.o -MF dep/lcdm8.o.d  -c  ../lcdm8.c

void OneWire_init(void)
{
    PORTB &= ~(1 << DQ);
    DDRB&=~_BV(PB1);
    
}


void OneWire_dlus(unsigned char x)
{
char q;
    if(x > 5) OCR2 = x-5; else return;
    TCCR2 = 0x01;
    for(q = 0; q < 4; q++)
    {
        TCNT2 = 0;
	    while(TCNT2 < OCR2);
    }
    TCCR2 = 0;
}



char OneWire_reset(void)//reset lini OneWire (1 - ok, 0 - brak)
{
    char q = 1;
    OneWire_dlus(35);
    CLR_DQ;//pull DQ line
    /*OneWire_dlus(250);
    OneWire_dlus(250);
	OneWire_dlus(250);
    OneWire_dlus(250);//450 us*/
	delayus(480);
    SET_DQ;//powrót lini 1w do trybu wejscia
    /*OneWire_dlus(70);
	OneWire_dlus(70);//31,88 us - czekamy na ustab. lini*/
	delayus(70);
    if(IN_DQ) q = 1;  else q = 0;//odczytujemy co wystawil na linie DS1820
    /*OneWire_dlus(200);
    OneWire_dlus(200);
	OneWire_dlus(200);
    OneWire_dlus(200);*/
	delayus(410);
    if(IN_DQ && q == 0) return 1; else return 0;
}


unsigned char OneWire_read_bit(void)
{
    //char x;
    CLR_DQ;//pull DQ low to start timeslot
    /*for(x = 0; x < 10; x++);
    asm ("nop");*/
	delayus(2);
    SET_DQ;//then return high
    //OneWire_dlus(10);//delay 15us from start of timeslot
	delayus(10);
    if(IN_DQ) return 1; else return 0;//return value of DQ line
}


void OneWire_write_bit(char bitval)
{
    CLR_DQ;//pull DQ low to start timeslot
    //char x;
    /*for(x = 0;x < 10; x++);
    asm ("nop");*/
	delayus(2);
    if(bitval == 1) SET_DQ;//return DQ high if write 1
    //OneWire_dlus(100);//old value for remainder of timeslot - delay 104us
	delayus(104);
    SET_DQ;
}


unsigned char OneWire_read_byte(void)
{
    unsigned char i;
    unsigned char val = 0;
    for (i = 0; i < 8; i++)
    {
        if(OneWire_read_bit()) val |= 0x01 << i;//reads byte in, one byte at a time and then
        //OneWire_dlus(70);// ??shifts it left wait for rest of timeslot 120us
		delayus(119);
    }
    return val;
}


void OneWire_write_byte(unsigned char val)
{
    unsigned char i;
    unsigned char temp;
    for (i = 0; i < 8; i++)// writes byte, one bit at a time
    {
        temp = val >> i;//shifts val right 'i' spaces
        temp &= 0x01;//copy that bit to temp
        OneWire_write_bit(temp);//write bit in temp into
    }
    //OneWire_dlus(50);
	delayus(119);
}