logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

[C] Obsługa ds18b20 - funkcja komunikacji 1 wire

kat85 11 Lip 2009 21:27 4379 8
  • #1 6767314
    kat85
    Poziom 11  
    Piszę obecnie program obsługujący termometr ds18b20. Nie mogę wykorzystać gotowych bibliotek dostarczonych razem z kompilatorem (CodeVision), więc obsługę 1 wire napisałem sam na podstawie specyfikacji. Jednak poza wysłaniem resetu komunikacja nie przebiega poprawnie. Oto mój kod:

    /*****************************************************
    This program was produced by the
    CodeWizardAVR V2.03.4 Standard
    Automatic Program Generator
    © Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.
    http://www.hpinfotech.com
    
    Project : 
    Version : 
    Date    : 2009-07-10
    Author  : 
    Company : 
    Comments: 
    
    
    Chip type           : ATmega8
    Program type        : Application
    Clock frequency     : 8,000000 MHz
    Memory model        : Small
    External RAM size   : 0
    Data Stack size     : 256
    *****************************************************/
    
    #include <mega8.h>
    #include <delay.h>
    
    //PC.3 -> 1wire
    
    #define CATCH1WIRE DDRC.3=1
    #define RELEACE1WIRE DDRC.3=0
    #define SET1WIRE PORTC.3=1
    #define CLEAR1WIRE PORTC.3=0
    #define PIN1WIRE PINC.3
    
    
    //*** FUNKCJA RESETUJACA MAGISTRALE 1WIRE ***//
    unsigned char reset_1wire(void)
    {
    unsigned char prescence=0;
    
    CATCH1WIRE;     	//przejmij magistrale
    CLEAR1WIRE;     	//wyslij reset na magistrale
    delay_us(500);  	//odczekaj 500us
    RELEACE1WIRE;       	//zwolnienie magstral - przejsce w stan wysokiej -impedancj
    delay_us(30);   	//odczekaj  30us
    
    if(PIN1WIRE==0)   	//jesli slave ustawil linie w stan niski
        {
        prescence=1;    	//znaczy ze wyslal sygnal zgloszenia
        }
        else
        {
        delay_us(470);
        SET1WIRE;  		//wlaczenie rezystora podciagajacego - wymuszenie 1
        CATCH1WIRE;
        return(0);    	//jesli nie, to uklad niekatywny
        }
    
    
    delay_us(470); 		//odczekaj 470us i sprawdz czy slave podciagnal stan magistrali - czy ja zwolnil  
    
    if(PIN1WIRE==1)
        {
        prescence=1;   	 //zwolnil
        }
        else
        {
        prescence=0;    	//nie zwolnil
        }
        
    SET1WIRE;  		//wlaczenie rezystora podciagajacego - wymuszenie 1
    CATCH1WIRE;   		//zmiana kierunku pina - wyjscie w stanie wysokim    
        
    return(prescence);
    }
    
    
    //*** FUNCJA WYSYLAJACA 1 BIT NA MAGISTRALE 1WIRE ***//
    void send1bit_1wire(char mark)
    {
    CATCH1WIRE;     	//przejmin magistrale
    CLEAR1WIRE;    		//wyslij reset na magistrale
    delay_us(5);    	//odczekaj 5us
    
    if(mark==1)
        {
        SET1WIRE;   	//jesli zadanie wyslania 1 to ustaw magistrale
        }
        
    delay_us(80);      	//poczekaj az save zakoczy probkowanie stanu lini
    SET1WIRE;       	//ustaw magistrale w stan spoczynku
    }
    
    
    //*** FUNKCJA ODBIERAJACA 1 BIT Z MAGISTRALI 1WIRE ***//
    unsigned char recive1bit_1wire(void)
    {
    unsigned char rebit=0;
    
    CATCH1WIRE;    	 	//przejmij magistrale
    CLEAR1WIRE;     	//resetuj magistrale
    delay_us(3);    	//czekaj 3us
    RELEACE1WIRE;       	//zwolnij magistrale - pin jako wejscie
    delay_us(15);   	//odczekaj 15us i probkuj stan magistrali - czast trwania bitu na magistrali to 15us
    
    if(PIN1WIRE==1)   	//jesli stan magistrali to 1
        {
        rebit=1;    	//odebrano jedynke
        }
        else
        {
        rebit=0;
        }
    
    delay_us(60);
    SET1WIRE;  		//wlaczenie rezystora podciagajacego - wymuszenie 1
    CATCH1WIRE;   		//zmiana kierunku pina - wyjscie w stanie wysokim    
    
    return(rebit);  	//zwroc wartosc odebranego bitu
    }
    
    
    //*** FUNKCA WYSYLAJACA 1 BAJT NA MAGISTALE 1WIRE ***//
    void send1byte_1wire(unsigned char data)
    {
    unsigned char i=0;  	//zmienna pomocnicza
    unsigned char bufor=0;
    
    for(i=0; i<8; i++)
        {
        bufor=data>>i;                  	//przesun dana o jedna pozycje w prawo
        send1bit_1wire(bufor &=0x01);    	//wyslij najmlodszy bit zmiennej data
        }
    delay_us(100);      			//odczekaj 100us po zakonczeniu transmisji
    }
    
    
    //*** FUNKCJA ODBIERAJACA 1 BAJT Z MAGISTRALI 1 WIRE ***//
    unsigned char recive1byte_1wire(void)
    {
    unsigned char i=0;
    unsigned char data=0;
    
    for(i=0; i<8; i++)
        {
        if(recive1bit_1wire())
            {
            data|=0x01<<i;
            delay_us(15);
            }
        }
    return(data);
    }
    
    //===================================================
    
    void main(void)
    {
    
    unsigned char temp_high=0;
    unsigned char temp_low=0;
    
    
    PORTB=0x00;
    DDRB=0xFF;
    PORTC=0x0E;
    DDRC=0x7E;
    PORTD=0x00;
    DDRD=0xFF;
    TCCR0=0x00;
    TCNT0=0x00;
    TCCR1A=0x00;
    TCCR1B=0x00;
    TCNT1H=0x00;
    TCNT1L=0x00;
    ICR1H=0x00;
    ICR1L=0x00;
    OCR1AH=0x00;
    OCR1AL=0x00;
    OCR1BH=0x00;
    OCR1BL=0x00;
    ASSR=0x00;
    TCCR2=0x00;
    TCNT2=0x00;
    OCR2=0x00;
    MCUCR=0x00;
    TIMSK=0x00;
    ACSR=0x80;
    SFIOR=0x00;
    
    while (1)
          {
          delay_ms(500);
          PORTB.0=0;  //KONTROLA
                
          /*if(reset_1wire())
            {
            send1byte_1wire(0x33);  //wybierz jeden uklad
            send1byte_1wire(0x4E);  //zapisz pamiec slave
            send1byte_1wire(0x00);  //zapisz Th
            send1byte_1wire(0x00);  //zapisz Tl
            send1byte_1wire(0x1F);  //zapisz R0=0 R1=0 - rozdzielczosc 9 bitowa
            reset_1wire();
            send1byte_1wire(0x33);  //wybierz jeden uklad
            send1byte_1wire(0x48);  //zapisz pamiec eeprom slave
            reset_1wire();
            }*/
          
          if(reset_1wire())
            {
            //send1byte_1wire(0x33);  	//wybierz jeden uklad
            //send1byte_1wire(0xB8); 	//recall ee
            //reset_1wire();
            send1byte_1wire(0x33);  	//wybierz jeden uklad
            send1byte_1wire(0xBE);  	//odczytaj pamiec slave
            temp_low=recive1byte_1wire();   //odczytaj mlodsza czesc temp
            reset_1wire();
            PORTD=temp_low;
            PORTB.0=1;  //KONTROLA
            delay_ms(1000);
            }
            
          /*
          
          if(reset_1wire())               //jesli uklad jest
            {
            send1byte_1wire(0x33);      //odczytaj jego pamiec
            delay_us(10);
            send1byte_1wire(0x44);      //rozpocznij konwersje temperatury
            
            //strong pull-up
            delay_ms(800);  //poczekaj na koniec pomiaru
            if(reset_1wire())      //wyslij reset
                {
                send1byte_1wire(0x33);  //wybierz jeden uklad
                send1byte_1wire(0xBE);  //odczytaj pamiec slave
                temp_low=recive1byte_1wire();   //odczytaj mlodsza czesc temp
                temp_high=recive1byte_1wire(); //odczytaj starsza czesc
                reset_1wire();
                }
            }
          if(temp_low!=0)
            {
            PORTD=temp_high;
            //PORTD=temp_low;
            }
          */ 
         };
    }
    


    Czytając pamięć czujnika dostaję stabilne, powtarzalne dane jednak różnią sie one od zakładanych.
    Mapa pamięci czujnika z odebranych danych jest następująca:


    
    0x00 - 10001010
    0x01 - 11000101 
    0x02 - 11001011
    tych wartości zapomniałem zapisać
    0x05 - 00000000 - według specyfikacji powinno być FFh
    0x06 - 11001101 - według specyfikacji powinno być 0Ch
    0x07 - 11111111 - według specyfikacji powinno być 10h
    0x08 - 11111111
    


    Tak więc sądząc po rejestrach 6-8 coś tu nie działa tak jak powinno. Ponowna analiza kodu nic nie dała. Problem ciągle sie powtarza. Program sprawdziłem na 2 sztukach czujnika w tym jeden był całkowicie nowy.
    Czy któryś z Kolegów byłby w stanie mi pomóc? Będę bardzo wdzięczny.

    Pozdrawiam

    PS
    Proszę nie zwracać uwagi na "wykwintność" treści komentarzy :D
  • #2 6768378
    michalko12
    Specjalista - Mikrokontrolery
    Na pewno popełniłeś błąd w odczycie bitu. Magistrale masz próbkować
    przed upływem 15us od chwili wymuszenia niskiego poziomu przez
    master, ty robisz to po upływie ponad 18us.

    Swoją droga masz jakiegoś pullupa na magistrali? Bo jeśli nie masz i DSa
    zasilasz z magistrali to musisz dać standardowo 4,7k dla 5V, a jesli
    zasilasz DSa z osobnego źródła i nie masz zewnętrznego pullupa to
    dodatkowo popełniłeś błąd przy odczycie nie właczając wewnętrznego pullupa.

    Spróbuj funkcje odczytu w tej postaci:

    //*** FUNKCJA ODBIERAJACA 1 BIT Z MAGISTRALI 1WIRE ***//
    unsigned char recive1bit_1wire(void)
    {
    unsigned char rebit=0;
    
    CATCH1WIRE;           //przejmij magistrale
    CLEAR1WIRE;        //resetuj magistrale
    delay_us(2);       //czekaj 2us
    RELEACE1WIRE;          //zwolnij magistrale - pin jako wejscie
    SET1WIRE;        //wlaczenie rezystora podciagajacego - wymuszenie 1
    delay_us(3);      //odczekaj 3us i probkuj stan magistrali - czast trwania bitu na magistrali to 15us
    
    if(PIN1WIRE==1)      //jesli stan magistrali to 1
        {
        rebit=1;       //odebrano jedynke
        }
        else
        {
        rebit=0;
        }
    
    delay_us(60);
    
    CATCH1WIRE;         //zmiana kierunku pina - wyjscie w stanie wysokim   
    
    return(rebit);     //zwroc wartosc odebranego bitu
    } 


    Zapomniałem dodać.
    Moment próbkowanie, w tym przypadku ustawiony na mniej więcej 5us od startu może się różnić w zależności od pojemności linii magistrali i od wartości rezystora podciągającego magistralę. Ważne jest aby odczyt nastąpił przed upływem 15us. Jak będą błędy w odczycie próbuj regulować ten czas (3us).
  • #3 6768437
    kat85
    Poziom 11  
    Mam rezystor 4k7, dodatkowo przy złączu do czujnika na liniach zasilających mam kondensator 100n. Czujnik podłączony za pomocą 3 linii GND DS VCC.
    Zabieram się do poprawy kodu i napisze jakie są tego wyniki.
  • #4 6768470
    michalko12
    Specjalista - Mikrokontrolery
    kat85 napisał:
    Mam rezystor 4k7, dodatkowo przy złączu do czujnika na liniach zasilających mam kondensator 100n. Czujnik podłączony za pomocą 3 linii GND DS VCC.
    Zabieram się do poprawy kodu i napisze jakie są tego wyniki.


    Jeszcze w funkcji resetu DSa czas 30µs zmieniłbym na 70µs ponieważ według dokumentacji DS może czekać na wystawienie Presence pulse nawet do 60µs.

    Trzymaj się tych czasów co podaje producent. Wszystkie czasy podane są w przedziale od x do 4x a to dlatego że DS posiada wewnątrz jakiś generator i nie jest on stabilny temperaturowo , według producenta częstotliwośc jego pracy może zmieniać się właśnie od x do 4x, zwłaszcza że jest to termometr i moze pracowac w skrajnych warunkach. Dla przykładu zniski poziom magistrali dla odczytu bitu o wartości 0 może trwać 15us a w innej temperaturze popłynąć nawet do 60us. I dlatego właśnie trzeba próbkować przed upływem tych 15us. Ta sama sytuację miałeś z tymi 30µs w funkcji resetu czujnika, przy jednej temperaturze funkcja działałaby przy innej już nie.


    Jeszcze tak z innej beczki

    Kod:
    if(PIN1WIRE==1)      //jesli stan magistrali to 1
        {
        rebit=1;       //odebrano jedynke
        }
        else
        {
        rebit=0;
        } 


    możesz zastąpić zapominanym przez wiekszośc operatorem wyrażenia warunkowego ?:

    rebit = PIN1WIRE ? 1:0; 
  • #5 6769121
    kat85
    Poziom 11  
    Zmieniłem nieco kod programu. Obecnie wygląda tak:

    /*****************************************************
    This program was produced by the
    CodeWizardAVR V2.03.4 Standard
    Automatic Program Generator
    © Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.
    http://www.hpinfotech.com
    
    Project : 
    Version : 
    Date    : 2009-07-12
    Author  : 
    Company : 
    Comments: 
    Clock 4MHz
    
    
    Chip type           : ATmega8
    Program type        : Application
    Clock frequency     : 4,000000 MHz
    Memory model        : Small
    External RAM size   : 0
    Data Stack size     : 256
    *****************************************************/
    
    #include <mega8.h>
    #include <delay.h>
    #define CATCH1WIRE DDRC.3=1
    #define RELEACE1WIRE DDRC.3=0
    #define SET1WIRE PORTC.3=1
    #define CLEAR1WIRE PORTC.3=0
    #define PIN1WIRE PINC.3
    
    //*** FUNKCJA RESETUJACA MAGISTRALE 1WIRE ***//
    unsigned char reset_1wire(void)
    {
    
    CATCH1WIRE;     //pin as output
    CLEAR1WIRE;     //drive bus low
    delay_us(480);  //delay 480us
    
    RELEACE1WIRE;   //release bus      
    delay_us(70);   //delay 70us
    
    if(PIN1WIRE==0)     //sample bus   
        {
        delay_us(410);  //delay 410us
        return(1);      //return ans=found device(s) 
        }
        else
        {
        delay_us(410);  //delay 410us
        return(0);      //return ans=no device found   
        }
    }
    
    //*** FUNCJA WYSYLAJACA 1 BIT NA MAGISTRALE 1WIRE ***// 
    void send1bit_1wire(char mark)
    {
    
    CATCH1WIRE;     //pin as output     
    CLEAR1WIRE;     //drive bus low  
    
    if(mark==1)
        {
        delay_us(6);    //delay 6us
        RELEACE1WIRE;   //release buss - pin as input HiZ     
        delay_us(64);   //delay 64us
        }
        else
        {
        delay_us(60);   //delay 60us
        RELEACE1WIRE;   //release buss - pin as input HiZ     
        delay_us(10);   //delay 10us
        }    
    }
    
    //*** FUNKCJA ODBIERAJACA 1 BIT Z MAGISTRALI 1WIRE ***// GOYTOWE
    unsigned char recive1bit_1wire(void)
    {
    
    CATCH1WIRE;     //pin as output     
    CLEAR1WIRE;     //drive bus low     
    delay_us(6);    //delay 6us 
    RELEACE1WIRE;   //release bus - pin as input HiZ    
    delay_us(9);    //delay 9us 
    
    if(PIN1WIRE==1)     //sample bus to read bit from SLAVE   
        {
        delay_us(9);    //delay 9us
        return(1);      //return read 1
        }
        else
        {
        delay_us(9);    //delay 9us
        return(0);      //return read 0
        }
    }
    
    //*** FUNKCA WYSYLAJACA 1 BAJT NA MAGISTALE 1WIRE ***//
    void send1byte_1wire(unsigned char data)
    {
    unsigned char i=0;  
    unsigned char bufor=0;
    
    for(i=0; i<8; i++)
        {
        bufor=data>>i;                  //przesun dana o jedna pozycje w prawo
        send1bit_1wire(bufor &=0x01);    //wyslij najmlodszy bit zmiennej data
        delay_us(2);
        }
    
    }
    
    //*** FUNKCJA ODBIERAJACA 1 BAJT Z MAGISTRALI 1 WIRE ***//
    unsigned char recive1byte_1wire(void)
    {
    unsigned char i=0;
    unsigned char data=0;
    
    for(i=0; i<8; i++)
        {
        if(recive1bit_1wire())
            {
            data|=0x01<<i;
            delay_us(10);
            }
        }
    return(data);
    }
    
    
    void main(void)
    {
    unsigned char i=0;
    unsigned char temp_high=0;
    unsigned char temp_low=0;
    
    PORTB=0x00;
    DDRB=0xFF;
    PORTC=0x0E;
    DDRC=0x7E;
    PORTD=0x00;
    DDRD=0xFF;
    TCCR0=0x00;
    TCNT0=0x00;
    TCCR1A=0x00;
    TCCR1B=0x00;
    TCNT1H=0x00;
    TCNT1L=0x00;
    ICR1H=0x00;
    ICR1L=0x00;
    OCR1AH=0x00;
    OCR1AL=0x00;
    OCR1BH=0x00;
    OCR1BL=0x00;
    ASSR=0x00;
    TCCR2=0x00;
    TCNT2=0x00;
    OCR2=0x00;
    MCUCR=0x00;
    TIMSK=0x00;
    ACSR=0x80;
    SFIOR=0x00;
    
    while (1)
          {
          delay_ms(1000);
          PORTB.0=0;  //KONTROLA
          
          if(reset_1wire())
            {
            send1byte_1wire(0x33);  //wybierz jeden uklad
            send1byte_1wire(0xBE);  //odczytaj pamiec slave
            temp_low=recive1byte_1wire();   //odczytaj mlodsza czesc temp
            reset_1wire();
            PORTD=temp_low;
            PORTB.0=1;  //KONTROLA
            delay_ms(1000);
            }
          };     
    }
    


    Jednak działanie programu jest podobne jak poprzednio. Dodam, że obecne czasu opóźnień zaczerpnąłem z publikacji firmy Maxim
    Link
    Jedyne co mi przychodzi do głowy to nieprawidłowe działanie funkcji delay_us().
    Korzystam z wewnętrznego generatora RC ustawionego na 4MHz (poprzednio ustawiłem na 8MHz).
    W innym temacie znalazłem funkcję generująca opóźnienie:

    
    void waitus(unsigned char tau) //range 0 to 255
    {    
    	do
    	{
    		#asm
                nop
            #endasm           //NOP
    	}while(--tau!=0);
    }


    Dla częstotliwości zegara 4MHz pętla wykonuje się 4 razy, więc funkcja generuje opóźnienie takie jak podano w parametrze tau (oczywiście w us). Dla tej funkcji zastosowanej w programie nie mogę nawet uzyskać odpowiedzi od układu slave.

    Czy któryś z Kolegów ma pomysł gdzie może leżeć błąd?

    Dodam, że na zewnętrznym rezonatorze ceramicznym problem pozostaje taki sam.
  • #6 6769312
    michalko12
    Specjalista - Mikrokontrolery
    unsigned char recive1bit_1wire(void)
    {
    
    CATCH1WIRE;     //pin as output     
    CLEAR1WIRE;     //drive bus low     
    delay_us(6);    //delay 6us
    RELEACE1WIRE;   //release bus - pin as input HiZ   
    delay_us(9);    //delay 9us
    
    if(PIN1WIRE==1)     //sample bus to read bit from SLAVE   
        {
        delay_us(9);    //delay 9us
        return(1);      //return read 1
        }
        else
        {
        delay_us(9);    //delay 9us
        return(0);      //return read 0
        }
    } 


    Czytaj ze zrozumieniem, dałem Ci poprawioną procedurę, a ty dalej z uporem czytasz po 15µs. 6+9 daje 15µs plus czasy instrukcji które są pomiędzy. Odczyt możesz zrobić już po kilku µs, nie musisz czekać do 15µs!

    Jeśli nie jesteś pewien jak działa Ci funkcja opóźniająca napisz funkcję która ja sprawdzi. Napisz funkcję która przy pomocy tej funkcji będzie generowała np 1Hz na którymś pinie.
  • #7 6769525
    kat85
    Poziom 11  
    Kolego, jak już napisałem w poprzednim poście, czasy za które mnie skrzyczałeś są zaczerpnięte z publikacji firmy Maxim, do której link również podałem. Oczywiście brałem pod uwagę również Twoją wypowiedź o próbkowaniu linii przed upływem 15us, jednak nic to nie dawało. Czy to było 3, 10, 15us odczytane dane są identyczne. Funkcję generującą częstotliwość za pomocą delay_us() napisałem już dawno. Na oko częstotliwość się zgadzała, jednak jutro dokładnie sprawdzę działanie tej funkcji za pomocą oscyloskopu.
  • #8 6770595
    michalko12
    Specjalista - Mikrokontrolery
    Wzoruj się na tym kodzie poniżej. Napisane dzisiaj według dokumentacji MAXIMa (WinAVR).

    
    
    #define OW 0x10     // PORTB.4
    
    //**************************************
    unsigned char OW_Reset(void)
    {
    
     PORTB &= ~OW;
     DDRB |= OW;       // pin jako wyjście
     
     _delay_us(500);
     
     DDRB &= ~OW;       // pin jako wejscie
     
      _delay_us(70);
      
     // sprawdzamy presence pulse
     
     if(PINB & OW)
     {          // Brak obecności DS
       return 0;
     }
     _delay_us(500);
     return 1;
     }
    
    //**************************************
    void OW_WriteBit(unsigned char bit)
    {
     cli();
     PORTB &= ~OW;
     DDRB |= OW;       // pin jako wyjście
    
     _delay_us(2);
    
     if(bit)
     {
         DDRB &= ~OW;       // pin jako wejscie
     }
    	_delay_us(60);
    	DDRB &= ~OW;       // pin jako wejscie
    	sei();
    }
    
    //**************************************
    unsigned char OW_ReadBit(void)
    {
    	unsigned char tmp;
    	cli();
    	PORTB &= ~OW;
    	DDRB |= OW;       // pin jako wyjście
    
    	_delay_us(3);
    	
     	DDRB &= ~OW;       // pin jako wejscie
    
    	_delay_us(3);
    
    	tmp = (PINB & OW) ? 1:0;
    	sei();
    	
    	_delay_us(55);
    
    	return tmp;
    }
    
    //**************************************
    void OW_WriteByte(unsigned char byte)
    {
      unsigned char i;
      
      for( i = 0; i<8; i++)
      {
    	  OW_WriteBit(byte & 1);
    	  byte >>= 1;
    	  _delay_us(2);
      }
    }
    
    //**************************************
    unsigned char OW_ReadByte(void)
    {
       unsigned char i,k=0;
       
       for(i=0; i<8; i++)
       {
           k >>= 1;
    	   if(OW_ReadBit()) k|= 0x80;
       }
      return k;
    }
    
    


    Fragment kodu sprawdzającego:

    if(OW_Reset())
    {
    	OW_WriteByte(0xCC);
    	OW_WriteByte(0xBE);
    	for(i=0; i<9; i++)
    	{
    		tmp = OW_ReadByte();
    		while(!(UCSRA & (1<<UDRE)));
    		UDR = tmp;
    	}
    	OW_Reset();
    	OW_WriteByte(0xCC);
    	OW_WriteByte(0x44);
    }




    Wartości po pierwszym odczycie:
    50,05,4B,46,7F,FF,0C,10,1C

    Wartości po kolejnym odczycie:
    AB,01,4B,46,7F,FF,05,10,92

    Dodano po 3 [godziny] 28 [minuty]:

    *************************************************************
    Zauważyłem jeszcze jeden chyba najważniejszy błąd:

    while (1)
          {
          delay_ms(1000);
          PORTB.0=0;  //KONTROLA
         
          if(reset_1wire())
            {
            send1byte_1wire(0x33);  //wybierz jeden uklad
            send1byte_1wire(0xBE);  //odczytaj pamiec slave
            temp_low=recive1byte_1wire();   //odczytaj mlodsza czesc temp
            reset_1wire();
            PORTD=temp_low;
            PORTB.0=1;  //KONTROLA
            delay_ms(1000);
            }
          };     
    }


    A powinno być:

    while (1)
          {
          delay_ms(1000);
          PORTB.0=0;  //KONTROLA
         
          if(reset_1wire())
            {
            send1byte_1wire(0xCC);  //przeskocz ROM
            send1byte_1wire(0xBE);  //odczytaj pamiec slave
            temp_low=recive1byte_1wire();   //odczytaj mlodsza czesc temp
            reset_1wire();
            PORTD=temp_low;
            PORTB.0=1;  //KONTROLA
            delay_ms(1000);
            }
          };     
    }
    


    Nic dziwnego że DS jakieś śmieci zwracał 0x33 to komenda do odczytu numeru seryjnego i wszystko może by działało jakbyś między instrukcjami:

    send1byte_1wire(0x33);


    send1byte_1wire(0xBE);


    odczytał 8 bajtów z DSa.
  • #9 6771613
    kat85
    Poziom 11  
    W sumie to całkie logiczne. Sprawdze to jutro. Narazie dodam, że kod który podałeś działa. Dzięki za niego:!: Jutro porównam oba kody.
REKLAMA