File content as of revision 0:5b6520e71eb6:

 /*** D'apres :       *********************************************************
 *
 *    FILENAME:    ds1820.h
 *    DATE:        25.02.2005
 *    AUTHOR:      Christian Stadler
 *
 *    DESCRIPTION: Driver for DS1820 1-Wire Temperature sensor (Dallas)
 *
 ******************************************************************************/
#include "mbed.h"
DigitalInOut DQ       (p15);                    // broche DQ relie a la broche p15 du MBED 
DigitalOut G__MOS_P   (p16);
Serial pc(USBTX, USBRX);                        // tx, rx
/* -------------------------------------------------------------------------- */
/*                         DS1820 Timing Parameters                           */
/* -------------------------------------------------------------------------- */
#define DS1820_RST_PULSE       480               /* master reset pulse time in [us] */
#define DS1820_MSTR_BITSTART   2                 /* delay time for bit start by master */
#define DS1820_PRESENCE_WAIT   40                /* delay after master reset pulse in [us] */
#define DS1820_PRESENCE_FIN    480               /* dealy after reading of presence pulse [us] */
#define DS1820_BITREAD_DLY     5                 /* bit read delay */
#define DS1820_BITWRITE_DLY    100               /* bit write delay */


/* -------------------------------------------------------------------------- */
/*                            DS1820 Registers                                */
/* -------------------------------------------------------------------------- */

#define DS1820_REG_TEMPLSB    0
#define DS1820_REG_TEMPMSB    1
#define DS1820_REG_CNTREMAIN  6
#define DS1820_REG_CNTPERSEC  7                     
#define DS1820_SCRPADMEM_LEN  9                     // length of scratchpad memory 

#define DS1820_ADDR_LEN       8


/* -------------------------------------------------------------------------- */
/*                            DS1820 Commands                                 */
/* -------------------------------------------------------------------------- */

#define DS1820_CMD_SEARCHROM     0xF0               // recherche des differents DS1820 et de leur numROMs
#define DS1820_CMD_READROM       0x33               // idem que SEARCHROM mais utilise pour 1 seul DS1820
#define DS1820_CMD_MATCHROM      0x55               // permet de communiquer avec un DS1820 en particulier grace a son numROM
#define DS1820_CMD_SKIPROM       0xCC               // permet de communiquer avec tous les DS1820 en meme temps
#define DS1820_CMD_ALARMSEARCH   0xEC               // permet de dialoguer seulement avec les DS1820 qui ont un flag 
#define DS1820_CMD_CONVERTTEMP   0x44               // permet de lancer un convertion de la temperature, le resultat sera stocke dans le scratchpad
#define DS1820_CMD_WRITESCRPAD   0x4E               // permet au MBED d'ecrire deux octets dans le scratchpad dont un dans le registre TH et un dans le registre TL
#define DS1820_CMD_READSCRPAD    0xBE               // permet au MBED de lire le scratchpad
#define DS1820_CMD_COPYSCRPAD    0x48               // permet de copier le scratchpad et les registres TH, TL stocke dans EEPROM
#define DS1820_CMD_RECALLEE      0xB8               // rappel les valeur de declenchement de l'alarme


#define DS1820_FAMILY_CODE_DS18B20      0x28
#define DS1820_FAMILY_CODE_DS18S20      0x10

char dowcrc=0;            // crc is accumulated in this variable
// crc lookup table
char const dscrc_table[] = {
0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53
};
             
/* -------------------------------------------------------------------------- */
bool doneFlag;                              // declaration d'une variable booleenne "doneFlag"
char lastDiscrep,numROMs;                   // declaration des variables lastDiscrep et numROMs
char RomBytes[DS1820_ADDR_LEN];             // declaration de la variable RomBytes[DS1820_ADDR_LEN]
char FoundROM[9][8];                        // Table of found ROM codes, 8 bytes for each


/* -------------------------------------------------------------------------- */
/*                           Low-Level Functions                              */
/* -------------------------------------------------------------------------- */
/*******************************************************************************
 * FUNCTION:   ow_reset
 * PURPOSE:    Initializes the DS1820 device.
 *
 * INPUT:      -
 * OUTPUT:     -
 * RETURN:     FALSE if at least one device is on the 1-wire bus, TRUE otherwise
 ******************************************************************************/
bool ow_reset(void)
{
   bool presence;

   /* reset pulse */
   DQ.output();
   DQ=0;
   wait_us(DS1820_RST_PULSE);
   DQ=1;

   /* wait until pullup pull 1-wire bus to high */
   wait_us(DS1820_PRESENCE_WAIT);

   /* get presence pulse */
   DQ.input();
   presence=DQ.read();

   wait_us(424);

   return presence;
}

/*******************************************************************************
 * FUNCTION:   read_bit
 * PURPOSE:    Reads a single bit from the DS1820 device.
 *
 * INPUT:      -
 * OUTPUT:     -
 * RETURN:     bool        value of the bit which as been read form the DS1820
 ******************************************************************************/
bool read_bit(void)
{
   DQ.output();
   DQ=0;
   wait_us(DS1820_MSTR_BITSTART);
   DQ.input();
   DQ.read();
   wait_us(DS1820_BITREAD_DLY);

   return (DQ);
}

/*******************************************************************************
 * FUNCTION:   write_bit
 * PURPOSE:    Writes a single bit to the DS1820 device.
 *
 * INPUT:      bBit        value of bit to be written
 * OUTPUT:     -
 * RETURN:     -
 ******************************************************************************/
void write_bit(bool bBit)
{
   DQ.output();
   DQ=0;
   wait_us(DS1820_MSTR_BITSTART);

   if (bBit != false) DQ=1;

   wait_us(DS1820_BITWRITE_DLY);
   DQ=1;

}

/*******************************************************************************
 * FUNCTION:   read_byte
 * PURPOSE:    Reads a single byte from the DS1820 device.
 *
 * INPUT:      -
 * OUTPUT:     -
 * RETURN:     uint8          byte which has been read from the DS1820
 ******************************************************************************/
char read_byte(void)
{
   char i;
   char value = 0;

   for (i=0 ; i < 8; i++)
   {
      if ( read_bit() ) value |= (1 << i);
      wait_us(120);
   }
   return(value);
}

/*******************************************************************************
 * FUNCTION:   write_byte
 * PURPOSE:    Writes a single byte to the DS1820 device.
 *
 * INPUT:      val_u8         byte to be written
 * OUTPUT:     -
 * RETURN:     -
 ******************************************************************************/
void write_byte(char val_u8)
{
   char i;
   char temp;

   for (i=0; i < 8; i++)      /* writes byte, one bit at a time */
   {
      temp = val_u8 >> i;     /* shifts val right 'i' spaces */
      temp &= 0x01;           /* copy that bit to temp */
      write_bit(temp);  /* write bit in temp into */
   }

   wait_us(105);
}
/* -------------------------------------------------------------------------- */
// One wire crc
char ow_crc(char x)
{
   dowcrc = dscrc_table[dowcrc^x];
   return dowcrc;
}
/* -------------------------------------------------------------------------- */
/*                             API Interface                                  */
/* -------------------------------------------------------------------------- */

/*******************************************************************************
 * FUNCTION:   DS1820_AddrDevice
 * PURPOSE:    Addresses a single or all devices on the 1-wire bus.
 *
 * INPUT:      nAddrMethod       use DS1820_CMD_MATCHROM to select a single
 *                               device or DS1820_CMD_SKIPROM to select all
 * OUTPUT:     -
 * RETURN:     -
 ******************************************************************************/
void DS1820_AddrDevice(char nAddrMethod)
{
   char i;

   if (nAddrMethod == DS1820_CMD_MATCHROM)
   {
      write_byte(DS1820_CMD_MATCHROM); /* address single devices on bus */
      for (i = 0; i < DS1820_ADDR_LEN; i ++)
         write_byte(RomBytes[i]);
   }
   else
      write_byte(DS1820_CMD_SKIPROM);  /* address all devices on bus */
}

/*******************************************************************************
 * FUNCTION:   Next
 * PURPOSE:    Finds next device connected to the 1-wire bus.
 *
 * INPUT:      -
 * OUTPUT:     RomBytes[]       ROM code of the next device
 * RETURN:     bool                 TRUE if there are more devices on the 1-wire
 *                                  bus, FALSE otherwise
 ******************************************************************************/
bool Next(void)
{
    char x;
    char n;
    char k = 1;
    char m = 1;
    char discrepMarker = 0;
    bool g;
    bool flag;
    bool nxt = false;

    /* init ROM address */
    for (n=0; n < 8; n ++)
        RomBytes[n] = 0x00;

    flag = ow_reset();        /* reset the 1-wire */

    if (flag || doneFlag)        /* no device found */
    {
        lastDiscrep = 0;     /* reset the search */
        return false;
    }

    /* send search rom command */
    write_byte(DS1820_CMD_SEARCHROM);

    n = 0;
    do
    {
        x = 0;

        /* read bit */
        if ( read_bit() == 1 )  x = 2;
        wait_us(120);

        /* read bit complement */
        if ( read_bit() == 1 )  x |= 1;
        wait_us(120);

        /* description for values of x: */
        /* 00    There are devices connected to the bus which have conflicting */
        /*       bits in the current ROM code bit position. */
        /* 01    All devices connected to the bus have a 0 in this bit position. */
        /* 10    All devices connected to the bus have a 1 in this bit position. */
        /* 11    There are no devices connected to the 1-wire bus. */

        /* if there are no devices on the bus */
        if (x == 3) break;
        else
        {
            /* devices have the same logical value at this position */
            if (x > 0)  g = (bool)(x >> 1);// get bit value
            /* devices have confilcting bits in the current ROM code */
            else
            {
                /* if there was a conflict on the last iteration */
                if (m < lastDiscrep)
                    /* take same bit as in last iteration */
                    g = ( (RomBytes[n] & k) > 0 );
                else
                    g = (m == lastDiscrep);

                if (g == 0)
                    discrepMarker = m;
            }

            /* store bit in ROM address */
           if (g ==1)
               RomBytes[n] |= k;
           else
               RomBytes[n] &= ~k;

           write_bit(g);

           /* increment bit position */
           m ++;

           /* calculate next mask value */
           k = k << 1;

           /* check if this byte has finished */
           if (k == 0)
           {
               ow_crc(RomBytes[n]);      // Accumulate the crc
               n ++;  /* advance to next byte of ROM mask */
               k = 1;    /* update mask */
           }
        }
    } while (n < DS1820_ADDR_LEN);


    /* if search was unsuccessful then */
    if ((m < 65) ||dowcrc)
//    if (m < 65 )
        /* reset the last discrepancy to 0 */
        lastDiscrep = 0;
    else
    {
        /* search was successful */
        lastDiscrep = discrepMarker;
        doneFlag = (lastDiscrep == 0);

        /* indicates search is not complete yet, more parts remain */
        nxt = true;
    }
    return nxt;
}

/*******************************************************************************
 * FUNCTION:   First
 * PURPOSE:    Starts the device search on the 1-wire bus.
 *
 * INPUT:      -
 * OUTPUT:     RomBytes[]       ROM code of the first device
 * RETURN:     bool                 TRUE if there are more devices on the 1-wire
 *                                  bus, FALSE otherwise
 ******************************************************************************/
bool First(void)
{
    lastDiscrep = 0;
    doneFlag = false;

    return ( Next() );
}
/* -------------------------------------------------------------------------- */
void FindDevices(void)
{
   char m;
   if(!ow_reset())
   {
      if(First())    // Begins when at least one part found
      {
         numROMs = 0;
         do
         {
            numROMs++;
            for (m=0;m<8;m++)
            {
               FoundROM[numROMs-1][m] = RomBytes[m];
            }
         } while (Next()&&(numROMs<10));   // Continues until no additional
      }
   }

}
//******************************************************************************
// Sends Match ROM command to bus then device address
char Send_MatchRom(char actNumROM)
{
   char i;
   if (ow_reset()) return false;          // 0 if device present
   write_byte(0x55);                      // Match ROM

   for (i=0;i<8;i++)
   {
      write_byte(FoundROM[actNumROM][i]);   // Send ROM code
   }

   return true;
}
//******************************************************************************
void Read_ROMCode(void)
{
char n;
char dat[9];

ow_reset();
write_byte(0x33);
for (n=0;n<8;n++){dat[n]=read_byte();}

pc.printf("\f%X%X%X%X\n%X%X%X%X",dat[0],dat[1],dat[2],dat[3],dat[4],dat[5],
                                                                 dat[6],dat[7]);

wait_ms(5000);
}
/*******************************************************************************
 * FUNCTION:   DS1820_WriteEEPROM
 * PURPOSE:    Writes to the DS1820 EEPROM memory (2 bytes available).
 *
 * INPUT:      nTHigh         high byte of EEPROM
 *             nTLow          low byte of EEPROM
 * OUTPUT:     -
 * RETURN:     -
 ******************************************************************************/
void DS1820_WriteEEPROM(char nTHigh, char nTLow)
{
    /* --- write to scratchpad ----------------------------------------------- */
    ow_reset();                                          // appel de la fonction ow_reset
    DS1820_AddrDevice(DS1820_CMD_MATCHROM);
    write_byte(DS1820_CMD_WRITESCRPAD);                  // debut conversion
    write_byte(nTHigh);
    write_byte(nTLow);
    wait_us(10);                                         // attendre 10ms
    ow_reset();                                          // appel de la fonction ow_reset
    DS1820_AddrDevice(DS1820_CMD_MATCHROM);
    write_byte(DS1820_CMD_COPYSCRPAD);                   // start conversion
    G__MOS_P=0;                                          // "strong pullup"
    wait_ms(10);                                         // attendre 10 ms
    G__MOS_P=1;                                          // "strong pullup"
}

/*******************************************************************************
 * FUNCTION:   DS1820_GetTemp
 * PURPOSE:    Get temperature value from single DS1820 device.
 *
 *             Scratchpad Memory Layout
 *             Byte  Register
 *             0     Temperature_LSB
 *             1     Temperature_MSB
 *             2     Temp Alarm High / User Byte 1
 *             3     Temp Alarm Low / User Byte 2
 *             4     Reserved
 *             5     Reserved
 *             6     Count_Remain
 *             7     Count_per_C
 *             8     CRC
 *
 *             Temperature calculation for DS18S20 (Family Code 0x10):
 *             =======================================================
 *                                             (Count_per_C - Count_Remain)
 *             Temperature = temp_read - 0.25 + ----------------------------
 *                                                     Count_per_C
 *
 *             Where temp_read is the value from the temp_MSB and temp_LSB with
 *             the least significant bit removed (the 0.5C bit).
 *
 *
 *             Temperature calculation for DS18B20 (Family Code 0x28):
 *             =======================================================
 *                      bit7   bit6   bit5   bit4   bit3   bit2   bit1   bit0
 *             LSB      2^3    2^2    2^1    2^0    2^-1   2^-2   2^-3   2^-4
 *                      bit15  bit14  bit13  bit12  bit3   bit2   bit1   bit0
 *             MSB      S      S      S      S      S      2^6    2^5    2^4
 *
 *             The temperature data is stored as a 16-bit sign-extended two&#65533;s
 *             complement number in the temperature register. The sign bits (S)
 *             indicate if the temperature is positive or negative: for
 *             positive numbers S = 0 and for negative numbers S = 1.
 *
 * RETURN:     float
 ******************************************************************************/
float DS1820_GetTemp(void)                          //fonction capture de la temperature
{
    char i;                                         //declaration de la variable i
    char scrpad[DS1820_SCRPADMEM_LEN];              //declaration de la variable scrpad[DS1820_SCRPADMEM_LEN]
    signed char temp_read;                          //declaration de la variable signe temp_read
    float temperature;                              //declaration de la variable flotante temperature

    /* --- start temperature conversion -------------------------------------- */
    ow_reset();
    DS1820_AddrDevice(DS1820_CMD_MATCHROM);          /* address the device */
    DQ.output();                                     //DQ en sortie
    DQ=1;                                            //DQ &#65533; 1
    write_byte(DS1820_CMD_CONVERTTEMP);              /* start conversion */
    G__MOS_P=0;                                      //"strong pullup"
    /* wait for temperature conversion */
    wait_ms(750);                                    // attendre 0.75s
    G__MOS_P=1;                                      //"strong pullup"

    /* --- read sratchpad ---------------------------------------------------- */
    ow_reset();
    DS1820_AddrDevice(DS1820_CMD_MATCHROM);           /* address the device */
    write_byte(DS1820_CMD_READSCRPAD);                /* read scratch pad */

    /* read scratch pad data */
    for (i=0; i < DS1820_SCRPADMEM_LEN; i++)          // boucle for : i=0 puis on l'incremante jusqu'a i < DS1820_SCRPADMEM_LEN
        scrpad[i] = read_byte();

    /* --- calculate temperature --------------------------------------------- */

    if (RomBytes[0] == DS1820_FAMILY_CODE_DS18S20)
    {
/////////////////////// precision O,5 degC //////////////////////////////////////
/*//   temp = (signed int) make16(scrpad[1],scrpad[0]);
   temp = (signed int) ((int)scrpad[1]<<8 | (int)scrpad[0]); 
   temperature =(float)temp/2;*/
/////////////////////////////////////////////////////////////////////////////////

////////////////////// precision O,1 deg ////////////////////////////////////////
//...calcul....
    temp_read=(signed char)(((int)scrpad[1]<<8 | (int)scrpad[0])>>1);
    temperature=(float)(temp_read);
    temperature = temperature + 0.75 - (float)(scrpad[6]/(float)scrpad[7]);
////////////////////////////////////////////////////////////////////////////////
   }
    else//ds18b20
        temperature =((float) (signed int)((int)scrpad[1]<<8 | (int)scrpad[0]))/16;

    return (temperature);
}
//******************************************************************************