timer.h

Go to the documentation of this file.

/*
 * atMETEO - An ATmega based weather station
 * Copyright (C) 2014-2015 Christian Fetzer
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#pragma once

#include <inttypes.h>  // AVR toolchain doesn't offer cinttypes header

#include <avr/io.h>
#include <avr/interrupt.h>

#include "lib/utils.h"

#include "interrupt.h"

// Ensure compatibility with older ATmega processors
#ifndef TIMSK1
    #define TIMSK1 TIMSK
#endif
#ifndef TICIE1
    #define TICIE1 ICIE1
#endif

#ifndef F_CPU
#error "F_CPU not defined for timer.h"
#endif

namespace Avr
{

template <uint16_t prescaler>
struct TimerUtils
{
    static constexpr uint8_t clockSelect()
    {
        static_assert(prescaler == 1 || prescaler == 8 || prescaler == 64 ||
                      prescaler == 256 || prescaler == 1024,
                      "Invalid prescaler (1, 8, 64, 256, 1024)");
        return prescaler ==    1 ? (1 << CS10) :
               prescaler ==    8 ? (1 << CS11) :
               prescaler ==   64 ? (1 << CS11) | (1 << CS10) :
               prescaler ==  256 ? (1 << CS12) :
               prescaler == 1024 ? (1 << CS12) | (1 << CS10) : 0;
    }

    template <uint16_t us>
    static constexpr uint16_t usToTicks()
    {
        return ((uint64_t)F_CPU * us) / (1000000UL * prescaler);
    }
};

namespace internal
{

class TimerInputCaptureBase
{
    CLASS_IRQ(InputCaptureInterrupt, TIMER1_CAPT_vect);
    static TimerInputCaptureBase* s_baseInstance;

    virtual void _pulseWidthReceived(uint16_t) = 0;
};
TimerInputCaptureBase *TimerInputCaptureBase::s_baseInstance = nullptr;

void TimerInputCaptureBase::InputCaptureInterrupt()
{
    s_baseInstance->_pulseWidthReceived(TCNT1);
    TCNT1 = 0;

    // Flip edge detection
    Sensors::bitFlip(TCCR1B, ICES1);
}

}  // namespace internal

template <uint16_t prescaler, class TObserver>
class TimerInputCapture
        : private internal::TimerInputCaptureBase, private TObserver
{
public:
    static TimerInputCapture& instance()
    {
        return s_instance;
    }

private:
    static TimerInputCapture s_instance;

    TimerInputCapture()
    {
        TCCR1B |= TimerUtils<prescaler>::clockSelect();

        // Input capture edge select: start with rising edge
        Sensors::bitSet(TCCR1B, ICES1);

        // Enable input capture
        Sensors::bitSet(TIMSK1, TICIE1);

        s_baseInstance = this;
    }

    void _pulseWidthReceived(uint16_t pulseWidth)
    {
        s_instance.pulseWidthReceived(pulseWidth);
    }
};

template <uint16_t prescaler, class TObserver>
TimerInputCapture<prescaler, TObserver>
TimerInputCapture<prescaler, TObserver>::s_instance = TimerInputCapture();
  // \addtogroup libtarget_timer

}  // namespace Avr