RTT.hh

Go to the documentation of this file.

#ifndef COSA_RTT_HH
#define COSA_RTT_HH

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

class RTT {
public:
  static bool begin();

  static bool end();

  static uint16_t us_per_tick();

  static uint16_t us_per_timer_cycle();

  static uint32_t micros();

  static void micros(uint32_t usec)
  {
    synchronized {
      s_micros = usec;
      s_millis = usec / 1000L;
    }
  }

  static uint32_t millis();

  static void millis(uint32_t ms)
  {
    synchronized {
      s_micros = ms * 1000L;
      s_millis = ms;
    }
  }

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

  static void delay(uint32_t ms);

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

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

    virtual bool start(Job* job);

    virtual void dispatch();

    virtual uint32_t time();
  };

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

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

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

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

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

private:
  static bool s_initiated;              
  static uint32_t s_micros;             
  static uint32_t s_millis;             
  static Scheduler* s_scheduler;        
  static Job* s_job;                    
  static Clock* s_clock;                

  RTT() {}

#if defined(TIMER2_COMPA_vect)
  friend void TIMER2_COMPA_vect(void);
  friend void TIMER2_COMPB_vect(void);
#elif defined(TCNT0)
  friend void TIMER0_COMPA_vect(void);
  friend void TIMER0_COMPB_vect(void);
#endif

  friend class RTT::Scheduler;
};

#endif