OWI.h

Go to the documentation of this file.

#ifndef OWI_H
#define OWI_H

#ifndef CHARBITS
#define CHARBITS 8
#endif

class OWI {
public:
  static const size_t ROM_MAX = 8;

  static const size_t ROMBITS = ROM_MAX * CHARBITS;

  virtual bool reset() = 0;

  virtual uint8_t read(uint8_t bits = CHARBITS) = 0;

  bool read(void* buf, size_t count)
  {
    uint8_t* bp = (uint8_t*) buf;
    uint8_t crc = 0;
    while (count--) {
      uint8_t value = read();
      *bp++ = value;
      crc = crc_update(crc, value);
    }
    return (crc == 0);
  }

  virtual void write(uint8_t value, uint8_t bits = CHARBITS) = 0;

  void write(uint8_t cmd, const void* buf, size_t count)
  {
    write(cmd);
    const uint8_t* bp = (const uint8_t*) buf;
    while (count--) write(*bp++);
  }

  virtual int8_t triplet(uint8_t& dir)
  {
    switch (read(2)) {
    case 0b00:
      write(dir, 1);
      return (0b00);
    case 0b01:
      write(1, 1);
      dir = 1;
      return (0b01);
    case 0b10:
      write(0, 1);
      dir = 0;
      return (0b10);
    default:
      return (0b11);
    }
  }

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

  static inline uint8_t crc_update(uint8_t crc, uint8_t data)
    __attribute__((always_inline))
  {
    crc = crc ^ data;
    for (uint8_t i = 0; i < 8; i++) {
      if (crc & 0x01)
        crc = (crc >> 1) ^ 0x8C;
      else
        crc >>= 1;
    }
    return (crc);
  }

  static inline uint8_t crc(const void* buf, size_t count)
  {
    const uint8_t* bp = (const uint8_t*) buf;
    uint8_t crc = 0;
    while (count--) crc = crc_update(crc, *bp++);
    return (crc);
  }

  static inline uint8_t crc_P(const void* buf, size_t count)
  {
    const uint8_t* bp = (const uint8_t*) buf;
    uint8_t crc = 0;
    while (count--) crc = crc_update(crc, pgm_read_byte(bp++));
    return (crc);
  }

  enum {
    FIRST = -1,                 
    ERROR = -1,                 
    LAST = ROMBITS              
  } __attribute__((packed));

  int8_t search_rom(uint8_t family, uint8_t* code, int8_t last = FIRST)
  {
    do {
      if (!reset()) return (ERROR);
      write(SEARCH_ROM);
      last = search(code, last);
      if (last == ERROR) return (ERROR);
    } while ((last != LAST) && (family != 0) && (code[0] != family));
    if (family != 0 && code[0] != family) return (ERROR);
    return (last);
  }

  bool read_rom(uint8_t* code)
  {
    if (!reset()) return (false);
    write(READ_ROM);
    return (read(code, ROM_MAX));
  }

  bool match_rom(uint8_t* code)
  {
    if (!reset()) return (false);
    write(MATCH_ROM, code, ROM_MAX);
    return (true);
  }

  bool skip_rom()
  {
    if (!reset()) return (false);
    write(SKIP_ROM);
    return (true);
  }

  int8_t alarm_search(uint8_t* code, int8_t last = FIRST)
  {
    if (!reset()) return (ERROR);
    write(ALARM_SEARCH);
    return (search(code, last));
  }

  bool match_label(uint8_t label)
  {
    if (!reset()) return (false);
    write(MATCH_LABEL);
    write(label);
    return (true);
  }

  class Device {
  public:
    Device(OWI& owi, const uint8_t* rom = NULL) :
      m_owi(owi)
    {
      if (rom != NULL) this->rom(rom);
    }

    void rom(const uint8_t* rom)
    {
      uint8_t crc = 0;
      for (size_t i = 0; i < ROM_MAX - 1; i++) {
        uint8_t data = *rom++;
        m_rom[i] = data;
        crc = OWI::crc_update(crc, data);
      }
      m_rom[ROM_MAX - 1] = crc;
    }

    void rom_P(const uint8_t* rom)
    {
      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 = OWI::crc_update(crc, data);
      }
      m_rom[ROM_MAX - 1] = crc;
    }

    uint8_t* rom()
    {
      return (m_rom);
    }

  protected:
    OWI& m_owi;

    uint8_t m_rom[ROM_MAX];
  };

protected:
  static const uint8_t RESET_RETRY_MAX = 4;

  int8_t search(uint8_t* code, int8_t last = FIRST)
  {
    uint8_t pos = 0;
    int8_t next = LAST;
    for (uint8_t i = 0; i < 8; i++) {
      uint8_t data = 0;
      for (uint8_t j = 0; j < 8; j++) {
        uint8_t dir = (pos == last) || ((pos < last) && (code[i] & (1 << j)));
        switch (triplet(dir)) {
        case 0b00:
          if (pos == last)
            last = FIRST;
          else if (pos > last || (code[i] & (1 << j)) == 0)
            next = pos;
          break;
        case 0b11:
          return (ERROR);
        }
        data >>= 1;
        if (dir) data |= 0x80;
        pos += 1;
      }
      code[i] = data;
    }
    return (next);
  }
};
#endif