DS1820, Sendet außer Presence nichts zurück.

[Matze (Gast)]

Hallo,

Habe Probleme damit einen DS1820 Temperatursensor auszulesen, welcher an 
einem Atmega16 hängt.

Er hängt an Port B0, und hat einen 4,7K Ohm-Pullup.

Das Programm sieht zum Reset des DS1820 einen 600us-Low vor, danach 
meldet er sich 28uS später mit einem Presence Pulse von 102uS.
Soweit ist alles OK.

Problem ist nun dass egal was ich an ihn Sende z.b. (0xBE für 
Read-Scratch-Pad oder 0x33 für Read Rom) er nichts zurück Sendet.

Ich Sende ihm 0en der Länge 85uS, einsen der Länge 9uS und gebe ihm ca 
0,5Sek Zeit um die Leitung selbst mal auf Masse zu ziehen.
Aber das tut er ja nicht.

ISR(TIMER0_COMP_vect)
{
  PORTB|=0x01;  //Pin Setzen
  TCCR0=0x00;    //Stoppen
  Tint=1;
  //while(1){;}
}

int main(void)
{
  Init();
  DDRD|=0x40;    //Triggerung
  One_Wire_Send(0x55,1);
  PORTD|=0x40;
  _delay_ms(3);
  PORTD&=0xBF;
  while(1)
    {  
    One_Wire_Send(0x44,0);
    PORTD|=0x40;
    _delay_ms(3);
    PORTD&=0xBF;  
    One_Wire_Send(0xB4,0);
    PORTD|=0x40;
    _delay_ms(1);
    PORTD&=0xBF;

    //Stellen();
    //Wecken();
    }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{
  Tint=0;
  DDRB|=0x01;    //PB0 auf Ausgang
  TIMSK|=0x02;  //Interrupt Timer0 Enable
  unsigned short int Vergleich = 0x80;
  if(Steuer==1)  //Reset des DS1820
  {
    TCNT0=0x00;    //Anfang des Zählens
    OCR0=38;    //--600uS
    PORTB&=0xFE;  //Pin = 0
    TCCR0=0x03;    //Prescaler = 8,Timer Starten --16uS
    while(Tint!=1) //warten bis IRQ Ausgelöst
    {
      ;
    }
  }
  else
  {
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      Tint=0;
      if(Byte & Vergleich)    //1 Senden
      {
        TCNT0=0x00;    //Anfang des Zählens
        OCR0=0x01;    //--10uS
        PORTB&=0xFE;  //Pin = 0
      }
      else        //0 Senden
      {
        TCNT0=0x00;    //Anfang des Zählens
        OCR0=0x25;    //--90uS
        PORTB&=0xFE;  //Pin = 0
      }
      TCCR0=0x02;    //Prescaler = 8,Timer Starten
      while(Tint!=1)
      {
        ;
      }
    }  
  }    
}

Eventuell seht ihr das Problem.

Grüße
Matze

[(prx) A. K. (prx)]

Und jetzt darf also jeder das Datasheet vorkramen, um rauszukriegen, 
welche Codes 0x55, 0xB4, ... sind?

[(prx) A. K. (prx)]

Bei 1-Wire darf der µC nie aktiv den Pin hochziehen, ausser in der 
Messphase bei parasitärer Versorgung. Das muss aufgrund der 
bidirektionalen Arbeitsweise ein externer Pullup-Widerstand machen.

Also: PORTB.0=0 lassen und DDRB.0=0 für high/input, DDRB.0=1 für low.

[Route_66 H. (route_66)]

Matze schrieb:
> Eventuell seht ihr das Problem.

Damit er erkennen kann dass er und nur er gemeint ist, muß er ein Skip 
ROM bekommen, es könnten ja mehrere am Draht hängen. Dann muß man 
nämlich ein Match ROM mit der zugehörigen Adresse senden.

[(prx) A. K. (prx)]

0x55 = MATCH ROM benötigt danach die Sensor ID. Bei einem einzelnen 
Sensor ist SKIP ROM sinnvoller.

[Matze (Gast)]

A. K. schrieb:
> Also: PORTB.0=0 lassen und DDRB.0=0 für high/input, DDRB.0=1 für low.

Danke, das hab ich nun erledigt und so geht der Presence auch wirklich 
bis 0V.

Route 66 schrieb:
> Damit er erkennen kann dass er und nur er gemeint ist, muß er ein Skip
> ROM bekommen, es könnten ja mehrere am Draht hängen. Dann muß man
> nämlich ein Match ROM mit der zugehörigen Adresse senden.

Stimmt, die würde eich es überhaupt machen wenn ich mehrere DS1820an 
einem Bus hätte?
Müsste ich sie mit der Sensior-ID Addressieren die ich vermutlich vor 
dem 1. Auslesen mittels Skip-Rom nicht kennen würde?

Das Problem ist jedoch immer noch das selbe, er gibt keine Daten aus.

Wenn ich dem Signalflussdiagramm im Datenblatt folge steht dort zuerst 
kommt ein Reset, danach kann ich ein Skip-Rom (0xCC) senden.

Danach hoffe ich die Temperatur wandeln zu können (0x44) und sie 
auslesen zu können (0xBE).

Habe den Code auch sonst etwas verbessert:

ISR(TIMER0_COMP_vect)
{
  DDRB&=0xFE;    //Pin Setzen / Input
  TCCR0=0x00;    //Stoppen
  Tint=1;
}

int main(void)
{
  Init();
  DDRD|=0x40;        //Triggerung für Oszi
  PORTB&=FE;        //PORTB.0=0
  TIMSK|=0x02;      //Interrupt Timer0 Enable
  while(1)
    {  

    One_Wire_Send(0x00,1);  //Reset
    _delay_ms(2);      //Zeit für Presence = 500uS
    One_Wire_Send(0xCC,0);  //DS1820Auswählen
    One_Wire_Send(0x44,0);  //Temperatur Wandeln
    PORTD|=0x40;      //Setzen
    One_Wire_Send(0xBE,0);  //Temperatur Zusenden
    _delay_ms(4);      //Zeit zum zusenden
    PORTD&=0xBF;      //Rücksetzen
    }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{
  Tint=0;
  unsigned short int Vergleich = 0x80;
  if(Steuer==1)  //Reset des DS1820
  {
    TCNT0=0x00;    //Anfang des Zählens
    OCR0=38;    //--600uS
    DDRB|=0x01;    //Portpin auf LOW / Ausgang  
    TCCR0=0x03;    //Prescaler = 8,Timer Starten --16uS
    while(Tint!=1)  //Warten bis IRQ Ausgelöst
    {;}
  }
  else        //Fals Kein Steuersignal übertragen werden soll
  {
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      TCNT0=0x00;    //Anfang des Zählens
      Tint=0;
      if(Byte & Vergleich)    //1 Senden
      {
        OCR0=0x01;    //--10uS
      }
      else        //0 Senden
      {
        OCR0=0x25;    //--90uS
      }
      DDRB|=0x01;      //Pin = 0
      TCCR0=0x02;      //Prescaler = 8,Timer Starten
      while(Tint!=1)    //Warten bis IRQ Ausgelöst
      {;}
    }  
  }    
}

[Karl H. (kbuchegg)]

>     One_Wire_Send(0x44,0);  //Temperatur Wandeln
>     PORTD|=0x40;      //Setzen
>     One_Wire_Send(0xBE,0);  //Temperatur Zusenden
>     _delay_ms(4);      //Zeit zum zusenden

He. Moment mal.
Ich hab jetzt die Codes nicht kontrolliert.
Aber nachdem du dem DS befohlen hast, die Temperatur festzustellen, 
musst du ihm auch Zeit geben, genau das zu tun.

Ehe da jetzt weiter analysiert wird.
In der Codesammlung gibt es Routinen für den DS1820. Im speziellen 
fallen mir die Routinen vom Peter Danegger ein. Hol dir die mal und 
studier mal, wie das alles gedacht ist.

[Matze (Gast)]

Ich hätte nicht gedacht das er 500mS zum Wandeln braucht.

Ein weiteres Problem war dass nicht einfach 0en und 1en gesendet werden, 
sondern die Kommunikation in Timeslots abläuft.

Ein Timeslot hat eine länge von 60-120uS.

Folglich müssen im Falle einer gesendeten 1 mit 10uS auf Low, zusätzlich 
80uS High folgen bevor das nächste Bit gesendet wird.

Diese Fehler wurden nun Korrigiert.

Eine 0 Besteht aus 80uS LOW und 10uS High.
Eine 1 aus 10uS LOW und 80uS High.

Aber auch das hat am eigentlichen Problem nichts geändert.
Er zieht die Leitung nur auf Low um sein dasein zu bestätigen.

So sieht es nun aus:

ISR(TIMER0_COMP_vect)
{
  DDRB&=0xFE;    //Pin Setzen / Input
  TCCR0=0x00;    //Stoppen
  Tint=1;
}

int main(void)
{
  Init();
  DDRD|=0x40;        //Triggerung für Oszi
  PORTB&=FE;        //PORTB.0=0
  TIMSK|=0x02;      //Interrupt Timer0 Enable
  while(1)
    {  
    One_Wire_Send(0x00,1);  //Reset
    _delay_ms(2);      //Zeit für Presence = 500uS
    One_Wire_Send(0xCC,0);  //DS1820 Auswählen
    _delay_ms(1);      //Zeit zum Wandeln
    One_Wire_Send(0x44,0);  //Temperatur Wandeln
    _delay_ms(600*4);    //Zeit zum Wandeln 600ms
    //One_Wire_Send(0xCC,0);  //DS1820 Auswählen
    _delay_ms(2);      //Zeit zum Wandeln
    while(1)
    {
      One_Wire_Send(0x00,1);  //Reset
      _delay_ms(2);      //Zeit für Presence = 500uS
      PORTD|=0x40;      //Setzen
      One_Wire_Send(0x33,0);  //Temperatur Zusenden
      _delay_ms(10);      //Zeit zum zusenden
      PORTD&=0xBF;      //Rücksetzen
    }

    }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{

  unsigned short int Vergleich = 0x80;
  if(Steuer==1)  //Reset des DS1820
  {  
    Tint=0;
    TCNT0=0x00;    //Anfang des Zählens
    OCR0=38;    //--600uS
    DDRB|=0x01;    //Portpin auf LOW / Ausgang  
    TCCR0=0x03;    //Prescaler = 8,Timer Starten --16uS
    while(Tint!=1)  //Warten bis IRQ Ausgelöst
    {;}
  }
  else        //Fals Kein Steuersignal übertragen werden soll
  {
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      Tint=0;
      TCNT0=0x00;    //Anfang des Zählens
      if(Byte & Vergleich)  //1 Senden
      {
        OCR0=0x01;      //--10uS
        DDRB|=0x01;      //Pin = 0
        TCCR0=0x02;      //Prescaler = 8,Timer Starten      
        while(Tint!=1)    //Warten bis IRQ Ausgelöst
        {;}  
        Tint=0;  
        TCNT0=0x00;      //Zähler=0
        OCR0=0x1A;      //80uS für 90uS - Timeslot
        TCCR0=0x02;      //Prescaler = 8,Timer Starten
        while(Tint!=1)  {;}  //Warten bis IRQ Ausgelöst      
      }
      else          //0 Senden
      {
        OCR0=0x25;      //--90uS
        DDRB|=0x01;      //Pin = 0
        TCCR0=0x02;      //Prescaler = 8,Timer Starten
        while(Tint!=1){;}    //Warten bis IRQ Ausgelöst
      }
    }  
  }    
}

[Klaus (Gast)]

@Matze

Das hier wird dir helfen sofer der Link funktioniert.
http://www.mikrocontroller.net/attachment/93011/1-Wire-Projekt-V1_3.zip

[Matze (Gast)]

@Klaus

Danke das Projekt ist sehr nützlich,

Darin steht dass der DS1820 die Daten 15uS nach dem beginn des LOWs bei 
senden einer 1 abgreift.
Um nun sicher zu gehen dass er auch wirklich eine 1 erkennt, habe ich 
das LOW auf 8uS verkürzt.
Ausserdem bin ich nun nur noch bei ca 62uS für einen Timeslot und habe 
die Timerinitialisierung ausgelagert.

Laut der Beschreibung des Projekts sendet ein einzelner Slave am Bus, 
nach Reset und Empfang von 0x33 für Read Rom seine 64Bit - ID.

Das müsste wohl noch am ehesten Funktionieren.

Soweit ich gelesen habe muss ich beim 1Wire-Bus das LSB zuerst senden?

Aber auch das alles hat mich noch nicht weiter gebracht.

ISR(TIMER0_COMP_vect)
{
  DDRB&=0xFE;    //Pin Setzen / Input
  TCCR0=0x00;    //Stoppen
  Tint=1;
}

int main(void)
{
  Init();
  DDRD|=0x40;        //Triggerung für Oszi
  PORTB&=FE;        //PORTB.0=0
  TIMSK|=0x02;      //Interrupt Timer0 Enable
  while(1)
    {  
      One_Wire_Send(0x00,1);  //Reset
      _delay_ms(2);      //Zeit für Presence = 500uS
      PORTD|=0x40;      //Setzen
      One_Wire_Send(0xCC,0);  //Temperatur Zusenden
      _delay_ms(10);      //Zeit zum zusenden
      PORTD&=0xBF;      //Rücksetzen
      _delay_ms(10);      //Zeit zum zusenden
    }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{
  if(Steuer==1)  //Reset des DS1820
    Timer0(38,0x03,0);
  else        //Fals Kein Steuersignal übertragen werden soll
  {  
    unsigned short int Vergleich = 0x80;
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      if(Byte & Vergleich)  //1 Senden
      {
        Timer0(0x02,0x01,0);//Pin ist nach 8 uS wieder auf High
        Timer0(0x0A,0x02,1);//ca 55 us Warten      
      }
      else          //0 Senden
      {
        Timer0(0x1C,0x02,0);//63 uS LOW
      }
    }  
  }    
}

void Timer0(short unsigned int Zeit,short unsigned int Prescaler, short unsigned int Reset)
{
  Tint=0;  
  TCNT0=0x00;      //Timer auf 0
  OCR0=Zeit;      
  if(Reset==0)
    DDRB|=0x01;    //Portpin auf LOW / Ausgang  
  TCCR0=Prescaler;
  while(Tint!=1){;}  //Warten bis IRQ Ausgelöst  
}

[Matze (Gast)]

Wenn ich nun wie im PDF des 1-Wire Projekts dem DS1820 zuerst ein
1. Reset
2. Skip-Rom
3. Messung
4. Reset
5. Skip-Rom
6. Read Scratscpad-Ram
sende.

Gibt er außer dem Presence nichts her.

Keine Ahnung was ich tun soll?

ISR(TIMER0_COMP_vect)
{
  DDRB&=0xFE;    //Pin Setzen / Input
  TCCR0=0x00;    //Stoppen
  Tint=1;
}

int main(void)
{
  Init();
  DDRD|=0x40;        //Triggerung für Oszi
  PORTB&=FE;        //PORTB.0=0
  TIMSK|=0x02;      //Interrupt Timer0 Enable
  One_Wire_Send(0x00,1);  //Reset
  _delay_ms(2);      //Zeit für Presence = 500uS
  One_Wire_Send(0x44,0);  //Temperatur Wandeln
  _delay_ms(750*4);    //Zeit zum Wandeln 600ms
  while(1)
  {
    One_Wire_Send(0x00,1);  //Reset
    _delay_ms(2);      //Zeit für Presence = 500uS
    PORTD|=0x40;      //Setzen
    One_Wire_Send(0xCC,0);  //DS1820 Auswählen
    One_Wire_Send(0xBE,0);  //DS1820 Auswählen
    _delay_ms(10);      //Zeit zum Wandeln
    PORTD&=0xBF;      //Rücksetzen
  }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{
  if(Steuer==1)  //Reset des DS1820
    Timer0(2);
  else        //Fals Kein Steuersignal übertragen werden soll
  {  
    unsigned short int Vergleich = 0x80;
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      if(Byte & Vergleich)  //1 Senden
      {
        Timer0(1);    
      }
      else          //0 Senden
      {
        Timer0(0);
      }
    }  
  }    
}

void Timer0(int sequenz)  //0 = 0 / 1 = 1 / 2 = Reset
{
  Tint=0;  
  TCNT0=0x00;      //Timer auf 0
  switch(sequenz)
  {
    case 0:      //0 Senden
      OCR0=0x1C;
      DDRB|=0x01;    //Portpin auf LOW / Ausgang
      TCCR0=0x02;
      while(Tint!=1){;}  //Warten bis IRQ Ausgelöst
    break;
    case 1:      //1 Senden
      OCR0=0x02;
      DDRB|=0x01;    //Portpin auf LOW / Ausgang
      TCCR0=0x01;
      while(Tint!=1){;}  //Warten bis IRQ Ausgelöst
      Tint=0;
      TCNT0=0x00;      //Timer auf 0
      OCR0=0x0A;
      TCCR0=0x02;
      while(Tint!=1){;}  //Warten bis IRQ Ausgelöst
    break;
    case 2:      //Reset
      OCR0=38;
      DDRB|=0x01;    //Portpin auf LOW / Ausgang
      TCCR0=0x03;
      while(Tint!=1){;}  //Warten bis IRQ Ausgelöst
    break;
  }
}

[(prx) A. K. (prx)]

Nach 0xBE sollte der µC das Scratchpad auslesen. Sehe ich hier nicht.

[Эраст Петрович Фандорин (Gast)]

>Sendet außer Presence nichts zurück.

Zitat Alison Moyet:
"I go weak in the presence of beauty"

[Matze (Gast)]

@A.K.

Ich sehe mit dem Oszi das der nichts sendet.
Also brauche ich wohl keine Einleseroutine schreiben.

[(prx) A. K. (prx)]

Matze schrieb:
> Ich sehe mit dem Oszi das der nichts sendet.
> Also brauche ich wohl keine Einleseroutine schreiben.

Bis ein 1-Wire Slave etwas sendet kannst du ewig warten.
Der Master holt es ab.

[Klaus (Gast)]

@Matze
>Er hängt an Port B0, und hat einen 4,7K Ohm-Pullup.
Wo ist der denn in deinem Schaltplan eingezeichnet?

Für mich sieht es eher aus als würde der DS1820 auf dem Port PB3 
verbunden zu sein. Korrigier mich!

[Klaus (Gast)]

@Matze

Warum benutzt du Timer Interrupt?

Kein Interrupt während dem Senden und Empfangen von Daten ist schon mal 
der erste Tipp.

[Klaus (Gast)]

@Matze

Äh! Wo ist der Codeschnipsel Init();

[Matze (Gast)]

@ A.K.

Ich wusste nicht das der Master die Daten abholen muss.

In diesem
http://www.atmel.com/Images/doc2579.pdf
Datenblatt steht um Daten zu lesen muss der Master den Pin für 1-15uS 
auf LOW ziehen.
Danach kann der Slave die Datenleitung weiterhin aktiv auf LOW ziehenund 
dem Master damit 0en senden.

@Klaus

1.
Stimmt im Schaltplan Hängt der DS1820 auf PinB3.
Ich habe den Schaltplan gezeichnet nach dem ich die "Uhr" aufgebaut 
hatte.
Dabei hat sich herausgestellt, dass es Layouttechnisch besser ist den 
DS1820 auf PB3 zu legen.

Auf dem Lochraster-Prototyp ist er auf PB0.

2.
Stimmt eigentlich kann ich auf den Interrupt verzichten, und es 
stattdessen mit einem Delay machen.
Und im uS-Bereich ist das vielleicht auch praktischer.
Wollte es ursprünglich mit Interrupts machen um sicherzustennen das Uhr 
mit Zeitmultiplexing nicht stehen bleibt.

3.
Der Codeschnipsel Init tut nichts was momentan wichtig ist.

Das Gesamtprogramm ist nun:

int main(void)
{
  Init();
  DDRD|=0x40;        //Triggerung für Oszi
  PORTB&=FE;        //PORTB.0=0
  TIMSK|=0x02;      //Interrupt Timer0 Enable
  One_Wire_Send(0x00,1);  //Reset
  _delay_ms(2);      //Zeit für Presence = 500uS
  One_Wire_Send(0x22,0);  //Temperatur Wandeln
  _delay_ms(750*4);    //Zeit zum Wandeln 600ms
  while(1)
  {
    One_Wire_Send(0x00,1);  //Reset
    _delay_ms(2);      //Zeit für Presence = 500uS
    One_Wire_Send(0x33,0);  //Skip-Rom
    PORTD&=0xBF;      //Rücksetzen
    One_Wire_Send(0x7D,0);  //Daten Lesen
    PORTD|=0x40;      //Setzen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    PORTD&=0xBF;      //Rücksetzen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    PORTD|=0x40;      //Setzen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
    One_Wire_Send(0xFF,0);  //DS1820 Auswählen
  }
}

void One_Wire_Send(unsigned short int Byte, int Steuer)
{
  if(Steuer==1)  //Reset des DS1820
    Bit_Senden(2);
  else        //Fals Kein Steuersignal übertragen werden soll
  {  
    unsigned short int Vergleich = 0x80;
    for(int i=8;i>=1;Vergleich=Vergleich/2, i--)
    {
      if(Byte & Vergleich)  //1 Senden
      {
        Bit_Senden(1);    
      }
      else          //0 Senden
      {
        Bit_Senden(0);
      }
    }  
  }    
}

void Init()
{
  TCNT1H=0x00;  //Timer auf  0
  TCNT1L=0x00;
  OCR1A = 15624;
  TCCR1A=0x00;  //Kein WPM  / Keine Ansteuerung von Pins
  sei();
  TIMSK |= (1<<OCIE1A);    //Interrupt Enable
  //TCCR1B=0x0C;  //=00001100  / CTC-Modus, Prescaler = 256, Starten
  DDRA=0xFF;
  DDRB=0x00;    //Eingang
  DDRC=0xFC;
  DDRD=0x00;
}

Nun Funktioniert es :)

Er gibt mir in den ersten 2 Bytes 01010101 00000000
Nun bin ich mit nur noch nicht so richtig sicher wie ich das 
interpretieren soll.
00000000 ist im zum glück positiven Bereich.

Aber 01010101 bedeitet bei +1 Pro 0.5°C für LSB zuletzt 42,5°C
und für LSB zuerst: 85°C.

Beides ist nicht so richtig realistisch.
Denke ich jetzt falsch?

[Klaus (Gast)]

>Der Codeschnipsel Init tut nichts was momentan wichtig ist.
Sag soetwas nicht Leichtsinnig.

Wie sieht den Bit_Senden(1);   genau aus.
wird dort das Timing der Zeitschlitze eingehalten.

Ein Beispiel wie es Aussehen könnte wenn du Skip-Rom verwendest.
Hier mal ein Codesipsel von mir.
void DS18S20_readrom (void)
{

  uint8_t i;

  DS18S20_writebyte(0xCC);  // Sende Skip ROM - Command
  DS18S20_Init();
  DS18S20_writebyte(0x33);  // Sende READ-ROM - Command
  for(i=0; i<8; i++)
  {
    DS18S20_ROM[i] = DS18S20_readbyte();
  }


}

Als Ergebnis steht dann z.B. in DS18S20_ROM folgendes:

10 0E 61 DD 01 08 00 75  Das ist der Familliencode komplett

[Klaus (Gast)]

So sieht es aus wenn ich die Temperatur auslesen möchte.

DS18S20_writebyte(0xCC);  // Sende Skip ROM - Command
      DS18S20_Conv_T();
      DS18S20_Init();
      DS18S20_writebyte(0xCC);  // Sende Skip ROM - Command

      DS18S20_writebyte(0xBE);  // Sende Read Scratchpad Command
      for(i=0; i<9; i++)
      {
          DS18S20_Scratchpad[i] = DS18S20_readbyte();
      }

[(prx) A. K. (prx)]

85° stünde für "kein Wert", wie das Datasheet in schönster Klarheit 
vermittelt.

Wird der Sensor parasitär versorgt, oder mit separatem Vcc?

Wärs nicht allmählich an der Zeit, mal Code anderer Leute anzusehen? 
Mittlerweile ist ohnehin das halbe Programm nicht mehr von dir.

[Matze (Gast)]

@A.K.

Der Sensor wird Separat versorgt.

Ich kann den Sensor nun auslesen, die Temparatur ausrechnen und 
anzeigen.

Habe das Programm nun in eine Main.c und eine DS1820.c sowie DS1820.h 
aufgeteilt.

Eine Erkennung für den Fall das sich der DS1820 nach Reset nicht meldet 
eingebaut.

Nun möchte ich noch die CRC-Prüfsumme berechnen.

Dann soll er mit der Uhr gemeinsam laufen.
Damit diese ganau wird soll später über I2C ein DS3231 (RTC mit TCXO) 
dazukommen.

Mich stört noch das der Sensor 500mS zum wandeln braucht.
Währenddessen soll die Anzeige nicht einfach stehen bleiben, eventuell 
lässt sich das mit einem Timer lösen?

Grüße
Matze

[chris (Gast)]

Matze schrieb:
> Mich stört noch das der Sensor 500mS zum wandeln braucht.
> Währenddessen soll die Anzeige nicht einfach stehen bleiben, eventuell
> lässt sich das mit einem Timer lösen?

du musst ja nicht warten, während der Sensor misst.
Starte einfach am Anfang die erste Messung.
In der Hauptschleife holst du dann z.B. alle 5-10 Sek. (häufiger ist bei 
Temp. eigentlich selten sinnvoll) den letzten Wert ab und startest die 
nächste Messung. Dein Messwert ist dann zwar jeweils um 4-9 Sekunden 
veraltet, aber das ist wie gesagt bei Temperaturen meistens unwichtig.