Watchdog.hh

Go to the documentation of this file.

#ifndef COSA_WATCHDOG_HH
#define COSA_WATCHDOG_HH

#include <avr/wdt.h>

#include "Cosa/Types.h"
#include "Cosa/Job.hh"
#include "Cosa/Clock.hh"

class Watchdog {
public:
  static bool is_initiated()
  {
    return (s_initiated);
  }

  static uint32_t millis()
    __attribute__((always_inline))
  {
    uint32_t res;
    synchronized res = s_millis;
    return (res);
  }

  static void millis(uint32_t ms)
  {
    synchronized s_millis = ms;
  }

  static uint16_t ms_per_tick()
  {
    return (s_ms_per_tick);
  }

  static void begin(uint16_t ms = 16);

  static void delay(uint32_t ms);

  static void await()
    __attribute__((always_inline))
  {
    delay(0);
  }

  static uint32_t since(uint32_t start)
    __attribute__((always_inline))
  {
    uint32_t now = millis();
    return (now - start);
  }

  static void end()
  {
    wdt_disable();
    s_initiated = false;
  }

  class Scheduler : public Job::Scheduler {
  public:
    Scheduler() : Job::Scheduler()
    {
      Watchdog::s_scheduler = this;
    }

    virtual uint32_t time()
    {
      return (Watchdog::millis());
    }
  };

  static void job(Watchdog::Scheduler* scheduler)
  {
    synchronized s_scheduler = scheduler;
  }

  static Watchdog::Scheduler* scheduler()
  {
    return (s_scheduler);
  }

  class Clock : public ::Clock {
  public:
    Clock() : ::Clock()
    {
      Watchdog::s_clock = this;
    }
  };

  static void wall(Clock* clock)
  {
    synchronized s_clock = clock;
  }

  static Clock* clock()
  {
    return (s_clock);
  }

private:
  static bool s_initiated;              
  static uint32_t s_millis;             
  static uint16_t s_ms_per_tick;        
  static Event::Handler* s_handler;     
  static Scheduler* s_scheduler;        
  static Clock* s_clock;                

  Watchdog() {}

  static uint8_t as_prescale(uint16_t ms);

  friend void WDT_vect(void);
};

#endif