DS18B20.h

Go to the documentation of this file.

#ifndef OWI_DRIVER_DS18B20_H
#define OWI_DRIVER_DS18B20_H

#include "OWI.h"

class DS18B20 : public OWI::Device {
public:
  static const uint8_t FAMILY_CODE = 0x28;

  static const uint16_t MAX_CONVERSION_TIME = 750;

  DS18B20(OWI& owi, uint8_t* rom = NULL) :
    OWI::Device(owi, rom),
    m_start(0),
    m_converting(false)
  {
    resolution(12);
    set_trigger(70, 75);
  }

  void resolution(uint8_t bits)
  {
    if (bits < 9) bits = 9; else if (bits > 12) bits = 12;
    m_scratchpad.configuration = (((bits - 9) << 5) | 0x1f);
  }

  void set_trigger(int8_t low, int8_t high)
  {
    m_scratchpad.low_trigger = low;
    m_scratchpad.high_trigger = high;
  }

  float temperature() const
  {
    return (m_scratchpad.temperature * 0.0625);
  }

  uint8_t resolution() const
  {
    return (9 + (m_scratchpad.configuration >> 5));
  }

  void get_trigger(int8_t& low, int8_t& high) const
  {
    low = m_scratchpad.low_trigger;
    high = m_scratchpad.high_trigger;
  }

  bool convert_request(bool broadcast = false)
  {
    if (broadcast) {
      if (!m_owi.skip_rom()) return (false);
    }
    else {
      if (!m_owi.match_rom(m_rom)) return (false);
    }
    m_owi.write(CONVERT_T);
    m_start = millis();
    m_converting = true;
    return (true);
  }

  uint16_t conversion_time()
  {
    if (!m_converting) return (0);
    m_converting = false;
    uint16_t ms = millis() - m_start;
    uint16_t conv_ms = (MAX_CONVERSION_TIME >> (12 - resolution()));
    if (conv_ms > ms) return (conv_ms - ms);
    return (0);
  }

  bool convert_ready()
  {
    if (!m_converting) return (true);
    bool res = m_owi.read(1);
    if (res) m_converting = false;
    return (res);
  }

  bool convert_await()
  {
    if (!m_converting) return (false);
    while (!convert_ready()) delay(1);
    return (true);
  }

  bool read_scratchpad(bool match = true)
  {
    if (match && !m_owi.match_rom(m_rom)) return (false);
    m_owi.write(READ_SCRATCHPAD);
    return (m_owi.read(&m_scratchpad, sizeof(m_scratchpad)));
  }

  bool write_scratchpad(bool match = true)
  {
    if (match && !m_owi.match_rom(m_rom)) return (false);
    m_owi.write(WRITE_SCRATCHPAD, &m_scratchpad.high_trigger, CONFIG_MAX);
    return (true);
  }

  bool copy_scratchpad(bool match = true)
  {
    if (match && !m_owi.match_rom(m_rom)) return (false);
    m_owi.write(COPY_SCRATCHPAD);
    return (true);
  }

  bool recall(bool match = true)
  {
    if (match && !m_owi.match_rom(m_rom)) return (false);
    m_owi.write(RECALL_E);
    return (true);
  }

protected:
  enum {
    CONVERT_T = 0x44,           
    READ_SCRATCHPAD = 0xBE,     
    WRITE_SCRATCHPAD = 0x4E,    
    COPY_SCRATCHPAD = 0x48,     
    RECALL_E = 0xB8,            
    READ_POWER_SUPPLY = 0xB4    
  } __attribute__((packed));

  struct scratchpad_t {
    int16_t temperature;        
    int8_t high_trigger;        
    int8_t low_trigger;         
    uint8_t configuration;      
    uint8_t reserved[3];        
    uint8_t crc;                
  } __attribute__((packed));
  scratchpad_t m_scratchpad;

  static const uint8_t CONFIG_MAX = 3;

  uint16_t m_start;

  bool m_converting;
};
#endif