path: root/libmaple/timers.h

/******************************************************************************
 * The MIT License
 *
 * Copyright (c) 2010 Perry Hung.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *****************************************************************************/

/**
 * @file timers.h
 *
 * @brief Timer prototypes and various definitions
 */

/* Note to self:
 * The timer clock frequencies are automatically fixed by hardware.
 * There are two cases:
 *     1.  if the APB prescaler is 1, the timer clock frequencies are
 *         set to the same frequency as that of the APB domain to which
 *         the timers are connected.
 *     2.  otherwise, they are set to twice (x2) the frequency of the
 *         APB domain to which the timers are connected.
 * See stm32 manual, 77/995
 *
 * hence, 72 mhz timers
 */

/* Maple Timer channels:
 * Timer        Maple Pin               STM32 Pin     Type
 * TIM1_CH1     D6                      PA8           Advanced
 * TIM1_CH2     D7                      PA9           Advanced
 * TIM1_CH3     D8                      PA10          Advanced
 *
 * TIM2_CH1     D2                      PA0
 * TIM2_CH2     D3                      PA1
 * TIM2_CH3     D1                      PA2
 * TIM2_CH4     D0                      PA3
 *
 * TIM3_CH1     D12                     PA6
 * TIM3_CH2     D11                     PA7
 * TIM3_CH3     EXT7                    PB0
 * TIM3_CH4     EXT8                    PB1
 *
 * TIM4_CH1     EXT5                    PB6
 * TIM4_CH1     EXT9                    PB7
 * TIM4_CH1     EXT15                   PB8
 * TIM4_CH1     EXT4                    PB9
 *
 * Not supported:
 * TIM1_CH4    USBDM, not available     PA11          Advanced
 * TIM1_CH1_N  EXT12                    PB13
 * TIM1_CH2_N  EXT13                    PB14
 * TIM1_CH3_N  EXT14                    PB15
 * */

/* I don't like the Arduino API for dealing with pin modes.
 * How about...
 *
 * pinMode(digitalPin, PWM);
 * pwmWrite(digitalPin) */

#ifndef _TIMERS_H_
#define _TIMERS_H_

#ifdef __cplusplus
extern "C"{
#endif

typedef volatile uint32* TimerCCR;

#define TIMER1_BASE        0x40012C00
#define TIMER2_BASE        0x40000000
#define TIMER3_BASE        0x40000400
#define TIMER4_BASE        0x40000800
#define TIMER5_BASE        0x40000C00   // High-density devices only
#define TIMER6_BASE        0x40001000   // High-density devices only
#define TIMER7_BASE        0x40001400   // High-density devices only
#define TIMER8_BASE        0x40013400   // High-density devices only

#define ARPE               BIT(7)       // Auto-reload preload enable
#define NOT_A_TIMER        0

#define TIMER_CCR(NUM,CHAN)     TIMER ## NUM ## _CH ## CHAN ## _CRR

#define TIMER1_CH1_CCR     TIMER1_BASE + 0x34
#define TIMER1_CH2_CCR     TIMER1_BASE + 0x38
#define TIMER1_CH3_CCR     TIMER1_BASE + 0x3C
#define TIMER1_CH4_CCR     TIMER1_BASE + 0x40

#define TIMER2_CH1_CCR     TIMER2_BASE + 0x34
#define TIMER2_CH2_CCR     TIMER2_BASE + 0x38
#define TIMER2_CH3_CCR     TIMER2_BASE + 0x3C
#define TIMER2_CH4_CCR     TIMER2_BASE + 0x40

#define TIMER3_CH1_CCR     TIMER3_BASE + 0x34
#define TIMER3_CH2_CCR     TIMER3_BASE + 0x38
#define TIMER3_CH3_CCR     TIMER3_BASE + 0x3C
#define TIMER3_CH4_CCR     TIMER3_BASE + 0x40

#define TIMER4_CH1_CCR     TIMER4_BASE + 0x34
#define TIMER4_CH2_CCR     TIMER4_BASE + 0x38
#define TIMER4_CH3_CCR     TIMER4_BASE + 0x3C
#define TIMER4_CH4_CCR     TIMER4_BASE + 0x40

/* Timer5 and Timer8 are in high-density devices only (such as Maple
   Native).  Timer6 and Timer7 in these devices have no output compare
   pins. */

#define TIMER5_CH1_CCR     TIMER5_BASE + 0x34
#define TIMER5_CH2_CCR     TIMER5_BASE + 0x38
#define TIMER5_CH3_CCR     TIMER5_BASE + 0x3C
#define TIMER5_CH4_CCR     TIMER5_BASE + 0x40

#define TIMER8_CH1_CCR     TIMER8_BASE + 0x34
#define TIMER8_CH2_CCR     TIMER8_BASE + 0x38
#define TIMER8_CH3_CCR     TIMER8_BASE + 0x3C
#define TIMER8_CH4_CCR     TIMER8_BASE + 0x40

/**
 * Used to configure the behavior of a timer.
 */
typedef enum TimerMode {
    TIMER_DISABLED, /**< In this mode, the timer stops counting,
                       interrupts are not called, and no state changes
                       are output. */
    TIMER_PWM, /**< This is the default mode for pins after
                  initialization. */
    TIMER_OUTPUTCOMPARE, /**< In this mode, the timer counts from 0 to
                            its reload value repeatedly; every time
                            the counter value reaches one of the
                            channel compare values, the corresponding
                            interrupt is fired. */
} TimerMode;

typedef struct {
    volatile uint16 CR1;
    uint16  RESERVED0;
    volatile uint16 CR2;
    uint16  RESERVED1;
    volatile uint16 SMCR;
    uint16  RESERVED2;
    volatile uint16 DIER;
    uint16  RESERVED3;
    volatile uint16 SR;
    uint16  RESERVED4;
    volatile uint16 EGR;
    uint16  RESERVED5;
    volatile uint16 CCMR1;
    uint16  RESERVED6;
    volatile uint16 CCMR2;
    uint16  RESERVED7;
    volatile uint16 CCER;
    uint16  RESERVED8;
    volatile uint16 CNT;
    uint16  RESERVED9;
    volatile uint16 PSC;
    uint16  RESERVED10;
    volatile uint16 ARR;
    uint16  RESERVED11;
    volatile uint16 RCR;
    uint16  RESERVED12;
    volatile uint16 CCR1;
    uint16  RESERVED13;
    volatile uint16 CCR2;
    uint16  RESERVED14;
    volatile uint16 CCR3;
    uint16  RESERVED15;
    volatile uint16 CCR4;
    uint16  RESERVED16;
    volatile uint16 BDTR;   // Not used in general purpose timers
    uint16  RESERVED17;     // Not used in general purpose timers
    volatile uint16 DCR;
    uint16  RESERVED18;
    volatile uint16 DMAR;
    uint16  RESERVED19;
} timer_port;

/**
 * All possible timer device numbers.
 */
typedef enum {
    TIMER1,
    TIMER2,
    TIMER3,
    TIMER4,
    TIMER5,      // High density only
    TIMER6,      // High density only; no compare
    TIMER7,      // High density only; no compare
    TIMER8,      // High density only
} timer_num_t;

/* timer descriptor */
struct timer_dev {
    timer_port *base;
    const uint8 rcc_dev_num;
    const uint8 nvic_dev_num;
    volatile voidFuncPtr handlers[4];
};

extern struct timer_dev timer_dev_table[];

/**
 * Turn on timer with prescale as the clock divisor.
 *
 * @param timer Timer number.  Valid values are TIMER1, TIMER2,
 * TIMER3, TIMER4, and (on high-density devices) TIMER5, TIMER8.
 *
 * @param prescale value in the range 1--65535 to use as a prescaler
 * for timer counter increment frequency.
 *
 * @see timer_set_prescaler()
 * @see timer_set_mode()
 */
void timer_init(uint8 timer, uint16 prescale);

/**
 * Quickly disable all timers.  Calling this function is faster than,
 * e.g., calling timer_set_mode() for all available timers/channels.
 */
void timer_disable_all(void);

/**
 * Returns the timer's counter value.  Due to function call overhead,
 * this value is likely to be inaccurate if the counter is running
 * with a low prescaler.
 *
 * @param timer the timer whose counter to return.
 */
uint16 timer_get_count(uint8 timer);

/**
 * Sets the counter value for the given timer.
 *
 * @param timer the timer whose counter to set.
 *
 * @param value the new counter value.
 */
void timer_set_count(uint8 timer, uint16 value);

/**
 * Stops the timer's counter from incrementing.  Does not modify the
 * timer's mode or settings.
 *
 * @param timer the timer to pause.
 *
 * @see timer_resume()
 */
void timer_pause(uint8 timer);

/**
 * Starts the counter for the given timer.  Does not modify the
 * timer's mode or settings.  The timer will begin counting on the
 * first rising clock cycle after it has been re-enabled using this
 * function.
 *
 * @param timer the timer to resume.
 *
 * @see timer_pause()
 */
void timer_resume(uint8 timer);

/**
 * Sets the prescaler for the given timer.  The prescaler acts as a
 * clock divider of the STM32 72MHz system clock, in that the timer's
 * counter will subsequently increment with frequency equal to 72MHz /
 * prescale.
 *
 * Note that the timer will continue with its current prescaler until
 * the next time its counter reaches its overflow value, starting a
 * counting cycle.  The new prescale value will be in effect for that
 * subsequent counting cycle.
 *
 * @param timer the timer whose prescaler to set.
 *
 * @param prescale the new prescaler, from 1--65,535.
 */
void timer_set_prescaler(uint8 timer, uint16 prescale);

/**
 * Sets the reload value for the entire timer.
 *
 * After this function returns, the timer's counter will reset to 0
 * after it has reached the value max_reload.
 *
 * @param timer the timer whose reload to set.
 *
 * @param max_reload the new reload value.
 */
void timer_set_reload(uint8 timer, uint16 max_reload);

/**
 * Set the mode of an individual timer channel.
 *
 * @param timer the timer whose channel mode to set.
 *
 * @param channel the channel whose mode to set (1 <= channel <= 4).
 *
 * @param mode the new mode value.  Currently acceptable values
 * include TIMER_DISABLED, TIMER_PWM, and TIMER_OUTPUTCOMPARE.  Note
 * that timer_disable_all() will disable all timers and all channels
 * much more quickly than repeated calls to this function with mode
 * TIMER_DISABLED.
 *
 * @see TimerMode
 *
 * @see timer_disable_all()
 */
void timer_set_mode(uint8 timer, uint8 channel, TimerMode mode);

/**
 * Sets the compare value for a given timer channel.  Useful for
 * scheduling when interrupt handlers will be called.
 *
 * @param timer the timer whose channel compare to set.
 *
 * @param channel the channel whose compare to set (1 <= channel <= 4).
 *
 * @param compare the new compare value.  This new value must be less
 * than or equal to the timer's reload value.
 *
 * @see timer_attach_interrupt()
 *
 * @see timer_detach_interrupt()
 *
 * @see timer_set_reload()
 */
void timer_set_compare_value(uint8 timer, uint8 channel, uint16 compare);

/**
 * Attach an interrupt handler for the given timer and channel.  The
 * handler will be called whenever the timer's counter reaches the
 * compare value for the given timer and channel.
 *
 * @param timer the timer whose channel to register with an interrupt handler.
 *
 * @param channel the channel with which the new handler will be
 * associated.  timer_set_compare_value() can be used to set the value
 * which the timer's counter must reach before handler is called (1 <=
 * channel <= 4).
 *
 * @param handler the interrupt handler to call once the timer reaches
 * the given channel's compare value.
 *
 * @pre The channel's mode must be set to TIMER_OUTPUTCOMPARE, or the
 * interrupt handler will not get called.
 *
 * @see timer_set_compare_value()
 *
 * @see timer_detach_interrupt()
 *
 * @see timer_set_mode()
 */
void timer_attach_interrupt(uint8 timer, uint8 channel, voidFuncPtr handler);

/**
 * Detach the interrupt handler for the given timer channel, if any.
 * After this function returns, any handler attached to the given
 * channel will no longer be called.
 *
 * @param timer the timer whose channel to detach the interrupt
 * handler from.
 *
 * @param channel the channel from which to detach the interrupt handler.
 *
 * @see timer_attach_interrupt()
 */
void timer_detach_interrupt(uint8 timer, uint8 channel);

/**
 * Turn on PWM with duty_cycle.
 *
 * @param channel TIMERx_CHn_CCR, where x goes from 1 to NR_TIMERS,
 * and n goes from 1 to 4.
 *
 * @param duty_cycle 0--65535.  duty_cycle=0 means always off;
 * duty_cycle=65535 means always on.
 *
 * @pre Pin has been set to alternate function output.
 *
 * @pre Timer has been initialized.
 */
static inline void timer_pwm_write_ccr(TimerCCR CCR, uint16 duty_cycle) {
    *CCR = duty_cycle;
}

#ifdef __cplusplus
} // extern "C"
#endif


#endif