OWI.h

Go to the documentation of this file.

#ifndef SLAVE_OWI_H
#define SLAVE_OWI_H

#include "GPIO.h"

namespace Slave {
template<BOARD::pin_t PIN>
class OWI {
public:
  static const size_t ROM_MAX = 8;

  static const size_t ROMBITS = ROM_MAX * 8;

  OWI(const uint8_t* rom) :
    m_timestamp(0),
    m_label(255),
    m_alarm(false)
  {
    uint8_t crc = 0;
    for (size_t i = 0; i < ROM_MAX - 1; i++) {
      uint8_t data = pgm_read_byte(rom++);
      m_rom[i] = data;
      crc = crc_update(crc, data);
    }
    m_rom[ROM_MAX - 1] = crc;
    m_pin.open_drain();
  }

  OWI(uint8_t family) :
    m_timestamp(0),
    m_label(255),
    m_alarm(false)
  {
    uint8_t crc = crc_update(0, family);
    uint8_t* p = 0;
    m_rom[0] = family;
    for (size_t i = 1; i < ROM_MAX - 1; i++) {
      uint8_t data = *p++;
      m_rom[i] = data;
      crc = crc_update(crc, data);
    }
    m_rom[ROM_MAX - 1] = crc;
    m_pin.open_drain();
  }

  uint8_t crc()
  {
    return (m_crc);
  }

  void crc(uint8_t value)
  {
    m_crc = value;
  }

  bool alarm()
  {
    return (m_alarm);
  }

  void alarm(bool value)
  {
    m_alarm = value;
  }

  bool reset()
  {
    // Check reset start
    if (m_timestamp == 0) {
      if (!m_pin) m_timestamp = micros();
      return (false);
    }

    // Check reset pulse stop
    if (!m_pin) return (false);

    // Check reset pulse width
    if (micros() - m_timestamp < 410) {
      m_timestamp = 0;
      return (false);
    }

    // Generate presence signal
    m_pin.output();
    delayMicroseconds(100);
    m_pin.input();

    // Wait for possible presence signals from other devices
    while (!m_pin);
    m_timestamp = 0;

    return (true);
  }

  uint8_t read(uint8_t bits = 8)
  {
    uint8_t adjust = 8 - bits;
    uint8_t res = 0;
    uint8_t mix = 0;
    do {
      noInterrupts();
      // Wait for bit start
      while (m_pin);
      // Delay to sample bit value
      delayMicroseconds(20);
      res >>= 1;
      if (m_pin) {
        res |= 0x80;
        mix = (m_crc ^ 1);
      }
      else {
        mix = (m_crc ^ 0);
      }
      interrupts();
      // Calculate cyclic redundancy check sum
      m_crc >>= 1;
      if (mix & 1) m_crc ^= 0x8C;
      // Wait for bit end (max 50 us)
      uint8_t count = 255;
      while (!m_pin && --count);
      if (count == 0) return (0);
    } while (--bits);
    res >>= adjust;
    return (res);
  }

  bool read(void* buf, size_t count)
  {
    // Write bytes and calculate crc
    uint8_t* bp = (uint8_t*) buf;
    m_crc = 0;
    do {
      uint8_t value = read();
      *bp++ = value;
    } while (--count);

    // Return crc validation
    return (m_crc == 0);
  }

  void write(uint8_t value, uint8_t bits = 8)
  {
    uint8_t mix = 0;
    do {
      noInterrupts();
      // Wait for bit start
      while (m_pin);
      // Streck low if bit is zero
      if ((value & 0x01) == 0) {
        m_pin.output();
        delayMicroseconds(20);
        m_pin.input();
        mix = (m_crc ^ 0);
      }
      else {
        mix = (m_crc ^ 1);
      }
      interrupts();
      value >>= 1;
      // Calculate cyclic redundancy check sum
      m_crc >>= 1;
      if (mix & 1) m_crc ^= 0x8C;
      // Wait for bit end (max 50 us)
      uint8_t count = 255;
      while (!m_pin && --count);
      if (count == 0) return;
    } while (--bits);
  }

  void write(const void* buf, size_t count)
  {
    // Write bytes and calculate cyclic redundancy check-sum
    const uint8_t* bp = (const uint8_t*) buf;
    m_crc = 0;
    do {
      uint8_t value = *bp++;
      write(value);
    } while (--count);

    // Write calculated crc
    write(m_crc);
  }

  bool triplet(bool bit)
  {
    write(bit, 1);
    write(!bit, 1);
    return (read(1));
  }

  enum {
    SEARCH_ROM = 0xF0,          
    READ_ROM = 0x33,            
    MATCH_ROM = 0x55,           
    SKIP_ROM = 0xCC,            
    ALARM_SEARCH = 0xEC,        
    LABEL_ROM = 0x15,           
    READ_LABEL = 0x16,          
    MATCH_LABEL = 0x51          
  } __attribute__((packed));

  bool rom_command()
  {
    // Wait for reset
    if (!reset()) return (false);

    // Standard ROM commands
    switch (read()) {
    case READ_ROM:
      // Write ROM to master
      write(m_rom, ROM_MAX - 1);
      return (false);
    case MATCH_ROM:
      // Match ROM from master
      for (size_t i = 0; i < ROM_MAX; i++)
        if (m_rom[i] != read())
          return (false);
    case SKIP_ROM:
      // Skip ROM, extended command will follow
      return (true);
    case ALARM_SEARCH:
      // Ignore search request if alarm is not set
      if (!m_alarm)
        return (false);
    case SEARCH_ROM:
      // Write ROM bit and check branching
      for (size_t i = 0; i < ROM_MAX; i++) {
        uint8_t value = m_rom[i];
        uint8_t mask = 0x01;
        do {
          uint8_t bit = (mask & value) != 0;
          bool dir = triplet(bit);
          if (dir != bit) return (false);
          mask <<= 1;
        } while (mask);
      }
      return (true);
    case MATCH_LABEL:
      // Device label setting
      if (m_label == read())
        return (true);
    default:
      // Ignore all other commands
      return (false);
    };
  }

  uint8_t read_command()
  {
    uint8_t cmd = read();
    switch (cmd) {
    case LABEL_ROM:
      // Set device label
      m_label = read();
      return (0);
    case READ_LABEL:
      // Get device label
      write(m_label);
      return (0);
    default:
      return (cmd);
    };
  }

  static inline uint8_t crc_update(uint8_t crc, uint8_t data)
    __attribute__((always_inline))
  {
    crc = crc ^ data;
    uint8_t bits = 8;
    do {
      if (crc & 0x01)
        crc = (crc >> 1) ^ 0x8C;
      else
        crc >>= 1;
    } while (--bits);
    return (crc);
  }

protected:
  GPIO<PIN> m_pin;

  uint32_t m_timestamp;

  uint8_t m_rom[ROM_MAX];

  uint8_t m_label;

  bool m_alarm;

  uint8_t m_crc;
};
};
#endif