DS2482.h

Go to the documentation of this file.

#ifndef DS2482_H
#define DS2482_H

#include "TWI.h"

class DS2482 : protected TWI::Device {
public:
  DS2482(TWI& twi, uint8_t subaddr = 0) :
    TWI::Device(twi, 0x18 | (subaddr & 0x03))
  {
  }

  bool one_wire_reset()
  {
    status_t status;
    uint8_t cmd;
    int count;
    bool res = false;

    // Issue one wire reset command
    cmd = ONE_WIRE_RESET;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(&cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;
    if (one_wire_await(status)) res = status.PPD;

  error:
    if (!TWI::Device::release()) return (false);
    return (res);
  }

  bool one_wire_read_bit(bool& value)
  {
    status_t status;
    uint8_t cmd[2];
    int count;
    bool res = false;

    // Issue one wire single bit command with read data time slot
    cmd[0] = ONE_WIRE_SINGLE_BIT;
    cmd[1] = 0x80;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Wait for one wire operation to complete
    res = one_wire_await(status);
    value = status.SBR;

  error:
    if (!TWI::Device::release()) return (false);
    return (res);
  }

  bool one_wire_write_bit(bool value)
  {
    status_t status;
    uint8_t cmd[2];
    int count;
    bool res = false;

    // Issue one wire single bit command with given data
    cmd[0] = ONE_WIRE_SINGLE_BIT;
    cmd[1] = (value ? 0x80 : 0x00);
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;
    res = one_wire_await(status);

  error:
    if (!TWI::Device::release()) return (false);
    return (res);
  }

  virtual bool one_wire_read_byte(uint8_t& value)
  {
    status_t status;
    uint8_t cmd;
    int count;

    // Issue one wire read byte command
    cmd = ONE_WIRE_READ_BYTE;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(&cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Wait for one wire operation to complete
    if (!one_wire_await(status)) goto error;
    if (!TWI::Device::release()) return (false);

    // Read data register value
    return (set_read_pointer(READ_DATA_REGISTER, value));

  error:
    TWI::Device::release();
    return (false);
  }

  bool one_wire_write_byte(uint8_t value)
  {
    status_t status;
    uint8_t cmd[2];
    int count;
    bool res = false;

    // Issue one wire write byte command with given data
    cmd[0] = ONE_WIRE_WRITE_BYTE;
    cmd[1] = value;
    if (!TWI::Device::acquire()) return (res);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;
    res = one_wire_await(status);

  error:
    if (!TWI::Device::release()) return (false);
    return (res);
  }

  int8_t one_wire_triplet(uint8_t& dir)
  {
    status_t status;
    uint8_t cmd[2];
    int count;

    // Issue one wire single bit command with given data
    cmd[0] = ONE_WIRE_TRIPLET;
    cmd[1] = (dir ? 0x80 : 0x00);
    if (!TWI::Device::acquire()) return (-1);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Wait for one wire operation to complete
    if (!one_wire_await(status)) goto error;
    if (!TWI::Device::release()) return (-1);
    dir = status.DIR;
    return ((status >> 5) & 0x3);

  error:
    TWI::Device::release();
    return (-1);
  }

  bool device_reset()
  {
    status_t status;
    uint8_t cmd;
    int count;

    // Issue device reset command
    cmd = DEVICE_RESET;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(&cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Check status register for device reset
    count = TWI::Device::read(&status, sizeof(status));
    if (!TWI::Device::release()) return (false);
    return ((count == sizeof(status)) && status.RST);

  error:
    TWI::Device::release();
    return (false);
  }

  bool write_configuration(bool apu = true, bool spu = false, bool iws = false)
  {
    config_t config;
    status_t status;
    uint8_t cmd[2];
    int count;

    // Set configuration bit-fields
    config.APU = apu;
    config.SPU = spu;
    config.IWS = iws;
    config.COMP = ~config;

    // Issue write configuration command with given setting
    cmd[0] = WRITE_CONGIFURATION;
    cmd[1] = config;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Read status and check configuration
    count = TWI::Device::read(&status, sizeof(status));
    if (!TWI::Device::release()) return (false);
    return ((count == sizeof(status)) && !status.RST);

  error:
    TWI::Device::release();
    return (false);
  }

  enum Register {
    STATUS_REGISTER = 0xf0,
    READ_DATA_REGISTER = 0xe1,
    CHANNEL_SELECTION_REGISTER = 0xd2,
    CONFIGURATION_REGISTER = 0xc3
  } __attribute__((packed));

  bool set_read_pointer(Register addr, uint8_t& value)
  {
    uint8_t cmd[2];
    int count;
    bool res = false;

    // Issue set read pointer command with given pointer
    cmd[0] = SET_READ_POINTER;
    cmd[1] = (uint8_t) addr;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (count != sizeof(cmd)) goto error;

    // Read register value
    count = TWI::Device::read(&value, sizeof(value));
    res = (count == sizeof(value));

  error:
    if (!TWI::Device::release()) return (false);
    return (res);
  }

  bool channel_select(uint8_t chan)
  {
    uint8_t cmd[2];
    int count;

    // Check channel number
    if (chan > 7) return (false);

    // Issue channel select command with channel code
    cmd[0] = CHANNEL_SELECT;
    cmd[1] = (~chan << 4) | chan;
    if (!TWI::Device::acquire()) return (false);
    count = TWI::Device::write(cmd, sizeof(cmd));
    if (!TWI::Device::release()) return (false);
    return (count == sizeof(cmd));
  }

protected:
  enum {
    DEVICE_RESET = 0xf0,        
    SET_READ_POINTER = 0xe1,    
    WRITE_CONGIFURATION = 0xd2, 
    CHANNEL_SELECT = 0xc3,      
    ONE_WIRE_RESET = 0xb4,      
    ONE_WIRE_SINGLE_BIT = 0x87, 
    ONE_WIRE_WRITE_BYTE = 0xa5, 
    ONE_WIRE_READ_BYTE = 0x96,  
    ONE_WIRE_TRIPLET = 0x78     
  } __attribute__((packed));

  union status_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t IWB:1;            
      uint8_t PPD:1;            
      uint8_t SD:1;             
      uint8_t LL:1;             
      uint8_t RST:1;            
      uint8_t SBR:1;            
      uint8_t TSB:1;            
      uint8_t DIR:1;            
    };
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union config_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t APU:1;            
      uint8_t ZERO:1;           
      uint8_t SPU:1;            
      uint8_t IWS:1;            
      uint8_t COMP:4;           
    };
    operator uint8_t()
    {
      return (as_uint8);
    }
    config_t()
    {
      as_uint8 = 0;
    }
  };

  static const int POLL_MAX = 20;

  bool one_wire_await(status_t& status)
  {
    // Wait for one wire operation to complete
    for (int i = 0; i < POLL_MAX; i++) {
      int count = TWI::Device::read(&status, sizeof(status));
      if (count == sizeof(status) && !status.IWB) return (true);
    }
    return (false);
  }

};
#endif