DS1820 an ATtiny25 in C, Massive Timingprobleme

#include <avr/io.h>

#include <inttypes.h>

#include <util/delay.h>

typedef union

{

  uint8_t     byte;

  struct

  {

    unsigned int bit0:1;

    unsigned int bit1:1;

    unsigned int bit2:1;

    unsigned int bit3:1;

    unsigned int bit4:1;

    unsigned int bit5:1;

    unsigned int bit6:1;

    unsigned int bit7:1;

  } s;

} byte8bits_t;

#ifdef DDRA

#define ddra  (*(volatile byte8bits_t*)(&DDRA))

#define porta (*(volatile byte8bits_t*)(&PORTA))

#define pina  (*(volatile byte8bits_t*)(&PINA))

#endif /* ifdef DDRA */

#ifdef DDRB

#define ddrb  (*(volatile byte8bits_t*)(&DDRB))

#define portb (*(volatile byte8bits_t*)(&PORTB))

#define pinb  (*(volatile byte8bits_t*)(&PINB))

#endif /* ifdef DDRB */

#ifdef DDRC

#define ddrc  (*(volatile byte8bits_t*)(&DDRC))

#define portc (*(volatile byte8bits_t*)(&PORTC))

#define pinc  (*(volatile byte8bits_t*)(&PINC))

#endif /* ifdef DDRC */

#ifdef DDRD

#define ddrd  (*(volatile byte8bits_t*)(&DDRD))

#define portd (*(volatile byte8bits_t*)(&PORTD))

#define pind  (*(volatile byte8bits_t*)(&PIND))

#endif /* ifdef DDRD */

#define DDR_DS18S20_VCC     ddrd.s.bit1

#define PORT_DS18S20_VCC    portd.s.bit1

#define PIN_DS18S20_VCC     pind.s.bit1

#define DDR_DS18S20_DQ      ddrd.s.bit2

#define PORT_DS18S20_DQ     portd.s.bit2

#define PIN_DS18S20_DQ      pind.s.bit2

uint8_t reset1wire()

{

  int cnt_wait = 0;

  PORT_DS18S20_DQ = 0;

  _delay_us( 480 );

  PORT_DS18S20_DQ = 1;

  // jetzt wartet der slave 15...60 usec und zieht dann die Leitung

  // für 60...240 sec auf low (presence pulse).

  // Also Pin als Eingang setzen, 60 usec warten und dann warten,

  // bis die Leitung wieder hoch geht:

  DDR_DS18S20_DQ  = 0;

  _delay_us( 60 );

  while( 1 )

  {

    if( PIN_DS18S20_DQ )

    {

      break;

    }

    cnt_wait++;

    _delay_us( 1 );

  }

  DDR_DS18S20_DQ  = 1; // auf Ausgang setzen

  PORT_DS18S20_DQ = 1; // high

  return cnt_wait;

}

void putc1wire( uint8_t c )

{

  for( uint8_t iBit=0; iBit<8; ++iBit )

  {

    if( c&1 )

    {

      // 1 schreiben

      // Leitung auf low, gleich wieder (maximal in 15 usec, aber

      // warum nicht gleich?) wieder auf high und 60 usec warten:

      PORT_DS18S20_DQ = 0;

      _delay_us( 1 );

      PORT_DS18S20_DQ = 1;

      _delay_us( 60 );

    }

    else

    {

      // 0 schreiben

      // Leitung auf low, 60 usec warten, dann wieder auf high:

      PORT_DS18S20_DQ = 0;

      _delay_us( 60 );

      PORT_DS18S20_DQ = 1; // high

    }

    _delay_us( 1 ); // Sicherheitsabstand zwischen zwei Bits

    c >>= 1;

  }

}

// liest ein Byte

uint8_t getc1wire()

{

  uint8_t   ret = 0;

  for( uint8_t iBit=0; iBit<8; ++iBit )

  {

    ret >>= 1;

    // Leitung auf low, gleich wieder (nach min. 1 usec) wieder auf

    // high und innerhalb der nächsten 15 usec lesen:

    PORT_DS18S20_DQ = 0;

    _delay_us( 1 );

    PORT_DS18S20_DQ = 1;

    DDR_DS18S20_DQ  = 0;

    _delay_us( 10 );

    if( PIN_DS18S20_DQ )

    {

      // 1 gelesen

      ret |= 0b10000000;

    }

    // den Rest auf 60 usec warten:

    _delay_us( 60 );

    DDR_DS18S20_DQ  = 1; // Ausgang

    _delay_us( 1 ); // Sicherheitsabstand zwischen zwei Bits

  }

  return ret;

}

// liest ein Bit

uint8_t getb1wire()

{

  uint8_t   ret = 0;

  // Leitung auf low, gleich wieder (nach min. 1 usec) wieder auf

  // high und innerhalb der nächsten 15 usec lesen:

  PORT_DS18S20_DQ = 0;

  _delay_us( 1 );

  PORT_DS18S20_DQ = 1;

  DDR_DS18S20_DQ = 0; // Eingang

  _delay_us( 10 );

  if( PIN_DS18S20_DQ )

  {

    // 1 gelesen

    ret |= 0b1;

  }

  // den Rest auf 60 usec warten:

  _delay_us( 60 );

  DDR_DS18S20_DQ = 1; // Ausgang

  _delay_us( 1 ); // Sicherheitsabstand zwischen zwei Bits

  return ret;

}

int main( int nargs, char **args )

{

  // Pin DQ erstmal als Ausgang und high setzen:

  DDR_DS18S20_DQ  = 1;

  PORT_DS18S20_DQ = 1;

  DDR_DS18S20_VCC  = 1;  // VCC für DS18S20 ausschalten

  PORT_DS18S20_VCC = 0;

  reset1wire();

  while( 1 )

  {

    uint8_t   t_ist; // IST-Temperatur [grad C]

    reset1wire();

    // Initialization:

    PORT_DS18S20_VCC  = 1;   // VCC einschalten

    // 1. reset pulse (mind. 480 usec low)

    // presence pulse ist rum

    // ROM Command

    // READ ROM (0x33) kann nur verwendet werden, wenn es nur einen

    // slave gibt; danach könnte man das ROM lesen.

    // SKIP ROM (0xCC) kann nur verwendet werden, wenn es nur einen

    // slave gibt.

    //putc1wire( 0x33 );

    putc1wire( 0xCC );

    // Function Command

    // convert command

    putc1wire( 0x44 );

    // warten, bis ein 1-Bit gelesen wird:

    while( !getb1wire() )

    {

      _delay_us( 1 );

      // TODO: notfalls abbrechen!

    }

    // jetzt wieder Reset und Daten lesen:

    reset1wire();

    putc1wire( 0xCC ); // SKIP ROM

    putc1wire( 0xBE ); // READ SCRATCHPAD

    uint8_t    data1wire[9];

    for( int iData=0; iData<9; ++iData )

    {

      data1wire[iData] = getc1wire();

    }

    PORT_DS18S20_VCC  = 0;   // VCC ausschalten

    // Temperatur in Grad C

    t_ist = ( ( (int)data1wire[1] << 8 ) | data1wire[0] )/2;

    _delay_ms( 1000 );

  }

  return 0;

}