OWI.hh

Go to the documentation of this file.

#ifndef COSA_OWI_HH
#define COSA_OWI_HH

#include "Cosa/Types.h"
#include "Cosa/IOPin.hh"
#include "Cosa/IOStream.hh"

class OWI : private IOPin {
public:
  enum {
    SEARCH_ROM = 0xF0,
    READ_ROM = 0x33,
    MATCH_ROM = 0x55,
    SKIP_ROM = 0xCC,
    ALARM_SEARCH = 0xEC
  } __attribute__((packed));

  static const uint8_t ROM_MAX = 8;

  static const uint8_t ROMBITS = ROM_MAX * CHARBITS;

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

    str_P NAME;

    Driver(OWI* pin, const char* name = NULL) :
      NAME((str_P) name),
      ROM(NULL),
      m_next(NULL),
      m_pin(pin)
    {
      memset(m_rom, 0, sizeof(m_rom));
    }

    Driver(OWI* pin, const uint8_t* rom, const char* name = NULL);

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

    bool update_rom();

    int8_t search_rom(int8_t last = FIRST);

    bool read_rom();

    bool match_rom();

    bool skip_rom();

    int8_t alarm_search(int8_t last = FIRST);

    bool connect(uint8_t family, uint8_t index);

    virtual void on_alarm() {}

  protected:
    uint8_t m_rom[ROM_MAX];
    const uint8_t* ROM;
    Driver* m_next;
    OWI* m_pin;

    int8_t search(int8_t last = FIRST);

    friend class OWI;
    friend IOStream& operator<<(IOStream& outs, OWI& owi);
    friend IOStream& operator<<(IOStream& outs, Driver& dev);
  };

  class Search : protected Driver {
  public:
    Search(OWI* owi, uint8_t family = 0) :
      Driver(owi),
      m_family(family),
      m_last(FIRST)
    {}

    Driver* next();

    void reset()
    {
      m_last = FIRST;
    }

  protected:
    uint8_t m_family;
    int8_t m_last;
  };

public:
  OWI(Board::DigitalPin pin) :
    IOPin(pin),
    m_devices(0),
    m_device(NULL),
    m_crc(0)
  {}

  bool reset();

  uint8_t read(uint8_t bits = CHARBITS);

  bool read(void* buf, uint8_t size);

  void write(uint8_t value, uint8_t bits = CHARBITS, bool power = false);

  void write(uint8_t value, void* buf, uint8_t size);

  void power_off()
    __attribute__((always_inline))
  {
    mode(INPUT_MODE);
    clear();
  }

  Driver* lookup(uint8_t* rom);

  bool alarm_dispatch();

private:
  uint8_t m_devices;

  Driver* m_device;

  uint8_t m_crc;
};

IOStream& operator<<(IOStream& outs, OWI::Driver& dev);

IOStream& operator<<(IOStream& outs, OWI& owi);

#endif