Elektroda.pl
Elektroda.pl
X

Wyszukiwarki naszych partnerów

Wyszukaj w ofercie 200 tys. produktów TME
Europejski lider sprzedaży techniki i elektroniki.
Fibaro Fibaro
Proszę, dodaj wyjątek elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

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

kat85 11 Lip 2009 21:27 4136 8
  • #1 11 Lip 2009 21:27
    kat85
    Poziom 10  

    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:

    Code:
    /*****************************************************
    
    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:


    Code:

    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

  • Fibaro
  • #2 12 Lip 2009 10:28
    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:

    Code:
    //*** 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).

  • Fibaro
  • #3 12 Lip 2009 10:45
    kat85
    Poziom 10  

    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 12 Lip 2009 10:56
    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:
    Code:
    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 ?:

    Code:
    rebit = PIN1WIRE ? 1:0; 

  • #5 12 Lip 2009 13:48
    kat85
    Poziom 10  

    Zmieniłem nieco kod programu. Obecnie wygląda tak:

    Code:
    /*****************************************************
    
    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:

    Code:

    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.

  • Fibaro
  • #6 12 Lip 2009 14:37
    michalko12
    Specjalista - Mikrokontrolery

    Code:
    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 12 Lip 2009 15:38
    kat85
    Poziom 10  

    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 13 Lip 2009 00:08
    michalko12
    Specjalista - Mikrokontrolery

    Wzoruj się na tym kodzie poniżej. Napisane dzisiaj według dokumentacji MAXIMa (WinAVR).

    Code:


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

    Code:
    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:

    Code:
    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ć:

    Code:
    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 13 Lip 2009 00:24
    kat85
    Poziom 10  

    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.

TME logo Szukaj w ofercie
Zamknij 
Wyszukaj w ofercie 200 tys. produktów TME
TME Logo