Timer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-2020, 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
 *
 *  @anchor ti_drivers_Timer_Overview
 *  # Overview
 *  The timer driver allows you to measure elapsed time with simple and
 *  portable APIs.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.
 *
 *  @anchor ti_drivers_Timer_Usage
 *  # Usage
 *
 *  This documentation provides a basic @ref ti_drivers_Timer_Synopsis
 *  "usage summary" and a set of @ref ti_drivers_Timer_Examples "examples"
 *  in the form of commented code fragments. Detailed descriptions of the
 *  APIs are provided in subsequent sections.
 *
 *  @anchor ti_drivers_Timer_Synopsis
 *  ## Synopsis
 *  @anchor ti_drivers_Timer_Synopsis_Code
 *  @code
 *  // Import Timer Driver definitions
 *  #include <ti/drivers/Timer.h>
 *
 *  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 = UserCallbackFunction;
 *
 *  handle = Timer_open(CONFIG_TIMER0, &params);
 *
 *  @code
 *  // Import Timer Driver definitions
 *  #include <ti/drivers/Timer.h>
 *
 *  Timer_Handle    handle;
 *  Timer_Params    params;
 *
 *  // Initialize Timer parameters
 *  Timer_Params_init(&params);
 *  params.periodUnits = Timer_PERIOD_HZ;
 *  params.period = 1000;
 *  params.timerMode  = Timer_CONTINUOUS_CALLBACK;
 *  params.timerCallback = UserCallbackFunction;
 *
 *  // Open Timer instance
 *  handle = Timer_open(CONFIG_TIMER0, &params);
 *
 *  sleep(10000);
 *
 *  Timer_stop(handle);
 *  @endcode
 *
 *  <hr>
 *  @anchor ti_drivers_Timer_Examples
 *  # Examples
 *
 *  @li @ref ti_drivers_Timer_Examples_open "Opening a Timer Instance"
 *  @li @ref ti_drivers_Timer_Examples_mode "Configuring Timer mode and period"
 *
 *  @anchor ti_drivers_Timer_Examples_open
 *  ## Opening a Timer instance
 *
 *  @code
 *  Timer_Handle    handle;
 *  Timer_Params    params;
 *
 *  Timer_Params_init(&params);
 *  handle = Timer_open(CONFIG_TIMER0, &params);
 *
 *  if (handle == NULL) {
 *      // Timer_open() failed
 *      while (1);
 *  }
 @endcode
 *
 *  @anchor ti_drivers_Timer_Examples_mode
 *  ##Configuring Timer mode and period
 *
 *  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 = UserCallbackFunction;
 *
 *  handle = Timer_open(CONFIG_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
 *
 *  ### 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[].
 *
 *  <hr>
 *  @anchor ti_drivers_Timer_Configuration
 *  # Configuration
 *
 *  Refer to the @ref driver_configuration "Driver's Configuration" section
 *  for driver configuration information.
 *  <hr>
*******************************************************************************
 */

#ifndef ti_drivers_Timer__include
#define ti_drivers_Timer__include

#include <stdint.h>

#include <ti/drivers/dpl/HwiP.h>
#include <ti/drivers/dpl/SemaphoreP.h>
#include <ti/drivers/Power.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_ONESHOT_CALLBACK,    
    Timer_ONESHOT_BLOCKING,    
    Timer_CONTINUOUS_CALLBACK, 
    Timer_FREE_RUNNING         
} Timer_Mode;

typedef enum
{
    Timer_PERIOD_US,    
    Timer_PERIOD_HZ,    
    Timer_PERIOD_COUNTS 
} Timer_PeriodUnits;

typedef void (*Timer_CallBackFxn)(Timer_Handle handle, int_fast16_t status);

typedef struct
{
    Timer_Mode timerMode;

    Timer_PeriodUnits periodUnits;

    Timer_CallBackFxn timerCallback;

    uint32_t period;
} Timer_Params;

#define TIMER_BASE_OBJECT                                             \
    /* Timer control variables */                                     \
    Timer_Mode mode;            /* Blocking or Callback mode */       \
    Timer_CallBackFxn callBack; /* Callback function pointer */       \
    Power_NotifyObj notifyObj;  /* Ptr to current I2C transaction */  \
    uint32_t timer;                                                   \
    uint32_t period;                                                  \
    uint32_t prescaler;                                               \
                                                                      \
    /* Timer RTOS objects */                                          \
    HwiP_Handle hwiHandle;       /* Hwi object handle */              \
    SemaphoreP_Struct semStruct; /* Grants exclusive access to I2C */ \
    SemaphoreP_Handle semHandle; /* Signal I2C transfer complete */   \
                                                                      \
    bool isRunning; /* Flag to show module is open */                 \

typedef struct
{
    TIMER_BASE_OBJECT
} Timer_Object;
#define TIMER_BASE_HWATTRS                      \
      \
    uint32_t baseAddress;                       \
  \
    uint32_t intNum;                            \
 \
    uint32_t intPriority;

typedef struct
{
    TIMER_BASE_HWATTRS
} Timer_HWAttrs;
typedef struct Timer_Config_
{
    void *object;

    void const *hwAttrs;
} Timer_Config;

extern const Timer_Config Timer_config[];
extern void Timer_close(Timer_Handle handle);

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

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 int32_t Timer_setPeriod(Timer_Handle handle, Timer_PeriodUnits periodUnits, uint32_t period);

extern void Timer_Params_init(Timer_Params *params);

extern int32_t Timer_start(Timer_Handle handle);

extern void Timer_stop(Timer_Handle handle);

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_Timer__include */