Embedded Lab

One-Wire Communication with DS18B20

Dallas DS18B20 is another one-wire device but as said earlier, it is different from DHT11 or other one-wire devices. DS18B20 is a high-resolution digital temperature sensor. This sensor also uses time-slotting mechanism to send and receive data from a host micro.

One advantage of time-slotting mechanism is the fact that no special hardware and therefore no dedicated pin of a host microcontroller is needed. Any physical pin can be used and only software delays along with polling methodology are what required. It is also possible to use internal timers instead of wasteful software delays.

Time-slotting technique is also used in infrared remote controllers.

Code Example

one_wire.h

#include "driverlib.h"
#include "delay.h"

#define DS18B20_PORT        GPIO_PORT_P3

#define DS18B20_PIN         GPIO_PIN7

#define DS18B20_OUTPUT()    GPIO_setAsOutputPin(DS18B20_PORT, DS18B20_PIN)
#define DS18B20_INPUT()     GPIO_setAsInputPin(DS18B20_PORT, DS18B20_PIN)

#define DS18B20_IN()        GPIO_getInputPinValue(DS18B20_PORT, DS18B20_PIN)

#define DS18B20_OUT_HIGH()  GPIO_setOutputHighOnPin(DS18B20_PORT, DS18B20_PIN)
#define DS18B20_OUT_LOW()   GPIO_setOutputLowOnPin(DS18B20_PORT, DS18B20_PIN)

#define TRUE                1
#define FALSE               0

unsigned char onewire_reset(void) ;
void onewire_write_bit(unsigned char bit_value);
unsigned char onewire_read_bit(void);
void onewire_write(unsigned char value);    
unsigned char onewire_read(void);

one_wire.c

#include "one_wire.h"
    

unsigned char onewire_reset(void)  
{                                         
     unsigned char res = FALSE; 
     
     DS18B20_OUTPUT();                 
     DS18B20_OUT_LOW();
     delay_us(480);        
     DS18B20_OUT_HIGH();
     delay_us(60);        

     DS18B20_INPUT();
     res = DS18B20_IN();
     delay_us(480);       
     
     return res; 
} 

void onewire_write_bit(unsigned char bit_value)
{
    DS18B20_OUTPUT();
    DS18B20_OUT_LOW(); 
    
    if(bit_value)
    {       
        delay_us(104);
        DS18B20_OUT_HIGH();   
    }              
}     

unsigned char onewire_read_bit(void)        
{     
    DS18B20_OUTPUT();
    DS18B20_OUT_LOW();  
    DS18B20_OUT_HIGH();  
    delay_us(15);      
    DS18B20_INPUT();

    return(DS18B20_IN());    
}

void onewire_write(unsigned char value) 
{                    
     unsigned char s = 0; 
     
     DS18B20_OUTPUT();

     while(s < 8)    
     {                              
          if((value & (1 << s)))
          {
              DS18B20_OUT_LOW(); 
              _delay_cycles(1);
              DS18B20_OUT_HIGH();  
              delay_us(60);   
          }       
                              
          else
          {
              DS18B20_OUT_LOW();           
              delay_us(60);           
              DS18B20_OUT_HIGH();   
              _delay_cycles(1);
          }

          s++;
     }
}                                      

unsigned char onewire_read(void)
{
     unsigned char s = 0x00;
     unsigned char value = 0x00;
    
     while(s < 8) 
     {
          DS18B20_OUTPUT();

          DS18B20_OUT_LOW();
          _delay_cycles(1);
          DS18B20_OUT_HIGH();  
          
          DS18B20_INPUT();
          if(DS18B20_IN())  
          {                                      
              value |=  (1 << s);                         
          }        
           
          delay_us(60);

          s++;
     }     
     
     return value;
}  

DS18B20.h

#include "one_wire.h"  

#define convert_T                       0x44
#define read_scratchpad                 0xBE            
#define write_scratchpad                0x4E 
#define copy_scratchpad                 0x48   
#define recall_E2                       0xB8 
#define read_power_supply               0xB4    
#define skip_ROM                        0xCC

#define resolution                      12

void DS18B20_init(void);
float DS18B20_get_temperature(void);  

DS18B20.c

#include "DS18B20.h"

void DS18B20_init(void)                             
{                                       
    onewire_reset();
    delay_ms(100);
}              

float DS18B20_get_temperature(void)
{                                               
    unsigned char msb = 0x00;
    unsigned char lsb = 0x00;
    register float temp = 0.0;  
                           
    onewire_reset();     
    onewire_write(skip_ROM);        
    onewire_write(convert_T); 
    
    switch(resolution)   
    {                                                  
        case 12:
        {                                            
            delay_ms(750);
            break;
        }                
        case 11:                                     
        {              
            delay_ms(375);
            break;
        }           
        case 10:                             
        {                                 
            delay_ms(188);   
            break;
        }                                        
        case 9:                                   
        {                                                
            delay_ms(94);                 
            break;                            
        }                        
    }                  

    onewire_reset(); 

    onewire_write(skip_ROM);                 
    onewire_write(read_scratchpad);

    lsb = onewire_read();
    msb = onewire_read();

    temp = msb;                           
    temp *= 256.0;
    temp += lsb;
    
    
    switch(resolution)   
    {                                  
        case 12:            
        {                                                
            temp *= 0.0625;                 
            break;                            
        }       
        case 11: 
        {           
            temp *= 0.125;      
            break;
        }                
        case 10:
        {            
            temp *= 0.25;       
            break;
        }  
        case 9:                                 
        {                                 
            temp *= 0.5;        
            break;      
        }                          
    }  
    
    delay_ms(40);       
    
    return (temp);       
}

main.c

#include "driverlib.h"
#include "delay.h"
#include "one_wire.h"
#include "DS18B20.h"
#include "lcd.h"
#include "lcd_print.h"

void clock_init(void);

void main(void)
{
    float t = 0.0;

    WDT_A_hold(WDT_A_BASE);

    clock_init();

    DS18B20_init();

    LCD_init();
    load_custom_symbol();

    LCD_goto(1, 0);
    LCD_putstr("MSP430 DS18B20");

    LCD_goto(0, 1);
    LCD_putstr("T/ C");
    print_symbol(2, 1, 0);

    while(1)
    {
        t = DS18B20_get_temperature();
        print_F(9, 1, t, 3);
        delay_ms(1000);
    };
}

void clock_init(void)
{
    PMM_setVCore(PMM_CORE_LEVEL_3);

    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5,
                                               (GPIO_PIN4 | GPIO_PIN2));

    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P5,
                                                (GPIO_PIN5 | GPIO_PIN3));

    UCS_setExternalClockSource(XT1_FREQ,
                               XT2_FREQ);

    UCS_turnOnXT2(UCS_XT2_DRIVE_4MHZ_8MHZ);

    UCS_turnOnLFXT1(UCS_XT1_DRIVE_0,
                    UCS_XCAP_3);

    UCS_initClockSignal(UCS_MCLK,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);

    UCS_initClockSignal(UCS_SMCLK,
                        UCS_REFOCLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);

    UCS_initClockSignal(UCS_ACLK,
                        UCS_XT1CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);
}

Hardware Setup

Explanation

One wire communication is detailed in these application notes from Maxim:

https://www.maximintegrated.com/en/app-notes/index.mvp/id/126

https://www.maximintegrated.com/en/app-notes/index.mvp/id/162

These notes are all that are needed for implementing the one wire communication interface for DS18B20. Please go through these notes for details. The codes are self-explanatory and are implemented from the code examples in these app notes.

Demo

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37