src/scheduling/realtime_timer.c

Go to the documentation of this file.

/*
 * realtime_timer.c
 *
 * Copyright 2011 Pieter Agten
 *
 * This file is part of Yarf.
 *
 * Yarf is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Yarf is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Yarf.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "realtime_timer.h"

#include "hardware/fastio.h"
#include "yarf.h"
#include "util/math.h"

#include <stdint.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <util/atomic.h>

#define RTTIMER_TICKS_PER_US (((float)F_CPU)/8/1000000)

static volatile realtime_task_t *pending_task;


static inline void
timer2_set(long ticks)
{
  /* Note: the timer should be disabled at this point */

  /* Limit the number of ticks to the maximum possible ticks in hardware */
  uint8_t hw_ticks = MIN(UINT8_MAX, MAX(0,ticks));

  /* Set TCNTn to 0 */
  TCNT2 = 0;
  /* Set the TOP register to the number of ticks we want to wait */
  OCR2A = hw_ticks;
  
  /* Enable timer 2 (with /8 prescaler) */
  TCCR2B =  (2 << CS20);
}

ISR(TIMER2_COMPA_vect, ISR_BLOCK)
{
  /* Disable the timer */
  TCCR2B = 0;

  if (pending_task != NULL) {
    if (pending_task->ticks_remaining > OCR2A) {
      pending_task->ticks_remaining -= OCR2A;

      /* The delay has not been passed yet */
      timer2_set(pending_task->ticks_remaining);
    } else {
      /* The delay has been passed, let's execute the task */

      volatile realtime_task_t *t = pending_task;
      /* Set pending_task to NULL so f will be able to schedule another task */
      pending_task = NULL;
      t->f();
    }
  }
}


void
rttimer_init(void)
{
  pending_task = NULL;
  
  /* Select OCR2A CTC mode; */
  TCCR2A = (2 << WGM20);
  TCCR2B = 0;

  /* Clear all timer 2 interrupt flags */
  TIFR2 = _BV(OCF2B)|_BV(OCF2A)|_BV(TOV2);

  /* Enable the OCR2A interrupt */
  TIMSK2 = _BV(OCIE2A);
}


int
rttimer_schedule_ticks(realtime_task_t *t, uint16_t ticks)
{
  if (pending_task != NULL) {
    return RTTIMER_BUSY;
  }
  pending_task = t;

  pending_task->ticks_remaining = ticks;
  timer2_set(pending_task->ticks_remaining);
  
  return RTTIMER_SUCCESS;
}


int
rttimer_cancel(void)
{
  if (pending_task == NULL) {
    return RTTIMER_NOT_RUNNING;
  }

  /* Disable the timer */
  TCCR2B = 0;
  
  /* Clear all timer 2 interrupt flags */
  TIFR2 = _BV(OCF2B)|_BV(OCF2A)|_BV(TOV2);

  /* Remove the pending task */
  pending_task = NULL;

  return RTTIMER_SUCCESS;
}