Timer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-2017, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*!*****************************************************************************
 *  @file       Timer.h
 *  @brief      Timer driver interface
 *
 *  The timer header file should be included in an application as follows:
 *  @code
 *  #include <ti/drivers/Timer.h>
 *  @endcode
 *
 *  # Overview #
 *  The timer driver serves as the main interface for a typical RTOS
 *  application. Its purpose is to redirect the timer APIs to device specific
 *  implementations which are specified using a pointer to a #Timer_FxnTable.
 *  The device specific implementations are responsible for creating all the
 *  RTOS specific primitives to allow for thead-safe operation. This driver
 *  does not have PWM or capture functionalities. These functionalities are
 *  addressed in both the capture and PWM driver.
 *
 *  The timer driver also handles the general purpose timer resource allocation.
 *  For each driver that requires use of a general purpose timer, it calls
 *  Timer_open() to occupy the specified timer, and calls Timer_close() to
 *  release the occupied timer resource.
 *
 *  # Usage #
 *  The following example code opens a timer in continuous callback mode. The
 *  period is set to 1000 Hz.
 *
 *  @code
 *  Timer_Handle    handle;
 *  Timer_Params    params;
 *
 *  Timer_Params_init(&params);
 *  params.periodUnits = Timer_PERIOD_HZ;
 *  params.period = 1000;
 *  params.timerMode  = Timer_CONTINUOUS_CALLBACK;
 *  params.timerCallback = someTimerCallbackFunction;
 *
 *  handle = Timer_open(Board_TIMER0, &params);
 *
 *  if (handle == NULL) {
 *      // Timer_open() failed
 *      while (1);
 *  }
 *
 *  status = Timer_start(handle);
 *
 *  if (status == Timer_STATUS_ERROR) {
 *      //Timer_start() failed
 *      while (1);
 *  }
 *
 *  sleep(10000);
 *
 *  Timer_stop(handle);
 *  @endcode
 *
 *  ### Timer Driver Configuration #
 *
 *  In order to use the timer APIs, the application is required to provide
 *  device specific timer configuration in the Board.c file. The timer driver
 *  interface defines a configuration data structure:
 *
 *  @code
 *  typedef struct Timer_Config_ {
 *      Timer_FxnTable const *fxnTablePtr;
 *      void                 *object;
 *      void           const *hwAttrs;
 *  } Timer_Config;
 *  @endcode
 *
 *  The application must declare an array of Timer_Config elements, named
 *  Timer_config[]. Each element of Timer_config[] are populated with
 *  pointers to a device specific timer driver implementation's function
 *  table, driver object, and hardware attributes. The hardware attributes
 *  define properties such as the timer peripheral's base address, interrupt
 *  number and interrupt priority. Each element in Timer_config[] corresponds
 *  to a timer instance, and none of the elements should have NULL pointers.
 *  There is no correlation between the index and the peripheral designation
 *  (such as TIMER0 or TIMER1). For example, it is possible to use
 *  Timer_config[0] for TIMER1.
 *
 *  You will need to check the device specific timer driver implementation's
 *  header file for example configuration.
 *
 *  ### Initializing the timer Driver #
 *
 *  Timer_init() must be called before any other timer APIs. This function
 *  calls the device implementation's timer initialization function, for each
 *  element of Timer_config[].
 *
 *  ### Modes of Operation #
 *
 *  The timer driver supports four modes of operation which may be specified in
 *  the Timer_Params.
 *
 *  #Timer_ONESHOT_CALLBACK is non-blocking. After Timer_start() is called,
 *  the calling thread will continue execution. When the timer interrupt
 *  is triggered, the specified callback function will be called. The timer
 *  will not generate another interrupt unless Timer_start() is called again.
 *  Calling Timer_stop() or Timer_close() after Timer_start() but, before the
 *  timer interrupt, will prevent the specified callback from ever being
 *  invoked.
 *
 *  #Timer_ONESHOT_BLOCKING is a blocking call. A semaphore is used to block
 *  the calling thead's execution until the timer generates an interrupt. If
 *  Timer_stop() is called, the calling thread will become unblocked
 *  immediately. The behavior of the timer in this mode is similar to a sleep
 *  function.
 *
 *  #Timer_CONTINUOUS_CALLBACK is non-blocking. After Timer_start() is called,
 *  the calling thread will continue execution. When the timer interrupt is
 *  treiggered, the specified callback function will be called. The timer is
 *  automatically restarted and will continue to periodically generate
 *  interrupts until Timer_stop() is called.
 *
 *  #Timer_FREE_RUNNING is non-blocking. After Timer_start() is called,
 *  the calling thread will continue execution. The timer will not
 *  generate an interrupt in this mode. The timer hardware will run until
 *  Timer_stop() is called.
 *
 *  # Implementation #
 *
 *  The timer driver interface module is joined (at link time) to an
 *  array of Timer_Config data structures named *Timer_config*.
 *  Timer_config is implemented in the application with each entry being an
 *  instance of a timer peripheral. Each entry in *Timer_config* contains a:
 *  - (Timer_FxnTable *) to a set of functions that implement a timer peripheral
 *  - (void *) data object that is associated with the Timer_FxnTable
 *  - (void *) hardware attributes that are associated with the Timer_FxnTable
 *
 *  The timer APIs are redirected to the device specific implementations
 *  using the Timer_FxnTable pointer of the Timer_config entry.
 *  In order to use device specific functions of the timer driver directly,
 *  link in the correct driver library for your device and include the
 *  device specific timer driver header file (which in turn includes Timer.h).
 *  For example, for the MSP432 family of devices, you would include the
 *  following header file:
 *
 *  @code
 *  #include <ti/drivers/timer/TimerMSP432.h>
 *  @endcode
 *
 *******************************************************************************
 */
#ifndef ti_drivers_Timer__include
#define ti_drivers_Timer__include

#include <stdint.h>

#ifdef __cplusplus
extern "C"
{
#endif

#define Timer_CMD_RESERVED                (32)

#define Timer_STATUS_RESERVED            (-32)

#define Timer_STATUS_SUCCESS               (0)

#define Timer_STATUS_ERROR                (-1)

#define Timer_STATUS_UNDEFINEDCMD         (-2)

typedef struct Timer_Config_ *Timer_Handle;

typedef enum Timer_Mode_ {
    Timer_ONESHOT_CALLBACK,       
    Timer_ONESHOT_BLOCKING,       
    Timer_CONTINUOUS_CALLBACK,    
    Timer_FREE_RUNNING
} Timer_Mode;

typedef enum Timer_PeriodUnits_ {
    Timer_PERIOD_US,      
    Timer_PERIOD_HZ,      
    Timer_PERIOD_COUNTS   
} Timer_PeriodUnits;

typedef void (*Timer_CallBackFxn)(Timer_Handle handle);

typedef struct Timer_Params_ {
    Timer_Mode           timerMode;

    Timer_PeriodUnits    periodUnits;

    Timer_CallBackFxn    timerCallback;

    uint32_t             period;
} Timer_Params;

typedef int_fast16_t (*Timer_ControlFxn)(Timer_Handle handle,
    uint_fast16_t cmd, void *arg);

typedef void (*Timer_CloseFxn)(Timer_Handle handle);

typedef uint32_t (*Timer_GetCountFxn)(Timer_Handle handle);

typedef void (*Timer_InitFxn)(Timer_Handle handle);

typedef Timer_Handle (*Timer_OpenFxn)(Timer_Handle handle,
    Timer_Params *params);

typedef int32_t (*Timer_StartFxn)(Timer_Handle handle);

typedef void (*Timer_StopFxn)(Timer_Handle handle);

typedef struct Timer_FxnTable_ {
    Timer_CloseFxn closeFxn;

    Timer_ControlFxn controlFxn;

    Timer_GetCountFxn getCountFxn;

    Timer_InitFxn initFxn;

    Timer_OpenFxn openFxn;

    Timer_StartFxn startFxn;

    Timer_StopFxn stopFxn;
} Timer_FxnTable;

typedef struct Timer_Config_ {
    Timer_FxnTable const *fxnTablePtr;

    void                 *object;

    void           const *hwAttrs;
} Timer_Config;

extern int_fast16_t Timer_control(Timer_Handle handle, uint_fast16_t cmd,
    void *arg);

extern void Timer_close(Timer_Handle handle);

extern uint32_t Timer_getCount(Timer_Handle handle);


extern void Timer_init(void);

extern Timer_Handle Timer_open(uint_least8_t index, Timer_Params *params);

extern void Timer_Params_init(Timer_Params *params);

extern int32_t Timer_start(Timer_Handle handle);

extern void Timer_stop(Timer_Handle handle);

/* The following are included for backwards compatibility. These should not be
 * used by the application.
 */
#define TIMER_CMD_RESERVED           Timer_CMD_RESERVED
#define TIMER_STATUS_RESERVED        Timer_STATUS_RESERVED
#define TIMER_STATUS_SUCCESS         Timer_STATUS_SUCCESS
#define TIMER_STATUS_ERROR           Timer_STATUS_ERROR
#define TIMER_STATUS_UNDEFINEDCMD    Timer_STATUS_UNDEFINEDCMD
#define TIMER_ONESHOT_CB             Timer_ONESHOT_CALLBACK
#define TIMER_ONESHOT_BLOCK          Timer_ONESHOT_BLOCKING
#define TIMER_CONTINUOUS_CB          Timer_CONTINUOUS_CALLBACK
#define TIMER_MODE_FREE_RUNNING      Timer_FREE_RUNNING
#define TIMER_PERIOD_US              Timer_PERIOD_US
#define TIMER_PERIOD_HZ              Timer_PERIOD_HZ
#define TIMER_PERIOD_COUNTS          Timer_PERIOD_COUNTS
#define Timer_Period_Units           Timer_PeriodUnits

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_Timer__include */